diff --git a/.vs/Guardian/v17/.wsuo b/.vs/Guardian/v17/.wsuo new file mode 100644 index 00000000..da4e51d0 Binary files /dev/null and b/.vs/Guardian/v17/.wsuo differ diff --git a/.vs/Guardian/v17/DocumentLayout.json b/.vs/Guardian/v17/DocumentLayout.json new file mode 100644 index 00000000..423417ac --- /dev/null +++ b/.vs/Guardian/v17/DocumentLayout.json @@ -0,0 +1,12 @@ +{ + "Version": 1, + "WorkspaceRootPath": "C:\\Users\\HP\\OneDrive\\Pictures\\Documents\\GitHub\\Guardian\\", + "Documents": [], + "DocumentGroupContainers": [ + { + "Orientation": 0, + "VerticalTabListWidth": 256, + "DocumentGroups": [] + } + ] +} \ No newline at end of file diff --git a/.vs/Guardian/v17/workspaceFileList.bin b/.vs/Guardian/v17/workspaceFileList.bin new file mode 100644 index 00000000..62506db4 Binary files /dev/null and b/.vs/Guardian/v17/workspaceFileList.bin differ diff --git a/.vs/VSWorkspaceState.json b/.vs/VSWorkspaceState.json new file mode 100644 index 00000000..6b611411 --- /dev/null +++ b/.vs/VSWorkspaceState.json @@ -0,0 +1,6 @@ +{ + "ExpandedNodes": [ + "" + ], + "PreviewInSolutionExplorer": false +} \ No newline at end of file diff --git a/.vs/slnx.sqlite b/.vs/slnx.sqlite new file mode 100644 index 00000000..58ede2c5 Binary files /dev/null and b/.vs/slnx.sqlite differ diff --git a/AI Guardian/emotion_analysis/emotion_EDA.ipynb b/AI Guardian/emotion_analysis/emotion_EDA.ipynb new file mode 100644 index 00000000..57a8c900 --- /dev/null +++ b/AI Guardian/emotion_analysis/emotion_EDA.ipynb @@ -0,0 +1,919 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "82692406", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from wordcloud import WordCloud\n", + "import re\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import WordNetLemmatizer\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import WordNetLemmatizer\n", + "from collections import Counter\n", + "from nltk.util import ngrams\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from wordcloud import WordCloud\n", + "import re\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import WordNetLemmatizer\n", + "from collections import Counter\n", + "from nltk.util import ngrams\n", + "\n", + "\n", + "import os\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "61848702", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Loading and Inspecting Data ---\n", + "\n", + "First 5 rows of the dataset:\n", + " patientid age gender observationStart \\\n", + "0 P0035 87 Male 2025-06-01T00:00:00+10:00 \n", + "1 P0035 87 Male 2025-06-01T06:00:00+10:00 \n", + "2 P0035 87 Male 2025-06-01T12:00:00+10:00 \n", + "3 P0035 87 Male 2025-06-01T18:00:00+10:00 \n", + "4 P0036 72 Female 2025-06-01T00:00:00+10:00 \n", + "\n", + " observationEnd \\\n", + "0 2025-06-01T06:00:00+10:00 \n", + "1 2025-06-01T12:00:00+10:00 \n", + "2 2025-06-01T18:00:00+10:00 \n", + "3 2025-06-02T00:00:00+10:00 \n", + "4 2025-06-01T06:00:00+10:00 \n", + "\n", + " nursingNote medications heartRate \\\n", + "0 Patient slept without disturbance and remained... NaN 75 \n", + "1 Patient appeared withdrawn and tearful; emotio... Lisinopril 80 \n", + "2 Patient was settled and cooperative during rou... Lisinopril 91 \n", + "3 Patient expressed concern; HR 96 and BP 146/64... Atorvastatin 96 \n", + "4 Patient appeared withdrawn and tearful; emotio... NaN 77 \n", + "\n", + " spo2 temperature ... behaviourTags emotionTags clinicalSummary \\\n", + "0 93 36.5 ... NaN Calm NaN \n", + "1 95 36.6 ... NaN Sad NaN \n", + "2 95 36.6 ... NaN Calm NaN \n", + "3 93 36.5 ... NaN Worried NaN \n", + "4 97 36.7 ... NaN Sad NaN \n", + "\n", + " entitiesExtracted baselineStats alerts state emotionpolarity \\\n", + "0 NaN NaN NaN NaN positive \n", + "1 NaN NaN NaN NaN negative \n", + "2 NaN NaN NaN NaN positive \n", + "3 NaN NaN NaN NaN negative \n", + "4 NaN NaN NaN NaN negative \n", + "\n", + " adls.sleep_minutes dose \n", + "0 378 NaN \n", + "1 55 5mg \n", + "2 10 5mg \n", + "3 20 20mg \n", + "4 337 NaN \n", + "\n", + "[5 rows x 28 columns]\n" + ] + } + ], + "source": [ + "# --- Load and Inspect Data ---\n", + "print(\"--- Loading and Inspecting Data ---\")\n", + "df = pd.read_csv('nurse_emotion.csv')\n", + "\n", + "print(\"\\nFirst 5 rows of the dataset:\")\n", + "print(df.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "71f6e906", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset Information (columns, data types, non-null counts):\n", + "\n", + "RangeIndex: 448 entries, 0 to 447\n", + "Data columns (total 28 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 patientid 448 non-null object \n", + " 1 age 448 non-null int64 \n", + " 2 gender 448 non-null object \n", + " 3 observationStart 448 non-null object \n", + " 4 observationEnd 448 non-null object \n", + " 5 nursingNote 448 non-null object \n", + " 6 medications 344 non-null object \n", + " 7 heartRate 448 non-null int64 \n", + " 8 spo2 448 non-null int64 \n", + " 9 temperature 448 non-null float64\n", + " 10 bloodPressure 448 non-null int64 \n", + " 11 stepsTaken 448 non-null int64 \n", + " 12 calorieIntake 448 non-null int64 \n", + " 13 sleepHours 448 non-null float64\n", + " 14 waterIntakeMl 448 non-null int64 \n", + " 15 mealsSkipped 448 non-null int64 \n", + " 16 exerciseMinutes 448 non-null int64 \n", + " 17 bathroomVisits 0 non-null float64\n", + " 18 behaviourTags 0 non-null float64\n", + " 19 emotionTags 448 non-null object \n", + " 20 clinicalSummary 0 non-null float64\n", + " 21 entitiesExtracted 0 non-null float64\n", + " 22 baselineStats 0 non-null float64\n", + " 23 alerts 0 non-null float64\n", + " 24 state 0 non-null float64\n", + " 25 emotionpolarity 448 non-null object \n", + " 26 adls.sleep_minutes 448 non-null int64 \n", + " 27 dose 344 non-null object \n", + "dtypes: float64(9), int64(10), object(9)\n", + "memory usage: 98.1+ KB\n" + ] + } + ], + "source": [ + "print(\"\\nDataset Information (columns, data types, non-null counts):\")\n", + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "81c7dd20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- : Data Cleaning ---\n", + "\n", + "Missing values per column before cleaning:\n", + "patientid 0\n", + "age 0\n", + "gender 0\n", + "observationStart 0\n", + "observationEnd 0\n", + "nursingNote 0\n", + "medications 104\n", + "heartRate 0\n", + "spo2 0\n", + "temperature 0\n", + "bloodPressure 0\n", + "stepsTaken 0\n", + "calorieIntake 0\n", + "sleepHours 0\n", + "waterIntakeMl 0\n", + "mealsSkipped 0\n", + "exerciseMinutes 0\n", + "bathroomVisits 448\n", + "behaviourTags 448\n", + "emotionTags 0\n", + "clinicalSummary 448\n", + "entitiesExtracted 448\n", + "baselineStats 448\n", + "alerts 448\n", + "state 448\n", + "emotionpolarity 0\n", + "adls.sleep_minutes 0\n", + "dose 104\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# --- Data Cleaning ---\n", + "print(\"\\n--- : Data Cleaning ---\")\n", + "print(\"\\nMissing values per column before cleaning:\")\n", + "print(df.isnull().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f39d7412", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Missing values after dropping empty columns:\n", + "patientid 0\n", + "age 0\n", + "gender 0\n", + "observationStart 0\n", + "observationEnd 0\n", + "nursingNote 0\n", + "medications 104\n", + "heartRate 0\n", + "spo2 0\n", + "temperature 0\n", + "bloodPressure 0\n", + "stepsTaken 0\n", + "calorieIntake 0\n", + "sleepHours 0\n", + "waterIntakeMl 0\n", + "mealsSkipped 0\n", + "exerciseMinutes 0\n", + "emotionTags 0\n", + "emotionpolarity 0\n", + "adls.sleep_minutes 0\n", + "dose 104\n", + "dtype: int64\n", + "\n", + "Empty columns have been removed.\n" + ] + } + ], + "source": [ + "# Drop columns that are completely empty\n", + "df.dropna(axis=1, how='all', inplace=True)\n", + "print(\"\\nMissing values after dropping empty columns:\")\n", + "print(df.isnull().sum())\n", + "print(\"\\nEmpty columns have been removed.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d422d9ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Analyzing the Target Variable ---\n", + "Generated 'emotion_polarity_distribution.png' to show the target variable balance.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_405475/1424761092.py:4: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.countplot(x='emotionpolarity', data=df, palette='viridis')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Analyze the Target Variable (emotionpolarity) ---\n", + "print(\"\\n--- Analyzing the Target Variable ---\")\n", + "plt.figure(figsize=(8, 6))\n", + "sns.countplot(x='emotionpolarity', data=df, palette='viridis')\n", + "plt.title('Distribution of Emotion Polarity', fontsize=16)\n", + "plt.xlabel('Emotion Polarity', fontsize=12)\n", + "plt.ylabel('Count', fontsize=12)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.savefig('emotion_polarity_distribution.png')\n", + "print(\"Generated 'emotion_polarity_distribution.png' to show the target variable balance.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "17608623", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "emotionpolarity\n", + "negative 225\n", + "positive 223\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['emotionpolarity'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c3bf9726", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Analyzing Key Features ---\n", + "Generated 'gender_distribution.png' for gender distribution.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_405475/1590082724.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.countplot(x='gender', data=df, palette='pastel')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Analyze Key Features ---\n", + "print(\"\\n--- Analyzing Key Features ---\")\n", + "# Gender Distribution\n", + "plt.figure(figsize=(8, 6))\n", + "sns.countplot(x='gender', data=df, palette='pastel')\n", + "plt.title('Distribution of Gender', fontsize=16)\n", + "plt.savefig('gender_distribution.png')\n", + "print(\"Generated 'gender_distribution.png' for gender distribution.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0318b73c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 'age_distribution.png' for age distribution.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Age Distribution\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(df['age'], bins=20, kde=True)\n", + "plt.title('Distribution of Age', fontsize=16)\n", + "plt.xlabel('Age', fontsize=12)\n", + "plt.savefig('age_distribution.png')\n", + "print(\"Generated 'age_distribution.png' for age distribution.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f418cb35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Exploring Text Data ---\n", + "Generated 'note_length_distribution.png' to analyze note length.\n", + "Generated 'wordcloud_positive.png' and 'wordcloud_negative.png' to visualize common words.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Explore the Text Data (nursingNote) ---\n", + "print(\"\\n--- Exploring Text Data ---\")\n", + "# Create a feature for the length of the nursing note\n", + "df['note_length'] = df['nursingNote'].str.len()\n", + "\n", + "# Plot the distribution of note length by emotion polarity\n", + "plt.figure(figsize=(12, 7))\n", + "sns.histplot(data=df, x='note_length', hue='emotionpolarity', multiple='stack', palette='plasma')\n", + "plt.title('Distribution of Nursing Note Length by Emotion', fontsize=16)\n", + "plt.xlabel('Length of Nursing Note', fontsize=12)\n", + "plt.savefig('note_length_distribution.png')\n", + "print(\"Generated 'note_length_distribution.png' to analyze note length.\")\n", + "\n", + "# Generate Word Clouds\n", + "positive_text = ' '.join(df[df['emotionpolarity'] == 'positive']['nursingNote'])\n", + "negative_text = ' '.join(df[df['emotionpolarity'] == 'negative']['nursingNote'])\n", + "\n", + "positive_wordcloud = WordCloud(width=800, height=400, background_color='white').generate(positive_text)\n", + "negative_wordcloud = WordCloud(width=800, height=400, background_color='black', colormap='Wistia').generate(negative_text)\n", + "\n", + "# Plot Positive Word Cloud\n", + "plt.figure(figsize=(10, 5))\n", + "plt.imshow(positive_wordcloud, interpolation='bilinear')\n", + "plt.axis('off')\n", + "plt.title('Most Common Words in Positive Nursing Notes', fontsize=16)\n", + "plt.savefig('wordcloud_positive.png')\n", + "\n", + "# Plot Negative Word Cloud\n", + "plt.figure(figsize=(10, 5))\n", + "plt.imshow(negative_wordcloud, interpolation='bilinear')\n", + "plt.axis('off')\n", + "plt.title('Most Common Words in Negative Nursing Notes', fontsize=16)\n", + "plt.savefig('wordcloud_negative.png')\n", + "print(\"Generated 'wordcloud_positive.png' and 'wordcloud_negative.png' to visualize common words.\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4b1de8e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Bivariate Analysis (Finding Relationships) ---\n", + "Generated 'age_vs_emotion.png' to see relationship between age and emotion.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_405475/2302326974.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(x='emotionpolarity', y='age', data=df, palette='coolwarm')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 'correlation_heatmap.png' for numerical feature correlations.\n", + "\n", + "EDA script finished successfully!\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAInCAYAAACmx6ndAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABO00lEQVR4nO3deZxO9f//8edl9n0wG2PM2COyJGQwVBIlpexk2ouyZMvnw8eoJNq0L5/6iCwfPkkUQsWUyC7rJ+pjmUQjy2yYMTPv3x9+c76uMzOMMVxjPO6327nVdc65znmdc13mup7X+33ex2GMMQIAAAAAWMq5ugAAAAAAKG0ISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAMqU+Ph4ORwOffLJJ64uRZLUtm1bORwOrVy50ml+aatTKp01ofQp7D19LXLFv5mEhAQ5HA4lJCRcsX0C1yqCElAGNWjQQA6HQz4+PkpNTXV1OUWW9wXs3Mnf31+RkZGKi4vT8OHDtW7duitSyyeffKKEhATt27fviuzvctuyZYsSEhL0xRdfuLqUMqug929BU2n+grty5UolJCRc9SGooNfCy8tLUVFR6tGjh9asWePqEkvcvn37lJCQwA8dQAlyd3UBAErWli1btH37dknS6dOn9dlnn+mhhx5ycVUXJyoqSlWrVpUkZWVl6dixY1q1apW+//57vfrqq2rbtq0++eQTRUdH53tupUqVVKdOHQUFBV1SDZ988okSExPVtm1bxcTEFHs7VatWVZ06deTr63tJ9VyqLVu2aPz48erfv7/uueeeAtcpqXN3rTv3/VuQ8y1ztZUrV2r8+PGSzoaNgpSW93RRnPtapKena/fu3Zo7d64+++wzvfPOO3riiSdcXOHFCwkJUZ06dRQSEuI0f9++fRo/frzi4uIUHx/vmuKAMoagBJQxn376qSQpODhYJ06c0KeffnrVBaWHHnoo36/uqamp+vzzz61fu5s1a6YNGzYoKirKab2JEydq4sSJV7Da85s+fbqrSyiy0nburlYFvX/LkqvpPW1/LdLS0vTEE09o1qxZGjx4sDp27FjgDy6l2VNPPaWnnnrK1WUA1wS63gFlSE5OjmbPni1Jevvtt+Xm5qbExEQdOHDAxZVdusDAQMXHx2vTpk1q0KCBkpOT9cADD7i6LABXkYCAAH300UeKiIhQVlaWPv/8c1eXBKAUIygBZcg333yjQ4cOKSIiQj179tQtt9wiY4xmzpx53uelpaVp5MiRiomJkbe3t6pVq6ZRo0YpIyPjghcrr1u3Tj179lRkZKQ8PT0VHh6ubt26afPmzZfhCKUKFSpo2rRpks52E/rpp5+clhdWrzFG06dPV5s2bRQcHCxPT09FREToxhtv1MiRI/X7779b23Q4HEpMTJQktWvXzuk6h7zt7tu3Tw6Hw+qW989//lM33XSTAgIC5HA4rP0W5cL33bt3q0ePHgoLC5OPj48aN26sf/3rXwWue6HXo6ALvWNiYvTggw9KkqZNm+Z0POd2r7rQthctWqQ77rhDISEh8vLyUrVq1TRgwAAlJSUVuH5MTIwcDof27dunn376SR07dlT58uXl5+en1q1b67vvviv0nNjl5OQoIiJCDodDGzZsKHS9YcOGyeFw6JlnnrHmZWdn64033lCzZs0UEBAgLy8vVa5cWS1bttS4ceN04sSJItdxOZx7nhITE3XbbbcpODhYFSpU0L333qs9e/ZY6y5cuFCtW7dWYGCgypcvr169eumPP/4odNs7duxQv379VKVKFevf53333Zfv340kORwOq9vd+PHjnd4n53blOt972hijGTNmKC4uTsHBwfLx8dF1112nUaNG6dixYwXWmLcPSVqyZInatGmjgIAABQUFqWPHjiX+t8THx0dNmzaVJKdzK0mrV69W165dFR4eLk9PT1WpUkUPPPCAdu3adVH7OHXqlGbPnq2ePXuqTp068vf3l7+/vxo1aqQXXnhBGRkZBT7v3PfCihUr1LFjR4WEhDid74L+jbdt21bt2rWTJCUmJjq9dnl/o1q0aCGHw6F58+YVWvcrr7wih8Ohbt26XdTxAmUVQQkoQ/K6xPTo0UNubm7q06ePpP/rjleQ1NRUxcXF6eWXX1ZSUpJq164tPz8/vfzyy2rXrp2ysrIKfe7rr7+uFi1aaM6cOTp9+rTq16+vnJwcffbZZ2revPll+7W2cePGat68uaSzX96LYsSIEerfv79++OEHBQUFqVGjRvL19dX27dv18ssvW1++g4KCFBsbq8DAQElS/fr1FRsba03h4eH5tv3kk0/qscce059//qnrrrtOwcHBRT6WPXv2qFmzZlqwYIGioqIUHh6uLVu26OGHH9agQYOKvJ3zuemmm1SrVi1JUlhYmNPxNGjQoEjbGD16tO666y4tXbpUPj4+Vqvee++9p4YNG543vHz11Vdq06aN1q9frxo1asjDw0OrVq1Shw4dijxogJubm7p37y5JVqupnTFGc+bMkST16tXLmt+zZ08NGTJE69evV3h4uBo2bCh3d3etW7dOzz33XKkZsGP+/Pm69dZbtW3bNtWoUUNZWVn64osvFBcXp8OHD+v1119Xly5dtG/fPlWvXl2nTp3Sv//9b91yyy06ffp0vu0tXLhQN954o2bMmKGMjAw1bNhQxhh9/vnnio2N1T//+U+n9WNjY62urFFRUU7vk9q1a1+wfmOM+vbtq379+un7779XxYoVVa9ePe3du1eTJ09WkyZN9L///a/Q57///vu688479euvv6p27drKycnR119/rTZt2ui///3vRZ7NC9dq995776lVq1aaP3++JKlhw4bKyMjQp59+qiZNmhT5b40kbdy4Ub1799a8efN08uRJ1a1bV5UrV9aOHTs0duxYtWnTRqdOnSr0+bNnz9Ztt92mtWvXqnr16qpSpcp599egQQPVr19f0tnW93Nfu5tuukmSrC7YeT80FSRvGdc4Af+fAVAmpKWlGV9fXyPJrFu3zhhjTGpqqvHx8TGSzIYNGwp83sCBA40kU716dbNz505r/vbt2010dLTx8PAwkszUqVOdnrdkyRLjcDhMSEiImTdvntOyjz76yLi7u5uAgADzxx9/FPkY4uLijCQzbty4C647bNgwI8l06NDBaX7//v3z1ZucnGzKlStngoKCzKpVq5zWP3XqlJk9e7b5+eefC6xlxYoVBe5/7969RpJxc3Mzfn5+ZsGCBdaykydPXnA7eXW6u7ubdu3ameTkZGvZf/7zH+u8f/XVVxc8vnONGzeuwHM4depUI8n079+/wOedb9tffvmlVeuMGTOs+SkpKebee+81kkxMTIzTcRtjTHR0tJFkPDw8zMSJE012drYxxpisrCzTp08fI8k0b9680Hrs1qxZYySZyMhIk5OTk2/5ypUrjSRTs2ZNa96GDRuMJBMVFeX0/s6r/5///Kc5cOBAkWs4n4t5/57r3PP06quvWsd2/Phx06JFCyPJ3HnnncbX19fMnDnTet6BAwdM9erVjSTz7rvvOm3z4MGDJjAw0EgygwcPNpmZmcYYY3JycsyECROs/dnf94W9fwo6Tvt7+q233jKSTEBAgFm2bJk1/9ChQyY2NrbQ11uSkWR8fX2d3nupqanm1ltvNZJMjx49znsOC6uxoOM4efKkiYiIMJLMq6++aowxZvPmzcbd3d1IMpMnT7Zeg9OnT5sBAwYYSSYoKCjf37PC/s3s27fPzJ0716SlpTnNP3TokLn//vuNJJOQkJCvtrz3gpubmxk/frw5c+aMMcaY3Nxcc/r0aWNM4a/RihUrjCQTFxdX4DlJSUkxvr6+xt3d3fz555/5lm/cuNFIMhEREda/VeBaR4sSUEbk/XJZs2ZN6xfEgIAA3XXXXZIKblVKSUnRxx9/LOlsa1TdunWtZddff70++eQTnTlzpsD9/f3vf5cxRh9//LG6du3qtOzhhx/W4MGDlZaWpo8++qhEjs8u75fv5OTkC67722+/KTc3V7fccotiY2Odlnl7e6tnz5664YYbilVHTk6OnnvuOd19993WPB8fnyI/383NTbNmzVJoaKg17/7779fTTz8tSZo8eXKx6ipJL730kiRp4MCBViuldPaX6xkzZigkJET79u0rtKXnjjvu0LPPPis3NzdJkoeHh6ZMmSIvLy+tXbtWx48fL1IdLVq0UPXq1XXw4EH98MMP+Zbn7f/c1qS8rlX333+/0/s7r/5HHnkk34Agl8rebc0+bdmypcDnderUSc8884zKlTv70RwcHGx1hVu0aJEeffRR9e7d21o/KipKI0eOlCR9/fXXTtt69913lZqaqkaNGmnKlCny9PSUJJUrV05/+9vf1KlTJ505c0avvPJKiRyzMcZ6rz733HNq3769tSwiIkJz5syRp6en1q5dW2iXy4cfftipJSMgIECvv/56gcdXXGlpaXr00Ud1+PBhubu7695775V0tstZdna2unTpohEjRlivgZeXl95++21df/31SklJ0XvvvVek/URHR6tbt27y9/d3mh8REaHp06fL09PzvF2iO3XqpH/84x9ydz875lbe8OaXIjAwUPfdd5+ys7M1a9asfMvzWpP69u1r/VsFrnUEJaCMyAtC536RkmR9sZ09e7ays7Odlv3www86ffq0atWqlS9ASGf7vVerVi3f/P3792vTpk0KCwtzCgjnypufd61PSfPz85N09ovPheR9EV67du1lGdjiUgaV6Nq1qyIiIvLNHzBggCTpxx9/LPR6hishPT3duudMXng7l6+vrx599FFJ0rJlywrcxiOPPJJvXkhIiHXtxPm6Y9nlhSB7KMvOztZnn30mSfnChCR9++23hV4jU9Ls3dbsk/3Lc56HH34437xGjRqdd3njxo0l5T+Hea9FYaOjDR482Gm9S7Vr1y4lJSXJ29vbej+cKzIyUvfdd99591nQ+6RBgwby9vZWSkqKjh49etF1/etf/1KrVq3UqlUrNWrUSOHh4Zo5c6YcDodeeeUV6+9bXk0FvccdDofVDfZizldubq4WLFiggQMHqmPHjmrdurVatWql9u3by+FwaM+ePTp58mSBz71cA9UU1v3uzJkz1r8put0B/4fhwYEy4ODBg1qxYoWk/EEp7wL65ORkLVu2TJ06dbKW5f3afr7WlAYNGmjv3r1O87Zt2ybp7H2aWrVqVeDz8q6ZOHjw4EUeTdGkp6dLknUt0flERkaqW7du+s9//qOaNWuqXbt2atu2rVq3bq0WLVpYv9oWR0hISL77mVwMeytHnurVq8vLy0uZmZn67bffit3idal+/fVX5ebmysvLS9WrVy9wneuvv17S2UEpClKjRo0C54eFhemXX36xXsui6N27tyZMmKDPPvtMb731ljw8PCSd/QJ79OhRNWrUSNddd521/s0336zmzZtr7dq1ioqKUvv27dWmTRvFxcWpSZMmTgNvlJTiDg9e0Hk6t6XxfMvt5zDvtahXr16B+8p7zf7880+lpqYW6d/R+eTtr2rVqtaPGIXt82LfJ6GhoUpKSlJ6eroqVqx4UXUlJSVZg424u7srNDRUHTt21KBBgxQXFydJOnHihI4cOSLpwuersNrtTpw4oU6dOl3wxrbHjx8v8H5Uhf1duFRxcXGqUaOGtmzZoq1bt1p/VxYvXqwjR46oadOm1rECoEUJKBNmzpyp3NxcNWnSRHXq1HFa5unpaY1gZO9+l9dSERAQUOi2C1qWkpIi6exAED/++GOB08aNGyXpvBcsX4q8lqGwsLAirT99+nSNGzdOYWFhWrZsmf72t7+pdevWqly5sl555RXl5uYWq47CvhQWVWH1OxwO60twUVrNLpe8L+ChoaGFhoq8AS4Kq7Owc5TXvckUcGF9YerVq6eGDRvq6NGjWr58uTU/79dw+w8F5cqV05IlSzR48GD5+PhowYIFGjZsmJo2bapq1aoVOsKfKxT0hfncc36+5fZzmPe6Ffb+OndQkpJ4f11of+fu80q8T/KMGzdOxhgZY3TmzBn98ccfmjdvnhWSzq39fPVfqHa7Z555RmvWrFGdOnU0b948HTx4UJmZmVYtkZGRklRo1+ZL/btSmHNHMDy3VYlBHICCEZSAMiAvAG3atKnAayI+/PBDSdKCBQuUmppqPS/vw/h8v+gX9MUgr+tQbGys9cFf2HS5RhRbtWqVJKlZs2ZFWt/b21sJCQn6/ffftWvXLn3wwQfq3Lmzjh49qhEjRui11167LHVeSN4v2XbGGGvZuWG1sC/GeUq6m17ea33kyJFC9/nnn39KOn/gLkn27nenTp3SggUL5HA41LNnz3zrly9fXlOmTNGRI0e0efNmvfHGG2rXrp3279+vBx980OqyV5bkvW6FXcOX95pJJfO6XWh/5+7zSr1PiurcrpAXOl9FqT07O1tz586VdPZvbteuXVW5cmXrOrHs7GwdPnz4Ussutvj4eJUrV04zZ85Udna2jh49qkWLFsnT09Pp+j4ABCXgqrd582Zt375dDodD4eHhhU6enp46deqU0z008ob83bp1a6Hbz+tmd6687im7du0qdkvMpdi0aZPWr18vSbrzzjsv+vnXXXedHnvsMS1cuFDvvvuuJOUbKvlydMkqSGH3Z9m7d68yMzNVrlw5py5JeeG2sID166+/Fji/uMdTs2ZNlStXTpmZmYVeS7Rjxw5JKtIQ0iWhV69ecjgc+uKLL3Tq1Cl9+eWXSktLU6tWrc47MIPD4VCjRo00aNAgfffdd3r22Wcl5X/ty4K812Lnzp0FLs97zcLDw5263RX3fZK3vwMHDhT6w8uVfp8UVXBwsNV6e6HzVZTajxw5ooyMDFWoUCFfC78kbd++XTk5OZdQccGK+tpVqVJF7du3159//qmvv/5as2bNUlZWlu6++25VqFChxOsCrmYEJeAql9ea1KZNGx0+fLjQadiwYU7rS1KrVq3k7e2t3bt3F9iX/vvvv893fZIk1apVS/Xr19exY8esezddKceOHVP//v0lSbfeemuRW5QK06JFC0nKd9POvJHrLlfXwTzz5s1z+nU/T16Ai42NdeqGk3edUF5QPNfvv/+upUuXFrif4h6Pv7+/WrZsKUl666238i0/deqUNbJhhw4dLmrbxVW1alXFxsYqPT1dX375ZYGj3RVFYa99WZD3Wrz99tsFLn/zzTed1stT3PdJ3bp1VbVqVZ0+fbrAkS7zurwVtM/SIK+mgt7jxhhrflFqzzuHqampBZ7HyzWS5cW8ducO6kC3O6BwBCXgKpaTk2N9SezXr9951+3bt68kaeXKldbFzUFBQdZIWv369dMvv/xirb9z507179/fuljebtKkSXI4HBo4cKA++uijfCPq/e9//9OECRNK7KazqampmjZtmpo0aaLt27crIiKiyNeXfPvttxoxYkS+X4vT09P18ssvS5KaNGnitCwvkFyuUfvy5OTkqE+fPvrrr7+sefPnz7e+mI0YMcJp/Y4dO0qSvvjiCy1evNiaf+jQIfXp0yff65Dn3IBV2EhbhRk1apSks+Ht3GGF09LS9MADD+jIkSOKiYkpsNvb5ZJ3LdL777+vJUuWyN3d3boW71wzZ87U888/n68L6NGjR62wYH/thw8frpiYGA0fPvzyFH8FPPnkkwoMDNSWLVs0dOhQ68bRubm5mjx5shYtWiQPDw/rB5Q8ee+T1atXF/peKojD4bDeq+PGjdO3335rLfvzzz/Vs2dPZWVlqUWLFmrXrt2lHl6JGzZsmNzd3bVgwQK9+uqrVkt5VlaWBg8erO3btysoKEhPPvnkBbcVHBys66+/XtnZ2U7nPicnR5MmTbKGSi9peSP47dy5s9AW5zz33HOPKlasqC+++EIbN25URESE7rjjjhKvCbjqXdG7NgEoUUuWLDGSjLe3tzlx4sQF12/cuLGRZCZOnGjNS0lJMY0aNTKSTLly5cwNN9xgGjRoYBwOh2natKnp2bOnkWSmT5+eb3tvv/22cXNzs24yeeONN5qmTZua8PBw6yaS7733XpGPJ+8mkVFRUSY2NtbExsaaZs2amZo1a5py5cpZ22zXrl2hNwkt6AaQ8+fPt54bGhpqmjZtaho2bGjdoDcoKMhs3LjRaTvff/+99ZzatWubNm3amLi4OLNkyRJjzP/dcDY6OrpIx1TYDWdHjx5tgoKCjLe3t7nxxhtNTEyMtd8BAwYUuM2HH37YWqdatWqmUaNGxt3d3Vx33XVm8ODBBd6MMicnx9SqVctIMhUrVjQ333yziYuLM4MHDz7vucvz7LPPWvuMiooyTZs2NX5+fkaSKV++vHWT43Pl3Txz7969F3VuiuLIkSPWDUIlmY4dOxa43uuvv26tExkZaW666SZTv3594+npac3bv3+/03PyzsP5bs57vuM59/1b0DR69Gin513oPOXVX5DzvQ8XLFhgHWf58uXNTTfdZMLCwqx/6x988EG+56SkpJjy5csbSaZSpUomNjbWxMXFOf3NKOx1y83NNb1797bqrVmzpmnSpIlVQ9WqVc1vv/12UcdXlPNTkOLc/Pfdd981DofDSDLh4eHmpptuMsHBwUaS8fLyynfzZ2MK/zezcOFCa1sVKlQwTZs2NSEhIUaSGTt2bKHHVJRjPd9NgW+55Rbr73Hz5s1NXFxcoTfrffrpp61zP3z48AudHuCaRIsScBXL60bXuXNnBQUFXXD9vFalc7vfBQYG6vvvv9fw4cNVpUoV/fe//1VqaqqGDh2qFStWWL8qF3QR88CBA7VlyxY98sgjCg0N1Y4dO7Rnzx6FhISoV69e+s9//lOs+4EkJSVZo+dt375dGRkZio2N1bBhw7Ru3Tp99913F3WT0NatW+vNN99U586d5e/vr507d2rfvn2qWbOmRo4cqf/+97/5WhVat26tWbNmqVmzZjp48KC+//57JSYmlvhF2LVr19a6devUuXNnHThwQIcOHVLDhg314YcfFtpt6v3339dzzz2nGjVq6ODBgzpy5Igef/xxrVmzRsHBwQU+p1y5clq0aJHuv/9+ubm5ad26dUpMTCz05qd2EydO1Jdffqn27dsrPT1dW7duVUhIiJ544gn9/PPP1k2Or5SQkBDdfvvt1mP7aHd57rvvPk2aNEnt27eXm5ubtm3bpkOHDql+/fp64YUXtH37dlWtWrVEazv3/VvQVNh1MCXt7rvv1saNG9WnTx95e3try5YtMsbo3nvv1apVq/TYY4/le05gYKCWLVumjh07KjMzU2vWrFFiYqL++9//XnB/DodDM2bM0PTp09W6dWslJydrx44dio6O1ogRI7Rp06ZCh5gvDZ588kn98MMPuueee5Sbm6stW7bI19dXffv21aZNmy7qesjOnTtryZIlatmypU6dOqVffvlFNWvW1IwZM/Tcc89dtmOYNWuW4uPjFRgYqI0bNyoxMVE//fRTges++OCD1v/T7Q4omMOYYoy3CeCa0aBBA23fvl2bN292uvklAODq9fXXX6tjx45q2rRpgdc8AuAaJQDnsX79em3fvt3qcw8AKBs+/vhjSc4tSwCcEZQA6G9/+5sOHjzoNG/dunXq3r27pLMjJBU2qAMA4Oqydu1azZ8/X4GBgerTp4+rywFKLbreAbDuvxEREaGoqCglJydr//79kqSmTZtqxYoVTjdlBABcfXr27Kl9+/Zp06ZNOnPmjF588UWNHj3a1WUBpRZBCYAmT56sxYsX65dfftGxY8fk6empOnXqqHv37nrqqafk6+vr6hIBAJcoJiZGBw4cUJUqVfTII49ozJgxKleOzkVAYQhKAAAAAGDDzwgAAAAAYOPuyp2npaVp7Nixmj9/vpKTk9W4cWO98cYb1v04jDEaP368PvzwQx0/flzNmzfXO++8c1Gjb+Xm5uqPP/5QQECAdR0GAAAAgGuPMUZpaWmqXLnyhbueuuhGt8YYY7p3727q1atnEhMTzZ49e8y4ceNMYGCg+f33340xxrz00ksmICDAzJs3z2zbts306NHDVKpUyaSmphZ5H0lJSdadp5mYmJiYmJiYmJiYmJKSki6YI1x2jdKpU6cUEBCgBQsWON3tulGjRrrrrrv0/PPPq3LlyhoyZIhGjRolScrMzFR4eLgmTZqkxx9/vEj7SUlJUXBwsJKSkhQYGHhZjgUAAABA6ZeamqqoqCidOHFCQUFB513XZV3vsrOzlZOTI29vb6f5Pj4+WrVqlfbu3avDhw/r9ttvt5Z5eXkpLi5Oq1evLjQoZWZmKjMz03qclpYmSQoMDCQoAQAAACjSJTkuG8whICBAN998s55//nn98ccfysnJ0YwZM7R27VodOnRIhw8fliSFh4c7PS88PNxaVpCJEycqKCjImqKioi7rcQAAAAAoe1w66t2nn34qY4wiIyPl5eWlN998U71795abm5u1jj3tGWPOmwBHjx6tlJQUa0pKSrps9QMAAAAom1walGrUqKHExESlp6crKSlJ69at05kzZ1StWjVFRERIUr7Wo+Tk5HytTOfy8vKyutnR3Q4AAABAcZSK+yj5+fmpUqVKOn78uJYuXaouXbpYYWn58uXWellZWUpMTFTLli1dWC0AAACAss6l91FaunSpjDGqU6eOfv31V40YMUJ16tTRgw8+KIfDoSFDhujFF19UrVq1VKtWLb344ovy9fVV7969XVk2AAAAgDLOpUEpJSVFo0eP1u+//64KFSrovvvu04QJE+Th4SFJGjlypE6dOqUBAwZYN5xdtmyZAgICXFk2AAAAgDLOZfdRulJSU1MVFBSklJQUrlcCAAAArmEXkw1KxTVKAAAAAFCaEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAxt3VBQAXIysrS0eOHHF1GbiGhIaGytPT09VlALDh8wBXGp8H1x6CEq4qR44c0TvvvOPqMnANGThwoCIjI11dBgAbPg9wpfF5cO1xGGOMq4u4nFJTUxUUFKSUlBQFBga6uhxcIn5BLJ4jR45o7ty56t69u0JDQ11dzlWFXxCB0onPg4vHZ8Gl4fOgbLiYbECLEq4qnp6e/JpzCUJDQzl/AMoEPg+Kj88CoGgYzAEAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALBxaVDKzs7WmDFjVK1aNfn4+Kh69ep67rnnlJuba60THx8vh8PhNLVo0cKFVQMAAAAo69xdufNJkybp/fff17Rp03T99ddrw4YNevDBBxUUFKTBgwdb691xxx2aOnWq9djT09MV5QIAAAC4Rrg0KK1Zs0ZdunTRnXfeKUmKiYnR7NmztWHDBqf1vLy8FBER4YoSAQAAAFyDXBqUWrVqpffff1+7d+9W7dq19fPPP2vVqlWaMmWK03orV65UWFiYgoODFRcXpwkTJigsLKzAbWZmZiozM9N6nJqaejkP4ZKdOHFCGRkZri4DZdyRI0ec/gtcTn5+fgoODnZ1GQAAXBKXBqVRo0YpJSVF1113ndzc3JSTk6MJEyaoV69e1jodO3ZUt27dFB0drb1792rs2LG65ZZbtHHjRnl5eeXb5sSJEzV+/PgreRjFduLECb32+uvKPnPG1aXgGjF37lxXl4BrgLuHh54ZOpSwBAC4qrk0KM2ZM0czZszQrFmzdP3112vLli0aMmSIKleurP79+0uSevToYa1fv359NW3aVNHR0Vq0aJG6du2ab5ujR4/WM888Yz1OTU1VVFTU5T+YYsjIyFD2mTOq3fRu+QaEuLocALhkJ9P+0u4NC5WRkUFQAgBc1VwalEaMGKFnn31WPXv2lCQ1aNBA+/fv18SJE62gZFepUiVFR0drz549BS738vIqsKWpNPMNCJF/MNdgAQAAAKWFS4cHP3nypMqVcy7Bzc3NaXhwu6NHjyopKUmVKlW63OUBAAAAuEa5tEWpc+fOmjBhgqpWrarrr79emzdv1muvvaaHHnpIkpSenq6EhATdd999qlSpkvbt26e//e1vCgkJ0b333uvK0gEAAACUYS4NSm+99ZbGjh2rAQMGKDk5WZUrV9bjjz+uf/zjH5LOti5t27ZN06dP14kTJ1SpUiW1a9dOc+bMUUBAgCtLBwAAAFCGuTQoBQQEaMqUKfmGA8/j4+OjpUuXXtmiAAAAAFzzXHqNEgAAAACURgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABs3F1dAAAA17oTJ04oIyPD1WWgjDty5IjTf4HLyc/PT8HBwa4u45IQlAAAcKETJ07o9ddf05kz2a4uBdeIuXPnuroEXAM8PNw1dOgzV3VYIigBAOBCGRkZOnMmW52uj1IFXy9XlwMAl+zYyUwt3pGkjIwMghIAALg0FXy9FB7o6+oyAAD/H4M5AAAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG5cGpezsbI0ZM0bVqlWTj4+Pqlevrueee065ubnWOsYYJSQkqHLlyvLx8VHbtm21Y8cOF1YNAAAAoKxzaVCaNGmS3n//fb399tvatWuXJk+erJdffllvvfWWtc7kyZP12muv6e2339b69esVERGh9u3bKy0tzYWVAwAAACjLXBqU1qxZoy5duujOO+9UTEyM7r//ft1+++3asGGDpLOtSVOmTNHf//53de3aVfXr19e0adN08uRJzZo1y5WlAwAAACjDXBqUWrVqpW+//Va7d++WJP38889atWqVOnXqJEnau3evDh8+rNtvv916jpeXl+Li4rR69eoCt5mZmanU1FSnCQAAAAAuhrsrdz5q1CilpKTouuuuk5ubm3JycjRhwgT16tVLknT48GFJUnh4uNPzwsPDtX///gK3OXHiRI0fP/7yFg4AAACgTHNpi9KcOXM0Y8YMzZo1S5s2bdK0adP0yiuvaNq0aU7rORwOp8fGmHzz8owePVopKSnWlJSUdNnqBwAAAFA2ubRFacSIEXr22WfVs2dPSVKDBg20f/9+TZw4Uf3791dERISksy1LlSpVsp6XnJycr5Upj5eXl7y8vC5/8QAAAADKLJe2KJ08eVLlyjmX4ObmZg0PXq1aNUVERGj58uXW8qysLCUmJqply5ZXtFYAAAAA1w6Xtih17txZEyZMUNWqVXX99ddr8+bNeu211/TQQw9JOtvlbsiQIXrxxRdVq1Yt1apVSy+++KJ8fX3Vu3dvV5YOAAAAoAxzaVB66623NHbsWA0YMEDJycmqXLmyHn/8cf3jH/+w1hk5cqROnTqlAQMG6Pjx42revLmWLVumgIAAF1YOAAAAoCxzaVAKCAjQlClTNGXKlELXcTgcSkhIUEJCwhWrCwAAAMC1zaXXKAEAAABAaURQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABt3VxcA6WTaX64uAQBKBH/PAABlBUGpFNi9YaGrSwAAAABwDoJSKVC76d3yDQhxdRkAcMlOpv3Fjz8AgDKBoFQK+AaEyD84wtVlAAAAAPj/GMwBAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMDmkoLSr7/+qqVLl+rUqVOSJGNMiRQFAAAAAK5UrKB09OhR3Xbbbapdu7Y6deqkQ4cOSZIeeeQRDRs2rEQLBAAAAIArrVhBaejQoXJ3d9eBAwfk6+trze/Ro4e+/vrrEisOAAAAAFzBvThPWrZsmZYuXaoqVao4za9Vq5b2799fIoUBAAAAgKsUq0UpIyPDqSUpz19//SUvL69LLgoAAAAAXKlYQalNmzaaPn269djhcCg3N1cvv/yy2rVrV2LFAQAAAIArFKvr3csvv6y2bdtqw4YNysrK0siRI7Vjxw4dO3ZMP/74Y0nXCAAAAABXVLFalOrVq6etW7eqWbNmat++vTIyMtS1a1dt3rxZNWrUKOkaAQAAAOCKKlaLkiRFRERo/PjxJVkLAAAAAJQKxQpKW7duLXC+w+GQt7e3qlatyqAOAAAAAK5axQpKjRo1ksPhkCQZYyTJeixJHh4e6tGjhz744AN5e3uXQJkAAJRtRzNOu7oEACgRZeXvWbGC0vz58zVq1CiNGDFCzZo1kzFG69ev16uvvqpx48YpOztbzz77rMaMGaNXXnmlpGsGAKDMWbLzd1eXAAA4R7GC0oQJE/TGG2+oQ4cO1rwbbrhBVapU0dixY7Vu3Tr5+flp2LBhBCUAAIqgY70qquhHLwwAV7+jGafLxI8/xQpK27ZtU3R0dL750dHR2rZtm6Sz3fMOHTp0adUBAHCNqOjnrfDA/DdzBwC4RrGGB7/uuuv00ksvKSsry5p35swZvfTSS7ruuuskSQcPHlR4eHjJVAkAAAAAV1CxWpTeeecd3X333apSpYpuuOEGORwObd26VTk5Ofrqq68kSf/73/80YMCAEi0WAAAAAK6EYgWlli1bat++fZoxY4Z2794tY4zuv/9+9e7dWwEBAZKkfv36lWihAAAAAHClFPuGs/7+/mrTpo1iYmKsLngrVqyQJN19990lUx0AAAAAuECxgtL//vc/3Xvvvdq2bZscDoeMMU73UcrJySmxAgEAAADgSivWYA6DBw9WtWrV9Oeff8rX11fbt29XYmKimjZtqpUrV5ZwiQAAAABwZRWrRWnNmjX67rvvFBoaqnLlysnNzU2tWrXSxIkTNWjQIG3evLmk6wQAAACAK6ZYLUo5OTny9/eXJIWEhOiPP/6QdPY+Sr/88kvJVQcAAAAALlCsFqX69etr69atql69upo3b67JkyfL09NTH374oapXr17SNQIAAADAFVWsoDRmzBhlZGRIkl544QXdddddat26tSpWrKg5c+aUaIEAAAAAcKUVKyh16NDB+v/q1atr586dOnbsmMqXL+80+h0AAAAAXI2KfR8luwoVKpTUpgAAAADApYo1mAMAAAAAlGUEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwMalQSkmJkYOhyPfNHDgQElSfHx8vmUtWrRwZckAAAAArgHurtz5+vXrlZOTYz3evn272rdvr27dulnz7rjjDk2dOtV67OnpeUVrBAAAAHDtcWlQCg0NdXr80ksvqUaNGoqLi7PmeXl5KSIi4kqXBgAAAOAaVmquUcrKytKMGTP00EMPyeFwWPNXrlypsLAw1a5dW48++qiSk5PPu53MzEylpqY6TQAAAABwMUpNUPriiy904sQJxcfHW/M6duyomTNn6rvvvtOrr76q9evX65ZbblFmZmah25k4caKCgoKsKSoq6gpUDwAAAKAscWnXu3N9/PHH6tixoypXrmzN69Gjh/X/9evXV9OmTRUdHa1Fixapa9euBW5n9OjReuaZZ6zHqamphCUAAAAAF6VUBKX9+/frm2++0eeff37e9SpVqqTo6Gjt2bOn0HW8vLzk5eVV0iUCAAAAuIaUiq53U6dOVVhYmO68887zrnf06FElJSWpUqVKV6gyAAAAANcilwel3NxcTZ06Vf3795e7+/81cKWnp2v48OFas2aN9u3bp5UrV6pz584KCQnRvffe68KKAQAAAJR1Lu9698033+jAgQN66KGHnOa7ublp27Ztmj59uk6cOKFKlSqpXbt2mjNnjgICAlxULQAAAIBrgcuD0u233y5jTL75Pj4+Wrp0qQsqAgAAAHCtc3nXOwAAAAAobQhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYuLu6AEgn0/5ydQkAUCL4ewYAKCsISi7k5+cndw8P7d6w0NWlAECJcffwkJ+fn6vLAADgkhCUXCg4OFjPDB2qjIwMV5eCMu7IkSOaO3euunfvrtDQUFeXgzLOz89PwcHBri4DAIBLQlByseDgYL5Q4IoJDQ1VZGSkq8sAAAAo9RjMAQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA27q4uAAAASMdOZrq6BAAoEWXl7xlBCQAAF/Lz85OHh7sW70hydSkAUGI8PNzl5+fn6jIuCUEJAAAXCg4O1tChzygjI8PVpaCMO3LkiObOnavu3bsrNDTU1eWgjPPz81NwcLCry7gkBCUAAFwsODj4qv9CgatHaGioIiMjXV0GUOoxmAMAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwMalQSkmJkYOhyPfNHDgQEmSMUYJCQmqXLmyfHx81LZtW+3YscOVJQMAAAC4Brg0KK1fv16HDh2ypuXLl0uSunXrJkmaPHmyXnvtNb399ttav369IiIi1L59e6WlpbmybAAAAABlnEuDUmhoqCIiIqzpq6++Uo0aNRQXFydjjKZMmaK///3v6tq1q+rXr69p06bp5MmTmjVrlivLBgAAAFDGlZprlLKysjRjxgw99NBDcjgc2rt3rw4fPqzbb7/dWsfLy0txcXFavXp1odvJzMxUamqq0wQAAAAAF6PUBKUvvvhCJ06cUHx8vCTp8OHDkqTw8HCn9cLDw61lBZk4caKCgoKsKSoq6rLVDAAAAKBsKjVB6eOPP1bHjh1VuXJlp/kOh8PpsTEm37xzjR49WikpKdaUlJR0WeoFAAAAUHa5u7oASdq/f7+++eYbff7559a8iIgISWdblipVqmTNT05OztfKdC4vLy95eXldvmIBAAAAlHmlokVp6tSpCgsL05133mnNq1atmiIiIqyR8KSz1zElJiaqZcuWrigTAAAAwDXC5S1Kubm5mjp1qvr37y939/8rx+FwaMiQIXrxxRdVq1Yt1apVSy+++KJ8fX3Vu3dvF1YMAAAAoKxzeVD65ptvdODAAT300EP5lo0cOVKnTp3SgAEDdPz4cTVv3lzLli1TQECACyoFAAAAcK1weVC6/fbbZYwpcJnD4VBCQoISEhKubFEAAAAArmml4holAAAAAChNCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMDG5UHp4MGD6tu3rypWrChfX181atRIGzdutJbHx8fL4XA4TS1atHBhxQAAAADKOndX7vz48eOKjY1Vu3bttGTJEoWFhem3335TcHCw03p33HGHpk6daj329PS8wpUCAAAAuJa4NChNmjRJUVFRTiEoJiYm33peXl6KiIi4gpUBAAAAuJa5NCgtXLhQHTp0ULdu3ZSYmKjIyEgNGDBAjz76qNN6K1euVFhYmIKDgxUXF6cJEyYoLCyswG1mZmYqMzPTepyamnpZjwFXVlZWlo4cOeLqMq46eeeMc3fxQkNDacUGSiE+Dy4enwWXhs+Da4/DGGNctXNvb29J0jPPPKNu3bpp3bp1GjJkiD744AM98MADkqQ5c+bI399f0dHR2rt3r8aOHavs7Gxt3LhRXl5e+baZkJCg8ePH55ufkpKiwMDAy3tAuOwOHjyod955x9Vl4BoycOBARUZGuroMADZ8HuBK4/OgbEhNTVVQUFCRsoFLg5Knp6eaNm2q1atXW/MGDRqk9evXa82aNQU+59ChQ4qOjta///1vde3aNd/yglqUoqKiCEplBL8g4krjF0SgdOLzAFcanwdlw8UEJZd2vatUqZLq1avnNK9u3bqaN2/eeZ8THR2tPXv2FLjcy8urwJYmlA2enp78mgMA4PMAwGXn0uHBY2Nj9csvvzjN2717t6Kjowt9ztGjR5WUlKRKlSpd7vIAAAAAXKNcGpSGDh2qn376SS+++KJ+/fVXzZo1Sx9++KEGDhwoSUpPT9fw4cO1Zs0a7du3TytXrlTnzp0VEhKie++915WlAwAAACjDXBqUbrrpJs2fP1+zZ89W/fr19fzzz2vKlCnq06ePJMnNzU3btm1Tly5dVLt2bfXv31+1a9fWmjVrFBAQ4MrSAQAAAJRhLh3M4Uq4mAu2AAAAAJRdF5MNXNqiBAAAAAClEUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANi4u7qAy80YI0lKTU11cSUAAAAAXCkvE+RlhPMp80EpLS1NkhQVFeXiSgAAAACUBmlpaQoKCjrvOg5TlDh1FcvNzdUff/yhgIAAORwOV5cDuERqaqqioqKUlJSkwMBAV5cDAHABPguAsy1JaWlpqly5ssqVO/9VSGW+RalcuXKqUqWKq8sASoXAwEA+HAHgGsdnAa51F2pJysNgDgAAAABgQ1ACAAAAABuCEnAN8PLy0rhx4+Tl5eXqUgAALsJnAXBxyvxgDgAAAABwsWhRAgAAAAAbghIAAAAA2BCUAAAAAMCGoASUYStXrpTD4dCJEyfOu15MTIymTJlyRWoCAJR+CQkJatSokavLAFyKwRyAMiwrK0vHjh1TeHi4HA6HPvnkEw0ZMiRfcDpy5Ij8/Pzk6+vrmkIBAC7jcDg0f/583XPPPda89PR0ZWZmqmLFiq4rDHAxd1cXAODy8fT0VERExAXXCw0NvQLVAACuFv7+/vL393d1GYBL0fUOcLG2bdvqqaee0lNPPaXg4GBVrFhRY8aMUV5j7/Hjx/XAAw+ofPny8vX1VceOHbVnzx7r+fv371fnzp1Vvnx5+fn56frrr9fixYslOXe9W7lypR588EGlpKTI4XDI4XAoISFBknPXu169eqlnz55ONZ45c0YhISGaOnWqJMkYo8mTJ6t69ery8fFRw4YN9dlnn13mMwUAZUvbtm01aNAgjRw5UhUqVFBERIT1d1mSUlJS9NhjjyksLEyBgYG65ZZb9PPPPztt44UXXlBYWJgCAgL0yCOP6Nlnn3XqMrd+/Xq1b99eISEhCgoKUlxcnDZt2mQtj4mJkSTde++9cjgc1uNzu94tXbpU3t7e+XojDBo0SHFxcdbj1atXq02bNvLx8VFUVJQGDRqkjIyMSz5PgKsQlIBSYNq0aXJ3d9fatWv15ptv6vXXX9dHH30kSYqPj9eGDRu0cOFCrVmzRsYYderUSWfOnJEkDRw4UJmZmfr++++1bds2TZo0qcBfAVu2bKkpU6YoMDBQhw4d0qFDhzR8+PB86/Xp00cLFy5Uenq6NW/p0qXKyMjQfffdJ0kaM2aMpk6dqvfee087duzQ0KFD1bdvXyUmJl6O0wMAZda0adPk5+entWvXavLkyXruuee0fPlyGWN055136vDhw1q8eLE2btyoJk2a6NZbb9WxY8ckSTNnztSECRM0adIkbdy4UVWrVtV7773ntP20tDT1799fP/zwg3766SfVqlVLnTp1UlpamqSzQUqSpk6dqkOHDlmPz3XbbbcpODhY8+bNs+bl5ORo7ty56tOnjyRp27Zt6tChg7p27aqtW7dqzpw5WrVqlZ566qnLct6AK8IAcKm4uDhTt25dk5uba80bNWqUqVu3rtm9e7eRZH788Udr2V9//WV8fHzM3LlzjTHGNGjQwCQkJBS47RUrVhhJ5vjx48YYY6ZOnWqCgoLyrRcdHW1ef/11Y4wxWVlZJiQkxEyfPt1a3qtXL9OtWzdjjDHp6enG29vbrF692mkbDz/8sOnVq9dFHz8AXKvi4uJMq1atnObddNNNZtSoUebbb781gYGB5vTp007La9SoYT744ANjjDHNmzc3AwcOdFoeGxtrGjZsWOg+s7OzTUBAgPnyyy+teZLM/PnzndYbN26c03YGDRpkbrnlFuvx0qVLjaenpzl27Jgxxph+/fqZxx57zGkbP/zwgylXrpw5depUofUApRktSkAp0KJFCzkcDuvxzTffrD179mjnzp1yd3dX8+bNrWUVK1ZUnTp1tGvXLklnuz688MILio2N1bhx47R169ZLqsXDw0PdunXTzJkzJUkZGRlasGCB9avhzp07dfr0abVv397qw+7v76/p06frt99+u6R9A8C15oYbbnB6XKlSJSUnJ2vjxo1KT09XxYoVnf7W7t271/pb+8svv6hZs2ZOz7c/Tk5O1hNPPKHatWsrKChIQUFBSk9P14EDBy6qzj59+mjlypX6448/JJ1tzerUqZPKly8vSdq4caM++eQTp1o7dOig3Nxc7d2796L2BZQWDOYAXIWMMVaweuSRR9ShQwctWrRIy5Yt08SJE/Xqq6/q6aefLvb2+/Tpo7i4OCUnJ2v58uXy9vZWx44dJUm5ubmSpEWLFikyMtLpeV5eXsXeJwBcizw8PJweOxwO5ebmKjc3V5UqVdLKlSvzPSc4ONhp/XMZ22DG8fHxOnLkiKZMmaLo6Gh5eXnp5ptvVlZW1kXV2axZM9WoUUP//ve/9eSTT2r+/PnWdavS2c+Gxx9/XIMGDcr33KpVq17UvoDSgqAElAI//fRTvse1atVSvXr1lJ2drbVr16ply5aSpKNHj2r37t2qW7eutX5UVJSeeOIJPfHEExo9erT++c9/FhiUPD09lZOTc8F6WrZsqaioKM2ZM0dLlixRt27d5OnpKUmqV6+evLy8dODAAaeLeAEAJadJkyY6fPiw3N3drQEW7OrUqaN169apX79+1rwNGzY4rfPDDz/o3XffVadOnSRJSUlJ+uuvv5zW8fDwKNJnQ+/evTVz5kxVqVJF5cqV05133ulU744dO1SzZs2iHiJQ6tH1DigFkpKS9Mwzz+iXX37R7Nmz9dZbb2nw4MGqVauWunTpokcffVSrVq3Szz//rL59+yoyMlJdunSRJA0ZMkRLly7V3r17tWnTJn333XdOIepcMTExSk9P17fffqu//vpLJ0+eLHA9h8Oh3r176/3339fy5cvVt29fa1lAQICGDx+uoUOHatq0afrtt9+0efNmvfPOO5o2bVrJnxwAuAbddtttuvnmm3XPPfdo6dKl2rdvn1avXq0xY8ZYYejpp5/Wxx9/rGnTpmnPnj164YUXtHXrVqdWppo1a+rTTz/Vrl27tHbtWvXp00c+Pj5O+4qJidG3336rw4cP6/jx44XW1KdPH23atEkTJkzQ/fffL29vb2vZqFGjtGbNGg0cOFBbtmzRnj17tHDhwkvq3QC4GkEJKAUeeOABnTp1Ss2aNdPAgQP19NNP67HHHpN0diSiG2+8UXfddZduvvlmGWO0ePFiq7tGTk6OBg4cqLp16+qOO+5QnTp19O677xa4n5YtW+qJJ55Qjx49FBoaqsmTJxdaU58+fbRz505FRkYqNjbWadnzzz+vf/zjH5o4caLq1q2rDh066Msvv1S1atVK6IwAwLXN4XBo8eLFatOmjR566CHVrl1bPXv21L59+xQeHi7p7N/p0aNHa/jw4WrSpIn27t2r+Ph4pwDzr3/9S8ePH1fjxo3Vr18/DRo0SGFhYU77evXVV7V8+XJFRUWpcePGhdZUq1Yt3XTTTdq6dat13WqeG264QYmJidqzZ49at26txo0ba+zYsapUqVIJnhXgynIYe2dWAFdU27Zt1ahRI+s+RgAAFFf79u0VERGhTz/91NWlAFc9rlECAAC4Cp08eVLvv/++OnToIDc3N82ePVvffPONli9f7urSgDKBoAQAAHAVyuue98ILLygzM1N16tTRvHnzdNttt7m6NKBMoOsdAAAAANgwmAMAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAFCqtW3bVkOGDHF1GfmsXLlSDodDJ06cuORtORwOffHFF5e8HQBAyeE+SgCAUmHlypVq166djh8/ruDgYGv+559/Lg8PD9cVdgUcOnRI5cuXlyTt27dP1apV0+bNm9WoUSPXFgYA1zCCEgCgVKtQoYKrS7hssrKy5OnpqYiICFeXAgCwoesdACAfY4wmT56s6tWry8fHRw0bNtRnn30m6f+6nC1dulSNGzeWj4+PbrnlFiUnJ2vJkiWqW7euAgMD1atXL508edLaZmZmpgYNGqSwsDB5e3urVatWWr9+vaSzrSjt2rWTJJUvX14Oh0Px8fGS8ne9O378uB544AGVL19evr6+6tixo/bs2WMt/+STTxQcHKylS5eqbt268vf31x133KFDhw5Z68THx+uee+7R+PHjFRYWpsDAQD3++OPKysoqUr0FOXr0qHr16qUqVarI19dXDRo00OzZs53Wadu2rZ566ik988wzCgkJUfv27SU5d72rVq2aJKlx48ZyOBxq27atvv/+e3l4eOjw4cNO2xs2bJjatGlT+AsJACg2ghIAIJ8xY8Zo6tSpeu+997Rjxw4NHTpUffv2VWJiorVOQkKC3n77ba1evVpJSUnq3r27pkyZolmzZmnRokVavny53nrrLWv9kSNHat68eZo2bZo2bdqkmjVrqkOHDjp27JiioqI0b948SdIvv/yiQ4cO6Y033iiwtvj4eG3YsEELFy7UmjVrZIxRp06ddObMGWudkydP6pVXXtGnn36q77//XgcOHNDw4cOdtvPtt99q165dWrFihWbPnq358+dr/PjxRaq3IKdPn9aNN96or776Stu3b9djjz2mfv36ae3atU7rTZs2Te7u7vrxxx/1wQcf5NvOunXrJEnffPONDh06pM8//1xt2rRR9erV9emnn1rrZWdna8aMGXrwwQcLrAcAcIkMAADnSE9PN97e3mb16tVO8x9++GHTq1cvs2LFCiPJfPPNN9ayiRMnGknmt99+s+Y9/vjjpkOHDtY2PTw8zMyZM63lWVlZpnLlymby5MnGGGNt9/jx4077jYuLM4MHDzbGGLN7924jyfz444/W8r/++sv4+PiYuXPnGmOMmTp1qpFkfv31V2udd955x4SHh1uP+/fvbypUqGAyMjKsee+9957x9/c3OTk5l1TvuTp16mSGDRvmdCyNGjXKt54kM3/+fGOMMXv37jWSzObNm53WmTRpkqlbt671+IsvvjD+/v4mPT290P0DAIqPFiUAgJOdO3fq9OnTat++vfz9/a1p+vTp+u2336z1brjhBuv/w8PD5evrq+rVqzvNS05OliT99ttvOnPmjGJjY63lHh4eatasmXbt2lXk2nbt2iV3d3c1b97cmlexYkXVqVPHaTu+vr6qUaOG9bhSpUpWLXkaNmwoX19f6/HNN9+s9PR0JSUlFavenJwcTZgwQTfccIMqVqwof39/LVu2TAcOHHBar2nTpkU+3nPFx8fr119/1U8//SRJ+te//qXu3bvLz8+vWNsDAJwfgzkAAJzk5uZKkhYtWqTIyEinZV5eXlZYOnckOofDkW9kOofDYW3LGGPNO5cxJt+888nbTkHzz91OQbUU9ly7c9e9mHpfffVVvf7665oyZYoaNGggPz8/DRkyxOm6J0nFDjZhYWHq3Lmzpk6dqurVq2vx4sVauXJlsbYFALgwWpQAAE7q1asnLy8vHThwQDVr1nSaoqKiirXNmjVrytPTU6tWrbLmnTlzRhs2bFDdunUlSZ6enpLOtsycr7bs7Gyn636OHj2q3bt3W9spqp9//lmnTp2yHv/000/y9/dXlSpVilSv3Q8//KAuXbqob9++atiwoapXr+40yERRne88PPLII/r3v/+tDz74QDVq1HBq8QIAlCxalAAATgICAjR8+HANHTpUubm5atWqlVJTU7V69Wr5+/srOjr6orfp5+enJ598UiNGjFCFChVUtWpVTZ48WSdPntTDDz8sSYqOjpbD4dBXX32lTp06ycfHR/7+/k7bqVWrlrp06aJHH31UH3zwgQICAvTss88qMjJSXbp0uaiasrKy9PDDD2vMmDHav3+/xo0bp6eeekrlypUrUr12NWvW1Lx587R69WqVL19er732mg4fPnzRAS4sLEw+Pj76+uuvVaVKFXl7eysoKEiS1KFDBwUFBemFF17Qc889d1HbBQBcHFqUAAD5PP/88/rHP/6hiRMnqm7duurQoYO+/PJLa+jq4njppZd03333qV+/fmrSpIl+/fVXLV261LrRamRkpMaPH69nn31W4eHheuqppwrcztSpU3XjjTfqrrvu0s033yxjjBYvXnzRN6W99dZbVatWLbVp00bdu3dX586dlZCQUOR67caOHasmTZqoQ4cOatu2rSIiInTPPfdcVE2S5O7urjfffFMffPCBKleu7BQAy5Urp/j4eOXk5OiBBx646G0DAIrOYYraaRsAgDIiPj5eJ06csO5ddDV59NFH9eeff2rhwoWuLgUAyjS63gEAcBVISUnR+vXrNXPmTC1YsMDV5QBAmUdQAgDgKtClSxetW7dOjz/+uNq3b+/qcgCgzKPrHQAAAADYMJgDAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAACb/wc36AVNNdz7zAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Bivariate Analysis ---\n", + "print(\"\\n--- Bivariate Analysis (Finding Relationships) ---\")\n", + "# Age vs. Emotion Polarity\n", + "plt.figure(figsize=(10, 6))\n", + "sns.boxplot(x='emotionpolarity', y='age', data=df, palette='coolwarm')\n", + "plt.title('Age Distribution vs. Emotion Polarity', fontsize=16)\n", + "plt.savefig('age_vs_emotion.png')\n", + "print(\"Generated 'age_vs_emotion.png' to see relationship between age and emotion.\")\n", + "\n", + "# Correlation Heatmap for numerical features\n", + "plt.figure(figsize=(14, 10))\n", + "numerical_cols = df.select_dtypes(include=['number'])\n", + "sns.heatmap(numerical_cols.corr(), annot=True, fmt='.2f', cmap='coolwarm')\n", + "plt.title('Correlation Heatmap of Numerical Features', fontsize=16)\n", + "plt.savefig('correlation_heatmap.png')\n", + "print(\"Generated 'correlation_heatmap.png' for numerical feature correlations.\")\n", + "\n", + "print(\"\\nEDA script finished successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3388591f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package stopwords to\n", + "[nltk_data] /home/unix_david/nltk_data...\n", + "[nltk_data] Package stopwords is already up-to-date!\n", + "[nltk_data] Downloading package wordnet to\n", + "[nltk_data] /home/unix_david/nltk_data...\n", + "[nltk_data] Package wordnet is already up-to-date!\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# --- Download NLTK data (only need to run once) ---\n", + "nltk.download('stopwords')\n", + "nltk.download('wordnet')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "99f02766", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Text Preprocessing ---\n", + "\n", + "Example of original vs. cleaned nursing note:\n", + "Original: Patient appeared withdrawn and tearful; emotional support provided.\n", + "Cleaned: patient appeared withdrawn tearful emotional support provided\n", + "\n", + "--- Pipeline Ready for Model Training ---\n" + ] + } + ], + "source": [ + "# --- Text Preprocessing ---\n", + "print(\"\\n--- Text Preprocessing ---\")\n", + "lemmatizer = WordNetLemmatizer()\n", + "stop_words = set(stopwords.words('english'))\n", + "\n", + "def clean_text(text):\n", + " # Remove punctuation and numbers\n", + " text = re.sub('[^a-zA-Z]', ' ', text)\n", + " # Convert to lowercase\n", + " text = text.lower()\n", + " # Tokenize\n", + " text = text.split()\n", + " # Lemmatize and remove stop words\n", + " text = [lemmatizer.lemmatize(word) for word in text if not word in stop_words]\n", + " text = ' '.join(text)\n", + " return text\n", + "\n", + "# Apply the cleaning function to the nursing notes\n", + "df['cleaned_note'] = df['nursingNote'].apply(clean_text)\n", + "\n", + "print(\"\\nExample of original vs. cleaned nursing note:\")\n", + "print(\"Original: \", df['nursingNote'][1])\n", + "print(\"Cleaned: \", df['cleaned_note'][1])\n", + "\n", + "\n", + "print(\"\\n--- Pipeline Ready for Model Training ---\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "90a1b666", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Deeper Data Profiling ---\n", + "\n", + "--- Profiling the Text Column ---\n", + "Average length of entries (in words): 7.16\n", + "Generated 'word_count_distribution.png' for word count distribution.\n", + "\n", + "Top 10 most common bigrams:\n", + "[(('patient', 'settled'), 141), (('settled', 'cooperative'), 141), (('cooperative', 'routine'), 141), (('routine', 'care'), 141), (('care', 'medication'), 141), (('medication', 'taken'), 141), (('taken', 'scheduled'), 141), (('scheduled', 'patient'), 141), (('hr', 'bp'), 89), (('patient', 'appeared'), 87)]\n", + "\n", + "Top 10 most common trigrams:\n", + "[(('patient', 'settled', 'cooperative'), 141), (('settled', 'cooperative', 'routine'), 141), (('cooperative', 'routine', 'care'), 141), (('routine', 'care', 'medication'), 141), (('care', 'medication', 'taken'), 141), (('medication', 'taken', 'scheduled'), 141), (('taken', 'scheduled', 'patient'), 141), (('patient', 'expressed', 'concern'), 76), (('expressed', 'concern', 'hr'), 76), (('concern', 'hr', 'bp'), 76)]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Deeper Data Profiling ---\n", + "print(\"\\n--- Deeper Data Profiling ---\")\n", + "\n", + "# --- 8.1 Profile your text column ---\n", + "print(\"\\n--- Profiling the Text Column ---\")\n", + "df['word_count'] = df['cleaned_note'].apply(lambda x: len(x.split()))\n", + "avg_word_count = df['word_count'].mean()\n", + "print(f\"Average length of entries (in words): {avg_word_count:.2f}\")\n", + "\n", + "# Distribution of entry lengths\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(data=df, x='word_count', bins=20, kde=True)\n", + "plt.title('Distribution of Note Length (in words)', fontsize=16)\n", + "plt.xlabel('Word Count', fontsize=12)\n", + "plt.savefig('word_count_distribution.png')\n", + "print(\"Generated 'word_count_distribution.png' for word count distribution.\")\n", + "\n", + "# Common n-grams\n", + "all_words = ' '.join(df['cleaned_note']).split()\n", + "# Bigrams\n", + "common_bigrams = Counter(ngrams(all_words, 2)).most_common(10)\n", + "print(\"\\nTop 10 most common bigrams:\")\n", + "print(common_bigrams)\n", + "# Trigrams\n", + "common_trigrams = Counter(ngrams(all_words, 3)).most_common(10)\n", + "print(\"\\nTop 10 most common trigrams:\")\n", + "print(common_trigrams)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "67abd5dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Profiling Emotion Labels ---\n", + "Generated 'emotion_tags_distribution.png' for specific emotion tags.\n", + "\n", + "Class distribution of emotionTags:\n", + "emotionTags\n", + "Calm 185\n", + "Worried 127\n", + "Sad 49\n", + "Happy 38\n", + "Agitated 27\n", + "Confused 22\n", + "Name: count, dtype: int64\n", + "\n", + "Note: Each entry appears to have a single emotion tag, not multiple labels.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_405475/479370261.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.countplot(y='emotionTags', data=df, order=df['emotionTags'].value_counts().index, palette='magma')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# --- Profile emotion labels ---\n", + "print(\"\\n--- Profiling Emotion Labels ---\")\n", + "# Using the more granular 'emotionTags' column\n", + "plt.figure(figsize=(10, 8))\n", + "sns.countplot(y='emotionTags', data=df, order=df['emotionTags'].value_counts().index, palette='magma')\n", + "plt.title('Distribution of Specific Emotion Tags', fontsize=16)\n", + "plt.xlabel('Count', fontsize=12)\n", + "plt.ylabel('Emotion Tag', fontsize=12)\n", + "plt.tight_layout()\n", + "plt.savefig('emotion_tags_distribution.png')\n", + "print(\"Generated 'emotion_tags_distribution.png' for specific emotion tags.\")\n", + "print(\"\\nClass distribution of emotionTags:\")\n", + "print(df['emotionTags'].value_counts())\n", + "print(\"\\nNote: Each entry appears to have a single emotion tag, not multiple labels.\")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "47a33833", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "---: Finding Cross Insights ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_405475/94455102.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(x='word_count', y='emotionTags', data=df, order=df['emotionTags'].value_counts().index, palette='viridis')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 'emotion_vs_note_length.png' showing relationship between emotions and note length.\n", + "Generated 'emotion_by_time_of_day.png' showing emotions across different times of day.\n", + "\n", + "--- Deep Profiling Complete. Pipeline Ready for Model Training ---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Cross insights ---\n", + "print(\"\\n---: Finding Cross Insights ---\")\n", + "# Do some emotions correlate with shorter/longer notes?\n", + "plt.figure(figsize=(12, 8))\n", + "sns.boxplot(x='word_count', y='emotionTags', data=df, order=df['emotionTags'].value_counts().index, palette='viridis')\n", + "plt.title('Note Length vs. Specific Emotion Tags', fontsize=16)\n", + "plt.xlabel('Word Count', fontsize=12)\n", + "plt.ylabel('Emotion Tag', fontsize=12)\n", + "plt.tight_layout()\n", + "plt.savefig('emotion_vs_note_length.png')\n", + "print(\"Generated 'emotion_vs_note_length.png' showing relationship between emotions and note length.\")\n", + "\n", + "# Do caregivers report more negative emotions at certain times of day?\n", + "df['observationStart'] = pd.to_datetime(df['observationStart'])\n", + "df['hour'] = df['observationStart'].dt.hour\n", + "\n", + "def get_time_of_day(hour):\n", + " if 5 <= hour < 12:\n", + " return 'Morning'\n", + " elif 12 <= hour < 17:\n", + " return 'Afternoon'\n", + " elif 17 <= hour < 21:\n", + " return 'Evening'\n", + " else:\n", + " return 'Night'\n", + "\n", + "df['time_of_day'] = df['hour'].apply(get_time_of_day)\n", + "\n", + "plt.figure(figsize=(10, 7))\n", + "sns.countplot(data=df, x='time_of_day', hue='emotionpolarity', order=['Morning', 'Afternoon', 'Evening', 'Night'], palette='coolwarm')\n", + "plt.title('Emotion Polarity Count by Time of Day', fontsize=16)\n", + "plt.xlabel('Time of Day', fontsize=12)\n", + "plt.ylabel('Count', fontsize=12)\n", + "plt.legend(title='Emotion Polarity')\n", + "plt.savefig('emotion_by_time_of_day.png')\n", + "print(\"Generated 'emotion_by_time_of_day.png' showing emotions across different times of day.\")\n", + "\n", + "\n", + "print(\"\\n--- Deep Profiling Complete. Pipeline Ready for Model Training ---\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/AI Guardian/emotion_analysis/emotion_dataset_V1.csv b/AI Guardian/emotion_analysis/emotion_dataset_V1.csv new file mode 100644 index 00000000..d297df9b --- /dev/null +++ b/AI Guardian/emotion_analysis/emotion_dataset_V1.csv @@ -0,0 +1,449 @@ +patientid,age,gender,observationStart,observationEnd,nursingNote,medications,heartRate,spo2,temperature,bloodPressure,stepsTaken,calorieIntake,sleepHours,waterIntakeMl,mealsSkipped,exerciseMinutes,bathroomVisits,behaviourTags,emotionTags,clinicalSummary,entitiesExtracted,baselineStats,alerts,state,emotionpolarity,adls.sleep_minutes,dose +P0035,87,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,75,93,36.5,193,103,95,6.3,257,0,5,,,Calm,,,,,,positive,378, +P0035,87,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,80,95,36.6,191,709,558,0.9,249,0,7,,,Sad,,,,,,negative,55,5mg +P0035,87,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,91,95,36.6,183,623,629,0.2,443,0,16,,,Calm,,,,,,positive,10,5mg +P0035,87,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient expressed concern; HR 96 and BP 146/64 slightly elevated.,Atorvastatin,96,93,36.5,210,1297,591,0.3,375,0,25,,,Worried,,,,,,negative,20,20mg +P0036,72,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,77,97,36.7,213,197,146,5.6,235,1,2,,,Sad,,,,,,negative,337, +P0036,72,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient resisted care and required reassurance. Medication was delayed this block.,Amlodipine,78,97,36.5,205,1158,578,0.6,375,0,9,,,Agitated,,,,,,negative,33,5mg +P0036,72,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,75,99,36.4,202,1610,679,0.2,451,0,10,,,Calm,,,,,,positive,14,5mg +P0036,72,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient expressed concern; HR 100 and BP 151/73 slightly elevated.,Simvastatin,100,99,36.6,224,718,616,0.8,284,0,9,,,Worried,,,,,,negative,46,20mg +P0037,74,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,78,96,36.6,200,200,4,6.6,164,0,1,,,Calm,,,,,,positive,394, +P0037,74,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was restless and sought reassurance.,Losartan,93,94,36.9,213,2047,297,0.3,429,0,9,,,Worried,,,,,,negative,19,50mg +P0037,74,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,72,94,36.8,204,2167,499,0.2,423,0,7,,,Confused,,,,,,negative,13,50mg +P0037,74,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,80,96,36.6,209,1152,410,0.6,594,0,8,,,Calm,,,,,,positive,38,10mg +P0038,65,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient expressed concern; HR 96 and BP 144/73 slightly elevated.,,96,92,37.2,217,53,166,6.1,273,0,2,,,Worried,,,,,,negative,367, +P0038,65,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient expressed concern; HR 99 and BP 148/71 slightly elevated.,Amlodipine,99,92,37,219,1177,446,0.7,440,0,1,,,Worried,,,,,,negative,40,5mg +P0038,65,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient expressed concern; HR 97 and BP 147/70 slightly elevated.,Amlodipine,97,94,37,217,1633,412,0,448,0,12,,,Worried,,,,,,negative,1,5mg +P0038,65,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient expressed concern; HR 100 and BP 143/69 slightly elevated.,Rosuvastatin,100,92,36.9,212,807,468,1,525,0,25,,,Worried,,,,,,negative,60,10mg +P0039,71,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,92,95,36.9,184,141,187,5,257,0,4,,,Calm,,,,,,positive,301, +P0039,71,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,80,95,36.9,169,646,262,0.8,291,0,1,,,Calm,,,,,,positive,47,50mg +P0039,71,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,79,95,36.7,161,3281,743,0.3,360,0,14,,,Calm,,,,,,positive,20,50mg +P0039,71,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,86,95,36.7,164,388,579,0.2,261,0,8,,,Calm,,,,,,positive,12,10mg +P0040,81,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 93 and BP 152/71 elevated.,Lorazepam,93,92,36.8,223,200,169,6,105,0,1,,,Agitated,,,,,,negative,359,0.5mg +P0040,81,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient expressed concern; HR 97 and BP 139/70 slightly elevated.,Losartan,97,92,37,209,1034,463,0.2,238,0,17,,,Worried,,,,,,negative,9,50mg +P0040,81,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient expressed concern; HR 98 and BP 147/69 slightly elevated.,Losartan,98,92,37,216,1447,743,0.2,387,0,7,,,Worried,,,,,,negative,14,50mg +P0040,81,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient expressed concern; HR 103 and BP 148/65 slightly elevated.,Atorvastatin,103,94,36.9,213,1372,836,0.4,263,0,6,,,Worried,,,,,,negative,26,20mg +P0041,82,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,65,98,36.3,188,174,188,5,100,0,5,,,Calm,,,,,,positive,303, +P0041,82,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,67,98,36.2,183,1892,576,0.5,239,0,14,,,Calm,,,,,,positive,30,50mg +P0041,82,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,69,96,36.2,185,2100,509,0.1,389,0,2,,,Sad,,,,,,negative,6,50mg +P0041,82,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,78,96,36.3,200,296,705,1,567,0,15,,,Calm,,,,,,positive,57,20mg +P0042,79,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,77,93,36.4,188,142,154,6.4,138,0,0,,,Sad,,,,,,negative,386, +P0042,79,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient resisted care and required reassurance.,Lisinopril,77,95,36.7,188,823,272,0.2,335,1,17,,,Agitated,,,,,,negative,10,5mg +P0042,79,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient expressed concern; HR 98 and BP 155/61 slightly elevated.,Lisinopril,98,95,36.5,216,3163,594,0.4,415,0,10,,,Worried,,,,,,negative,22,5mg +P0042,79,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Atorvastatin,85,93,36.8,199,616,487,0.4,333,0,21,,,Sad,,,,,,negative,25,20mg +P0043,77,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,66,94,37,191,3,200,5.1,278,0,2,,,Sad,,,,,,negative,305, +P0043,77,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,70,94,37,179,1495,543,0.6,452,0,6,,,Calm,,,,,,positive,38,5mg +P0043,77,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient expressed concern; HR 96 and BP 137/67 slightly elevated.,Lisinopril,96,96,37,204,2868,438,0.4,677,1,7,,,Worried,,,,,,negative,26,5mg +P0043,77,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,85,94,36.9,175,1418,713,1,420,1,21,,,Calm,,,,,,positive,60,20mg +P0044,65,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,,90,95,37,198,88,146,6.8,205,1,5,,,Happy,,,,,,positive,410, +P0044,65,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,76,93,37,199,2274,291,0,393,0,10,,,Calm,,,,,,positive,3,50mg +P0044,65,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,93,95,37,219,3388,429,0.2,308,0,26,,,Worried,,,,,,negative,12,50mg +P0044,65,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Atorvastatin,86,93,37,191,558,450,0.4,367,0,9,,,Sad,,,,,,negative,25,20mg +P0045,72,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,89,97,36.4,199,147,113,5.9,119,0,5,,,Calm,,,,,,positive,352, +P0045,72,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,78,97,36.4,211,1659,388,0.4,279,0,5,,,Calm,,,,,,positive,23,5mg +P0045,72,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Lisinopril,90,95,36.3,214,787,733,0.4,385,0,10,,,Happy,,,,,,positive,22,5mg +P0045,72,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Simvastatin,80,95,36.6,206,1459,430,0.3,545,0,1,,,Happy,,,,,,positive,19,20mg +P0046,89,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient expressed concern; HR 99 and BP 149/90 slightly elevated.,,99,95,36.9,239,67,92,6.8,185,0,3,,,Worried,,,,,,negative,405, +P0046,89,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient expressed concern; HR 92 and BP 150/87 slightly elevated.,Losartan,92,97,37.1,237,1033,279,0.2,259,0,12,,,Worried,,,,,,negative,11,50mg +P0046,89,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient resisted care and required reassurance.,Losartan,75,97,36.7,217,1486,492,0.1,456,0,13,,,Agitated,,,,,,negative,7,50mg +P0046,89,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,74,97,36.7,204,934,523,0.7,274,0,2,,,Calm,,,,,,positive,40,10mg +P0047,81,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,71,97,36.9,190,200,181,5.4,273,0,5,,,Calm,,,,,,positive,327, +P0047,81,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,71,99,36.6,168,2219,491,0.4,226,0,9,,,Sad,,,,,,negative,22,50mg +P0047,81,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,72,97,36.9,165,2699,430,0,456,0,4,,,Happy,,,,,,positive,1,50mg +P0047,81,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,81,97,36.8,192,1060,415,0,316,0,2,,,Calm,,,,,,positive,0,20mg +P0048,86,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,86,97,36.7,195,200,48,5.1,119,0,0,,,Sad,,,,,,negative,307, +P0048,86,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Amlodipine,79,97,37.1,198,1604,575,1,356,0,3,,,Sad,,,,,,negative,58,5mg +P0048,86,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,86,99,37,222,1300,623,0,591,0,21,,,Calm,,,,,,positive,0,5mg +P0048,86,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,91,97,37,213,604,520,0.2,531,1,16,,,Worried,,,,,,negative,13,20mg +P0049,67,Male,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient was restless and sought reassurance.,,90,95,36.1,205,19,154,6.9,134,0,4,,,Worried,,,,,,negative,416, +P0049,67,Male,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Amlodipine,83,95,36.3,198,2194,393,0.5,426,0,13,,,Happy,,,,,,positive,32,5mg +P0049,67,Male,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,85,93,36.3,206,2922,611,0.4,326,0,34,,,Calm,,,,,,positive,26,5mg +P0049,67,Male,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,82,95,36.4,205,779,666,0.9,216,0,18,,,Worried,,,,,,negative,52,20mg +P0050,85,Female,2025-06-01T00:00:00+10:00,2025-06-01T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,66,96,37.2,226,115,178,6.4,224,0,3,,,Calm,,,,,,positive,381, +P0050,85,Female,2025-06-01T06:00:00+10:00,2025-06-01T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,81,94,37.1,216,634,478,0.6,396,0,9,,,Calm,,,,,,positive,38,5mg +P0050,85,Female,2025-06-01T12:00:00+10:00,2025-06-01T18:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,85,96,37.1,209,1810,461,0.4,574,0,34,,,Worried,,,,,,negative,24,5mg +P0050,85,Female,2025-06-01T18:00:00+10:00,2025-06-02T00:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Simvastatin,68,94,36.9,219,1224,445,0,567,0,10,,,Happy,,,,,,positive,2,20mg +P0035,87,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,89,93,36.3,171,181,122,6.6,160,0,2,,,Calm,,,,,,positive,398, +P0035,87,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,86,95,36.5,184,908,421,0,467,0,6,,,Calm,,,,,,positive,3,5mg +P0035,87,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient expressed concern; HR 92 and BP 146/63 slightly elevated. Medication was missed this block.,Lisinopril,92,95,36.4,209,3071,619,0.1,662,0,20,,,Worried,,,,,,negative,4,5mg +P0035,87,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Atorvastatin,78,95,36.6,185,478,700,0.5,315,0,8,,,Confused,,,,,,negative,32,20mg +P0036,72,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,,87,97,36.6,223,200,10,6.8,245,1,1,,,Happy,,,,,,positive,409, +P0036,72,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,79,99,36.4,212,532,276,0.7,272,1,19,,,Calm,,,,,,positive,43,5mg +P0036,72,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,91,99,36.4,202,902,772,0,372,0,19,,,Calm,,,,,,positive,2,5mg +P0036,72,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Simvastatin,85,99,36.5,219,1499,527,0.5,404,0,25,,,Confused,,,,,,negative,32,20mg +P0037,74,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,72,96,36.9,198,11,47,5.8,163,0,5,,,Calm,,,,,,positive,348, +P0037,74,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Losartan,84,96,37,214,1596,364,0.4,485,0,15,,,Happy,,,,,,positive,21,50mg +P0037,74,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,74,96,36.6,211,1787,601,0.4,391,0,9,,,Happy,,,,,,positive,24,50mg +P0037,74,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,85,96,37,199,203,647,0,218,0,22,,,Calm,,,,,,positive,1,10mg +P0038,65,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient expressed concern; HR 95 and BP 145/77 slightly elevated.,,95,94,37,222,104,98,6.8,269,0,1,,,Worried,,,,,,negative,407, +P0038,65,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient expressed concern; HR 92 and BP 149/72 slightly elevated.,Amlodipine,92,92,37.2,221,763,362,0.2,243,0,10,,,Worried,,,,,,negative,11,5mg +P0038,65,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,78,94,37.1,210,2408,782,0.5,467,0,16,,,Worried,,,,,,negative,30,5mg +P0038,65,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient expressed concern; HR 101 and BP 155/69 slightly elevated.,Rosuvastatin,101,94,36.9,224,964,492,0.2,530,0,7,,,Worried,,,,,,negative,9,10mg +P0039,71,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,89,95,36.7,184,100,133,6.2,256,0,1,,,Sad,,,,,,negative,370, +P0039,71,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,81,95,36.9,183,2090,387,0.9,399,0,18,,,Calm,,,,,,positive,55,50mg +P0039,71,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,76,95,36.6,175,1561,759,0,406,1,2,,,Confused,,,,,,negative,0,50mg +P0039,71,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Rosuvastatin,90,93,36.5,175,231,673,0.3,499,1,6,,,Sad,,,,,,negative,16,10mg +P0040,81,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient was restless and sought reassurance.,Lorazepam,88,92,37.2,181,173,19,5.8,144,0,1,,,Worried,,,,,,negative,347,0.5mg +P0040,81,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,87,94,37.1,178,450,280,0.1,353,0,11,,,Calm,,,,,,positive,7,50mg +P0040,81,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,85,94,37.1,169,711,460,0.2,651,0,29,,,Worried,,,,,,negative,12,50mg +P0040,81,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient expressed concern; HR 96 and BP 141/69 slightly elevated.,Atorvastatin,96,92,37,210,1063,642,0.6,392,0,25,,,Worried,,,,,,negative,35,20mg +P0041,82,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 91 and BP 146/78 elevated.,,91,98,36.3,224,170,41,6.4,161,0,0,,,Agitated,,,,,,negative,387, +P0041,82,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,77,96,36.6,189,1216,535,0.9,258,0,3,,,Confused,,,,,,negative,52,50mg +P0041,82,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,96,36.5,189,2419,777,0,666,0,23,,,Calm,,,,,,positive,1,50mg +P0041,82,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,85,98,36.2,177,681,489,0,370,0,20,,,Calm,,,,,,positive,2,20mg +P0042,79,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,76,95,36.7,203,41,198,6.1,187,0,2,,,Calm,,,,,,positive,368, +P0042,79,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,79,95,36.5,200,2300,253,0.9,492,0,18,,,Calm,,,,,,positive,53,5mg +P0042,79,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Lisinopril,85,93,36.4,184,2617,530,0.4,573,1,23,,,Sad,,,,,,negative,27,5mg +P0042,79,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,73,95,36.7,194,286,597,0.4,533,0,14,,,Calm,,,,,,positive,23,20mg +P0043,77,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,69,96,36.8,181,46,133,6.8,178,0,1,,,Sad,,,,,,negative,406, +P0043,77,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,80,94,37.1,192,1543,534,0.4,249,0,17,,,Sad,,,,,,negative,26,5mg +P0043,77,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,70,94,37.1,189,3197,730,0.3,480,0,6,,,Calm,,,,,,positive,19,5mg +P0043,77,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Atorvastatin,75,96,37.1,173,246,459,0.6,376,0,14,,,Sad,,,,,,negative,36,20mg +P0044,65,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient expressed concern; HR 104 and BP 151/83 slightly elevated.,,104,93,36.8,234,57,136,6.2,133,0,0,,,Worried,,,,,,negative,374, +P0044,65,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,77,95,37,195,616,272,0.9,386,0,9,,,Calm,,,,,,positive,52,50mg +P0044,65,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,95,95,37,219,1204,744,0.4,401,0,14,,,Worried,,,,,,negative,21,50mg +P0044,65,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,76,93,36.8,191,397,749,0.6,322,1,1,,,Calm,,,,,,positive,36,20mg +P0045,72,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,74,97,36.2,208,79,80,6.2,233,0,1,,,Calm,,,,,,positive,375, +P0045,72,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,87,95,36.6,190,1305,311,0.3,346,0,9,,,Calm,,,,,,positive,19,5mg +P0045,72,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Lisinopril,87,95,36.3,200,1837,426,0.2,595,0,3,,,Happy,,,,,,positive,11,5mg +P0045,72,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was restless and sought reassurance.,Simvastatin,85,95,36.6,191,1099,808,0.5,540,0,19,,,Worried,,,,,,negative,29,20mg +P0046,89,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,87,97,37,201,41,77,5.1,255,0,2,,,Happy,,,,,,positive,308, +P0046,89,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,89,95,36.8,214,1262,487,0.3,246,0,16,,,Sad,,,,,,negative,16,50mg +P0046,89,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,74,95,36.8,222,2595,775,0.2,268,0,16,,,Calm,,,,,,positive,12,50mg +P0046,89,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,74,95,37,196,1136,521,0.2,413,0,11,,,Calm,,,,,,positive,14,10mg +P0047,81,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,78,99,37,169,62,169,5.8,292,0,2,,,Calm,,,,,,positive,348, +P0047,81,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,82,97,36.9,182,1611,285,0.1,330,0,18,,,Confused,,,,,,negative,4,50mg +P0047,81,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,84,99,37,171,2377,513,0.5,677,0,6,,,Confused,,,,,,negative,30,50mg +P0047,81,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,85,99,36.9,176,500,703,1,524,0,23,,,Calm,,,,,,positive,58,20mg +P0048,86,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient was restless and sought reassurance.,,89,97,37.1,206,125,98,5.8,198,0,5,,,Worried,,,,,,negative,346, +P0048,86,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient expressed concern; HR 94 and BP 146/75 slightly elevated.,Amlodipine,94,99,36.8,221,1756,473,0.1,420,0,14,,,Worried,,,,,,negative,5,5mg +P0048,86,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,90,97,36.8,212,2084,684,0,297,0,0,,,Worried,,,,,,negative,2,5mg +P0048,86,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient expressed concern; HR 100 and BP 154/73 slightly elevated.,Atorvastatin,100,99,36.9,227,466,734,0.3,269,0,1,,,Worried,,,,,,negative,20,20mg +P0049,67,Male,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,85,93,36.2,184,82,141,6.5,217,0,5,,,Sad,,,,,,negative,389, +P0049,67,Male,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient expressed concern; HR 94 and BP 146/74 slightly elevated.,Amlodipine,94,95,36.1,220,1336,523,0.7,339,0,10,,,Worried,,,,,,negative,40,5mg +P0049,67,Male,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,73,93,36.1,185,1638,682,0.4,437,0,7,,,Calm,,,,,,positive,22,5mg +P0049,67,Male,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,74,93,36.4,207,1314,605,0.4,231,0,15,,,Calm,,,,,,positive,27,20mg +P0050,85,Female,2025-06-02T00:00:00+10:00,2025-06-02T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,71,96,36.8,205,96,198,5.2,226,0,5,,,Calm,,,,,,positive,311, +P0050,85,Female,2025-06-02T06:00:00+10:00,2025-06-02T12:00:00+10:00,Patient expressed concern; HR 78 and BP 146/83 slightly elevated.,Lisinopril,78,94,37,229,482,456,0.5,449,0,11,,,Worried,,,,,,negative,31,5mg +P0050,85,Female,2025-06-02T12:00:00+10:00,2025-06-02T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,85,94,37.1,212,2777,482,0.1,595,0,25,,,Calm,,,,,,positive,7,5mg +P0050,85,Female,2025-06-02T18:00:00+10:00,2025-06-03T00:00:00+10:00,Patient expressed concern; HR 77 and BP 145/85 slightly elevated.,Simvastatin,77,94,37,230,880,697,0.2,240,0,18,,,Worried,,,,,,negative,11,20mg +P0035,87,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless and sought reassurance.,,78,93,36.4,176,128,18,5.8,220,0,1,,,Worried,,,,,,negative,348, +P0035,87,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 91 and BP 150/71 slightly elevated.,Lisinopril,91,93,36.6,221,1403,407,1,331,0,0,,,Worried,,,,,,negative,60,5mg +P0035,87,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,88,95,36.4,191,1105,715,0.5,463,0,2,,,Sad,,,,,,negative,29,5mg +P0035,87,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient expressed concern; HR 91 and BP 146/64 slightly elevated.,Atorvastatin,91,95,36.7,210,1067,546,1,512,0,4,,,Worried,,,,,,negative,58,20mg +P0036,72,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,81,99,36.6,212,80,140,5,136,0,0,,,Calm,,,,,,positive,303, +P0036,72,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,80,97,36.3,210,1168,474,0.6,374,0,2,,,Calm,,,,,,positive,38,5mg +P0036,72,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Amlodipine,75,99,36.5,214,2817,720,0.1,327,0,11,,,Happy,,,,,,positive,7,5mg +P0036,72,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was restless and sought reassurance.,Simvastatin,95,99,36.4,217,650,835,0.4,372,0,20,,,Worried,,,,,,negative,25,20mg +P0037,74,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless and sought reassurance.,,79,96,36.7,199,174,180,5.5,179,0,3,,,Worried,,,,,,negative,329, +P0037,74,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Losartan,85,96,36.8,195,909,349,0.1,428,0,20,,,Happy,,,,,,positive,8,50mg +P0037,74,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Losartan,85,94,36.7,204,2855,618,0.3,507,0,29,,,Happy,,,,,,positive,18,50mg +P0037,74,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,69,94,36.7,191,231,436,0.6,287,0,4,,,Calm,,,,,,positive,39,10mg +P0038,65,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation.,,94,92,36.9,222,199,35,7,112,1,5,,,Agitated,,,,,,negative,419, +P0038,65,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 99 and BP 144/78 slightly elevated.,Amlodipine,99,92,37.2,222,781,415,1,490,0,6,,,Worried,,,,,,negative,59,5mg +P0038,65,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,94,92,37,223,2207,721,0.3,370,0,10,,,Worried,,,,,,negative,19,5mg +P0038,65,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient expressed concern; HR 86 and BP 148/80 slightly elevated.,Rosuvastatin,86,94,37.2,228,1491,687,0,274,0,24,,,Worried,,,,,,negative,0,10mg +P0039,71,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,88,93,36.9,175,180,64,5.3,239,0,2,,,Happy,,,,,,positive,317, +P0039,71,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 99 and BP 150/67 slightly elevated.,Losartan,99,93,36.7,217,1620,438,0.5,431,0,18,,,Worried,,,,,,negative,30,50mg +P0039,71,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,87,93,36.7,184,742,619,0.1,368,0,28,,,Sad,,,,,,negative,6,50mg +P0039,71,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,79,95,36.6,179,1066,403,0.2,446,0,17,,,Calm,,,,,,positive,11,10mg +P0040,81,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless and sought reassurance.,,76,94,37,192,194,180,6.5,221,0,3,,,Worried,,,,,,negative,390, +P0040,81,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,88,92,37.1,188,650,410,0.2,255,0,17,,,Calm,,,,,,positive,11,50mg +P0040,81,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,95,94,36.8,213,921,606,0.4,266,0,32,,,Worried,,,,,,negative,27,50mg +P0040,81,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,95,92,37.2,209,819,720,0.2,401,0,8,,,Worried,,,,,,negative,14,20mg +P0041,82,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,70,98,36.4,187,200,114,5.6,297,0,3,,,Calm,,,,,,positive,338, +P0041,82,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,74,98,36.2,192,2428,557,0.5,321,0,4,,,Calm,,,,,,positive,28,50mg +P0041,82,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was disoriented to time/place and required cues. Medication was missed this block.,Losartan,85,96,36.6,183,1381,617,0.2,378,0,27,,,Confused,,,,,,negative,13,50mg +P0041,82,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,78,96,36.3,180,648,758,0.9,383,0,3,,,Calm,,,,,,positive,53,20mg +P0042,79,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient expressed concern; HR 99 and BP 142/70 slightly elevated.,,99,95,36.7,212,29,176,6.6,235,1,1,,,Worried,,,,,,negative,399, +P0042,79,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,93,93,36.7,209,634,537,0.9,438,0,4,,,Worried,,,,,,negative,54,5mg +P0042,79,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,89,93,36.7,195,1976,773,0.4,530,0,25,,,Calm,,,,,,positive,27,5mg +P0042,79,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Atorvastatin,83,93,36.6,185,254,422,1,416,0,2,,,Confused,,,,,,negative,60,20mg +P0043,77,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,69,94,36.9,190,89,143,5.9,237,0,5,,,Calm,,,,,,positive,352, +P0043,77,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 97 and BP 155/64 slightly elevated.,Lisinopril,97,96,37.1,219,480,306,1,328,0,15,,,Worried,,,,,,negative,58,5mg +P0043,77,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient expressed concern; HR 93 and BP 148/64 slightly elevated.,Lisinopril,93,94,36.9,212,2628,634,0,539,0,32,,,Worried,,,,,,negative,0,5mg +P0043,77,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,78,94,36.9,190,747,533,0.7,269,0,12,,,Worried,,,,,,negative,44,20mg +P0044,65,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was disoriented to time/place and required cues.,,78,93,37,193,74,27,6,146,0,4,,,Confused,,,,,,negative,361, +P0044,65,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 99 and BP 146/75 slightly elevated.,Losartan,99,95,37.1,221,1129,355,0.6,314,0,18,,,Worried,,,,,,negative,37,50mg +P0044,65,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient expressed concern; HR 103 and BP 144/74 slightly elevated.,Losartan,103,95,37.1,218,2223,621,0.4,267,0,25,,,Worried,,,,,,negative,22,50mg +P0044,65,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,89,93,37.1,197,704,886,0.9,374,0,3,,,Worried,,,,,,negative,53,20mg +P0045,72,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless and sought reassurance.,Lorazepam,87,97,36.4,200,121,63,5.6,249,1,2,,,Worried,,,,,,negative,333,0.5mg +P0045,72,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient expressed concern; HR 93 and BP 149/66 slightly elevated.,Lisinopril,93,97,36.5,215,2282,512,0.4,472,0,14,,,Worried,,,,,,negative,26,5mg +P0045,72,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,85,95,36.5,215,739,413,0,451,0,33,,,Sad,,,,,,negative,0,5mg +P0045,72,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient expressed concern; HR 100 and BP 149/65 slightly elevated.,Simvastatin,100,97,36.4,214,467,740,1,205,0,20,,,Worried,,,,,,negative,59,20mg +P0046,89,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,75,97,37,197,72,200,5.2,150,0,2,,,Sad,,,,,,negative,312, +P0046,89,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,89,97,36.8,196,1955,397,0.2,459,0,4,,,Calm,,,,,,positive,13,50mg +P0046,89,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,88,97,36.8,205,2814,596,0.5,685,0,29,,,Calm,,,,,,positive,30,50mg +P0046,89,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,87,95,36.8,209,395,629,0,406,0,18,,,Calm,,,,,,positive,3,10mg +P0047,81,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,79,97,36.6,165,44,25,5.4,190,0,1,,,Sad,,,,,,negative,321, +P0047,81,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,79,97,36.7,180,819,516,0.3,357,0,16,,,Calm,,,,,,positive,19,50mg +P0047,81,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,99,36.6,184,1377,520,0.2,520,0,34,,,Calm,,,,,,positive,11,50mg +P0047,81,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,83,97,36.9,179,1407,641,0.7,559,0,3,,,Calm,,,,,,positive,43,20mg +P0048,86,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,89,99,36.8,207,200,192,6.6,109,1,2,,,Calm,,,,,,positive,396, +P0048,86,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,82,99,37,203,892,444,0.4,404,0,19,,,Worried,,,,,,negative,26,5mg +P0048,86,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Amlodipine,82,99,36.8,195,1396,651,0.5,644,1,13,,,Sad,,,,,,negative,28,5mg +P0048,86,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,90,97,37,208,439,583,0.2,511,0,18,,,Calm,,,,,,positive,9,20mg +P0049,67,Male,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Paracetamol,76,93,36.3,183,40,44,5.5,110,0,5,,,Sad,,,,,,negative,329,500mg +P0049,67,Male,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,86,95,36.2,185,2318,592,1,214,0,4,,,Calm,,,,,,positive,58,5mg +P0049,67,Male,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,74,95,36.3,205,3104,401,0.4,303,0,11,,,Calm,,,,,,positive,24,5mg +P0049,67,Male,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,86,93,36.4,199,596,853,0.5,327,0,3,,,Calm,,,,,,positive,32,20mg +P0050,85,Female,2025-06-03T00:00:00+10:00,2025-06-03T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 68 and BP 146/74 elevated.,,68,94,36.9,220,200,0,5.8,282,0,2,,,Agitated,,,,,,negative,348, +P0050,85,Female,2025-06-03T06:00:00+10:00,2025-06-03T12:00:00+10:00,Patient resisted care and required reassurance.,Lisinopril,95,94,37,217,1583,390,0.7,243,0,13,,,Agitated,,,,,,negative,43,5mg +P0050,85,Female,2025-06-03T12:00:00+10:00,2025-06-03T18:00:00+10:00,Patient expressed concern; HR 92 and BP 145/81 slightly elevated.,Lisinopril,92,94,36.8,226,1698,423,0.1,293,0,26,,,Worried,,,,,,negative,6,5mg +P0050,85,Female,2025-06-03T18:00:00+10:00,2025-06-04T00:00:00+10:00,Patient was restless and sought reassurance.,Simvastatin,85,96,37,227,1183,871,1,268,0,20,,,Worried,,,,,,negative,59,20mg +P0035,87,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,89,93,36.5,183,1,41,5.9,136,0,1,,,Calm,,,,,,positive,352, +P0035,87,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,88,95,36.7,169,2170,488,0.4,378,0,7,,,Calm,,,,,,positive,27,5mg +P0035,87,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,94,95,36.7,205,2876,423,0.1,395,0,35,,,Worried,,,,,,negative,4,5mg +P0035,87,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,85,93,36.3,170,1092,619,0.8,351,0,25,,,Calm,,,,,,positive,49,20mg +P0036,72,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient was restless and sought reassurance.,,90,99,36.7,226,10,116,7,260,0,2,,,Worried,,,,,,negative,418, +P0036,72,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,87,97,36.5,225,1532,556,0.7,435,0,12,,,Calm,,,,,,positive,44,5mg +P0036,72,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,89,97,36.5,212,2323,601,0.1,534,0,4,,,Calm,,,,,,positive,4,5mg +P0036,72,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,90,97,36.3,214,651,874,0.3,258,0,11,,,Calm,,,,,,positive,18,20mg +P0037,74,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,78,96,36.8,190,143,41,5.8,130,0,4,,,Calm,,,,,,positive,345, +P0037,74,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,72,94,36.7,193,2225,570,0.7,394,0,6,,,Sad,,,,,,negative,42,50mg +P0037,74,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,83,96,36.9,187,1797,778,0,388,0,6,,,Happy,,,,,,positive,2,50mg +P0037,74,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,85,96,37,203,489,471,0.2,439,1,25,,,Calm,,,,,,positive,11,10mg +P0038,65,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient expressed concern; HR 100 and BP 144/78 slightly elevated.,,100,94,36.9,222,17,72,6.3,255,0,2,,,Worried,,,,,,negative,379, +P0038,65,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient expressed concern; HR 88 and BP 145/70 slightly elevated.,Amlodipine,88,94,37.1,215,2110,599,0.9,278,0,9,,,Worried,,,,,,negative,52,5mg +P0038,65,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Amlodipine,80,92,37.1,211,1030,414,0.3,511,0,1,,,Confused,,,,,,negative,20,5mg +P0038,65,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient expressed concern; HR 76 and BP 146/70 slightly elevated.,Rosuvastatin,76,94,37.1,216,298,665,0.7,361,1,16,,,Worried,,,,,,negative,44,10mg +P0039,71,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,77,95,36.8,179,120,152,6,271,0,4,,,Happy,,,,,,positive,358, +P0039,71,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient resisted care and required reassurance.,Losartan,81,93,36.9,167,406,426,0.1,446,1,6,,,Agitated,,,,,,negative,5,50mg +P0039,71,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,86,95,36.8,177,2080,605,0.4,639,0,1,,,Calm,,,,,,positive,23,50mg +P0039,71,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Rosuvastatin,79,93,36.8,184,1141,731,0.3,305,0,7,,,Sad,,,,,,negative,16,10mg +P0040,81,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,90,92,37.2,181,110,73,6.5,137,0,4,,,Sad,,,,,,negative,388, +P0040,81,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,74,94,36.8,188,1693,449,0.2,404,0,6,,,Sad,,,,,,negative,13,50mg +P0040,81,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient expressed concern; HR 98 and BP 145/69 slightly elevated.,Losartan,98,92,36.9,214,1252,747,0.2,496,0,21,,,Worried,,,,,,negative,12,50mg +P0040,81,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient expressed concern; HR 91 and BP 145/73 slightly elevated.,Atorvastatin,91,94,37.1,218,1172,837,0.1,581,0,4,,,Worried,,,,,,negative,5,20mg +P0041,82,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,,76,98,36.5,198,147,82,6.3,267,1,2,,,Happy,,,,,,positive,377, +P0041,82,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,75,96,36.3,188,2498,518,0.6,294,0,11,,,Calm,,,,,,positive,39,50mg +P0041,82,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,98,36.3,185,1149,657,0.3,686,1,25,,,Calm,,,,,,positive,17,50mg +P0041,82,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient expressed concern; HR 100 and BP 138/79 slightly elevated.,Simvastatin,100,96,36.3,217,1492,624,0.5,410,0,23,,,Worried,,,,,,negative,29,20mg +P0042,79,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient was restless and sought reassurance.,,87,95,36.7,203,81,139,6.4,296,1,0,,,Worried,,,,,,negative,385, +P0042,79,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient expressed concern; HR 94 and BP 148/62 slightly elevated.,Lisinopril,94,93,36.7,210,2111,562,0.8,459,0,10,,,Worried,,,,,,negative,45,5mg +P0042,79,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,84,93,36.6,198,2408,594,0,535,0,1,,,Calm,,,,,,positive,0,5mg +P0042,79,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,90,95,36.6,206,299,620,0.1,557,0,14,,,Worried,,,,,,negative,8,20mg +P0043,77,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,78,94,37,182,200,54,5.8,135,1,4,,,Calm,,,,,,positive,348, +P0043,77,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,75,96,36.8,174,498,392,0.3,222,0,12,,,Calm,,,,,,positive,16,5mg +P0043,77,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,85,94,37,185,2653,668,0.4,253,1,29,,,Calm,,,,,,positive,22,5mg +P0043,77,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,Atorvastatin,70,96,37.2,183,924,408,0.6,414,1,13,,,Happy,,,,,,positive,34,20mg +P0044,65,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,86,93,37,202,107,56,5.1,200,0,5,,,Calm,,,,,,positive,307, +P0044,65,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,86,95,37.1,195,881,362,0.1,393,0,9,,,Sad,,,,,,negative,8,50mg +P0044,65,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,86,93,37.2,185,1379,578,0.2,678,0,12,,,Happy,,,,,,positive,12,50mg +P0044,65,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,80,95,36.8,198,1132,615,0.5,431,0,10,,,Calm,,,,,,positive,30,20mg +P0045,72,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,90,97,36.2,203,99,197,7,200,0,0,,,Calm,,,,,,positive,419, +P0045,72,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,76,97,36.3,200,934,416,0.4,451,0,0,,,Calm,,,,,,positive,27,5mg +P0045,72,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Lisinopril,88,95,36.3,189,3452,437,0.2,352,0,26,,,Happy,,,,,,positive,12,5mg +P0045,72,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Simvastatin,89,97,36.4,190,1084,447,0.7,265,0,3,,,Confused,,,,,,negative,42,20mg +P0046,89,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,74,95,37,219,77,7,6.9,237,1,3,,,Calm,,,,,,positive,412, +P0046,89,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,89,97,36.8,198,1711,500,0.4,465,0,4,,,Happy,,,,,,positive,24,50mg +P0046,89,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient expressed concern; HR 97 and BP 142/91 slightly elevated.,Losartan,97,95,36.8,233,754,663,0,288,0,28,,,Worried,,,,,,negative,2,50mg +P0046,89,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,87,97,36.7,207,1114,531,0.2,329,0,7,,,Calm,,,,,,positive,9,10mg +P0047,81,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient was disoriented to time/place and required cues.,,80,97,36.8,179,45,86,5.6,144,0,2,,,Confused,,,,,,negative,338, +P0047,81,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient expressed concern; HR 91 and BP 145/69 slightly elevated.,Losartan,91,99,37,214,2084,331,0.1,341,0,5,,,Worried,,,,,,negative,8,50mg +P0047,81,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Medication was missed this block.,Losartan,83,97,36.7,186,2648,531,0.2,518,0,11,,,Sad,,,,,,negative,13,50mg +P0047,81,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Atorvastatin,85,99,36.7,172,1300,548,0.5,290,0,23,,,Confused,,,,,,negative,29,20mg +P0048,86,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,81,97,36.9,223,200,193,6.5,224,0,2,,,Calm,,,,,,positive,388, +P0048,86,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Amlodipine,81,99,36.7,213,2135,343,0.3,390,0,0,,,Happy,,,,,,positive,16,5mg +P0048,86,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,78,99,36.9,208,1420,472,0.4,288,0,11,,,Calm,,,,,,positive,21,5mg +P0048,86,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,79,99,36.7,208,1484,787,0.4,535,0,2,,,Calm,,,,,,positive,27,20mg +P0049,67,Male,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,77,95,36.2,194,200,134,5.9,292,0,1,,,Sad,,,,,,negative,355, +P0049,67,Male,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Amlodipine,77,93,36.3,186,1640,449,0.2,428,0,17,,,Happy,,,,,,positive,12,5mg +P0049,67,Male,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Amlodipine,84,93,36.5,196,3419,634,0.4,308,0,17,,,Happy,,,,,,positive,24,5mg +P0049,67,Male,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,71,95,36.2,196,675,701,0.4,384,0,9,,,Calm,,,,,,positive,27,20mg +P0050,85,Female,2025-06-04T00:00:00+10:00,2025-06-04T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 67 and BP 147/76 elevated.,,67,96,37.1,223,200,27,6.2,172,0,5,,,Agitated,,,,,,negative,372, +P0050,85,Female,2025-06-04T06:00:00+10:00,2025-06-04T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,76,94,36.9,220,755,598,0.2,236,0,16,,,Calm,,,,,,positive,9,5mg +P0050,85,Female,2025-06-04T12:00:00+10:00,2025-06-04T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,85,96,36.9,207,1116,457,0,537,0,26,,,Sad,,,,,,negative,0,5mg +P0050,85,Female,2025-06-04T18:00:00+10:00,2025-06-05T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Simvastatin,85,94,37.1,210,965,835,0.8,342,0,22,,,Confused,,,,,,negative,51,20mg +P0035,87,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,75,93,36.7,192,187,95,5.8,165,0,3,,,Happy,,,,,,positive,345, +P0035,87,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,86,93,36.5,180,1222,424,0.6,252,0,7,,,Calm,,,,,,positive,35,5mg +P0035,87,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,91,93,36.6,194,1801,744,0.4,573,1,8,,,Calm,,,,,,positive,27,5mg +P0035,87,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,88,93,36.6,193,1030,512,0.9,391,0,18,,,Calm,,,,,,positive,54,20mg +P0036,72,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was restless and sought reassurance.,Lorazepam,95,99,36.6,214,200,49,6,114,0,4,,,Worried,,,,,,negative,360,0.5mg +P0036,72,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,80,99,36.6,225,787,287,0.2,480,0,0,,,Calm,,,,,,positive,11,5mg +P0036,72,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,90,97,36.6,217,2308,685,0.2,395,0,7,,,Calm,,,,,,positive,11,5mg +P0036,72,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,86,97,36.3,219,634,829,0.4,600,0,23,,,Calm,,,,,,positive,27,20mg +P0037,74,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was restless and sought reassurance.,,79,94,36.8,196,200,11,5.5,273,1,2,,,Worried,,,,,,negative,329, +P0037,74,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,84,96,36.6,195,1671,474,0.3,434,0,16,,,Sad,,,,,,negative,20,50mg +P0037,74,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,80,96,36.7,194,1235,406,0.4,268,0,12,,,Worried,,,,,,negative,22,50mg +P0037,74,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 101 and BP 150/63 slightly elevated.,Rosuvastatin,101,94,36.6,213,1461,696,0,540,0,2,,,Worried,,,,,,negative,1,10mg +P0038,65,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 100 and BP 137/80 elevated.,Lorazepam,100,94,36.8,217,200,155,6.8,149,0,2,,,Agitated,,,,,,negative,407,0.5mg +P0038,65,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient expressed concern; HR 97 and BP 149/81 slightly elevated.,Amlodipine,97,92,37.2,230,1308,465,0.5,448,1,9,,,Worried,,,,,,negative,31,5mg +P0038,65,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,87,92,36.8,200,3260,666,0.2,420,0,0,,,Worried,,,,,,negative,13,5mg +P0038,65,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 93 and BP 150/77 slightly elevated.,Rosuvastatin,93,92,36.9,227,692,654,0.2,238,0,5,,,Worried,,,,,,negative,14,10mg +P0039,71,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,78,95,36.6,162,66,154,6.2,209,0,4,,,Calm,,,,,,positive,373, +P0039,71,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was restless and sought reassurance.,Losartan,92,95,36.7,181,1812,404,0.1,242,0,13,,,Worried,,,,,,negative,6,50mg +P0039,71,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient resisted care and required reassurance.,Losartan,94,95,36.8,200,2645,771,0.2,578,0,15,,,Agitated,,,,,,negative,14,50mg +P0039,71,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was restless and sought reassurance.,Rosuvastatin,89,93,36.5,163,1161,589,0.2,394,0,25,,,Worried,,,,,,negative,9,10mg +P0040,81,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 97 and BP 137/69 elevated.,Lorazepam,97,92,37.1,206,141,192,6,143,1,3,,,Agitated,,,,,,negative,358,0.5mg +P0040,81,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient expressed concern; HR 90 and BP 148/65 slightly elevated.,Losartan,90,94,36.9,213,2156,462,0.6,357,0,9,,,Worried,,,,,,negative,37,50mg +P0040,81,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,86,92,36.8,171,2327,456,0.1,438,0,30,,,Calm,,,,,,positive,5,50mg +P0040,81,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 97 and BP 143/61 slightly elevated.,Atorvastatin,97,94,37.2,204,903,454,0.7,572,0,11,,,Worried,,,,,,negative,44,20mg +P0041,82,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,75,98,36.5,192,199,167,6.3,142,1,1,,,Calm,,,,,,positive,377, +P0041,82,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,65,96,36.4,203,1250,300,0.4,403,0,12,,,Calm,,,,,,positive,26,50mg +P0041,82,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,98,36.5,182,661,793,0,468,0,35,,,Calm,,,,,,positive,0,50mg +P0041,82,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 99 and BP 152/71 slightly elevated.,Simvastatin,99,96,36.4,223,1101,880,0.4,444,0,5,,,Worried,,,,,,negative,26,20mg +P0042,79,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was disoriented to time/place and required cues.,,75,93,36.5,193,64,22,7,264,0,4,,,Confused,,,,,,negative,419, +P0042,79,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient expressed concern; HR 104 and BP 143/69 slightly elevated.,Lisinopril,104,93,36.6,212,2428,596,0.7,218,0,19,,,Worried,,,,,,negative,40,5mg +P0042,79,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient expressed concern; HR 97 and BP 137/69 slightly elevated.,Lisinopril,97,93,36.6,206,3099,441,0.2,523,0,16,,,Worried,,,,,,negative,15,5mg +P0042,79,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 101 and BP 150/71 slightly elevated.,Atorvastatin,101,93,36.4,221,533,789,0.4,519,0,18,,,Worried,,,,,,negative,24,20mg +P0043,77,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,,66,94,37.2,181,200,96,5.2,280,1,0,,,Happy,,,,,,positive,315, +P0043,77,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,77,94,37.1,181,2175,311,0.6,349,0,18,,,Calm,,,,,,positive,38,5mg +P0043,77,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Lisinopril,66,94,37.2,181,3173,556,0.3,362,0,9,,,Happy,,,,,,positive,18,5mg +P0043,77,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient expressed concern; HR 99 and BP 144/75 slightly elevated.,Atorvastatin,99,94,36.8,219,745,650,0.3,369,0,11,,,Worried,,,,,,negative,16,20mg +P0044,65,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient was restless and sought reassurance.,,86,95,37.1,214,174,93,5.7,155,0,0,,,Worried,,,,,,negative,343, +P0044,65,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was restless and sought reassurance.,Losartan,90,95,37,187,661,341,0.8,484,0,12,,,Worried,,,,,,negative,50,50mg +P0044,65,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient expressed concern; HR 98 and BP 149/83 slightly elevated.,Losartan,98,93,37,232,1214,759,0.2,657,0,23,,,Worried,,,,,,negative,11,50mg +P0044,65,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Atorvastatin,86,95,37,197,769,696,0.4,416,1,13,,,Sad,,,,,,negative,25,20mg +P0045,72,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient expressed concern; HR 90 and BP 146/74 slightly elevated.,,90,95,36.2,220,112,44,6.9,300,0,0,,,Worried,,,,,,negative,412, +P0045,72,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,77,97,36.5,211,1030,287,0.5,367,0,15,,,Calm,,,,,,positive,30,5mg +P0045,72,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,78,95,36.5,205,2690,651,0.3,375,0,15,,,Calm,,,,,,positive,16,5mg +P0045,72,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,88,95,36.2,208,1274,501,0.5,281,0,0,,,Calm,,,,,,positive,32,20mg +P0046,89,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,89,97,36.8,199,182,169,5.8,278,0,4,,,Happy,,,,,,positive,347, +P0046,89,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,88,97,36.9,199,1170,398,0.8,499,0,18,,,Calm,,,,,,positive,49,50mg +P0046,89,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,84,95,36.8,195,2949,761,0.5,566,0,15,,,Calm,,,,,,positive,29,50mg +P0046,89,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient resisted care and required reassurance.,Rosuvastatin,77,97,37,203,1029,412,0.3,462,1,12,,,Agitated,,,,,,negative,17,10mg +P0047,81,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,68,97,36.7,187,200,117,6.6,167,0,0,,,Calm,,,,,,positive,399, +P0047,81,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,71,99,36.9,191,965,443,0.5,384,0,14,,,Calm,,,,,,positive,29,50mg +P0047,81,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,71,97,37,177,1510,799,0.5,463,0,0,,,Calm,,,,,,positive,30,50mg +P0047,81,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,85,99,36.7,169,596,414,0.4,290,0,25,,,Calm,,,,,,positive,25,20mg +P0048,86,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient expressed concern; HR 100 and BP 141/80 slightly elevated.,,100,97,37,221,76,43,6.2,270,1,2,,,Worried,,,,,,negative,372, +P0048,86,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,81,99,36.8,206,1190,567,0.4,484,0,4,,,Worried,,,,,,negative,21,5mg +P0048,86,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,80,99,36.8,205,2009,620,0.2,453,0,0,,,Calm,,,,,,positive,14,5mg +P0048,86,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,87,97,37,208,783,648,0.2,317,0,2,,,Worried,,,,,,negative,9,20mg +P0049,67,Male,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,,87,93,36.3,200,200,19,5.8,161,0,0,,,Happy,,,,,,positive,348, +P0049,67,Male,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient expressed concern; HR 99 and BP 154/73 slightly elevated.,Amlodipine,99,93,36.2,227,875,595,0.7,471,0,20,,,Worried,,,,,,negative,42,5mg +P0049,67,Male,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Amlodipine,87,95,36.3,190,2178,665,0,625,0,18,,,Sad,,,,,,negative,1,5mg +P0049,67,Male,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Atorvastatin,85,93,36.1,209,391,697,0.1,487,0,22,,,Happy,,,,,,positive,7,20mg +P0050,85,Female,2025-06-05T00:00:00+10:00,2025-06-05T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,79,96,36.8,205,152,21,5.8,218,0,4,,,Calm,,,,,,positive,347, +P0050,85,Female,2025-06-05T06:00:00+10:00,2025-06-05T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,79,96,36.9,227,681,533,0.9,220,0,15,,,Calm,,,,,,positive,52,5mg +P0050,85,Female,2025-06-05T12:00:00+10:00,2025-06-05T18:00:00+10:00,Patient expressed concern; HR 92 and BP 145/75 slightly elevated.,Lisinopril,92,94,37,220,1300,590,0.4,459,0,15,,,Worried,,,,,,negative,21,5mg +P0050,85,Female,2025-06-05T18:00:00+10:00,2025-06-06T00:00:00+10:00,Patient resisted care and required reassurance. Medication was refused this block.,Simvastatin,85,94,37.2,207,1382,521,0.7,540,0,20,,,Agitated,,,,,,negative,41,20mg +P0035,87,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,91,93,36.5,192,2,81,6.2,225,0,0,,,Calm,,,,,,positive,375, +P0035,87,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Lisinopril,86,95,36.4,185,2446,511,0.8,295,0,0,,,Happy,,,,,,positive,51,5mg +P0035,87,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,85,95,36.5,193,2112,634,0.3,700,0,29,,,Calm,,,,,,positive,19,5mg +P0035,87,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety. Medication was missed this block.,Atorvastatin,87,93,36.4,181,1098,466,0.5,496,0,18,,,Confused,,,,,,negative,31,20mg +P0036,72,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,86,99,36.5,223,200,149,7,282,0,5,,,Sad,,,,,,negative,420, +P0036,72,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Amlodipine,85,97,36.4,218,1828,537,0.9,356,0,20,,,Sad,,,,,,negative,54,5mg +P0036,72,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Amlodipine,86,99,36.5,213,1313,601,0.5,508,0,29,,,Sad,,,,,,negative,29,5mg +P0036,72,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Simvastatin,79,97,36.6,220,226,693,0.9,442,0,16,,,Sad,,,,,,negative,52,20mg +P0037,74,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,84,94,36.8,200,198,170,6.2,246,1,5,,,Calm,,,,,,positive,369, +P0037,74,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Losartan,73,94,36.8,207,1944,526,0.8,315,0,6,,,Happy,,,,,,positive,45,50mg +P0037,74,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,85,94,36.8,185,838,528,0.2,684,0,23,,,Sad,,,,,,negative,15,50mg +P0037,74,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,84,94,36.9,200,387,731,0.4,375,0,3,,,Calm,,,,,,positive,26,10mg +P0038,65,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 98 and BP 147/81 elevated.,,98,92,37.2,228,152,192,6.9,256,0,4,,,Agitated,,,,,,negative,415, +P0038,65,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,90,92,36.9,221,1262,516,0.7,308,0,14,,,Worried,,,,,,negative,40,5mg +P0038,65,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was restless and sought reassurance.,Amlodipine,85,92,36.9,203,2177,445,0.1,295,0,10,,,Worried,,,,,,negative,7,5mg +P0038,65,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,88,92,37.1,204,1469,892,0.7,446,0,23,,,Calm,,,,,,positive,44,10mg +P0039,71,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 94 and BP 149/67 elevated.,,94,93,36.8,216,181,130,5.3,285,0,1,,,Agitated,,,,,,negative,317, +P0039,71,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,91,93,36.6,178,1842,551,0.2,254,0,15,,,Confused,,,,,,negative,14,50mg +P0039,71,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient appeared cheerful and completed light exercise. Good appetite noted.,Losartan,89,95,36.8,166,3395,650,0.4,574,0,33,,,Happy,,,,,,positive,27,50mg +P0039,71,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,82,93,36.6,183,1025,522,0.1,240,0,10,,,Calm,,,,,,positive,7,10mg +P0040,81,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was restless and sought reassurance.,,88,92,36.9,172,90,90,5.2,110,0,2,,,Worried,,,,,,negative,312, +P0040,81,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient expressed concern; HR 101 and BP 138/73 slightly elevated.,Losartan,101,94,37.2,211,741,537,0,292,0,14,,,Worried,,,,,,negative,1,50mg +P0040,81,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was restless and sought reassurance.,Losartan,93,94,37.2,206,809,772,0.4,564,0,1,,,Worried,,,,,,negative,26,50mg +P0040,81,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient resisted care and required reassurance.,Atorvastatin,93,94,37.2,204,351,864,0.4,476,0,15,,,Agitated,,,,,,negative,25,20mg +P0041,82,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,65,96,36.5,197,150,144,6.3,230,0,1,,,Calm,,,,,,positive,376, +P0041,82,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient resisted care and required reassurance.,Losartan,70,98,36.3,202,1878,327,0.7,282,0,8,,,Agitated,,,,,,negative,41,50mg +P0041,82,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,69,96,36.3,205,3464,661,0.5,676,0,13,,,Confused,,,,,,negative,29,50mg +P0041,82,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,85,96,36.4,182,1346,563,1,565,0,24,,,Calm,,,,,,positive,59,20mg +P0042,79,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff.,,78,93,36.6,183,70,89,5.3,220,1,1,,,Happy,,,,,,positive,317, +P0042,79,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,83,95,36.6,183,818,345,0.4,264,0,4,,,Calm,,,,,,positive,27,5mg +P0042,79,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,87,93,36.5,193,2510,666,0,328,0,18,,,Calm,,,,,,positive,2,5mg +P0042,79,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,89,93,36.4,207,416,402,0.9,548,0,1,,,Calm,,,,,,positive,54,20mg +P0043,77,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 99 and BP 147/67 elevated.,,99,96,36.9,214,200,26,6.8,107,0,1,,,Agitated,,,,,,negative,410, +P0043,77,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Lisinopril,68,96,36.8,187,2225,419,0.3,243,1,1,,,Sad,,,,,,negative,17,5mg +P0043,77,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,76,96,37,168,938,617,0.4,274,0,6,,,Calm,,,,,,positive,22,5mg +P0043,77,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Atorvastatin,66,94,36.9,181,981,545,0.7,382,0,11,,,Happy,,,,,,positive,44,20mg +P0044,65,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 99 and BP 138/81 elevated.,,99,95,36.9,219,189,56,6.7,268,0,3,,,Agitated,,,,,,negative,402, +P0044,65,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,77,93,36.9,198,1570,486,0.9,256,0,0,,,Calm,,,,,,positive,53,50mg +P0044,65,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,77,95,37,198,3089,754,0.1,311,0,19,,,Calm,,,,,,positive,6,50mg +P0044,65,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,90,95,37.1,212,548,760,0.7,432,0,20,,,Calm,,,,,,positive,41,20mg +P0045,72,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient was disoriented to time/place and required cues.,,88,97,36.5,212,71,159,5.9,243,0,4,,,Confused,,,,,,negative,354, +P0045,72,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,77,97,36.2,200,1792,414,0.8,393,0,18,,,Calm,,,,,,positive,46,5mg +P0045,72,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,84,97,36.4,201,878,463,0.1,338,0,19,,,Calm,,,,,,positive,5,5mg +P0045,72,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient showed evening disorientation and needed redirection for safety.,Simvastatin,85,97,36.3,197,806,829,0.3,524,1,23,,,Confused,,,,,,negative,18,20mg +P0046,89,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,86,97,36.8,213,135,43,6.1,132,0,1,,,Calm,,,,,,positive,365, +P0046,89,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,79,95,36.8,200,1337,285,0.4,306,0,12,,,Calm,,,,,,positive,22,50mg +P0046,89,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,97,36.8,201,1608,429,0.2,545,0,26,,,Calm,,,,,,positive,15,50mg +P0046,89,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,85,95,36.9,196,1388,484,0.5,536,0,23,,,Calm,,,,,,positive,31,10mg +P0047,81,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,,78,97,36.6,176,31,107,6.9,172,0,5,,,Sad,,,,,,negative,415, +P0047,81,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Losartan,72,99,36.7,191,784,598,0.1,280,0,14,,,Sad,,,,,,negative,6,50mg +P0047,81,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was disoriented to time/place and required cues.,Losartan,82,99,36.7,177,1361,760,0.3,454,0,7,,,Confused,,,,,,negative,16,50mg +P0047,81,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Atorvastatin,72,99,36.8,174,816,688,0.3,598,0,2,,,Sad,,,,,,negative,20,20mg +P0048,86,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,88,99,37.1,210,159,108,5.6,198,0,1,,,Calm,,,,,,positive,339, +P0048,86,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Amlodipine,78,97,36.8,208,2048,294,0.9,495,0,12,,,Sad,,,,,,negative,53,5mg +P0048,86,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient resisted care and required reassurance.,Amlodipine,89,99,36.9,206,1298,478,0.3,349,0,9,,,Agitated,,,,,,negative,17,5mg +P0048,86,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient resisted care and required reassurance.,Atorvastatin,92,99,37.1,199,1420,811,0.9,434,0,19,,,Agitated,,,,,,negative,56,20mg +P0049,67,Male,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient expressed concern; HR 94 and BP 150/68 slightly elevated.,,94,95,36.3,218,85,66,6,199,1,0,,,Worried,,,,,,negative,358, +P0049,67,Male,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient resisted care and required reassurance.,Amlodipine,74,93,36.4,189,1618,594,1,266,0,9,,,Agitated,,,,,,negative,58,5mg +P0049,67,Male,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient expressed concern; HR 93 and BP 148/75 slightly elevated.,Amlodipine,93,93,36.4,223,2896,597,0.1,519,0,19,,,Worried,,,,,,negative,7,5mg +P0049,67,Male,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient expressed concern; HR 105 and BP 144/66 slightly elevated.,Atorvastatin,105,95,36.1,210,499,559,0.4,436,0,12,,,Worried,,,,,,negative,27,20mg +P0050,85,Female,2025-06-06T00:00:00+10:00,2025-06-06T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,67,94,37.2,210,74,100,5.7,178,0,4,,,Calm,,,,,,positive,341, +P0050,85,Female,2025-06-06T06:00:00+10:00,2025-06-06T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,78,96,37.1,203,1750,291,0.6,295,0,13,,,Calm,,,,,,positive,38,5mg +P0050,85,Female,2025-06-06T12:00:00+10:00,2025-06-06T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,78,94,36.9,216,2404,410,0.4,644,0,17,,,Calm,,,,,,positive,22,5mg +P0050,85,Female,2025-06-06T18:00:00+10:00,2025-06-07T00:00:00+10:00,Patient expressed concern; HR 96 and BP 140/76 slightly elevated.,Simvastatin,96,96,36.9,216,1152,664,0.4,297,1,6,,,Worried,,,,,,negative,21,20mg +P0035,87,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient was restless and sought reassurance.,,81,95,36.4,178,26,96,5.6,259,0,5,,,Worried,,,,,,negative,338, +P0035,87,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient expressed concern; HR 96 and BP 138/64 slightly elevated.,Lisinopril,96,93,36.7,202,887,421,0.9,388,0,9,,,Worried,,,,,,negative,54,5mg +P0035,87,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Lisinopril,85,95,36.3,172,2364,633,0,595,0,30,,,Sad,,,,,,negative,2,5mg +P0035,87,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,87,95,36.4,189,753,798,0.9,200,0,13,,,Calm,,,,,,positive,55,20mg +P0036,72,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 100 and BP 154/75 elevated.,,100,97,36.5,229,200,94,6.6,207,0,3,,,Agitated,,,,,,negative,398, +P0036,72,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,78,99,36.4,216,1300,466,0.1,464,0,11,,,Calm,,,,,,positive,5,5mg +P0036,72,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,77,99,36.6,213,687,765,0.2,668,0,0,,,Calm,,,,,,positive,13,5mg +P0036,72,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was restless and sought reassurance.,Simvastatin,86,99,36.7,227,1053,469,0.4,440,1,21,,,Worried,,,,,,negative,27,20mg +P0037,74,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,83,94,36.7,201,117,124,5.4,198,1,0,,,Calm,,,,,,positive,325, +P0037,74,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient expressed concern; HR 104 and BP 153/62 slightly elevated.,Losartan,104,96,36.7,215,1830,593,0.4,256,0,0,,,Worried,,,,,,negative,26,50mg +P0037,74,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient expressed concern; HR 97 and BP 144/70 slightly elevated.,Losartan,97,96,36.8,214,1278,738,0.5,560,0,12,,,Worried,,,,,,negative,30,50mg +P0037,74,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided.,Rosuvastatin,81,96,36.9,215,1441,782,0.4,498,0,12,,,Sad,,,,,,negative,24,10mg +P0038,65,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient expressed concern; HR 93 and BP 150/69 slightly elevated.,,93,92,36.9,219,22,32,6.5,268,0,5,,,Worried,,,,,,negative,392, +P0038,65,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient expressed concern; HR 85 and BP 149/72 slightly elevated.,Amlodipine,85,94,36.9,221,2312,539,0.9,393,0,20,,,Worried,,,,,,negative,54,5mg +P0038,65,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,85,92,36.8,222,891,715,0.4,676,0,28,,,Calm,,,,,,positive,27,5mg +P0038,65,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Rosuvastatin,77,92,36.8,221,733,468,0.4,438,0,6,,,Happy,,,,,,positive,24,10mg +P0039,71,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,87,93,36.5,188,1,154,6.9,297,0,0,,,Calm,,,,,,positive,415, +P0039,71,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,90,93,36.5,178,649,259,0.1,481,0,16,,,Calm,,,,,,positive,8,50mg +P0039,71,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,95,36.5,184,3315,654,0.4,349,0,30,,,Calm,,,,,,positive,25,50mg +P0039,71,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,79,93,36.7,164,208,632,0.7,513,0,2,,,Calm,,,,,,positive,41,10mg +P0040,81,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,90,92,36.9,176,51,91,5.6,167,0,2,,,Calm,,,,,,positive,339, +P0040,81,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,94,37.1,172,1790,486,0.6,351,0,10,,,Calm,,,,,,positive,37,50mg +P0040,81,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,85,94,37.1,178,2200,556,0.2,252,0,25,,,Calm,,,,,,positive,10,50mg +P0040,81,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,87,94,37,195,820,712,0.5,546,0,25,,,Calm,,,,,,positive,29,20mg +P0041,82,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,66,96,36.3,183,183,60,6.9,249,0,1,,,Calm,,,,,,positive,415, +P0041,82,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,76,96,36.3,193,1184,542,0.3,433,0,16,,,Calm,,,,,,positive,20,50mg +P0041,82,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,79,96,36.5,193,3425,400,0.1,627,0,16,,,Calm,,,,,,positive,8,50mg +P0041,82,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,77,98,36.2,194,352,518,1,369,0,2,,,Calm,,,,,,positive,57,20mg +P0042,79,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,84,93,36.5,181,200,57,6.6,220,0,2,,,Calm,,,,,,positive,397, +P0042,79,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,79,93,36.8,190,1232,585,0.8,486,0,2,,,Worried,,,,,,negative,49,5mg +P0042,79,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,85,95,36.8,181,3242,548,0.2,352,0,16,,,Calm,,,,,,positive,12,5mg +P0042,79,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,89,95,36.6,199,590,481,0.2,216,0,22,,,Calm,,,,,,positive,11,20mg +P0043,77,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,76,94,37,178,191,34,6.8,130,0,5,,,Calm,,,,,,positive,406, +P0043,77,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,68,94,36.9,191,1659,444,0.7,205,0,1,,,Calm,,,,,,positive,44,5mg +P0043,77,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient expressed concern; HR 93 and BP 149/73 slightly elevated.,Lisinopril,93,96,37.1,222,2978,718,0.2,535,0,15,,,Worried,,,,,,negative,9,5mg +P0043,77,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,69,94,37.2,167,939,723,0.8,236,0,13,,,Calm,,,,,,positive,48,20mg +P0044,65,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,81,93,37.1,194,111,166,5.3,217,0,2,,,Calm,,,,,,positive,319, +P0044,65,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,77,95,36.8,191,1155,293,0,454,0,13,,,Calm,,,,,,positive,2,50mg +P0044,65,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,88,93,36.9,198,3007,444,0.5,576,0,28,,,Calm,,,,,,positive,30,50mg +P0044,65,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient expressed concern; HR 97 and BP 149/75 slightly elevated.,Atorvastatin,97,95,37,224,868,518,0,433,0,9,,,Worried,,,,,,negative,0,20mg +P0045,72,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient appeared withdrawn and tearful; emotional support provided. Ate very little this block.,Paracetamol,87,95,36.3,204,184,75,5.8,185,0,0,,,Sad,,,,,,negative,351,500mg +P0045,72,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient expressed concern; HR 97 and BP 142/63 slightly elevated.,Lisinopril,97,95,36.5,205,1276,576,1,430,0,10,,,Worried,,,,,,negative,60,5mg +P0045,72,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,95,95,36.3,212,2262,654,0.2,396,0,4,,,Worried,,,,,,negative,13,5mg +P0045,72,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Simvastatin,75,95,36.3,196,861,739,0,573,0,8,,,Calm,,,,,,positive,1,20mg +P0046,89,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,90,95,37.1,199,41,74,7,206,0,4,,,Calm,,,,,,positive,417, +P0046,89,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,87,97,37,202,465,526,0.6,415,0,5,,,Calm,,,,,,positive,38,50mg +P0046,89,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was restless and sought reassurance. Medication was missed this block.,Losartan,91,97,36.9,220,880,556,0.3,454,0,3,,,Worried,,,,,,negative,17,50mg +P0046,89,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Rosuvastatin,77,95,36.7,218,1495,641,0.8,399,0,17,,,Calm,,,,,,positive,49,10mg +P0047,81,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,71,97,36.8,192,173,123,5.2,128,0,4,,,Calm,,,,,,positive,314, +P0047,81,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,78,99,36.9,167,749,456,0.3,451,0,15,,,Calm,,,,,,positive,19,50mg +P0047,81,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Losartan,72,99,36.9,166,2878,580,0,376,0,3,,,Calm,,,,,,positive,0,50mg +P0047,81,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,82,97,36.7,189,1212,400,0.8,314,0,3,,,Calm,,,,,,positive,50,20mg +P0048,86,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 100 and BP 144/80 elevated.,,100,97,36.9,224,199,35,5.2,209,0,1,,,Agitated,,,,,,negative,309, +P0048,86,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient expressed concern; HR 100 and BP 140/84 slightly elevated.,Amlodipine,100,97,37.1,224,2043,364,0.1,365,0,16,,,Worried,,,,,,negative,5,5mg +P0048,86,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,89,99,36.9,216,1164,741,0.1,325,0,3,,,Calm,,,,,,positive,4,5mg +P0048,86,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was restless and sought reassurance.,Atorvastatin,92,99,36.9,215,1297,625,0.3,450,0,4,,,Worried,,,,,,negative,17,20mg +P0049,67,Male,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient slept without disturbance and remained cooperative.,,73,93,36.2,182,110,132,6.9,126,0,2,,,Calm,,,,,,positive,412, +P0049,67,Male,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Amlodipine,81,93,36.5,199,958,320,0.2,207,0,4,,,Calm,,,,,,positive,15,5mg +P0049,67,Male,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient appeared cheerful and engaged pleasantly with staff. Good appetite noted.,Amlodipine,84,93,36.1,199,1961,402,0.2,560,0,13,,,Happy,,,,,,positive,14,5mg +P0049,67,Male,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Atorvastatin,85,95,36.4,208,687,500,0.2,288,0,21,,,Calm,,,,,,positive,12,20mg +P0050,85,Female,2025-06-07T00:00:00+10:00,2025-06-07T06:00:00+10:00,Patient was restless overnight with pacing and reduced cooperation. HR 98 and BP 155/76 elevated.,,98,96,37,231,163,68,6.4,217,0,0,,,Agitated,,,,,,negative,385, +P0050,85,Female,2025-06-07T06:00:00+10:00,2025-06-07T12:00:00+10:00,Patient was restless and sought reassurance.,Lisinopril,92,96,36.9,219,2158,399,0.9,499,0,18,,,Worried,,,,,,negative,55,5mg +P0050,85,Female,2025-06-07T12:00:00+10:00,2025-06-07T18:00:00+10:00,Patient was settled and cooperative during routine care. Medications taken as scheduled.,Lisinopril,76,94,37,212,2665,408,0.4,294,0,1,,,Calm,,,,,,positive,27,5mg +P0050,85,Female,2025-06-07T18:00:00+10:00,2025-06-08T00:00:00+10:00,Patient expressed concern; HR 99 and BP 135/81 slightly elevated.,Simvastatin,99,96,37.1,216,557,712,1,328,1,15,,,Worried,,,,,,negative,57,20mg diff --git a/Guardian b/Guardian new file mode 160000 index 00000000..8cbcd88c --- /dev/null +++ b/Guardian @@ -0,0 +1 @@ +Subproject commit 8cbcd88cbfb866d9ea39d41351d2e0ceb83d009e diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/DockerFile b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/DockerFile new file mode 100644 index 00000000..8ddbf892 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/DockerFile @@ -0,0 +1,18 @@ +# Use Node.js LTS image +FROM node:18 + +# Set working directory +WORKDIR /usr/src/app + +# Copy package.json and install dependencies +COPY package*.json ./ +RUN npm install + +# Copy source code +COPY . . + +# Expose port 3000 +EXPOSE 3000 + +# Start the app +CMD [ "npm", "start" ] diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/index.js new file mode 100644 index 00000000..9eb89147 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/index.js @@ -0,0 +1,12 @@ +// index.js +const express = require('express'); +const app = express(); +const port = process.env.PORT || 3000; + +app.get('/', (req, res) => { + res.send('SIT323 Task 5.2D is running!'); +}); + +app.listen(port, () => { + console.log(`App listening on port ${port}`); +}); diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime new file mode 100644 index 00000000..7751de3c --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../mime/cli.js" "$@" +else + exec node "$basedir/../mime/cli.js" "$@" +fi diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.cmd b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.cmd new file mode 100644 index 00000000..54491f12 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.cmd @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\mime\cli.js" %* diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.ps1 b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.ps1 new file mode 100644 index 00000000..2222f40b --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.bin/mime.ps1 @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../mime/cli.js" $args + } else { + & "$basedir/node$exe" "$basedir/../mime/cli.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../mime/cli.js" $args + } else { + & "node$exe" "$basedir/../mime/cli.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.package-lock.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.package-lock.json new file mode 100644 index 00000000..2f417f1e --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/.package-lock.json @@ -0,0 +1,825 @@ +{ + "name": "sit323-2025-prac5d", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "license": "MIT" + }, + "node_modules/body-parser": { + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.13.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==", + "license": "MIT" + }, + "node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/express": { + "version": "4.21.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz", + "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.3", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.3.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.12", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.19.0", + "serve-static": "1.16.2", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/finalhandler": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "license": "MIT", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.0.6" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/send": { + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/serve-static": { + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.19.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + } + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/HISTORY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/HISTORY.md new file mode 100644 index 00000000..cb5990c7 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/HISTORY.md @@ -0,0 +1,243 @@ +1.3.8 / 2022-02-02 +================== + + * deps: mime-types@~2.1.34 + - deps: mime-db@~1.51.0 + * deps: negotiator@0.6.3 + +1.3.7 / 2019-04-29 +================== + + * deps: negotiator@0.6.2 + - Fix sorting charset, encoding, and language with extra parameters + +1.3.6 / 2019-04-28 +================== + + * deps: mime-types@~2.1.24 + - deps: mime-db@~1.40.0 + +1.3.5 / 2018-02-28 +================== + + * deps: mime-types@~2.1.18 + - deps: mime-db@~1.33.0 + +1.3.4 / 2017-08-22 +================== + + * deps: mime-types@~2.1.16 + - deps: mime-db@~1.29.0 + +1.3.3 / 2016-05-02 +================== + + * deps: mime-types@~2.1.11 + - deps: mime-db@~1.23.0 + * deps: negotiator@0.6.1 + - perf: improve `Accept` parsing speed + - perf: improve `Accept-Charset` parsing speed + - perf: improve `Accept-Encoding` parsing speed + - perf: improve `Accept-Language` parsing speed + +1.3.2 / 2016-03-08 +================== + + * deps: mime-types@~2.1.10 + - Fix extension of `application/dash+xml` + - Update primary extension for `audio/mp4` + - deps: mime-db@~1.22.0 + +1.3.1 / 2016-01-19 +================== + + * deps: mime-types@~2.1.9 + - deps: mime-db@~1.21.0 + +1.3.0 / 2015-09-29 +================== + + * deps: mime-types@~2.1.7 + - deps: mime-db@~1.19.0 + * deps: negotiator@0.6.0 + - Fix including type extensions in parameters in `Accept` parsing + - Fix parsing `Accept` parameters with quoted equals + - Fix parsing `Accept` parameters with quoted semicolons + - Lazy-load modules from main entry point + - perf: delay type concatenation until needed + - perf: enable strict mode + - perf: hoist regular expressions + - perf: remove closures getting spec properties + - perf: remove a closure from media type parsing + - perf: remove property delete from media type parsing + +1.2.13 / 2015-09-06 +=================== + + * deps: mime-types@~2.1.6 + - deps: mime-db@~1.18.0 + +1.2.12 / 2015-07-30 +=================== + + * deps: mime-types@~2.1.4 + - deps: mime-db@~1.16.0 + +1.2.11 / 2015-07-16 +=================== + + * deps: mime-types@~2.1.3 + - deps: mime-db@~1.15.0 + +1.2.10 / 2015-07-01 +=================== + + * deps: mime-types@~2.1.2 + - deps: mime-db@~1.14.0 + +1.2.9 / 2015-06-08 +================== + + * deps: mime-types@~2.1.1 + - perf: fix deopt during mapping + +1.2.8 / 2015-06-07 +================== + + * deps: mime-types@~2.1.0 + - deps: mime-db@~1.13.0 + * perf: avoid argument reassignment & argument slice + * perf: avoid negotiator recursive construction + * perf: enable strict mode + * perf: remove unnecessary bitwise operator + +1.2.7 / 2015-05-10 +================== + + * deps: negotiator@0.5.3 + - Fix media type parameter matching to be case-insensitive + +1.2.6 / 2015-05-07 +================== + + * deps: mime-types@~2.0.11 + - deps: mime-db@~1.9.1 + * deps: negotiator@0.5.2 + - Fix comparing media types with quoted values + - Fix splitting media types with quoted commas + +1.2.5 / 2015-03-13 +================== + + * deps: mime-types@~2.0.10 + - deps: mime-db@~1.8.0 + +1.2.4 / 2015-02-14 +================== + + * Support Node.js 0.6 + * deps: mime-types@~2.0.9 + - deps: mime-db@~1.7.0 + * deps: negotiator@0.5.1 + - Fix preference sorting to be stable for long acceptable lists + +1.2.3 / 2015-01-31 +================== + + * deps: mime-types@~2.0.8 + - deps: mime-db@~1.6.0 + +1.2.2 / 2014-12-30 +================== + + * deps: mime-types@~2.0.7 + - deps: mime-db@~1.5.0 + +1.2.1 / 2014-12-30 +================== + + * deps: mime-types@~2.0.5 + - deps: mime-db@~1.3.1 + +1.2.0 / 2014-12-19 +================== + + * deps: negotiator@0.5.0 + - Fix list return order when large accepted list + - Fix missing identity encoding when q=0 exists + - Remove dynamic building of Negotiator class + +1.1.4 / 2014-12-10 +================== + + * deps: mime-types@~2.0.4 + - deps: mime-db@~1.3.0 + +1.1.3 / 2014-11-09 +================== + + * deps: mime-types@~2.0.3 + - deps: mime-db@~1.2.0 + +1.1.2 / 2014-10-14 +================== + + * deps: negotiator@0.4.9 + - Fix error when media type has invalid parameter + +1.1.1 / 2014-09-28 +================== + + * deps: mime-types@~2.0.2 + - deps: mime-db@~1.1.0 + * deps: negotiator@0.4.8 + - Fix all negotiations to be case-insensitive + - Stable sort preferences of same quality according to client order + +1.1.0 / 2014-09-02 +================== + + * update `mime-types` + +1.0.7 / 2014-07-04 +================== + + * Fix wrong type returned from `type` when match after unknown extension + +1.0.6 / 2014-06-24 +================== + + * deps: negotiator@0.4.7 + +1.0.5 / 2014-06-20 +================== + + * fix crash when unknown extension given + +1.0.4 / 2014-06-19 +================== + + * use `mime-types` + +1.0.3 / 2014-06-11 +================== + + * deps: negotiator@0.4.6 + - Order by specificity when quality is the same + +1.0.2 / 2014-05-29 +================== + + * Fix interpretation when header not in request + * deps: pin negotiator@0.4.5 + +1.0.1 / 2014-01-18 +================== + + * Identity encoding isn't always acceptable + * deps: negotiator@~0.4.0 + +1.0.0 / 2013-12-27 +================== + + * Genesis diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/LICENSE new file mode 100644 index 00000000..06166077 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/LICENSE @@ -0,0 +1,23 @@ +(The MIT License) + +Copyright (c) 2014 Jonathan Ong +Copyright (c) 2015 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/README.md new file mode 100644 index 00000000..82680c53 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/README.md @@ -0,0 +1,140 @@ +# accepts + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-url] +[![Node.js Version][node-version-image]][node-version-url] +[![Build Status][github-actions-ci-image]][github-actions-ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] + +Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator). +Extracted from [koa](https://www.npmjs.com/package/koa) for general use. + +In addition to negotiator, it allows: + +- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])` + as well as `('text/html', 'application/json')`. +- Allows type shorthands such as `json`. +- Returns `false` when no types match +- Treats non-existent headers as `*` + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```sh +$ npm install accepts +``` + +## API + +```js +var accepts = require('accepts') +``` + +### accepts(req) + +Create a new `Accepts` object for the given `req`. + +#### .charset(charsets) + +Return the first accepted charset. If nothing in `charsets` is accepted, +then `false` is returned. + +#### .charsets() + +Return the charsets that the request accepts, in the order of the client's +preference (most preferred first). + +#### .encoding(encodings) + +Return the first accepted encoding. If nothing in `encodings` is accepted, +then `false` is returned. + +#### .encodings() + +Return the encodings that the request accepts, in the order of the client's +preference (most preferred first). + +#### .language(languages) + +Return the first accepted language. If nothing in `languages` is accepted, +then `false` is returned. + +#### .languages() + +Return the languages that the request accepts, in the order of the client's +preference (most preferred first). + +#### .type(types) + +Return the first accepted type (and it is returned as the same text as what +appears in the `types` array). If nothing in `types` is accepted, then `false` +is returned. + +The `types` array can contain full MIME types or file extensions. Any value +that is not a full MIME types is passed to `require('mime-types').lookup`. + +#### .types() + +Return the types that the request accepts, in the order of the client's +preference (most preferred first). + +## Examples + +### Simple type negotiation + +This simple example shows how to use `accepts` to return a different typed +respond body based on what the client wants to accept. The server lists it's +preferences in order and will get back the best match between the client and +server. + +```js +var accepts = require('accepts') +var http = require('http') + +function app (req, res) { + var accept = accepts(req) + + // the order of this list is significant; should be server preferred order + switch (accept.type(['json', 'html'])) { + case 'json': + res.setHeader('Content-Type', 'application/json') + res.write('{"hello":"world!"}') + break + case 'html': + res.setHeader('Content-Type', 'text/html') + res.write('hello, world!') + break + default: + // the fallback is text/plain, so no need to specify it above + res.setHeader('Content-Type', 'text/plain') + res.write('hello, world!') + break + } + + res.end() +} + +http.createServer(app).listen(3000) +``` + +You can test this out with the cURL program: +```sh +curl -I -H'Accept: text/html' http://localhost:3000/ +``` + +## License + +[MIT](LICENSE) + +[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/accepts/master +[coveralls-url]: https://coveralls.io/r/jshttp/accepts?branch=master +[github-actions-ci-image]: https://badgen.net/github/checks/jshttp/accepts/master?label=ci +[github-actions-ci-url]: https://github.com/jshttp/accepts/actions/workflows/ci.yml +[node-version-image]: https://badgen.net/npm/node/accepts +[node-version-url]: https://nodejs.org/en/download +[npm-downloads-image]: https://badgen.net/npm/dm/accepts +[npm-url]: https://npmjs.org/package/accepts +[npm-version-image]: https://badgen.net/npm/v/accepts diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/index.js new file mode 100644 index 00000000..e9b2f63f --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/index.js @@ -0,0 +1,238 @@ +/*! + * accepts + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var Negotiator = require('negotiator') +var mime = require('mime-types') + +/** + * Module exports. + * @public + */ + +module.exports = Accepts + +/** + * Create a new Accepts object for the given req. + * + * @param {object} req + * @public + */ + +function Accepts (req) { + if (!(this instanceof Accepts)) { + return new Accepts(req) + } + + this.headers = req.headers + this.negotiator = new Negotiator(req) +} + +/** + * Check if the given `type(s)` is acceptable, returning + * the best match when true, otherwise `undefined`, in which + * case you should respond with 406 "Not Acceptable". + * + * The `type` value may be a single mime type string + * such as "application/json", the extension name + * such as "json" or an array `["json", "html", "text/plain"]`. When a list + * or array is given the _best_ match, if any is returned. + * + * Examples: + * + * // Accept: text/html + * this.types('html'); + * // => "html" + * + * // Accept: text/*, application/json + * this.types('html'); + * // => "html" + * this.types('text/html'); + * // => "text/html" + * this.types('json', 'text'); + * // => "json" + * this.types('application/json'); + * // => "application/json" + * + * // Accept: text/*, application/json + * this.types('image/png'); + * this.types('png'); + * // => undefined + * + * // Accept: text/*;q=.5, application/json + * this.types(['html', 'json']); + * this.types('html', 'json'); + * // => "json" + * + * @param {String|Array} types... + * @return {String|Array|Boolean} + * @public + */ + +Accepts.prototype.type = +Accepts.prototype.types = function (types_) { + var types = types_ + + // support flattened arguments + if (types && !Array.isArray(types)) { + types = new Array(arguments.length) + for (var i = 0; i < types.length; i++) { + types[i] = arguments[i] + } + } + + // no types, return all requested types + if (!types || types.length === 0) { + return this.negotiator.mediaTypes() + } + + // no accept header, return first given type + if (!this.headers.accept) { + return types[0] + } + + var mimes = types.map(extToMime) + var accepts = this.negotiator.mediaTypes(mimes.filter(validMime)) + var first = accepts[0] + + return first + ? types[mimes.indexOf(first)] + : false +} + +/** + * Return accepted encodings or best fit based on `encodings`. + * + * Given `Accept-Encoding: gzip, deflate` + * an array sorted by quality is returned: + * + * ['gzip', 'deflate'] + * + * @param {String|Array} encodings... + * @return {String|Array} + * @public + */ + +Accepts.prototype.encoding = +Accepts.prototype.encodings = function (encodings_) { + var encodings = encodings_ + + // support flattened arguments + if (encodings && !Array.isArray(encodings)) { + encodings = new Array(arguments.length) + for (var i = 0; i < encodings.length; i++) { + encodings[i] = arguments[i] + } + } + + // no encodings, return all requested encodings + if (!encodings || encodings.length === 0) { + return this.negotiator.encodings() + } + + return this.negotiator.encodings(encodings)[0] || false +} + +/** + * Return accepted charsets or best fit based on `charsets`. + * + * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5` + * an array sorted by quality is returned: + * + * ['utf-8', 'utf-7', 'iso-8859-1'] + * + * @param {String|Array} charsets... + * @return {String|Array} + * @public + */ + +Accepts.prototype.charset = +Accepts.prototype.charsets = function (charsets_) { + var charsets = charsets_ + + // support flattened arguments + if (charsets && !Array.isArray(charsets)) { + charsets = new Array(arguments.length) + for (var i = 0; i < charsets.length; i++) { + charsets[i] = arguments[i] + } + } + + // no charsets, return all requested charsets + if (!charsets || charsets.length === 0) { + return this.negotiator.charsets() + } + + return this.negotiator.charsets(charsets)[0] || false +} + +/** + * Return accepted languages or best fit based on `langs`. + * + * Given `Accept-Language: en;q=0.8, es, pt` + * an array sorted by quality is returned: + * + * ['es', 'pt', 'en'] + * + * @param {String|Array} langs... + * @return {Array|String} + * @public + */ + +Accepts.prototype.lang = +Accepts.prototype.langs = +Accepts.prototype.language = +Accepts.prototype.languages = function (languages_) { + var languages = languages_ + + // support flattened arguments + if (languages && !Array.isArray(languages)) { + languages = new Array(arguments.length) + for (var i = 0; i < languages.length; i++) { + languages[i] = arguments[i] + } + } + + // no languages, return all requested languages + if (!languages || languages.length === 0) { + return this.negotiator.languages() + } + + return this.negotiator.languages(languages)[0] || false +} + +/** + * Convert extnames to mime. + * + * @param {String} type + * @return {String} + * @private + */ + +function extToMime (type) { + return type.indexOf('/') === -1 + ? mime.lookup(type) + : type +} + +/** + * Check if mime is valid. + * + * @param {String} type + * @return {String} + * @private + */ + +function validMime (type) { + return typeof type === 'string' +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/package.json new file mode 100644 index 00000000..0f2d15da --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/accepts/package.json @@ -0,0 +1,47 @@ +{ + "name": "accepts", + "description": "Higher-level content negotiation", + "version": "1.3.8", + "contributors": [ + "Douglas Christopher Wilson ", + "Jonathan Ong (http://jongleberry.com)" + ], + "license": "MIT", + "repository": "jshttp/accepts", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "devDependencies": { + "deep-equal": "1.0.1", + "eslint": "7.32.0", + "eslint-config-standard": "14.1.1", + "eslint-plugin-import": "2.25.4", + "eslint-plugin-markdown": "2.2.1", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "4.3.1", + "eslint-plugin-standard": "4.1.0", + "mocha": "9.2.0", + "nyc": "15.1.0" + }, + "files": [ + "LICENSE", + "HISTORY.md", + "index.js" + ], + "engines": { + "node": ">= 0.6" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --reporter spec --check-leaks --bail test/", + "test-ci": "nyc --reporter=lcov --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test" + }, + "keywords": [ + "content", + "negotiation", + "accept", + "accepts" + ] +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/LICENSE new file mode 100644 index 00000000..983fbe8a --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/README.md new file mode 100644 index 00000000..91fa5b63 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/README.md @@ -0,0 +1,43 @@ +# Array Flatten + +[![NPM version][npm-image]][npm-url] +[![NPM downloads][downloads-image]][downloads-url] +[![Build status][travis-image]][travis-url] +[![Test coverage][coveralls-image]][coveralls-url] + +> Flatten an array of nested arrays into a single flat array. Accepts an optional depth. + +## Installation + +``` +npm install array-flatten --save +``` + +## Usage + +```javascript +var flatten = require('array-flatten') + +flatten([1, [2, [3, [4, [5], 6], 7], 8], 9]) +//=> [1, 2, 3, 4, 5, 6, 7, 8, 9] + +flatten([1, [2, [3, [4, [5], 6], 7], 8], 9], 2) +//=> [1, 2, 3, [4, [5], 6], 7, 8, 9] + +(function () { + flatten(arguments) //=> [1, 2, 3] +})(1, [2, 3]) +``` + +## License + +MIT + +[npm-image]: https://img.shields.io/npm/v/array-flatten.svg?style=flat +[npm-url]: https://npmjs.org/package/array-flatten +[downloads-image]: https://img.shields.io/npm/dm/array-flatten.svg?style=flat +[downloads-url]: https://npmjs.org/package/array-flatten +[travis-image]: https://img.shields.io/travis/blakeembrey/array-flatten.svg?style=flat +[travis-url]: https://travis-ci.org/blakeembrey/array-flatten +[coveralls-image]: https://img.shields.io/coveralls/blakeembrey/array-flatten.svg?style=flat +[coveralls-url]: https://coveralls.io/r/blakeembrey/array-flatten?branch=master diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/array-flatten.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/array-flatten.js new file mode 100644 index 00000000..089117b3 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/array-flatten.js @@ -0,0 +1,64 @@ +'use strict' + +/** + * Expose `arrayFlatten`. + */ +module.exports = arrayFlatten + +/** + * Recursive flatten function with depth. + * + * @param {Array} array + * @param {Array} result + * @param {Number} depth + * @return {Array} + */ +function flattenWithDepth (array, result, depth) { + for (var i = 0; i < array.length; i++) { + var value = array[i] + + if (depth > 0 && Array.isArray(value)) { + flattenWithDepth(value, result, depth - 1) + } else { + result.push(value) + } + } + + return result +} + +/** + * Recursive flatten function. Omitting depth is slightly faster. + * + * @param {Array} array + * @param {Array} result + * @return {Array} + */ +function flattenForever (array, result) { + for (var i = 0; i < array.length; i++) { + var value = array[i] + + if (Array.isArray(value)) { + flattenForever(value, result) + } else { + result.push(value) + } + } + + return result +} + +/** + * Flatten an array, with the ability to define a depth. + * + * @param {Array} array + * @param {Number} depth + * @return {Array} + */ +function arrayFlatten (array, depth) { + if (depth == null) { + return flattenForever(array, []) + } + + return flattenWithDepth(array, [], depth) +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/package.json new file mode 100644 index 00000000..1a24e2a1 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/array-flatten/package.json @@ -0,0 +1,39 @@ +{ + "name": "array-flatten", + "version": "1.1.1", + "description": "Flatten an array of nested arrays into a single flat array", + "main": "array-flatten.js", + "files": [ + "array-flatten.js", + "LICENSE" + ], + "scripts": { + "test": "istanbul cover _mocha -- -R spec" + }, + "repository": { + "type": "git", + "url": "git://github.com/blakeembrey/array-flatten.git" + }, + "keywords": [ + "array", + "flatten", + "arguments", + "depth" + ], + "author": { + "name": "Blake Embrey", + "email": "hello@blakeembrey.com", + "url": "http://blakeembrey.me" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/blakeembrey/array-flatten/issues" + }, + "homepage": "https://github.com/blakeembrey/array-flatten", + "devDependencies": { + "istanbul": "^0.3.13", + "mocha": "^2.2.4", + "pre-commit": "^1.0.7", + "standard": "^3.7.3" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/HISTORY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/HISTORY.md new file mode 100644 index 00000000..81d23e06 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/HISTORY.md @@ -0,0 +1,672 @@ +1.20.3 / 2024-09-10 +=================== + + * deps: qs@6.13.0 + * add `depth` option to customize the depth level in the parser + * IMPORTANT: The default `depth` level for parsing URL-encoded data is now `32` (previously was `Infinity`) + +1.20.2 / 2023-02-21 +=================== + + * Fix strict json error message on Node.js 19+ + * deps: content-type@~1.0.5 + - perf: skip value escaping when unnecessary + * deps: raw-body@2.5.2 + +1.20.1 / 2022-10-06 +=================== + + * deps: qs@6.11.0 + * perf: remove unnecessary object clone + +1.20.0 / 2022-04-02 +=================== + + * Fix error message for json parse whitespace in `strict` + * Fix internal error when inflated body exceeds limit + * Prevent loss of async hooks context + * Prevent hanging when request already read + * deps: depd@2.0.0 + - Replace internal `eval` usage with `Function` constructor + - Use instance methods on `process` to check for listeners + * deps: http-errors@2.0.0 + - deps: depd@2.0.0 + - deps: statuses@2.0.1 + * deps: on-finished@2.4.1 + * deps: qs@6.10.3 + * deps: raw-body@2.5.1 + - deps: http-errors@2.0.0 + +1.19.2 / 2022-02-15 +=================== + + * deps: bytes@3.1.2 + * deps: qs@6.9.7 + * Fix handling of `__proto__` keys + * deps: raw-body@2.4.3 + - deps: bytes@3.1.2 + +1.19.1 / 2021-12-10 +=================== + + * deps: bytes@3.1.1 + * deps: http-errors@1.8.1 + - deps: inherits@2.0.4 + - deps: toidentifier@1.0.1 + - deps: setprototypeof@1.2.0 + * deps: qs@6.9.6 + * deps: raw-body@2.4.2 + - deps: bytes@3.1.1 + - deps: http-errors@1.8.1 + * deps: safe-buffer@5.2.1 + * deps: type-is@~1.6.18 + +1.19.0 / 2019-04-25 +=================== + + * deps: bytes@3.1.0 + - Add petabyte (`pb`) support + * deps: http-errors@1.7.2 + - Set constructor name when possible + - deps: setprototypeof@1.1.1 + - deps: statuses@'>= 1.5.0 < 2' + * deps: iconv-lite@0.4.24 + - Added encoding MIK + * deps: qs@6.7.0 + - Fix parsing array brackets after index + * deps: raw-body@2.4.0 + - deps: bytes@3.1.0 + - deps: http-errors@1.7.2 + - deps: iconv-lite@0.4.24 + * deps: type-is@~1.6.17 + - deps: mime-types@~2.1.24 + - perf: prevent internal `throw` on invalid type + +1.18.3 / 2018-05-14 +=================== + + * Fix stack trace for strict json parse error + * deps: depd@~1.1.2 + - perf: remove argument reassignment + * deps: http-errors@~1.6.3 + - deps: depd@~1.1.2 + - deps: setprototypeof@1.1.0 + - deps: statuses@'>= 1.3.1 < 2' + * deps: iconv-lite@0.4.23 + - Fix loading encoding with year appended + - Fix deprecation warnings on Node.js 10+ + * deps: qs@6.5.2 + * deps: raw-body@2.3.3 + - deps: http-errors@1.6.3 + - deps: iconv-lite@0.4.23 + * deps: type-is@~1.6.16 + - deps: mime-types@~2.1.18 + +1.18.2 / 2017-09-22 +=================== + + * deps: debug@2.6.9 + * perf: remove argument reassignment + +1.18.1 / 2017-09-12 +=================== + + * deps: content-type@~1.0.4 + - perf: remove argument reassignment + - perf: skip parameter parsing when no parameters + * deps: iconv-lite@0.4.19 + - Fix ISO-8859-1 regression + - Update Windows-1255 + * deps: qs@6.5.1 + - Fix parsing & compacting very deep objects + * deps: raw-body@2.3.2 + - deps: iconv-lite@0.4.19 + +1.18.0 / 2017-09-08 +=================== + + * Fix JSON strict violation error to match native parse error + * Include the `body` property on verify errors + * Include the `type` property on all generated errors + * Use `http-errors` to set status code on errors + * deps: bytes@3.0.0 + * deps: debug@2.6.8 + * deps: depd@~1.1.1 + - Remove unnecessary `Buffer` loading + * deps: http-errors@~1.6.2 + - deps: depd@1.1.1 + * deps: iconv-lite@0.4.18 + - Add support for React Native + - Add a warning if not loaded as utf-8 + - Fix CESU-8 decoding in Node.js 8 + - Improve speed of ISO-8859-1 encoding + * deps: qs@6.5.0 + * deps: raw-body@2.3.1 + - Use `http-errors` for standard emitted errors + - deps: bytes@3.0.0 + - deps: iconv-lite@0.4.18 + - perf: skip buffer decoding on overage chunk + * perf: prevent internal `throw` when missing charset + +1.17.2 / 2017-05-17 +=================== + + * deps: debug@2.6.7 + - Fix `DEBUG_MAX_ARRAY_LENGTH` + - deps: ms@2.0.0 + * deps: type-is@~1.6.15 + - deps: mime-types@~2.1.15 + +1.17.1 / 2017-03-06 +=================== + + * deps: qs@6.4.0 + - Fix regression parsing keys starting with `[` + +1.17.0 / 2017-03-01 +=================== + + * deps: http-errors@~1.6.1 + - Make `message` property enumerable for `HttpError`s + - deps: setprototypeof@1.0.3 + * deps: qs@6.3.1 + - Fix compacting nested arrays + +1.16.1 / 2017-02-10 +=================== + + * deps: debug@2.6.1 + - Fix deprecation messages in WebStorm and other editors + - Undeprecate `DEBUG_FD` set to `1` or `2` + +1.16.0 / 2017-01-17 +=================== + + * deps: debug@2.6.0 + - Allow colors in workers + - Deprecated `DEBUG_FD` environment variable + - Fix error when running under React Native + - Use same color for same namespace + - deps: ms@0.7.2 + * deps: http-errors@~1.5.1 + - deps: inherits@2.0.3 + - deps: setprototypeof@1.0.2 + - deps: statuses@'>= 1.3.1 < 2' + * deps: iconv-lite@0.4.15 + - Added encoding MS-31J + - Added encoding MS-932 + - Added encoding MS-936 + - Added encoding MS-949 + - Added encoding MS-950 + - Fix GBK/GB18030 handling of Euro character + * deps: qs@6.2.1 + - Fix array parsing from skipping empty values + * deps: raw-body@~2.2.0 + - deps: iconv-lite@0.4.15 + * deps: type-is@~1.6.14 + - deps: mime-types@~2.1.13 + +1.15.2 / 2016-06-19 +=================== + + * deps: bytes@2.4.0 + * deps: content-type@~1.0.2 + - perf: enable strict mode + * deps: http-errors@~1.5.0 + - Use `setprototypeof` module to replace `__proto__` setting + - deps: statuses@'>= 1.3.0 < 2' + - perf: enable strict mode + * deps: qs@6.2.0 + * deps: raw-body@~2.1.7 + - deps: bytes@2.4.0 + - perf: remove double-cleanup on happy path + * deps: type-is@~1.6.13 + - deps: mime-types@~2.1.11 + +1.15.1 / 2016-05-05 +=================== + + * deps: bytes@2.3.0 + - Drop partial bytes on all parsed units + - Fix parsing byte string that looks like hex + * deps: raw-body@~2.1.6 + - deps: bytes@2.3.0 + * deps: type-is@~1.6.12 + - deps: mime-types@~2.1.10 + +1.15.0 / 2016-02-10 +=================== + + * deps: http-errors@~1.4.0 + - Add `HttpError` export, for `err instanceof createError.HttpError` + - deps: inherits@2.0.1 + - deps: statuses@'>= 1.2.1 < 2' + * deps: qs@6.1.0 + * deps: type-is@~1.6.11 + - deps: mime-types@~2.1.9 + +1.14.2 / 2015-12-16 +=================== + + * deps: bytes@2.2.0 + * deps: iconv-lite@0.4.13 + * deps: qs@5.2.0 + * deps: raw-body@~2.1.5 + - deps: bytes@2.2.0 + - deps: iconv-lite@0.4.13 + * deps: type-is@~1.6.10 + - deps: mime-types@~2.1.8 + +1.14.1 / 2015-09-27 +=================== + + * Fix issue where invalid charset results in 400 when `verify` used + * deps: iconv-lite@0.4.12 + - Fix CESU-8 decoding in Node.js 4.x + * deps: raw-body@~2.1.4 + - Fix masking critical errors from `iconv-lite` + - deps: iconv-lite@0.4.12 + * deps: type-is@~1.6.9 + - deps: mime-types@~2.1.7 + +1.14.0 / 2015-09-16 +=================== + + * Fix JSON strict parse error to match syntax errors + * Provide static `require` analysis in `urlencoded` parser + * deps: depd@~1.1.0 + - Support web browser loading + * deps: qs@5.1.0 + * deps: raw-body@~2.1.3 + - Fix sync callback when attaching data listener causes sync read + * deps: type-is@~1.6.8 + - Fix type error when given invalid type to match against + - deps: mime-types@~2.1.6 + +1.13.3 / 2015-07-31 +=================== + + * deps: type-is@~1.6.6 + - deps: mime-types@~2.1.4 + +1.13.2 / 2015-07-05 +=================== + + * deps: iconv-lite@0.4.11 + * deps: qs@4.0.0 + - Fix dropping parameters like `hasOwnProperty` + - Fix user-visible incompatibilities from 3.1.0 + - Fix various parsing edge cases + * deps: raw-body@~2.1.2 + - Fix error stack traces to skip `makeError` + - deps: iconv-lite@0.4.11 + * deps: type-is@~1.6.4 + - deps: mime-types@~2.1.2 + - perf: enable strict mode + - perf: remove argument reassignment + +1.13.1 / 2015-06-16 +=================== + + * deps: qs@2.4.2 + - Downgraded from 3.1.0 because of user-visible incompatibilities + +1.13.0 / 2015-06-14 +=================== + + * Add `statusCode` property on `Error`s, in addition to `status` + * Change `type` default to `application/json` for JSON parser + * Change `type` default to `application/x-www-form-urlencoded` for urlencoded parser + * Provide static `require` analysis + * Use the `http-errors` module to generate errors + * deps: bytes@2.1.0 + - Slight optimizations + * deps: iconv-lite@0.4.10 + - The encoding UTF-16 without BOM now defaults to UTF-16LE when detection fails + - Leading BOM is now removed when decoding + * deps: on-finished@~2.3.0 + - Add defined behavior for HTTP `CONNECT` requests + - Add defined behavior for HTTP `Upgrade` requests + - deps: ee-first@1.1.1 + * deps: qs@3.1.0 + - Fix dropping parameters like `hasOwnProperty` + - Fix various parsing edge cases + - Parsed object now has `null` prototype + * deps: raw-body@~2.1.1 + - Use `unpipe` module for unpiping requests + - deps: iconv-lite@0.4.10 + * deps: type-is@~1.6.3 + - deps: mime-types@~2.1.1 + - perf: reduce try block size + - perf: remove bitwise operations + * perf: enable strict mode + * perf: remove argument reassignment + * perf: remove delete call + +1.12.4 / 2015-05-10 +=================== + + * deps: debug@~2.2.0 + * deps: qs@2.4.2 + - Fix allowing parameters like `constructor` + * deps: on-finished@~2.2.1 + * deps: raw-body@~2.0.1 + - Fix a false-positive when unpiping in Node.js 0.8 + - deps: bytes@2.0.1 + * deps: type-is@~1.6.2 + - deps: mime-types@~2.0.11 + +1.12.3 / 2015-04-15 +=================== + + * Slight efficiency improvement when not debugging + * deps: depd@~1.0.1 + * deps: iconv-lite@0.4.8 + - Add encoding alias UNICODE-1-1-UTF-7 + * deps: raw-body@1.3.4 + - Fix hanging callback if request aborts during read + - deps: iconv-lite@0.4.8 + +1.12.2 / 2015-03-16 +=================== + + * deps: qs@2.4.1 + - Fix error when parameter `hasOwnProperty` is present + +1.12.1 / 2015-03-15 +=================== + + * deps: debug@~2.1.3 + - Fix high intensity foreground color for bold + - deps: ms@0.7.0 + * deps: type-is@~1.6.1 + - deps: mime-types@~2.0.10 + +1.12.0 / 2015-02-13 +=================== + + * add `debug` messages + * accept a function for the `type` option + * use `content-type` to parse `Content-Type` headers + * deps: iconv-lite@0.4.7 + - Gracefully support enumerables on `Object.prototype` + * deps: raw-body@1.3.3 + - deps: iconv-lite@0.4.7 + * deps: type-is@~1.6.0 + - fix argument reassignment + - fix false-positives in `hasBody` `Transfer-Encoding` check + - support wildcard for both type and subtype (`*/*`) + - deps: mime-types@~2.0.9 + +1.11.0 / 2015-01-30 +=================== + + * make internal `extended: true` depth limit infinity + * deps: type-is@~1.5.6 + - deps: mime-types@~2.0.8 + +1.10.2 / 2015-01-20 +=================== + + * deps: iconv-lite@0.4.6 + - Fix rare aliases of single-byte encodings + * deps: raw-body@1.3.2 + - deps: iconv-lite@0.4.6 + +1.10.1 / 2015-01-01 +=================== + + * deps: on-finished@~2.2.0 + * deps: type-is@~1.5.5 + - deps: mime-types@~2.0.7 + +1.10.0 / 2014-12-02 +=================== + + * make internal `extended: true` array limit dynamic + +1.9.3 / 2014-11-21 +================== + + * deps: iconv-lite@0.4.5 + - Fix Windows-31J and X-SJIS encoding support + * deps: qs@2.3.3 + - Fix `arrayLimit` behavior + * deps: raw-body@1.3.1 + - deps: iconv-lite@0.4.5 + * deps: type-is@~1.5.3 + - deps: mime-types@~2.0.3 + +1.9.2 / 2014-10-27 +================== + + * deps: qs@2.3.2 + - Fix parsing of mixed objects and values + +1.9.1 / 2014-10-22 +================== + + * deps: on-finished@~2.1.1 + - Fix handling of pipelined requests + * deps: qs@2.3.0 + - Fix parsing of mixed implicit and explicit arrays + * deps: type-is@~1.5.2 + - deps: mime-types@~2.0.2 + +1.9.0 / 2014-09-24 +================== + + * include the charset in "unsupported charset" error message + * include the encoding in "unsupported content encoding" error message + * deps: depd@~1.0.0 + +1.8.4 / 2014-09-23 +================== + + * fix content encoding to be case-insensitive + +1.8.3 / 2014-09-19 +================== + + * deps: qs@2.2.4 + - Fix issue with object keys starting with numbers truncated + +1.8.2 / 2014-09-15 +================== + + * deps: depd@0.4.5 + +1.8.1 / 2014-09-07 +================== + + * deps: media-typer@0.3.0 + * deps: type-is@~1.5.1 + +1.8.0 / 2014-09-05 +================== + + * make empty-body-handling consistent between chunked requests + - empty `json` produces `{}` + - empty `raw` produces `new Buffer(0)` + - empty `text` produces `''` + - empty `urlencoded` produces `{}` + * deps: qs@2.2.3 + - Fix issue where first empty value in array is discarded + * deps: type-is@~1.5.0 + - fix `hasbody` to be true for `content-length: 0` + +1.7.0 / 2014-09-01 +================== + + * add `parameterLimit` option to `urlencoded` parser + * change `urlencoded` extended array limit to 100 + * respond with 413 when over `parameterLimit` in `urlencoded` + +1.6.7 / 2014-08-29 +================== + + * deps: qs@2.2.2 + - Remove unnecessary cloning + +1.6.6 / 2014-08-27 +================== + + * deps: qs@2.2.0 + - Array parsing fix + - Performance improvements + +1.6.5 / 2014-08-16 +================== + + * deps: on-finished@2.1.0 + +1.6.4 / 2014-08-14 +================== + + * deps: qs@1.2.2 + +1.6.3 / 2014-08-10 +================== + + * deps: qs@1.2.1 + +1.6.2 / 2014-08-07 +================== + + * deps: qs@1.2.0 + - Fix parsing array of objects + +1.6.1 / 2014-08-06 +================== + + * deps: qs@1.1.0 + - Accept urlencoded square brackets + - Accept empty values in implicit array notation + +1.6.0 / 2014-08-05 +================== + + * deps: qs@1.0.2 + - Complete rewrite + - Limits array length to 20 + - Limits object depth to 5 + - Limits parameters to 1,000 + +1.5.2 / 2014-07-27 +================== + + * deps: depd@0.4.4 + - Work-around v8 generating empty stack traces + +1.5.1 / 2014-07-26 +================== + + * deps: depd@0.4.3 + - Fix exception when global `Error.stackTraceLimit` is too low + +1.5.0 / 2014-07-20 +================== + + * deps: depd@0.4.2 + - Add `TRACE_DEPRECATION` environment variable + - Remove non-standard grey color from color output + - Support `--no-deprecation` argument + - Support `--trace-deprecation` argument + * deps: iconv-lite@0.4.4 + - Added encoding UTF-7 + * deps: raw-body@1.3.0 + - deps: iconv-lite@0.4.4 + - Added encoding UTF-7 + - Fix `Cannot switch to old mode now` error on Node.js 0.10+ + * deps: type-is@~1.3.2 + +1.4.3 / 2014-06-19 +================== + + * deps: type-is@1.3.1 + - fix global variable leak + +1.4.2 / 2014-06-19 +================== + + * deps: type-is@1.3.0 + - improve type parsing + +1.4.1 / 2014-06-19 +================== + + * fix urlencoded extended deprecation message + +1.4.0 / 2014-06-19 +================== + + * add `text` parser + * add `raw` parser + * check accepted charset in content-type (accepts utf-8) + * check accepted encoding in content-encoding (accepts identity) + * deprecate `bodyParser()` middleware; use `.json()` and `.urlencoded()` as needed + * deprecate `urlencoded()` without provided `extended` option + * lazy-load urlencoded parsers + * parsers split into files for reduced mem usage + * support gzip and deflate bodies + - set `inflate: false` to turn off + * deps: raw-body@1.2.2 + - Support all encodings from `iconv-lite` + +1.3.1 / 2014-06-11 +================== + + * deps: type-is@1.2.1 + - Switch dependency from mime to mime-types@1.0.0 + +1.3.0 / 2014-05-31 +================== + + * add `extended` option to urlencoded parser + +1.2.2 / 2014-05-27 +================== + + * deps: raw-body@1.1.6 + - assert stream encoding on node.js 0.8 + - assert stream encoding on node.js < 0.10.6 + - deps: bytes@1 + +1.2.1 / 2014-05-26 +================== + + * invoke `next(err)` after request fully read + - prevents hung responses and socket hang ups + +1.2.0 / 2014-05-11 +================== + + * add `verify` option + * deps: type-is@1.2.0 + - support suffix matching + +1.1.2 / 2014-05-11 +================== + + * improve json parser speed + +1.1.1 / 2014-05-11 +================== + + * fix repeated limit parsing with every request + +1.1.0 / 2014-05-10 +================== + + * add `type` option + * deps: pin for safety and consistency + +1.0.2 / 2014-04-14 +================== + + * use `type-is` module + +1.0.1 / 2014-03-20 +================== + + * lower default limits to 100kb diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/LICENSE new file mode 100644 index 00000000..386b7b69 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/LICENSE @@ -0,0 +1,23 @@ +(The MIT License) + +Copyright (c) 2014 Jonathan Ong +Copyright (c) 2014-2015 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/README.md new file mode 100644 index 00000000..f6661b7d --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/README.md @@ -0,0 +1,476 @@ +# body-parser + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-url] +[![Build Status][ci-image]][ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] +[![OpenSSF Scorecard Badge][ossf-scorecard-badge]][ossf-scorecard-visualizer] + +Node.js body parsing middleware. + +Parse incoming request bodies in a middleware before your handlers, available +under the `req.body` property. + +**Note** As `req.body`'s shape is based on user-controlled input, all +properties and values in this object are untrusted and should be validated +before trusting. For example, `req.body.foo.toString()` may fail in multiple +ways, for example the `foo` property may not be there or may not be a string, +and `toString` may not be a function and instead a string or other user input. + +[Learn about the anatomy of an HTTP transaction in Node.js](https://nodejs.org/en/docs/guides/anatomy-of-an-http-transaction/). + +_This does not handle multipart bodies_, due to their complex and typically +large nature. For multipart bodies, you may be interested in the following +modules: + + * [busboy](https://www.npmjs.org/package/busboy#readme) and + [connect-busboy](https://www.npmjs.org/package/connect-busboy#readme) + * [multiparty](https://www.npmjs.org/package/multiparty#readme) and + [connect-multiparty](https://www.npmjs.org/package/connect-multiparty#readme) + * [formidable](https://www.npmjs.org/package/formidable#readme) + * [multer](https://www.npmjs.org/package/multer#readme) + +This module provides the following parsers: + + * [JSON body parser](#bodyparserjsonoptions) + * [Raw body parser](#bodyparserrawoptions) + * [Text body parser](#bodyparsertextoptions) + * [URL-encoded form body parser](#bodyparserurlencodedoptions) + +Other body parsers you might be interested in: + +- [body](https://www.npmjs.org/package/body#readme) +- [co-body](https://www.npmjs.org/package/co-body#readme) + +## Installation + +```sh +$ npm install body-parser +``` + +## API + +```js +var bodyParser = require('body-parser') +``` + +The `bodyParser` object exposes various factories to create middlewares. All +middlewares will populate the `req.body` property with the parsed body when +the `Content-Type` request header matches the `type` option, or an empty +object (`{}`) if there was no body to parse, the `Content-Type` was not matched, +or an error occurred. + +The various errors returned by this module are described in the +[errors section](#errors). + +### bodyParser.json([options]) + +Returns middleware that only parses `json` and only looks at requests where +the `Content-Type` header matches the `type` option. This parser accepts any +Unicode encoding of the body and supports automatic inflation of `gzip` and +`deflate` encodings. + +A new `body` object containing the parsed data is populated on the `request` +object after the middleware (i.e. `req.body`). + +#### Options + +The `json` function takes an optional `options` object that may contain any of +the following keys: + +##### inflate + +When set to `true`, then deflated (compressed) bodies will be inflated; when +`false`, deflated bodies are rejected. Defaults to `true`. + +##### limit + +Controls the maximum request body size. If this is a number, then the value +specifies the number of bytes; if it is a string, the value is passed to the +[bytes](https://www.npmjs.com/package/bytes) library for parsing. Defaults +to `'100kb'`. + +##### reviver + +The `reviver` option is passed directly to `JSON.parse` as the second +argument. You can find more information on this argument +[in the MDN documentation about JSON.parse](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Example.3A_Using_the_reviver_parameter). + +##### strict + +When set to `true`, will only accept arrays and objects; when `false` will +accept anything `JSON.parse` accepts. Defaults to `true`. + +##### type + +The `type` option is used to determine what media type the middleware will +parse. This option can be a string, array of strings, or a function. If not a +function, `type` option is passed directly to the +[type-is](https://www.npmjs.org/package/type-is#readme) library and this can +be an extension name (like `json`), a mime type (like `application/json`), or +a mime type with a wildcard (like `*/*` or `*/json`). If a function, the `type` +option is called as `fn(req)` and the request is parsed if it returns a truthy +value. Defaults to `application/json`. + +##### verify + +The `verify` option, if supplied, is called as `verify(req, res, buf, encoding)`, +where `buf` is a `Buffer` of the raw request body and `encoding` is the +encoding of the request. The parsing can be aborted by throwing an error. + +### bodyParser.raw([options]) + +Returns middleware that parses all bodies as a `Buffer` and only looks at +requests where the `Content-Type` header matches the `type` option. This +parser supports automatic inflation of `gzip` and `deflate` encodings. + +A new `body` object containing the parsed data is populated on the `request` +object after the middleware (i.e. `req.body`). This will be a `Buffer` object +of the body. + +#### Options + +The `raw` function takes an optional `options` object that may contain any of +the following keys: + +##### inflate + +When set to `true`, then deflated (compressed) bodies will be inflated; when +`false`, deflated bodies are rejected. Defaults to `true`. + +##### limit + +Controls the maximum request body size. If this is a number, then the value +specifies the number of bytes; if it is a string, the value is passed to the +[bytes](https://www.npmjs.com/package/bytes) library for parsing. Defaults +to `'100kb'`. + +##### type + +The `type` option is used to determine what media type the middleware will +parse. This option can be a string, array of strings, or a function. +If not a function, `type` option is passed directly to the +[type-is](https://www.npmjs.org/package/type-is#readme) library and this +can be an extension name (like `bin`), a mime type (like +`application/octet-stream`), or a mime type with a wildcard (like `*/*` or +`application/*`). If a function, the `type` option is called as `fn(req)` +and the request is parsed if it returns a truthy value. Defaults to +`application/octet-stream`. + +##### verify + +The `verify` option, if supplied, is called as `verify(req, res, buf, encoding)`, +where `buf` is a `Buffer` of the raw request body and `encoding` is the +encoding of the request. The parsing can be aborted by throwing an error. + +### bodyParser.text([options]) + +Returns middleware that parses all bodies as a string and only looks at +requests where the `Content-Type` header matches the `type` option. This +parser supports automatic inflation of `gzip` and `deflate` encodings. + +A new `body` string containing the parsed data is populated on the `request` +object after the middleware (i.e. `req.body`). This will be a string of the +body. + +#### Options + +The `text` function takes an optional `options` object that may contain any of +the following keys: + +##### defaultCharset + +Specify the default character set for the text content if the charset is not +specified in the `Content-Type` header of the request. Defaults to `utf-8`. + +##### inflate + +When set to `true`, then deflated (compressed) bodies will be inflated; when +`false`, deflated bodies are rejected. Defaults to `true`. + +##### limit + +Controls the maximum request body size. If this is a number, then the value +specifies the number of bytes; if it is a string, the value is passed to the +[bytes](https://www.npmjs.com/package/bytes) library for parsing. Defaults +to `'100kb'`. + +##### type + +The `type` option is used to determine what media type the middleware will +parse. This option can be a string, array of strings, or a function. If not +a function, `type` option is passed directly to the +[type-is](https://www.npmjs.org/package/type-is#readme) library and this can +be an extension name (like `txt`), a mime type (like `text/plain`), or a mime +type with a wildcard (like `*/*` or `text/*`). If a function, the `type` +option is called as `fn(req)` and the request is parsed if it returns a +truthy value. Defaults to `text/plain`. + +##### verify + +The `verify` option, if supplied, is called as `verify(req, res, buf, encoding)`, +where `buf` is a `Buffer` of the raw request body and `encoding` is the +encoding of the request. The parsing can be aborted by throwing an error. + +### bodyParser.urlencoded([options]) + +Returns middleware that only parses `urlencoded` bodies and only looks at +requests where the `Content-Type` header matches the `type` option. This +parser accepts only UTF-8 encoding of the body and supports automatic +inflation of `gzip` and `deflate` encodings. + +A new `body` object containing the parsed data is populated on the `request` +object after the middleware (i.e. `req.body`). This object will contain +key-value pairs, where the value can be a string or array (when `extended` is +`false`), or any type (when `extended` is `true`). + +#### Options + +The `urlencoded` function takes an optional `options` object that may contain +any of the following keys: + +##### extended + +The `extended` option allows to choose between parsing the URL-encoded data +with the `querystring` library (when `false`) or the `qs` library (when +`true`). The "extended" syntax allows for rich objects and arrays to be +encoded into the URL-encoded format, allowing for a JSON-like experience +with URL-encoded. For more information, please +[see the qs library](https://www.npmjs.org/package/qs#readme). + +Defaults to `true`, but using the default has been deprecated. Please +research into the difference between `qs` and `querystring` and choose the +appropriate setting. + +##### inflate + +When set to `true`, then deflated (compressed) bodies will be inflated; when +`false`, deflated bodies are rejected. Defaults to `true`. + +##### limit + +Controls the maximum request body size. If this is a number, then the value +specifies the number of bytes; if it is a string, the value is passed to the +[bytes](https://www.npmjs.com/package/bytes) library for parsing. Defaults +to `'100kb'`. + +##### parameterLimit + +The `parameterLimit` option controls the maximum number of parameters that +are allowed in the URL-encoded data. If a request contains more parameters +than this value, a 413 will be returned to the client. Defaults to `1000`. + +##### type + +The `type` option is used to determine what media type the middleware will +parse. This option can be a string, array of strings, or a function. If not +a function, `type` option is passed directly to the +[type-is](https://www.npmjs.org/package/type-is#readme) library and this can +be an extension name (like `urlencoded`), a mime type (like +`application/x-www-form-urlencoded`), or a mime type with a wildcard (like +`*/x-www-form-urlencoded`). If a function, the `type` option is called as +`fn(req)` and the request is parsed if it returns a truthy value. Defaults +to `application/x-www-form-urlencoded`. + +##### verify + +The `verify` option, if supplied, is called as `verify(req, res, buf, encoding)`, +where `buf` is a `Buffer` of the raw request body and `encoding` is the +encoding of the request. The parsing can be aborted by throwing an error. + +#### depth + +The `depth` option is used to configure the maximum depth of the `qs` library when `extended` is `true`. This allows you to limit the amount of keys that are parsed and can be useful to prevent certain types of abuse. Defaults to `32`. It is recommended to keep this value as low as possible. + +## Errors + +The middlewares provided by this module create errors using the +[`http-errors` module](https://www.npmjs.com/package/http-errors). The errors +will typically have a `status`/`statusCode` property that contains the suggested +HTTP response code, an `expose` property to determine if the `message` property +should be displayed to the client, a `type` property to determine the type of +error without matching against the `message`, and a `body` property containing +the read body, if available. + +The following are the common errors created, though any error can come through +for various reasons. + +### content encoding unsupported + +This error will occur when the request had a `Content-Encoding` header that +contained an encoding but the "inflation" option was set to `false`. The +`status` property is set to `415`, the `type` property is set to +`'encoding.unsupported'`, and the `charset` property will be set to the +encoding that is unsupported. + +### entity parse failed + +This error will occur when the request contained an entity that could not be +parsed by the middleware. The `status` property is set to `400`, the `type` +property is set to `'entity.parse.failed'`, and the `body` property is set to +the entity value that failed parsing. + +### entity verify failed + +This error will occur when the request contained an entity that could not be +failed verification by the defined `verify` option. The `status` property is +set to `403`, the `type` property is set to `'entity.verify.failed'`, and the +`body` property is set to the entity value that failed verification. + +### request aborted + +This error will occur when the request is aborted by the client before reading +the body has finished. The `received` property will be set to the number of +bytes received before the request was aborted and the `expected` property is +set to the number of expected bytes. The `status` property is set to `400` +and `type` property is set to `'request.aborted'`. + +### request entity too large + +This error will occur when the request body's size is larger than the "limit" +option. The `limit` property will be set to the byte limit and the `length` +property will be set to the request body's length. The `status` property is +set to `413` and the `type` property is set to `'entity.too.large'`. + +### request size did not match content length + +This error will occur when the request's length did not match the length from +the `Content-Length` header. This typically occurs when the request is malformed, +typically when the `Content-Length` header was calculated based on characters +instead of bytes. The `status` property is set to `400` and the `type` property +is set to `'request.size.invalid'`. + +### stream encoding should not be set + +This error will occur when something called the `req.setEncoding` method prior +to this middleware. This module operates directly on bytes only and you cannot +call `req.setEncoding` when using this module. The `status` property is set to +`500` and the `type` property is set to `'stream.encoding.set'`. + +### stream is not readable + +This error will occur when the request is no longer readable when this middleware +attempts to read it. This typically means something other than a middleware from +this module read the request body already and the middleware was also configured to +read the same request. The `status` property is set to `500` and the `type` +property is set to `'stream.not.readable'`. + +### too many parameters + +This error will occur when the content of the request exceeds the configured +`parameterLimit` for the `urlencoded` parser. The `status` property is set to +`413` and the `type` property is set to `'parameters.too.many'`. + +### unsupported charset "BOGUS" + +This error will occur when the request had a charset parameter in the +`Content-Type` header, but the `iconv-lite` module does not support it OR the +parser does not support it. The charset is contained in the message as well +as in the `charset` property. The `status` property is set to `415`, the +`type` property is set to `'charset.unsupported'`, and the `charset` property +is set to the charset that is unsupported. + +### unsupported content encoding "bogus" + +This error will occur when the request had a `Content-Encoding` header that +contained an unsupported encoding. The encoding is contained in the message +as well as in the `encoding` property. The `status` property is set to `415`, +the `type` property is set to `'encoding.unsupported'`, and the `encoding` +property is set to the encoding that is unsupported. + +### The input exceeded the depth + +This error occurs when using `bodyParser.urlencoded` with the `extended` property set to `true` and the input exceeds the configured `depth` option. The `status` property is set to `400`. It is recommended to review the `depth` option and evaluate if it requires a higher value. When the `depth` option is set to `32` (default value), the error will not be thrown. + +## Examples + +### Express/Connect top-level generic + +This example demonstrates adding a generic JSON and URL-encoded parser as a +top-level middleware, which will parse the bodies of all incoming requests. +This is the simplest setup. + +```js +var express = require('express') +var bodyParser = require('body-parser') + +var app = express() + +// parse application/x-www-form-urlencoded +app.use(bodyParser.urlencoded({ extended: false })) + +// parse application/json +app.use(bodyParser.json()) + +app.use(function (req, res) { + res.setHeader('Content-Type', 'text/plain') + res.write('you posted:\n') + res.end(JSON.stringify(req.body, null, 2)) +}) +``` + +### Express route-specific + +This example demonstrates adding body parsers specifically to the routes that +need them. In general, this is the most recommended way to use body-parser with +Express. + +```js +var express = require('express') +var bodyParser = require('body-parser') + +var app = express() + +// create application/json parser +var jsonParser = bodyParser.json() + +// create application/x-www-form-urlencoded parser +var urlencodedParser = bodyParser.urlencoded({ extended: false }) + +// POST /login gets urlencoded bodies +app.post('/login', urlencodedParser, function (req, res) { + res.send('welcome, ' + req.body.username) +}) + +// POST /api/users gets JSON bodies +app.post('/api/users', jsonParser, function (req, res) { + // create user in req.body +}) +``` + +### Change accepted type for parsers + +All the parsers accept a `type` option which allows you to change the +`Content-Type` that the middleware will parse. + +```js +var express = require('express') +var bodyParser = require('body-parser') + +var app = express() + +// parse various different custom JSON types as JSON +app.use(bodyParser.json({ type: 'application/*+json' })) + +// parse some custom thing into a Buffer +app.use(bodyParser.raw({ type: 'application/vnd.custom-type' })) + +// parse an HTML body into a string +app.use(bodyParser.text({ type: 'text/html' })) +``` + +## License + +[MIT](LICENSE) + +[ci-image]: https://badgen.net/github/checks/expressjs/body-parser/master?label=ci +[ci-url]: https://github.com/expressjs/body-parser/actions/workflows/ci.yml +[coveralls-image]: https://badgen.net/coveralls/c/github/expressjs/body-parser/master +[coveralls-url]: https://coveralls.io/r/expressjs/body-parser?branch=master +[node-version-image]: https://badgen.net/npm/node/body-parser +[node-version-url]: https://nodejs.org/en/download +[npm-downloads-image]: https://badgen.net/npm/dm/body-parser +[npm-url]: https://npmjs.org/package/body-parser +[npm-version-image]: https://badgen.net/npm/v/body-parser +[ossf-scorecard-badge]: https://api.scorecard.dev/projects/github.com/expressjs/body-parser/badge +[ossf-scorecard-visualizer]: https://ossf.github.io/scorecard-visualizer/#/projects/github.com/expressjs/body-parser \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/SECURITY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/SECURITY.md new file mode 100644 index 00000000..9694d429 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/SECURITY.md @@ -0,0 +1,25 @@ +# Security Policies and Procedures + +## Reporting a Bug + +The Express team and community take all security bugs seriously. Thank you +for improving the security of Express. We appreciate your efforts and +responsible disclosure and will make every effort to acknowledge your +contributions. + +Report security bugs by emailing the current owner(s) of `body-parser`. This +information can be found in the npm registry using the command +`npm owner ls body-parser`. +If unsure or unable to get the information from the above, open an issue +in the [project issue tracker](https://github.com/expressjs/body-parser/issues) +asking for the current contact information. + +To ensure the timely response to your report, please ensure that the entirety +of the report is contained within the email body and not solely behind a web +link or an attachment. + +At least one owner will acknowledge your email within 48 hours, and will send a +more detailed response within 48 hours indicating the next steps in handling +your report. After the initial reply to your report, the owners will +endeavor to keep you informed of the progress towards a fix and full +announcement, and may ask for additional information or guidance. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/index.js new file mode 100644 index 00000000..bb24d739 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/index.js @@ -0,0 +1,156 @@ +/*! + * body-parser + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var deprecate = require('depd')('body-parser') + +/** + * Cache of loaded parsers. + * @private + */ + +var parsers = Object.create(null) + +/** + * @typedef Parsers + * @type {function} + * @property {function} json + * @property {function} raw + * @property {function} text + * @property {function} urlencoded + */ + +/** + * Module exports. + * @type {Parsers} + */ + +exports = module.exports = deprecate.function(bodyParser, + 'bodyParser: use individual json/urlencoded middlewares') + +/** + * JSON parser. + * @public + */ + +Object.defineProperty(exports, 'json', { + configurable: true, + enumerable: true, + get: createParserGetter('json') +}) + +/** + * Raw parser. + * @public + */ + +Object.defineProperty(exports, 'raw', { + configurable: true, + enumerable: true, + get: createParserGetter('raw') +}) + +/** + * Text parser. + * @public + */ + +Object.defineProperty(exports, 'text', { + configurable: true, + enumerable: true, + get: createParserGetter('text') +}) + +/** + * URL-encoded parser. + * @public + */ + +Object.defineProperty(exports, 'urlencoded', { + configurable: true, + enumerable: true, + get: createParserGetter('urlencoded') +}) + +/** + * Create a middleware to parse json and urlencoded bodies. + * + * @param {object} [options] + * @return {function} + * @deprecated + * @public + */ + +function bodyParser (options) { + // use default type for parsers + var opts = Object.create(options || null, { + type: { + configurable: true, + enumerable: true, + value: undefined, + writable: true + } + }) + + var _urlencoded = exports.urlencoded(opts) + var _json = exports.json(opts) + + return function bodyParser (req, res, next) { + _json(req, res, function (err) { + if (err) return next(err) + _urlencoded(req, res, next) + }) + } +} + +/** + * Create a getter for loading a parser. + * @private + */ + +function createParserGetter (name) { + return function get () { + return loadParser(name) + } +} + +/** + * Load a parser module. + * @private + */ + +function loadParser (parserName) { + var parser = parsers[parserName] + + if (parser !== undefined) { + return parser + } + + // this uses a switch for static require analysis + switch (parserName) { + case 'json': + parser = require('./lib/types/json') + break + case 'raw': + parser = require('./lib/types/raw') + break + case 'text': + parser = require('./lib/types/text') + break + case 'urlencoded': + parser = require('./lib/types/urlencoded') + break + } + + // store to prevent invoking require() + return (parsers[parserName] = parser) +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/read.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/read.js new file mode 100644 index 00000000..fce6283f --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/read.js @@ -0,0 +1,205 @@ +/*! + * body-parser + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var createError = require('http-errors') +var destroy = require('destroy') +var getBody = require('raw-body') +var iconv = require('iconv-lite') +var onFinished = require('on-finished') +var unpipe = require('unpipe') +var zlib = require('zlib') + +/** + * Module exports. + */ + +module.exports = read + +/** + * Read a request into a buffer and parse. + * + * @param {object} req + * @param {object} res + * @param {function} next + * @param {function} parse + * @param {function} debug + * @param {object} options + * @private + */ + +function read (req, res, next, parse, debug, options) { + var length + var opts = options + var stream + + // flag as parsed + req._body = true + + // read options + var encoding = opts.encoding !== null + ? opts.encoding + : null + var verify = opts.verify + + try { + // get the content stream + stream = contentstream(req, debug, opts.inflate) + length = stream.length + stream.length = undefined + } catch (err) { + return next(err) + } + + // set raw-body options + opts.length = length + opts.encoding = verify + ? null + : encoding + + // assert charset is supported + if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) { + return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', { + charset: encoding.toLowerCase(), + type: 'charset.unsupported' + })) + } + + // read body + debug('read body') + getBody(stream, opts, function (error, body) { + if (error) { + var _error + + if (error.type === 'encoding.unsupported') { + // echo back charset + _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', { + charset: encoding.toLowerCase(), + type: 'charset.unsupported' + }) + } else { + // set status code on error + _error = createError(400, error) + } + + // unpipe from stream and destroy + if (stream !== req) { + unpipe(req) + destroy(stream, true) + } + + // read off entire request + dump(req, function onfinished () { + next(createError(400, _error)) + }) + return + } + + // verify + if (verify) { + try { + debug('verify body') + verify(req, res, body, encoding) + } catch (err) { + next(createError(403, err, { + body: body, + type: err.type || 'entity.verify.failed' + })) + return + } + } + + // parse + var str = body + try { + debug('parse body') + str = typeof body !== 'string' && encoding !== null + ? iconv.decode(body, encoding) + : body + req.body = parse(str) + } catch (err) { + next(createError(400, err, { + body: str, + type: err.type || 'entity.parse.failed' + })) + return + } + + next() + }) +} + +/** + * Get the content stream of the request. + * + * @param {object} req + * @param {function} debug + * @param {boolean} [inflate=true] + * @return {object} + * @api private + */ + +function contentstream (req, debug, inflate) { + var encoding = (req.headers['content-encoding'] || 'identity').toLowerCase() + var length = req.headers['content-length'] + var stream + + debug('content-encoding "%s"', encoding) + + if (inflate === false && encoding !== 'identity') { + throw createError(415, 'content encoding unsupported', { + encoding: encoding, + type: 'encoding.unsupported' + }) + } + + switch (encoding) { + case 'deflate': + stream = zlib.createInflate() + debug('inflate body') + req.pipe(stream) + break + case 'gzip': + stream = zlib.createGunzip() + debug('gunzip body') + req.pipe(stream) + break + case 'identity': + stream = req + stream.length = length + break + default: + throw createError(415, 'unsupported content encoding "' + encoding + '"', { + encoding: encoding, + type: 'encoding.unsupported' + }) + } + + return stream +} + +/** + * Dump the contents of a request. + * + * @param {object} req + * @param {function} callback + * @api private + */ + +function dump (req, callback) { + if (onFinished.isFinished(req)) { + callback(null) + } else { + onFinished(req, callback) + req.resume() + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/json.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/json.js new file mode 100644 index 00000000..59f3f7e2 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/json.js @@ -0,0 +1,247 @@ +/*! + * body-parser + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var bytes = require('bytes') +var contentType = require('content-type') +var createError = require('http-errors') +var debug = require('debug')('body-parser:json') +var read = require('../read') +var typeis = require('type-is') + +/** + * Module exports. + */ + +module.exports = json + +/** + * RegExp to match the first non-space in a string. + * + * Allowed whitespace is defined in RFC 7159: + * + * ws = *( + * %x20 / ; Space + * %x09 / ; Horizontal tab + * %x0A / ; Line feed or New line + * %x0D ) ; Carriage return + */ + +var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/ // eslint-disable-line no-control-regex + +var JSON_SYNTAX_CHAR = '#' +var JSON_SYNTAX_REGEXP = /#+/g + +/** + * Create a middleware to parse JSON bodies. + * + * @param {object} [options] + * @return {function} + * @public + */ + +function json (options) { + var opts = options || {} + + var limit = typeof opts.limit !== 'number' + ? bytes.parse(opts.limit || '100kb') + : opts.limit + var inflate = opts.inflate !== false + var reviver = opts.reviver + var strict = opts.strict !== false + var type = opts.type || 'application/json' + var verify = opts.verify || false + + if (verify !== false && typeof verify !== 'function') { + throw new TypeError('option verify must be function') + } + + // create the appropriate type checking function + var shouldParse = typeof type !== 'function' + ? typeChecker(type) + : type + + function parse (body) { + if (body.length === 0) { + // special-case empty json body, as it's a common client-side mistake + // TODO: maybe make this configurable or part of "strict" option + return {} + } + + if (strict) { + var first = firstchar(body) + + if (first !== '{' && first !== '[') { + debug('strict violation') + throw createStrictSyntaxError(body, first) + } + } + + try { + debug('parse json') + return JSON.parse(body, reviver) + } catch (e) { + throw normalizeJsonSyntaxError(e, { + message: e.message, + stack: e.stack + }) + } + } + + return function jsonParser (req, res, next) { + if (req._body) { + debug('body already parsed') + next() + return + } + + req.body = req.body || {} + + // skip requests without bodies + if (!typeis.hasBody(req)) { + debug('skip empty body') + next() + return + } + + debug('content-type %j', req.headers['content-type']) + + // determine if request should be parsed + if (!shouldParse(req)) { + debug('skip parsing') + next() + return + } + + // assert charset per RFC 7159 sec 8.1 + var charset = getCharset(req) || 'utf-8' + if (charset.slice(0, 4) !== 'utf-') { + debug('invalid charset') + next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', { + charset: charset, + type: 'charset.unsupported' + })) + return + } + + // read + read(req, res, next, parse, debug, { + encoding: charset, + inflate: inflate, + limit: limit, + verify: verify + }) + } +} + +/** + * Create strict violation syntax error matching native error. + * + * @param {string} str + * @param {string} char + * @return {Error} + * @private + */ + +function createStrictSyntaxError (str, char) { + var index = str.indexOf(char) + var partial = '' + + if (index !== -1) { + partial = str.substring(0, index) + JSON_SYNTAX_CHAR + + for (var i = index + 1; i < str.length; i++) { + partial += JSON_SYNTAX_CHAR + } + } + + try { + JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation') + } catch (e) { + return normalizeJsonSyntaxError(e, { + message: e.message.replace(JSON_SYNTAX_REGEXP, function (placeholder) { + return str.substring(index, index + placeholder.length) + }), + stack: e.stack + }) + } +} + +/** + * Get the first non-whitespace character in a string. + * + * @param {string} str + * @return {function} + * @private + */ + +function firstchar (str) { + var match = FIRST_CHAR_REGEXP.exec(str) + + return match + ? match[1] + : undefined +} + +/** + * Get the charset of a request. + * + * @param {object} req + * @api private + */ + +function getCharset (req) { + try { + return (contentType.parse(req).parameters.charset || '').toLowerCase() + } catch (e) { + return undefined + } +} + +/** + * Normalize a SyntaxError for JSON.parse. + * + * @param {SyntaxError} error + * @param {object} obj + * @return {SyntaxError} + */ + +function normalizeJsonSyntaxError (error, obj) { + var keys = Object.getOwnPropertyNames(error) + + for (var i = 0; i < keys.length; i++) { + var key = keys[i] + if (key !== 'stack' && key !== 'message') { + delete error[key] + } + } + + // replace stack before message for Node.js 0.10 and below + error.stack = obj.stack.replace(error.message, obj.message) + error.message = obj.message + + return error +} + +/** + * Get the simple type checker. + * + * @param {string} type + * @return {function} + */ + +function typeChecker (type) { + return function checkType (req) { + return Boolean(typeis(req, type)) + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/raw.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/raw.js new file mode 100644 index 00000000..f5d1b674 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/raw.js @@ -0,0 +1,101 @@ +/*! + * body-parser + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + */ + +var bytes = require('bytes') +var debug = require('debug')('body-parser:raw') +var read = require('../read') +var typeis = require('type-is') + +/** + * Module exports. + */ + +module.exports = raw + +/** + * Create a middleware to parse raw bodies. + * + * @param {object} [options] + * @return {function} + * @api public + */ + +function raw (options) { + var opts = options || {} + + var inflate = opts.inflate !== false + var limit = typeof opts.limit !== 'number' + ? bytes.parse(opts.limit || '100kb') + : opts.limit + var type = opts.type || 'application/octet-stream' + var verify = opts.verify || false + + if (verify !== false && typeof verify !== 'function') { + throw new TypeError('option verify must be function') + } + + // create the appropriate type checking function + var shouldParse = typeof type !== 'function' + ? typeChecker(type) + : type + + function parse (buf) { + return buf + } + + return function rawParser (req, res, next) { + if (req._body) { + debug('body already parsed') + next() + return + } + + req.body = req.body || {} + + // skip requests without bodies + if (!typeis.hasBody(req)) { + debug('skip empty body') + next() + return + } + + debug('content-type %j', req.headers['content-type']) + + // determine if request should be parsed + if (!shouldParse(req)) { + debug('skip parsing') + next() + return + } + + // read + read(req, res, next, parse, debug, { + encoding: null, + inflate: inflate, + limit: limit, + verify: verify + }) + } +} + +/** + * Get the simple type checker. + * + * @param {string} type + * @return {function} + */ + +function typeChecker (type) { + return function checkType (req) { + return Boolean(typeis(req, type)) + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/text.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/text.js new file mode 100644 index 00000000..083a0090 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/text.js @@ -0,0 +1,121 @@ +/*! + * body-parser + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + */ + +var bytes = require('bytes') +var contentType = require('content-type') +var debug = require('debug')('body-parser:text') +var read = require('../read') +var typeis = require('type-is') + +/** + * Module exports. + */ + +module.exports = text + +/** + * Create a middleware to parse text bodies. + * + * @param {object} [options] + * @return {function} + * @api public + */ + +function text (options) { + var opts = options || {} + + var defaultCharset = opts.defaultCharset || 'utf-8' + var inflate = opts.inflate !== false + var limit = typeof opts.limit !== 'number' + ? bytes.parse(opts.limit || '100kb') + : opts.limit + var type = opts.type || 'text/plain' + var verify = opts.verify || false + + if (verify !== false && typeof verify !== 'function') { + throw new TypeError('option verify must be function') + } + + // create the appropriate type checking function + var shouldParse = typeof type !== 'function' + ? typeChecker(type) + : type + + function parse (buf) { + return buf + } + + return function textParser (req, res, next) { + if (req._body) { + debug('body already parsed') + next() + return + } + + req.body = req.body || {} + + // skip requests without bodies + if (!typeis.hasBody(req)) { + debug('skip empty body') + next() + return + } + + debug('content-type %j', req.headers['content-type']) + + // determine if request should be parsed + if (!shouldParse(req)) { + debug('skip parsing') + next() + return + } + + // get charset + var charset = getCharset(req) || defaultCharset + + // read + read(req, res, next, parse, debug, { + encoding: charset, + inflate: inflate, + limit: limit, + verify: verify + }) + } +} + +/** + * Get the charset of a request. + * + * @param {object} req + * @api private + */ + +function getCharset (req) { + try { + return (contentType.parse(req).parameters.charset || '').toLowerCase() + } catch (e) { + return undefined + } +} + +/** + * Get the simple type checker. + * + * @param {string} type + * @return {function} + */ + +function typeChecker (type) { + return function checkType (req) { + return Boolean(typeis(req, type)) + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/urlencoded.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/urlencoded.js new file mode 100644 index 00000000..2bd4485f --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/lib/types/urlencoded.js @@ -0,0 +1,307 @@ +/*! + * body-parser + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var bytes = require('bytes') +var contentType = require('content-type') +var createError = require('http-errors') +var debug = require('debug')('body-parser:urlencoded') +var deprecate = require('depd')('body-parser') +var read = require('../read') +var typeis = require('type-is') + +/** + * Module exports. + */ + +module.exports = urlencoded + +/** + * Cache of parser modules. + */ + +var parsers = Object.create(null) + +/** + * Create a middleware to parse urlencoded bodies. + * + * @param {object} [options] + * @return {function} + * @public + */ + +function urlencoded (options) { + var opts = options || {} + + // notice because option default will flip in next major + if (opts.extended === undefined) { + deprecate('undefined extended: provide extended option') + } + + var extended = opts.extended !== false + var inflate = opts.inflate !== false + var limit = typeof opts.limit !== 'number' + ? bytes.parse(opts.limit || '100kb') + : opts.limit + var type = opts.type || 'application/x-www-form-urlencoded' + var verify = opts.verify || false + var depth = typeof opts.depth !== 'number' + ? Number(opts.depth || 32) + : opts.depth + + if (verify !== false && typeof verify !== 'function') { + throw new TypeError('option verify must be function') + } + + // create the appropriate query parser + var queryparse = extended + ? extendedparser(opts) + : simpleparser(opts) + + // create the appropriate type checking function + var shouldParse = typeof type !== 'function' + ? typeChecker(type) + : type + + function parse (body) { + return body.length + ? queryparse(body) + : {} + } + + return function urlencodedParser (req, res, next) { + if (req._body) { + debug('body already parsed') + next() + return + } + + req.body = req.body || {} + + // skip requests without bodies + if (!typeis.hasBody(req)) { + debug('skip empty body') + next() + return + } + + debug('content-type %j', req.headers['content-type']) + + // determine if request should be parsed + if (!shouldParse(req)) { + debug('skip parsing') + next() + return + } + + // assert charset + var charset = getCharset(req) || 'utf-8' + if (charset !== 'utf-8') { + debug('invalid charset') + next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', { + charset: charset, + type: 'charset.unsupported' + })) + return + } + + // read + read(req, res, next, parse, debug, { + debug: debug, + encoding: charset, + inflate: inflate, + limit: limit, + verify: verify, + depth: depth + }) + } +} + +/** + * Get the extended query parser. + * + * @param {object} options + */ + +function extendedparser (options) { + var parameterLimit = options.parameterLimit !== undefined + ? options.parameterLimit + : 1000 + + var depth = typeof options.depth !== 'number' + ? Number(options.depth || 32) + : options.depth + var parse = parser('qs') + + if (isNaN(parameterLimit) || parameterLimit < 1) { + throw new TypeError('option parameterLimit must be a positive number') + } + + if (isNaN(depth) || depth < 0) { + throw new TypeError('option depth must be a zero or a positive number') + } + + if (isFinite(parameterLimit)) { + parameterLimit = parameterLimit | 0 + } + + return function queryparse (body) { + var paramCount = parameterCount(body, parameterLimit) + + if (paramCount === undefined) { + debug('too many parameters') + throw createError(413, 'too many parameters', { + type: 'parameters.too.many' + }) + } + + var arrayLimit = Math.max(100, paramCount) + + debug('parse extended urlencoding') + try { + return parse(body, { + allowPrototypes: true, + arrayLimit: arrayLimit, + depth: depth, + strictDepth: true, + parameterLimit: parameterLimit + }) + } catch (err) { + if (err instanceof RangeError) { + throw createError(400, 'The input exceeded the depth', { + type: 'querystring.parse.rangeError' + }) + } else { + throw err + } + } + } +} + +/** + * Get the charset of a request. + * + * @param {object} req + * @api private + */ + +function getCharset (req) { + try { + return (contentType.parse(req).parameters.charset || '').toLowerCase() + } catch (e) { + return undefined + } +} + +/** + * Count the number of parameters, stopping once limit reached + * + * @param {string} body + * @param {number} limit + * @api private + */ + +function parameterCount (body, limit) { + var count = 0 + var index = 0 + + while ((index = body.indexOf('&', index)) !== -1) { + count++ + index++ + + if (count === limit) { + return undefined + } + } + + return count +} + +/** + * Get parser for module name dynamically. + * + * @param {string} name + * @return {function} + * @api private + */ + +function parser (name) { + var mod = parsers[name] + + if (mod !== undefined) { + return mod.parse + } + + // this uses a switch for static require analysis + switch (name) { + case 'qs': + mod = require('qs') + break + case 'querystring': + mod = require('querystring') + break + } + + // store to prevent invoking require() + parsers[name] = mod + + return mod.parse +} + +/** + * Get the simple query parser. + * + * @param {object} options + */ + +function simpleparser (options) { + var parameterLimit = options.parameterLimit !== undefined + ? options.parameterLimit + : 1000 + var parse = parser('querystring') + + if (isNaN(parameterLimit) || parameterLimit < 1) { + throw new TypeError('option parameterLimit must be a positive number') + } + + if (isFinite(parameterLimit)) { + parameterLimit = parameterLimit | 0 + } + + return function queryparse (body) { + var paramCount = parameterCount(body, parameterLimit) + + if (paramCount === undefined) { + debug('too many parameters') + throw createError(413, 'too many parameters', { + type: 'parameters.too.many' + }) + } + + debug('parse urlencoding') + return parse(body, undefined, undefined, { maxKeys: parameterLimit }) + } +} + +/** + * Get the simple type checker. + * + * @param {string} type + * @return {function} + */ + +function typeChecker (type) { + return function checkType (req) { + return Boolean(typeis(req, type)) + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/package.json new file mode 100644 index 00000000..3c9926fc --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/body-parser/package.json @@ -0,0 +1,56 @@ +{ + "name": "body-parser", + "description": "Node.js body parsing middleware", + "version": "1.20.3", + "contributors": [ + "Douglas Christopher Wilson ", + "Jonathan Ong (http://jongleberry.com)" + ], + "license": "MIT", + "repository": "expressjs/body-parser", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.13.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "devDependencies": { + "eslint": "8.34.0", + "eslint-config-standard": "14.1.1", + "eslint-plugin-import": "2.27.5", + "eslint-plugin-markdown": "3.0.0", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "6.1.1", + "eslint-plugin-standard": "4.1.0", + "methods": "1.1.2", + "mocha": "10.2.0", + "nyc": "15.1.0", + "safe-buffer": "5.2.1", + "supertest": "6.3.3" + }, + "files": [ + "lib/", + "LICENSE", + "HISTORY.md", + "SECURITY.md", + "index.js" + ], + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --require test/support/env --reporter spec --check-leaks --bail test/", + "test-ci": "nyc --reporter=lcov --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/History.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/History.md new file mode 100644 index 00000000..d60ce0e6 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/History.md @@ -0,0 +1,97 @@ +3.1.2 / 2022-01-27 +================== + + * Fix return value for un-parsable strings + +3.1.1 / 2021-11-15 +================== + + * Fix "thousandsSeparator" incorrecting formatting fractional part + +3.1.0 / 2019-01-22 +================== + + * Add petabyte (`pb`) support + +3.0.0 / 2017-08-31 +================== + + * Change "kB" to "KB" in format output + * Remove support for Node.js 0.6 + * Remove support for ComponentJS + +2.5.0 / 2017-03-24 +================== + + * Add option "unit" + +2.4.0 / 2016-06-01 +================== + + * Add option "unitSeparator" + +2.3.0 / 2016-02-15 +================== + + * Drop partial bytes on all parsed units + * Fix non-finite numbers to `.format` to return `null` + * Fix parsing byte string that looks like hex + * perf: hoist regular expressions + +2.2.0 / 2015-11-13 +================== + + * add option "decimalPlaces" + * add option "fixedDecimals" + +2.1.0 / 2015-05-21 +================== + + * add `.format` export + * add `.parse` export + +2.0.2 / 2015-05-20 +================== + + * remove map recreation + * remove unnecessary object construction + +2.0.1 / 2015-05-07 +================== + + * fix browserify require + * remove node.extend dependency + +2.0.0 / 2015-04-12 +================== + + * add option "case" + * add option "thousandsSeparator" + * return "null" on invalid parse input + * support proper round-trip: bytes(bytes(num)) === num + * units no longer case sensitive when parsing + +1.0.0 / 2014-05-05 +================== + + * add negative support. fixes #6 + +0.3.0 / 2014-03-19 +================== + + * added terabyte support + +0.2.1 / 2013-04-01 +================== + + * add .component + +0.2.0 / 2012-10-28 +================== + + * bytes(200).should.eql('200b') + +0.1.0 / 2012-07-04 +================== + + * add bytes to string conversion [yields] diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/LICENSE new file mode 100644 index 00000000..63e95a96 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/LICENSE @@ -0,0 +1,23 @@ +(The MIT License) + +Copyright (c) 2012-2014 TJ Holowaychuk +Copyright (c) 2015 Jed Watson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/Readme.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/Readme.md new file mode 100644 index 00000000..5790e23e --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/Readme.md @@ -0,0 +1,152 @@ +# Bytes utility + +[![NPM Version][npm-image]][npm-url] +[![NPM Downloads][downloads-image]][downloads-url] +[![Build Status][ci-image]][ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] + +Utility to parse a string bytes (ex: `1TB`) to bytes (`1099511627776`) and vice-versa. + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```bash +$ npm install bytes +``` + +## Usage + +```js +var bytes = require('bytes'); +``` + +#### bytes(number｜string value, [options]): number｜string｜null + +Default export function. Delegates to either `bytes.format` or `bytes.parse` based on the type of `value`. + +**Arguments** + +| Name | Type | Description | +|---------|----------|--------------------| +| value | `number`｜`string` | Number value to format or string value to parse | +| options | `Object` | Conversion options for `format` | + +**Returns** + +| Name | Type | Description | +|---------|------------------|-------------------------------------------------| +| results | `string`｜`number`｜`null` | Return null upon error. Numeric value in bytes, or string value otherwise. | + +**Example** + +```js +bytes(1024); +// output: '1KB' + +bytes('1KB'); +// output: 1024 +``` + +#### bytes.format(number value, [options]): string｜null + +Format the given value in bytes into a string. If the value is negative, it is kept as such. If it is a float, it is + rounded. + +**Arguments** + +| Name | Type | Description | +|---------|----------|--------------------| +| value | `number` | Value in bytes | +| options | `Object` | Conversion options | + +**Options** + +| Property | Type | Description | +|-------------------|--------|-----------------------------------------------------------------------------------------| +| decimalPlaces | `number`｜`null` | Maximum number of decimal places to include in output. Default value to `2`. | +| fixedDecimals | `boolean`｜`null` | Whether to always display the maximum number of decimal places. Default value to `false` | +| thousandsSeparator | `string`｜`null` | Example of values: `' '`, `','` and `'.'`... Default value to `''`. | +| unit | `string`｜`null` | The unit in which the result will be returned (B/KB/MB/GB/TB). Default value to `''` (which means auto detect). | +| unitSeparator | `string`｜`null` | Separator to use between number and unit. Default value to `''`. | + +**Returns** + +| Name | Type | Description | +|---------|------------------|-------------------------------------------------| +| results | `string`｜`null` | Return null upon error. String value otherwise. | + +**Example** + +```js +bytes.format(1024); +// output: '1KB' + +bytes.format(1000); +// output: '1000B' + +bytes.format(1000, {thousandsSeparator: ' '}); +// output: '1 000B' + +bytes.format(1024 * 1.7, {decimalPlaces: 0}); +// output: '2KB' + +bytes.format(1024, {unitSeparator: ' '}); +// output: '1 KB' +``` + +#### bytes.parse(string｜number value): number｜null + +Parse the string value into an integer in bytes. If no unit is given, or `value` +is a number, it is assumed the value is in bytes. + +Supported units and abbreviations are as follows and are case-insensitive: + + * `b` for bytes + * `kb` for kilobytes + * `mb` for megabytes + * `gb` for gigabytes + * `tb` for terabytes + * `pb` for petabytes + +The units are in powers of two, not ten. This means 1kb = 1024b according to this parser. + +**Arguments** + +| Name | Type | Description | +|---------------|--------|--------------------| +| value | `string`｜`number` | String to parse, or number in bytes. | + +**Returns** + +| Name | Type | Description | +|---------|-------------|-------------------------| +| results | `number`｜`null` | Return null upon error. Value in bytes otherwise. | + +**Example** + +```js +bytes.parse('1KB'); +// output: 1024 + +bytes.parse('1024'); +// output: 1024 + +bytes.parse(1024); +// output: 1024 +``` + +## License + +[MIT](LICENSE) + +[ci-image]: https://badgen.net/github/checks/visionmedia/bytes.js/master?label=ci +[ci-url]: https://github.com/visionmedia/bytes.js/actions?query=workflow%3Aci +[coveralls-image]: https://badgen.net/coveralls/c/github/visionmedia/bytes.js/master +[coveralls-url]: https://coveralls.io/r/visionmedia/bytes.js?branch=master +[downloads-image]: https://badgen.net/npm/dm/bytes +[downloads-url]: https://npmjs.org/package/bytes +[npm-image]: https://badgen.net/npm/v/bytes +[npm-url]: https://npmjs.org/package/bytes diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/index.js new file mode 100644 index 00000000..6f2d0f89 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/index.js @@ -0,0 +1,170 @@ +/*! + * bytes + * Copyright(c) 2012-2014 TJ Holowaychuk + * Copyright(c) 2015 Jed Watson + * MIT Licensed + */ + +'use strict'; + +/** + * Module exports. + * @public + */ + +module.exports = bytes; +module.exports.format = format; +module.exports.parse = parse; + +/** + * Module variables. + * @private + */ + +var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g; + +var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/; + +var map = { + b: 1, + kb: 1 << 10, + mb: 1 << 20, + gb: 1 << 30, + tb: Math.pow(1024, 4), + pb: Math.pow(1024, 5), +}; + +var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i; + +/** + * Convert the given value in bytes into a string or parse to string to an integer in bytes. + * + * @param {string|number} value + * @param {{ + * case: [string], + * decimalPlaces: [number] + * fixedDecimals: [boolean] + * thousandsSeparator: [string] + * unitSeparator: [string] + * }} [options] bytes options. + * + * @returns {string|number|null} + */ + +function bytes(value, options) { + if (typeof value === 'string') { + return parse(value); + } + + if (typeof value === 'number') { + return format(value, options); + } + + return null; +} + +/** + * Format the given value in bytes into a string. + * + * If the value is negative, it is kept as such. If it is a float, + * it is rounded. + * + * @param {number} value + * @param {object} [options] + * @param {number} [options.decimalPlaces=2] + * @param {number} [options.fixedDecimals=false] + * @param {string} [options.thousandsSeparator=] + * @param {string} [options.unit=] + * @param {string} [options.unitSeparator=] + * + * @returns {string|null} + * @public + */ + +function format(value, options) { + if (!Number.isFinite(value)) { + return null; + } + + var mag = Math.abs(value); + var thousandsSeparator = (options && options.thousandsSeparator) || ''; + var unitSeparator = (options && options.unitSeparator) || ''; + var decimalPlaces = (options && options.decimalPlaces !== undefined) ? options.decimalPlaces : 2; + var fixedDecimals = Boolean(options && options.fixedDecimals); + var unit = (options && options.unit) || ''; + + if (!unit || !map[unit.toLowerCase()]) { + if (mag >= map.pb) { + unit = 'PB'; + } else if (mag >= map.tb) { + unit = 'TB'; + } else if (mag >= map.gb) { + unit = 'GB'; + } else if (mag >= map.mb) { + unit = 'MB'; + } else if (mag >= map.kb) { + unit = 'KB'; + } else { + unit = 'B'; + } + } + + var val = value / map[unit.toLowerCase()]; + var str = val.toFixed(decimalPlaces); + + if (!fixedDecimals) { + str = str.replace(formatDecimalsRegExp, '$1'); + } + + if (thousandsSeparator) { + str = str.split('.').map(function (s, i) { + return i === 0 + ? s.replace(formatThousandsRegExp, thousandsSeparator) + : s + }).join('.'); + } + + return str + unitSeparator + unit; +} + +/** + * Parse the string value into an integer in bytes. + * + * If no unit is given, it is assumed the value is in bytes. + * + * @param {number|string} val + * + * @returns {number|null} + * @public + */ + +function parse(val) { + if (typeof val === 'number' && !isNaN(val)) { + return val; + } + + if (typeof val !== 'string') { + return null; + } + + // Test if the string passed is valid + var results = parseRegExp.exec(val); + var floatValue; + var unit = 'b'; + + if (!results) { + // Nothing could be extracted from the given string + floatValue = parseInt(val, 10); + unit = 'b' + } else { + // Retrieve the value and the unit + floatValue = parseFloat(results[1]); + unit = results[4].toLowerCase(); + } + + if (isNaN(floatValue)) { + return null; + } + + return Math.floor(map[unit] * floatValue); +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/package.json new file mode 100644 index 00000000..f2b6a8b0 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/bytes/package.json @@ -0,0 +1,42 @@ +{ + "name": "bytes", + "description": "Utility to parse a string bytes to bytes and vice-versa", + "version": "3.1.2", + "author": "TJ Holowaychuk (http://tjholowaychuk.com)", + "contributors": [ + "Jed Watson ", + "Théo FIDRY " + ], + "license": "MIT", + "keywords": [ + "byte", + "bytes", + "utility", + "parse", + "parser", + "convert", + "converter" + ], + "repository": "visionmedia/bytes.js", + "devDependencies": { + "eslint": "7.32.0", + "eslint-plugin-markdown": "2.2.1", + "mocha": "9.2.0", + "nyc": "15.1.0" + }, + "files": [ + "History.md", + "LICENSE", + "Readme.md", + "index.js" + ], + "engines": { + "node": ">= 0.8" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --check-leaks --reporter spec", + "test-ci": "nyc --reporter=lcov --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.eslintrc b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.eslintrc new file mode 100644 index 00000000..201e859b --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.eslintrc @@ -0,0 +1,17 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "func-name-matching": 0, + "id-length": 0, + "new-cap": [2, { + "capIsNewExceptions": [ + "GetIntrinsic", + ], + }], + "no-extra-parens": 0, + "no-magic-numbers": 0, + }, +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.github/FUNDING.yml b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.github/FUNDING.yml new file mode 100644 index 00000000..0011e9d6 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/call-bind-apply-helpers +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.nycrc b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.nycrc new file mode 100644 index 00000000..bdd626ce --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/CHANGELOG.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/CHANGELOG.md new file mode 100644 index 00000000..24849428 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/CHANGELOG.md @@ -0,0 +1,30 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.2](https://github.com/ljharb/call-bind-apply-helpers/compare/v1.0.1...v1.0.2) - 2025-02-12 + +### Commits + +- [types] improve inferred types [`e6f9586`](https://github.com/ljharb/call-bind-apply-helpers/commit/e6f95860a3c72879cb861a858cdfb8138fbedec1) +- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/tsconfig`, `@types/tape`, `es-value-fixtures`, `for-each`, `has-strict-mode`, `object-inspect` [`e43d540`](https://github.com/ljharb/call-bind-apply-helpers/commit/e43d5409f97543bfbb11f345d47d8ce4e066d8c1) + +## [v1.0.1](https://github.com/ljharb/call-bind-apply-helpers/compare/v1.0.0...v1.0.1) - 2024-12-08 + +### Commits + +- [types] `reflectApply`: fix types [`4efc396`](https://github.com/ljharb/call-bind-apply-helpers/commit/4efc3965351a4f02cc55e836fa391d3d11ef2ef8) +- [Fix] `reflectApply`: oops, Reflect is not a function [`83cc739`](https://github.com/ljharb/call-bind-apply-helpers/commit/83cc7395de6b79b7730bdf092f1436f0b1263c75) +- [Dev Deps] update `@arethetypeswrong/cli` [`80bd5d3`](https://github.com/ljharb/call-bind-apply-helpers/commit/80bd5d3ae58b4f6b6995ce439dd5a1bcb178a940) + +## v1.0.0 - 2024-12-05 + +### Commits + +- Initial implementation, tests, readme [`7879629`](https://github.com/ljharb/call-bind-apply-helpers/commit/78796290f9b7430c9934d6f33d94ae9bc89fce04) +- Initial commit [`3f1dc16`](https://github.com/ljharb/call-bind-apply-helpers/commit/3f1dc164afc43285631b114a5f9dd9137b2b952f) +- npm init [`081df04`](https://github.com/ljharb/call-bind-apply-helpers/commit/081df048c312fcee400922026f6e97281200a603) +- Only apps should have lockfiles [`5b9ca0f`](https://github.com/ljharb/call-bind-apply-helpers/commit/5b9ca0fe8101ebfaf309c549caac4e0a017ed930) diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/LICENSE new file mode 100644 index 00000000..f82f3896 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/README.md new file mode 100644 index 00000000..8fc0dae1 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/README.md @@ -0,0 +1,62 @@ +# call-bind-apply-helpers [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Helper functions around Function call/apply/bind, for use in `call-bind`. + +The only packages that should likely ever use this package directly are `call-bind` and `get-intrinsic`. +Please use `call-bind` unless you have a very good reason not to. + +## Getting started + +```sh +npm install --save call-bind-apply-helpers +``` + +## Usage/Examples + +```js +const assert = require('assert'); +const callBindBasic = require('call-bind-apply-helpers'); + +function f(a, b) { + assert.equal(this, 1); + assert.equal(a, 2); + assert.equal(b, 3); + assert.equal(arguments.length, 2); +} + +const fBound = callBindBasic([f, 1]); + +delete Function.prototype.call; +delete Function.prototype.bind; + +fBound(2, 3); +``` + +## Tests + +Clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/call-bind-apply-helpers +[npm-version-svg]: https://versionbadg.es/ljharb/call-bind-apply-helpers.svg +[deps-svg]: https://david-dm.org/ljharb/call-bind-apply-helpers.svg +[deps-url]: https://david-dm.org/ljharb/call-bind-apply-helpers +[dev-deps-svg]: https://david-dm.org/ljharb/call-bind-apply-helpers/dev-status.svg +[dev-deps-url]: https://david-dm.org/ljharb/call-bind-apply-helpers#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/call-bind-apply-helpers.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/call-bind-apply-helpers.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/call-bind-apply-helpers.svg +[downloads-url]: https://npm-stat.com/charts.html?package=call-bind-apply-helpers +[codecov-image]: https://codecov.io/gh/ljharb/call-bind-apply-helpers/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/ljharb/call-bind-apply-helpers/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/call-bind-apply-helpers +[actions-url]: https://github.com/ljharb/call-bind-apply-helpers/actions diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.d.ts new file mode 100644 index 00000000..b87286a2 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.d.ts @@ -0,0 +1 @@ +export = Reflect.apply; \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.js new file mode 100644 index 00000000..ffa51355 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/actualApply.js @@ -0,0 +1,10 @@ +'use strict'; + +var bind = require('function-bind'); + +var $apply = require('./functionApply'); +var $call = require('./functionCall'); +var $reflectApply = require('./reflectApply'); + +/** @type {import('./actualApply')} */ +module.exports = $reflectApply || bind.call($call, $apply); diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.d.ts new file mode 100644 index 00000000..d176c1ab --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.d.ts @@ -0,0 +1,19 @@ +import actualApply from './actualApply'; + +type TupleSplitHead = T['length'] extends N + ? T + : T extends [...infer R, any] + ? TupleSplitHead + : never + +type TupleSplitTail = O['length'] extends N + ? T + : T extends [infer F, ...infer R] + ? TupleSplitTail<[...R], N, [...O, F]> + : never + +type TupleSplit = [TupleSplitHead, TupleSplitTail] + +declare function applyBind(...args: TupleSplit, 2>[1]): ReturnType; + +export = applyBind; \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.js new file mode 100644 index 00000000..d2b77231 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/applyBind.js @@ -0,0 +1,10 @@ +'use strict'; + +var bind = require('function-bind'); +var $apply = require('./functionApply'); +var actualApply = require('./actualApply'); + +/** @type {import('./applyBind')} */ +module.exports = function applyBind() { + return actualApply(bind, $apply, arguments); +}; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.d.ts new file mode 100644 index 00000000..1f6e11b3 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.d.ts @@ -0,0 +1 @@ +export = Function.prototype.apply; \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.js new file mode 100644 index 00000000..c71df9c2 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionApply.js @@ -0,0 +1,4 @@ +'use strict'; + +/** @type {import('./functionApply')} */ +module.exports = Function.prototype.apply; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.d.ts new file mode 100644 index 00000000..15e93df3 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.d.ts @@ -0,0 +1 @@ +export = Function.prototype.call; \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.js new file mode 100644 index 00000000..7a8d8735 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/functionCall.js @@ -0,0 +1,4 @@ +'use strict'; + +/** @type {import('./functionCall')} */ +module.exports = Function.prototype.call; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.d.ts new file mode 100644 index 00000000..541516bd --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.d.ts @@ -0,0 +1,64 @@ +type RemoveFromTuple< + Tuple extends readonly unknown[], + RemoveCount extends number, + Index extends 1[] = [] +> = Index["length"] extends RemoveCount + ? Tuple + : Tuple extends [infer First, ...infer Rest] + ? RemoveFromTuple + : Tuple; + +type ConcatTuples< + Prefix extends readonly unknown[], + Suffix extends readonly unknown[] +> = [...Prefix, ...Suffix]; + +type ExtractFunctionParams = T extends (this: infer TThis, ...args: infer P extends readonly unknown[]) => infer R + ? { thisArg: TThis; params: P; returnType: R } + : never; + +type BindFunction< + T extends (this: any, ...args: any[]) => any, + TThis, + TBoundArgs extends readonly unknown[], + ReceiverBound extends boolean +> = ExtractFunctionParams extends { + thisArg: infer OrigThis; + params: infer P extends readonly unknown[]; + returnType: infer R; +} + ? ReceiverBound extends true + ? (...args: RemoveFromTuple>) => R extends [OrigThis, ...infer Rest] + ? [TThis, ...Rest] // Replace `this` with `thisArg` + : R + : >>( + thisArg: U, + ...args: RemainingArgs + ) => R extends [OrigThis, ...infer Rest] + ? [U, ...ConcatTuples] // Preserve bound args in return type + : R + : never; + +declare function callBind< + const T extends (this: any, ...args: any[]) => any, + Extracted extends ExtractFunctionParams, + const TBoundArgs extends Partial & readonly unknown[], + const TThis extends Extracted["thisArg"] +>( + args: [fn: T, thisArg: TThis, ...boundArgs: TBoundArgs] +): BindFunction; + +declare function callBind< + const T extends (this: any, ...args: any[]) => any, + Extracted extends ExtractFunctionParams, + const TBoundArgs extends Partial & readonly unknown[] +>( + args: [fn: T, ...boundArgs: TBoundArgs] +): BindFunction; + +declare function callBind( + args: [fn: Exclude, ...rest: TArgs] +): never; + +// export as namespace callBind; +export = callBind; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.js new file mode 100644 index 00000000..2f6dab4c --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/index.js @@ -0,0 +1,15 @@ +'use strict'; + +var bind = require('function-bind'); +var $TypeError = require('es-errors/type'); + +var $call = require('./functionCall'); +var $actualApply = require('./actualApply'); + +/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */ +module.exports = function callBindBasic(args) { + if (args.length < 1 || typeof args[0] !== 'function') { + throw new $TypeError('a function is required'); + } + return $actualApply(bind, $call, args); +}; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/package.json new file mode 100644 index 00000000..923b8be2 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/package.json @@ -0,0 +1,85 @@ +{ + "name": "call-bind-apply-helpers", + "version": "1.0.2", + "description": "Helper functions around Function call/apply/bind, for use in `call-bind`", + "main": "index.js", + "exports": { + ".": "./index.js", + "./actualApply": "./actualApply.js", + "./applyBind": "./applyBind.js", + "./functionApply": "./functionApply.js", + "./functionCall": "./functionCall.js", + "./reflectApply": "./reflectApply.js", + "./package.json": "./package.json" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=auto", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint --ext=.js,.mjs .", + "postlint": "tsc -p . && attw -P", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/call-bind-apply-helpers.git" + }, + "author": "Jordan Harband ", + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/call-bind-apply-helpers/issues" + }, + "homepage": "https://github.com/ljharb/call-bind-apply-helpers#readme", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.3", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.3", + "@types/for-each": "^0.3.3", + "@types/function-bind": "^1.1.10", + "@types/object-inspect": "^1.13.0", + "@types/tape": "^5.8.1", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "es-value-fixtures": "^1.7.1", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "for-each": "^0.3.5", + "has-strict-mode": "^1.1.0", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "object-inspect": "^1.13.4", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "testling": { + "files": "test/index.js" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "engines": { + "node": ">= 0.4" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.d.ts new file mode 100644 index 00000000..6b2ae764 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.d.ts @@ -0,0 +1,3 @@ +declare const reflectApply: false | typeof Reflect.apply; + +export = reflectApply; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.js new file mode 100644 index 00000000..3d03caa6 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/reflectApply.js @@ -0,0 +1,4 @@ +'use strict'; + +/** @type {import('./reflectApply')} */ +module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/test/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/test/index.js new file mode 100644 index 00000000..1cdc89ed --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/test/index.js @@ -0,0 +1,63 @@ +'use strict'; + +var callBind = require('../'); +var hasStrictMode = require('has-strict-mode')(); +var forEach = require('for-each'); +var inspect = require('object-inspect'); +var v = require('es-value-fixtures'); + +var test = require('tape'); + +test('callBindBasic', function (t) { + forEach(v.nonFunctions, function (nonFunction) { + t['throws']( + // @ts-expect-error + function () { callBind([nonFunction]); }, + TypeError, + inspect(nonFunction) + ' is not a function' + ); + }); + + var sentinel = { sentinel: true }; + /** @type {(this: T, a: A, b: B) => [T | undefined, A, B]} */ + var func = function (a, b) { + // eslint-disable-next-line no-invalid-this + return [!hasStrictMode && this === global ? undefined : this, a, b]; + }; + t.equal(func.length, 2, 'original function length is 2'); + + /** type {(thisArg: unknown, a: number, b: number) => [unknown, number, number]} */ + var bound = callBind([func]); + /** type {((a: number, b: number) => [typeof sentinel, typeof a, typeof b])} */ + var boundR = callBind([func, sentinel]); + /** type {((b: number) => [typeof sentinel, number, typeof b])} */ + var boundArg = callBind([func, sentinel, /** @type {const} */ (1)]); + + // @ts-expect-error + t.deepEqual(bound(), [undefined, undefined, undefined], 'bound func with no args'); + + // @ts-expect-error + t.deepEqual(func(), [undefined, undefined, undefined], 'unbound func with too few args'); + // @ts-expect-error + t.deepEqual(bound(1, 2), [hasStrictMode ? 1 : Object(1), 2, undefined], 'bound func too few args'); + // @ts-expect-error + t.deepEqual(boundR(), [sentinel, undefined, undefined], 'bound func with receiver, with too few args'); + // @ts-expect-error + t.deepEqual(boundArg(), [sentinel, 1, undefined], 'bound func with receiver and arg, with too few args'); + + t.deepEqual(func(1, 2), [undefined, 1, 2], 'unbound func with right args'); + t.deepEqual(bound(1, 2, 3), [hasStrictMode ? 1 : Object(1), 2, 3], 'bound func with right args'); + t.deepEqual(boundR(1, 2), [sentinel, 1, 2], 'bound func with receiver, with right args'); + t.deepEqual(boundArg(2), [sentinel, 1, 2], 'bound func with receiver and arg, with right arg'); + + // @ts-expect-error + t.deepEqual(func(1, 2, 3), [undefined, 1, 2], 'unbound func with too many args'); + // @ts-expect-error + t.deepEqual(bound(1, 2, 3, 4), [hasStrictMode ? 1 : Object(1), 2, 3], 'bound func with too many args'); + // @ts-expect-error + t.deepEqual(boundR(1, 2, 3), [sentinel, 1, 2], 'bound func with receiver, with too many args'); + // @ts-expect-error + t.deepEqual(boundArg(2, 3), [sentinel, 1, 2], 'bound func with receiver and arg, with too many args'); + + t.end(); +}); diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/tsconfig.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/tsconfig.json new file mode 100644 index 00000000..aef99930 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bind-apply-helpers/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "es2021", + }, + "exclude": [ + "coverage", + ], +} \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.eslintrc b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.eslintrc new file mode 100644 index 00000000..2612ed8f --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.eslintrc @@ -0,0 +1,13 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "new-cap": [2, { + "capIsNewExceptions": [ + "GetIntrinsic", + ], + }], + }, +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.github/FUNDING.yml b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.github/FUNDING.yml new file mode 100644 index 00000000..2a2a1357 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/call-bound +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.nycrc b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.nycrc new file mode 100644 index 00000000..bdd626ce --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/CHANGELOG.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/CHANGELOG.md new file mode 100644 index 00000000..8bde4e9a --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/CHANGELOG.md @@ -0,0 +1,42 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.4](https://github.com/ljharb/call-bound/compare/v1.0.3...v1.0.4) - 2025-03-03 + +### Commits + +- [types] improve types [`e648922`](https://github.com/ljharb/call-bound/commit/e6489222a9e54f350fbf952ceabe51fd8b6027ff) +- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/tsconfig`, `@types/tape`, `es-value-fixtures`, `for-each`, `has-strict-mode`, `object-inspect` [`a42a5eb`](https://github.com/ljharb/call-bound/commit/a42a5ebe6c1b54fcdc7997c7dc64fdca9e936719) +- [Deps] update `call-bind-apply-helpers`, `get-intrinsic` [`f529eac`](https://github.com/ljharb/call-bound/commit/f529eac132404c17156bbc23ab2297a25d0f20b8) + +## [v1.0.3](https://github.com/ljharb/call-bound/compare/v1.0.2...v1.0.3) - 2024-12-15 + +### Commits + +- [Refactor] use `call-bind-apply-helpers` instead of `call-bind` [`5e0b134`](https://github.com/ljharb/call-bound/commit/5e0b13496df14fb7d05dae9412f088da8d3f75be) +- [Deps] update `get-intrinsic` [`41fc967`](https://github.com/ljharb/call-bound/commit/41fc96732a22c7b7e8f381f93ccc54bb6293be2e) +- [readme] fix example [`79a0137`](https://github.com/ljharb/call-bound/commit/79a0137723f7c6d09c9c05452bbf8d5efb5d6e49) +- [meta] add `sideEffects` flag [`08b07be`](https://github.com/ljharb/call-bound/commit/08b07be7f1c03f67dc6f3cdaf0906259771859f7) + +## [v1.0.2](https://github.com/ljharb/call-bound/compare/v1.0.1...v1.0.2) - 2024-12-10 + +### Commits + +- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/tsconfig`, `gopd` [`e6a5ffe`](https://github.com/ljharb/call-bound/commit/e6a5ffe849368fe4f74dfd6cdeca1b9baa39e8d5) +- [Deps] update `call-bind`, `get-intrinsic` [`2aeb5b5`](https://github.com/ljharb/call-bound/commit/2aeb5b521dc2b2683d1345c753ea1161de2d1c14) +- [types] improve return type [`1a0c9fe`](https://github.com/ljharb/call-bound/commit/1a0c9fe3114471e7ca1f57d104e2efe713bb4871) + +## v1.0.1 - 2024-12-05 + +### Commits + +- Initial implementation, tests, readme, types [`6d94121`](https://github.com/ljharb/call-bound/commit/6d94121a9243602e506334069f7a03189fe3363d) +- Initial commit [`0eae867`](https://github.com/ljharb/call-bound/commit/0eae867334ea025c33e6e91cdecfc9df96680cf9) +- npm init [`71b2479`](https://github.com/ljharb/call-bound/commit/71b2479c6723e0b7d91a6b663613067e98b7b275) +- Only apps should have lockfiles [`c3754a9`](https://github.com/ljharb/call-bound/commit/c3754a949b7f9132b47e2d18c1729889736741eb) +- [actions] skip `npm ls` in node < 10 [`74275a5`](https://github.com/ljharb/call-bound/commit/74275a5186b8caf6309b6b97472bdcb0df4683a8) +- [Dev Deps] add missing peer dep [`1354de8`](https://github.com/ljharb/call-bound/commit/1354de8679413e4ae9c523d85f76fa7a5e032d97) diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/LICENSE new file mode 100644 index 00000000..f82f3896 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/README.md new file mode 100644 index 00000000..a44e43e5 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/README.md @@ -0,0 +1,53 @@ +# call-bound [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Robust call-bound JavaScript intrinsics, using `call-bind` and `get-intrinsic`. + +## Getting started + +```sh +npm install --save call-bound +``` + +## Usage/Examples + +```js +const assert = require('assert'); +const callBound = require('call-bound'); + +const slice = callBound('Array.prototype.slice'); + +delete Function.prototype.call; +delete Function.prototype.bind; +delete Array.prototype.slice; + +assert.deepEqual(slice([1, 2, 3, 4], 1, -1), [2, 3]); +``` + +## Tests + +Clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/call-bound +[npm-version-svg]: https://versionbadg.es/ljharb/call-bound.svg +[deps-svg]: https://david-dm.org/ljharb/call-bound.svg +[deps-url]: https://david-dm.org/ljharb/call-bound +[dev-deps-svg]: https://david-dm.org/ljharb/call-bound/dev-status.svg +[dev-deps-url]: https://david-dm.org/ljharb/call-bound#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/call-bound.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/call-bound.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/call-bound.svg +[downloads-url]: https://npm-stat.com/charts.html?package=call-bound +[codecov-image]: https://codecov.io/gh/ljharb/call-bound/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/ljharb/call-bound/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/call-bound +[actions-url]: https://github.com/ljharb/call-bound/actions diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.d.ts b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.d.ts new file mode 100644 index 00000000..5562f00e --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.d.ts @@ -0,0 +1,94 @@ +type Intrinsic = typeof globalThis; + +type IntrinsicName = keyof Intrinsic | `%${keyof Intrinsic}%`; + +type IntrinsicPath = IntrinsicName | `${StripPercents}.${string}` | `%${StripPercents}.${string}%`; + +type AllowMissing = boolean; + +type StripPercents = T extends `%${infer U}%` ? U : T; + +type BindMethodPrecise = + F extends (this: infer This, ...args: infer Args) => infer R + ? (obj: This, ...args: Args) => R + : F extends { + (this: infer This1, ...args: infer Args1): infer R1; + (this: infer This2, ...args: infer Args2): infer R2 + } + ? { + (obj: This1, ...args: Args1): R1; + (obj: This2, ...args: Args2): R2 + } + : never + +// Extract method type from a prototype +type GetPrototypeMethod = + (typeof globalThis)[T] extends { prototype: any } + ? M extends keyof (typeof globalThis)[T]['prototype'] + ? (typeof globalThis)[T]['prototype'][M] + : never + : never + +// Get static property/method +type GetStaticMember = + P extends keyof (typeof globalThis)[T] ? (typeof globalThis)[T][P] : never + +// Type that maps string path to actual bound function or value with better precision +type BoundIntrinsic = + S extends `${infer Obj}.prototype.${infer Method}` + ? Obj extends keyof typeof globalThis + ? BindMethodPrecise> + : unknown + : S extends `${infer Obj}.${infer Prop}` + ? Obj extends keyof typeof globalThis + ? GetStaticMember + : unknown + : unknown + +declare function arraySlice(array: readonly T[], start?: number, end?: number): T[]; +declare function arraySlice(array: ArrayLike, start?: number, end?: number): T[]; +declare function arraySlice(array: IArguments, start?: number, end?: number): T[]; + +// Special cases for methods that need explicit typing +interface SpecialCases { + '%Object.prototype.isPrototypeOf%': (thisArg: {}, obj: unknown) => boolean; + '%String.prototype.replace%': { + (str: string, searchValue: string | RegExp, replaceValue: string): string; + (str: string, searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string + }; + '%Object.prototype.toString%': (obj: {}) => string; + '%Object.prototype.hasOwnProperty%': (obj: {}, v: PropertyKey) => boolean; + '%Array.prototype.slice%': typeof arraySlice; + '%Array.prototype.map%': (array: readonly T[], callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any) => U[]; + '%Array.prototype.filter%': (array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any) => T[]; + '%Array.prototype.indexOf%': (array: readonly T[], searchElement: T, fromIndex?: number) => number; + '%Function.prototype.apply%': (fn: (...args: A) => R, thisArg: any, args: A) => R; + '%Function.prototype.call%': (fn: (...args: A) => R, thisArg: any, ...args: A) => R; + '%Function.prototype.bind%': (fn: (...args: A) => R, thisArg: any, ...args: A) => (...remainingArgs: A) => R; + '%Promise.prototype.then%': { + (promise: Promise, onfulfilled: (value: T) => R | PromiseLike): Promise; + (promise: Promise, onfulfilled: ((value: T) => R | PromiseLike) | undefined | null, onrejected: (reason: any) => R | PromiseLike): Promise; + }; + '%RegExp.prototype.test%': (regexp: RegExp, str: string) => boolean; + '%RegExp.prototype.exec%': (regexp: RegExp, str: string) => RegExpExecArray | null; + '%Error.prototype.toString%': (error: Error) => string; + '%TypeError.prototype.toString%': (error: TypeError) => string; + '%String.prototype.split%': ( + obj: unknown, + splitter: string | RegExp | { + [Symbol.split](string: string, limit?: number): string[]; + }, + limit?: number | undefined + ) => string[]; +} + +/** + * Returns a bound function for a prototype method, or a value for a static property. + * + * @param name - The name of the intrinsic (e.g. 'Array.prototype.slice') + * @param {AllowMissing} [allowMissing] - Whether to allow missing intrinsics (default: false) + */ +declare function callBound, S extends IntrinsicPath>(name: K, allowMissing?: AllowMissing): SpecialCases[`%${StripPercents}%`]; +declare function callBound, S extends IntrinsicPath>(name: S, allowMissing?: AllowMissing): BoundIntrinsic; + +export = callBound; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.js new file mode 100644 index 00000000..e9ade749 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/index.js @@ -0,0 +1,19 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var callBindBasic = require('call-bind-apply-helpers'); + +/** @type {(thisArg: string, searchString: string, position?: number) => number} */ +var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]); + +/** @type {import('.')} */ +module.exports = function callBoundIntrinsic(name, allowMissing) { + /* eslint no-extra-parens: 0 */ + + var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing)); + if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { + return callBindBasic(/** @type {const} */ ([intrinsic])); + } + return intrinsic; +}; diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/package.json new file mode 100644 index 00000000..d542db43 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/package.json @@ -0,0 +1,99 @@ +{ + "name": "call-bound", + "version": "1.0.4", + "description": "Robust call-bound JavaScript intrinsics, using `call-bind` and `get-intrinsic`.", + "main": "index.js", + "exports": { + ".": "./index.js", + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=auto", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint --ext=.js,.mjs .", + "postlint": "tsc -p . && attw -P", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/call-bound.git" + }, + "keywords": [ + "javascript", + "ecmascript", + "es", + "js", + "callbind", + "callbound", + "call", + "bind", + "bound", + "call-bind", + "call-bound", + "function", + "es-abstract" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/call-bound/issues" + }, + "homepage": "https://github.com/ljharb/call-bound#readme", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.4", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.3.0", + "@types/call-bind": "^1.0.5", + "@types/get-intrinsic": "^1.2.3", + "@types/tape": "^5.8.1", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "es-value-fixtures": "^1.7.1", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "for-each": "^0.3.5", + "gopd": "^1.2.0", + "has-strict-mode": "^1.1.0", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "object-inspect": "^1.13.4", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "testling": { + "files": "test/index.js" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "engines": { + "node": ">= 0.4" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/test/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/test/index.js new file mode 100644 index 00000000..a2fc9f0f --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/test/index.js @@ -0,0 +1,61 @@ +'use strict'; + +var test = require('tape'); + +var callBound = require('../'); + +/** @template {true} T @template U @typedef {T extends U ? T : never} AssertType */ + +test('callBound', function (t) { + // static primitive + t.equal(callBound('Array.length'), Array.length, 'Array.length yields itself'); + t.equal(callBound('%Array.length%'), Array.length, '%Array.length% yields itself'); + + // static non-function object + t.equal(callBound('Array.prototype'), Array.prototype, 'Array.prototype yields itself'); + t.equal(callBound('%Array.prototype%'), Array.prototype, '%Array.prototype% yields itself'); + t.equal(callBound('Array.constructor'), Array.constructor, 'Array.constructor yields itself'); + t.equal(callBound('%Array.constructor%'), Array.constructor, '%Array.constructor% yields itself'); + + // static function + t.equal(callBound('Date.parse'), Date.parse, 'Date.parse yields itself'); + t.equal(callBound('%Date.parse%'), Date.parse, '%Date.parse% yields itself'); + + // prototype primitive + t.equal(callBound('Error.prototype.message'), Error.prototype.message, 'Error.prototype.message yields itself'); + t.equal(callBound('%Error.prototype.message%'), Error.prototype.message, '%Error.prototype.message% yields itself'); + + var x = callBound('Object.prototype.toString'); + var y = callBound('%Object.prototype.toString%'); + + // prototype function + t.notEqual(x, Object.prototype.toString, 'Object.prototype.toString does not yield itself'); + t.notEqual(y, Object.prototype.toString, '%Object.prototype.toString% does not yield itself'); + t.equal(x(true), Object.prototype.toString.call(true), 'call-bound Object.prototype.toString calls into the original'); + t.equal(y(true), Object.prototype.toString.call(true), 'call-bound %Object.prototype.toString% calls into the original'); + + t['throws']( + // @ts-expect-error + function () { callBound('does not exist'); }, + SyntaxError, + 'nonexistent intrinsic throws' + ); + t['throws']( + // @ts-expect-error + function () { callBound('does not exist', true); }, + SyntaxError, + 'allowMissing arg still throws for unknown intrinsic' + ); + + t.test('real but absent intrinsic', { skip: typeof WeakRef !== 'undefined' }, function (st) { + st['throws']( + function () { callBound('WeakRef'); }, + TypeError, + 'real but absent intrinsic throws' + ); + st.equal(callBound('WeakRef', true), undefined, 'allowMissing arg avoids exception'); + st.end(); + }); + + t.end(); +}); diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/tsconfig.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/tsconfig.json new file mode 100644 index 00000000..8976d98b --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/call-bound/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "ESNext", + "lib": ["es2024"], + }, + "exclude": [ + "coverage", + ], +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/HISTORY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/HISTORY.md new file mode 100644 index 00000000..488effa0 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/HISTORY.md @@ -0,0 +1,60 @@ +0.5.4 / 2021-12-10 +================== + + * deps: safe-buffer@5.2.1 + +0.5.3 / 2018-12-17 +================== + + * Use `safe-buffer` for improved Buffer API + +0.5.2 / 2016-12-08 +================== + + * Fix `parse` to accept any linear whitespace character + +0.5.1 / 2016-01-17 +================== + + * perf: enable strict mode + +0.5.0 / 2014-10-11 +================== + + * Add `parse` function + +0.4.0 / 2014-09-21 +================== + + * Expand non-Unicode `filename` to the full ISO-8859-1 charset + +0.3.0 / 2014-09-20 +================== + + * Add `fallback` option + * Add `type` option + +0.2.0 / 2014-09-19 +================== + + * Reduce ambiguity of file names with hex escape in buggy browsers + +0.1.2 / 2014-09-19 +================== + + * Fix periodic invalid Unicode filename header + +0.1.1 / 2014-09-19 +================== + + * Fix invalid characters appearing in `filename*` parameter + +0.1.0 / 2014-09-18 +================== + + * Make the `filename` argument optional + +0.0.0 / 2014-09-18 +================== + + * Initial release diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/LICENSE new file mode 100644 index 00000000..84441fbb --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2014-2017 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/README.md new file mode 100644 index 00000000..3a0bb055 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/README.md @@ -0,0 +1,142 @@ +# content-disposition + +[![NPM Version][npm-image]][npm-url] +[![NPM Downloads][downloads-image]][downloads-url] +[![Node.js Version][node-version-image]][node-version-url] +[![Build Status][github-actions-ci-image]][github-actions-ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] + +Create and parse HTTP `Content-Disposition` header + +## Installation + +```sh +$ npm install content-disposition +``` + +## API + +```js +var contentDisposition = require('content-disposition') +``` + +### contentDisposition(filename, options) + +Create an attachment `Content-Disposition` header value using the given file name, +if supplied. The `filename` is optional and if no file name is desired, but you +want to specify `options`, set `filename` to `undefined`. + +```js +res.setHeader('Content-Disposition', contentDisposition('∫ maths.pdf')) +``` + +**note** HTTP headers are of the ISO-8859-1 character set. If you are writing this +header through a means different from `setHeader` in Node.js, you'll want to specify +the `'binary'` encoding in Node.js. + +#### Options + +`contentDisposition` accepts these properties in the options object. + +##### fallback + +If the `filename` option is outside ISO-8859-1, then the file name is actually +stored in a supplemental field for clients that support Unicode file names and +a ISO-8859-1 version of the file name is automatically generated. + +This specifies the ISO-8859-1 file name to override the automatic generation or +disables the generation all together, defaults to `true`. + + - A string will specify the ISO-8859-1 file name to use in place of automatic + generation. + - `false` will disable including a ISO-8859-1 file name and only include the + Unicode version (unless the file name is already ISO-8859-1). + - `true` will enable automatic generation if the file name is outside ISO-8859-1. + +If the `filename` option is ISO-8859-1 and this option is specified and has a +different value, then the `filename` option is encoded in the extended field +and this set as the fallback field, even though they are both ISO-8859-1. + +##### type + +Specifies the disposition type, defaults to `"attachment"`. This can also be +`"inline"`, or any other value (all values except inline are treated like +`attachment`, but can convey additional information if both parties agree to +it). The type is normalized to lower-case. + +### contentDisposition.parse(string) + +```js +var disposition = contentDisposition.parse('attachment; filename="EURO rates.txt"; filename*=UTF-8\'\'%e2%82%ac%20rates.txt') +``` + +Parse a `Content-Disposition` header string. This automatically handles extended +("Unicode") parameters by decoding them and providing them under the standard +parameter name. This will return an object with the following properties (examples +are shown for the string `'attachment; filename="EURO rates.txt"; filename*=UTF-8\'\'%e2%82%ac%20rates.txt'`): + + - `type`: The disposition type (always lower case). Example: `'attachment'` + + - `parameters`: An object of the parameters in the disposition (name of parameter + always lower case and extended versions replace non-extended versions). Example: + `{filename: "€ rates.txt"}` + +## Examples + +### Send a file for download + +```js +var contentDisposition = require('content-disposition') +var destroy = require('destroy') +var fs = require('fs') +var http = require('http') +var onFinished = require('on-finished') + +var filePath = '/path/to/public/plans.pdf' + +http.createServer(function onRequest (req, res) { + // set headers + res.setHeader('Content-Type', 'application/pdf') + res.setHeader('Content-Disposition', contentDisposition(filePath)) + + // send file + var stream = fs.createReadStream(filePath) + stream.pipe(res) + onFinished(res, function () { + destroy(stream) + }) +}) +``` + +## Testing + +```sh +$ npm test +``` + +## References + +- [RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1][rfc-2616] +- [RFC 5987: Character Set and Language Encoding for Hypertext Transfer Protocol (HTTP) Header Field Parameters][rfc-5987] +- [RFC 6266: Use of the Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)][rfc-6266] +- [Test Cases for HTTP Content-Disposition header field (RFC 6266) and the Encodings defined in RFCs 2047, 2231 and 5987][tc-2231] + +[rfc-2616]: https://tools.ietf.org/html/rfc2616 +[rfc-5987]: https://tools.ietf.org/html/rfc5987 +[rfc-6266]: https://tools.ietf.org/html/rfc6266 +[tc-2231]: http://greenbytes.de/tech/tc2231/ + +## License + +[MIT](LICENSE) + +[npm-image]: https://img.shields.io/npm/v/content-disposition.svg +[npm-url]: https://npmjs.org/package/content-disposition +[node-version-image]: https://img.shields.io/node/v/content-disposition.svg +[node-version-url]: https://nodejs.org/en/download +[coveralls-image]: https://img.shields.io/coveralls/jshttp/content-disposition.svg +[coveralls-url]: https://coveralls.io/r/jshttp/content-disposition?branch=master +[downloads-image]: https://img.shields.io/npm/dm/content-disposition.svg +[downloads-url]: https://npmjs.org/package/content-disposition +[github-actions-ci-image]: https://img.shields.io/github/workflow/status/jshttp/content-disposition/ci/master?label=ci +[github-actions-ci-url]: https://github.com/jshttp/content-disposition?query=workflow%3Aci diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/index.js new file mode 100644 index 00000000..ecec899a --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/index.js @@ -0,0 +1,458 @@ +/*! + * content-disposition + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module exports. + * @public + */ + +module.exports = contentDisposition +module.exports.parse = parse + +/** + * Module dependencies. + * @private + */ + +var basename = require('path').basename +var Buffer = require('safe-buffer').Buffer + +/** + * RegExp to match non attr-char, *after* encodeURIComponent (i.e. not including "%") + * @private + */ + +var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g // eslint-disable-line no-control-regex + +/** + * RegExp to match percent encoding escape. + * @private + */ + +var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/ +var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g + +/** + * RegExp to match non-latin1 characters. + * @private + */ + +var NON_LATIN1_REGEXP = /[^\x20-\x7e\xa0-\xff]/g + +/** + * RegExp to match quoted-pair in RFC 2616 + * + * quoted-pair = "\" CHAR + * CHAR = + * @private + */ + +var QESC_REGEXP = /\\([\u0000-\u007f])/g // eslint-disable-line no-control-regex + +/** + * RegExp to match chars that must be quoted-pair in RFC 2616 + * @private + */ + +var QUOTE_REGEXP = /([\\"])/g + +/** + * RegExp for various RFC 2616 grammar + * + * parameter = token "=" ( token | quoted-string ) + * token = 1* + * separators = "(" | ")" | "<" | ">" | "@" + * | "," | ";" | ":" | "\" | <"> + * | "/" | "[" | "]" | "?" | "=" + * | "{" | "}" | SP | HT + * quoted-string = ( <"> *(qdtext | quoted-pair ) <"> ) + * qdtext = > + * quoted-pair = "\" CHAR + * CHAR = + * TEXT = + * LWS = [CRLF] 1*( SP | HT ) + * CRLF = CR LF + * CR = + * LF = + * SP = + * HT = + * CTL = + * OCTET = + * @private + */ + +var PARAM_REGEXP = /;[\x09\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*=[\x09\x20]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*/g // eslint-disable-line no-control-regex +var TEXT_REGEXP = /^[\x20-\x7e\x80-\xff]+$/ +var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/ + +/** + * RegExp for various RFC 5987 grammar + * + * ext-value = charset "'" [ language ] "'" value-chars + * charset = "UTF-8" / "ISO-8859-1" / mime-charset + * mime-charset = 1*mime-charsetc + * mime-charsetc = ALPHA / DIGIT + * / "!" / "#" / "$" / "%" / "&" + * / "+" / "-" / "^" / "_" / "`" + * / "{" / "}" / "~" + * language = ( 2*3ALPHA [ extlang ] ) + * / 4ALPHA + * / 5*8ALPHA + * extlang = *3( "-" 3ALPHA ) + * value-chars = *( pct-encoded / attr-char ) + * pct-encoded = "%" HEXDIG HEXDIG + * attr-char = ALPHA / DIGIT + * / "!" / "#" / "$" / "&" / "+" / "-" / "." + * / "^" / "_" / "`" / "|" / "~" + * @private + */ + +var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/ + +/** + * RegExp for various RFC 6266 grammar + * + * disposition-type = "inline" | "attachment" | disp-ext-type + * disp-ext-type = token + * disposition-parm = filename-parm | disp-ext-parm + * filename-parm = "filename" "=" value + * | "filename*" "=" ext-value + * disp-ext-parm = token "=" value + * | ext-token "=" ext-value + * ext-token = + * @private + */ + +var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*(?:$|;)/ // eslint-disable-line no-control-regex + +/** + * Create an attachment Content-Disposition header. + * + * @param {string} [filename] + * @param {object} [options] + * @param {string} [options.type=attachment] + * @param {string|boolean} [options.fallback=true] + * @return {string} + * @public + */ + +function contentDisposition (filename, options) { + var opts = options || {} + + // get type + var type = opts.type || 'attachment' + + // get parameters + var params = createparams(filename, opts.fallback) + + // format into string + return format(new ContentDisposition(type, params)) +} + +/** + * Create parameters object from filename and fallback. + * + * @param {string} [filename] + * @param {string|boolean} [fallback=true] + * @return {object} + * @private + */ + +function createparams (filename, fallback) { + if (filename === undefined) { + return + } + + var params = {} + + if (typeof filename !== 'string') { + throw new TypeError('filename must be a string') + } + + // fallback defaults to true + if (fallback === undefined) { + fallback = true + } + + if (typeof fallback !== 'string' && typeof fallback !== 'boolean') { + throw new TypeError('fallback must be a string or boolean') + } + + if (typeof fallback === 'string' && NON_LATIN1_REGEXP.test(fallback)) { + throw new TypeError('fallback must be ISO-8859-1 string') + } + + // restrict to file base name + var name = basename(filename) + + // determine if name is suitable for quoted string + var isQuotedString = TEXT_REGEXP.test(name) + + // generate fallback name + var fallbackName = typeof fallback !== 'string' + ? fallback && getlatin1(name) + : basename(fallback) + var hasFallback = typeof fallbackName === 'string' && fallbackName !== name + + // set extended filename parameter + if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) { + params['filename*'] = name + } + + // set filename parameter + if (isQuotedString || hasFallback) { + params.filename = hasFallback + ? fallbackName + : name + } + + return params +} + +/** + * Format object to Content-Disposition header. + * + * @param {object} obj + * @param {string} obj.type + * @param {object} [obj.parameters] + * @return {string} + * @private + */ + +function format (obj) { + var parameters = obj.parameters + var type = obj.type + + if (!type || typeof type !== 'string' || !TOKEN_REGEXP.test(type)) { + throw new TypeError('invalid type') + } + + // start with normalized type + var string = String(type).toLowerCase() + + // append parameters + if (parameters && typeof parameters === 'object') { + var param + var params = Object.keys(parameters).sort() + + for (var i = 0; i < params.length; i++) { + param = params[i] + + var val = param.substr(-1) === '*' + ? ustring(parameters[param]) + : qstring(parameters[param]) + + string += '; ' + param + '=' + val + } + } + + return string +} + +/** + * Decode a RFC 5987 field value (gracefully). + * + * @param {string} str + * @return {string} + * @private + */ + +function decodefield (str) { + var match = EXT_VALUE_REGEXP.exec(str) + + if (!match) { + throw new TypeError('invalid extended field value') + } + + var charset = match[1].toLowerCase() + var encoded = match[2] + var value + + // to binary string + var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode) + + switch (charset) { + case 'iso-8859-1': + value = getlatin1(binary) + break + case 'utf-8': + value = Buffer.from(binary, 'binary').toString('utf8') + break + default: + throw new TypeError('unsupported charset in extended field') + } + + return value +} + +/** + * Get ISO-8859-1 version of string. + * + * @param {string} val + * @return {string} + * @private + */ + +function getlatin1 (val) { + // simple Unicode -> ISO-8859-1 transformation + return String(val).replace(NON_LATIN1_REGEXP, '?') +} + +/** + * Parse Content-Disposition header string. + * + * @param {string} string + * @return {object} + * @public + */ + +function parse (string) { + if (!string || typeof string !== 'string') { + throw new TypeError('argument string is required') + } + + var match = DISPOSITION_TYPE_REGEXP.exec(string) + + if (!match) { + throw new TypeError('invalid type format') + } + + // normalize type + var index = match[0].length + var type = match[1].toLowerCase() + + var key + var names = [] + var params = {} + var value + + // calculate index to start at + index = PARAM_REGEXP.lastIndex = match[0].substr(-1) === ';' + ? index - 1 + : index + + // match parameters + while ((match = PARAM_REGEXP.exec(string))) { + if (match.index !== index) { + throw new TypeError('invalid parameter format') + } + + index += match[0].length + key = match[1].toLowerCase() + value = match[2] + + if (names.indexOf(key) !== -1) { + throw new TypeError('invalid duplicate parameter') + } + + names.push(key) + + if (key.indexOf('*') + 1 === key.length) { + // decode extended value + key = key.slice(0, -1) + value = decodefield(value) + + // overwrite existing value + params[key] = value + continue + } + + if (typeof params[key] === 'string') { + continue + } + + if (value[0] === '"') { + // remove quotes and escapes + value = value + .substr(1, value.length - 2) + .replace(QESC_REGEXP, '$1') + } + + params[key] = value + } + + if (index !== -1 && index !== string.length) { + throw new TypeError('invalid parameter format') + } + + return new ContentDisposition(type, params) +} + +/** + * Percent decode a single character. + * + * @param {string} str + * @param {string} hex + * @return {string} + * @private + */ + +function pdecode (str, hex) { + return String.fromCharCode(parseInt(hex, 16)) +} + +/** + * Percent encode a single character. + * + * @param {string} char + * @return {string} + * @private + */ + +function pencode (char) { + return '%' + String(char) + .charCodeAt(0) + .toString(16) + .toUpperCase() +} + +/** + * Quote a string for HTTP. + * + * @param {string} val + * @return {string} + * @private + */ + +function qstring (val) { + var str = String(val) + + return '"' + str.replace(QUOTE_REGEXP, '\\$1') + '"' +} + +/** + * Encode a Unicode string for HTTP (RFC 5987). + * + * @param {string} val + * @return {string} + * @private + */ + +function ustring (val) { + var str = String(val) + + // percent encode as UTF-8 + var encoded = encodeURIComponent(str) + .replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode) + + return 'UTF-8\'\'' + encoded +} + +/** + * Class for parsed Content-Disposition header for v8 optimization + * + * @public + * @param {string} type + * @param {object} parameters + * @constructor + */ + +function ContentDisposition (type, parameters) { + this.type = type + this.parameters = parameters +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/package.json new file mode 100644 index 00000000..43c70ce2 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-disposition/package.json @@ -0,0 +1,44 @@ +{ + "name": "content-disposition", + "description": "Create and parse Content-Disposition header", + "version": "0.5.4", + "author": "Douglas Christopher Wilson ", + "license": "MIT", + "keywords": [ + "content-disposition", + "http", + "rfc6266", + "res" + ], + "repository": "jshttp/content-disposition", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "devDependencies": { + "deep-equal": "1.0.1", + "eslint": "7.32.0", + "eslint-config-standard": "13.0.1", + "eslint-plugin-import": "2.25.3", + "eslint-plugin-markdown": "2.2.1", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "5.2.0", + "eslint-plugin-standard": "4.1.0", + "istanbul": "0.4.5", + "mocha": "9.1.3" + }, + "files": [ + "LICENSE", + "HISTORY.md", + "README.md", + "index.js" + ], + "engines": { + "node": ">= 0.6" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --reporter spec --bail --check-leaks test/", + "test-ci": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/", + "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/HISTORY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/HISTORY.md new file mode 100644 index 00000000..45836713 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/HISTORY.md @@ -0,0 +1,29 @@ +1.0.5 / 2023-01-29 +================== + + * perf: skip value escaping when unnecessary + +1.0.4 / 2017-09-11 +================== + + * perf: skip parameter parsing when no parameters + +1.0.3 / 2017-09-10 +================== + + * perf: remove argument reassignment + +1.0.2 / 2016-05-09 +================== + + * perf: enable strict mode + +1.0.1 / 2015-02-13 +================== + + * Improve missing `Content-Type` header error message + +1.0.0 / 2015-02-01 +================== + + * Initial implementation, derived from `media-typer@0.3.0` diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/LICENSE new file mode 100644 index 00000000..34b1a2de --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2015 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/README.md new file mode 100644 index 00000000..c1a922a9 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/README.md @@ -0,0 +1,94 @@ +# content-type + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-url] +[![Node.js Version][node-image]][node-url] +[![Build Status][ci-image]][ci-url] +[![Coverage Status][coveralls-image]][coveralls-url] + +Create and parse HTTP Content-Type header according to RFC 7231 + +## Installation + +```sh +$ npm install content-type +``` + +## API + +```js +var contentType = require('content-type') +``` + +### contentType.parse(string) + +```js +var obj = contentType.parse('image/svg+xml; charset=utf-8') +``` + +Parse a `Content-Type` header. This will return an object with the following +properties (examples are shown for the string `'image/svg+xml; charset=utf-8'`): + + - `type`: The media type (the type and subtype, always lower case). + Example: `'image/svg+xml'` + + - `parameters`: An object of the parameters in the media type (name of parameter + always lower case). Example: `{charset: 'utf-8'}` + +Throws a `TypeError` if the string is missing or invalid. + +### contentType.parse(req) + +```js +var obj = contentType.parse(req) +``` + +Parse the `Content-Type` header from the given `req`. Short-cut for +`contentType.parse(req.headers['content-type'])`. + +Throws a `TypeError` if the `Content-Type` header is missing or invalid. + +### contentType.parse(res) + +```js +var obj = contentType.parse(res) +``` + +Parse the `Content-Type` header set on the given `res`. Short-cut for +`contentType.parse(res.getHeader('content-type'))`. + +Throws a `TypeError` if the `Content-Type` header is missing or invalid. + +### contentType.format(obj) + +```js +var str = contentType.format({ + type: 'image/svg+xml', + parameters: { charset: 'utf-8' } +}) +``` + +Format an object into a `Content-Type` header. This will return a string of the +content type for the given object with the following properties (examples are +shown that produce the string `'image/svg+xml; charset=utf-8'`): + + - `type`: The media type (will be lower-cased). Example: `'image/svg+xml'` + + - `parameters`: An object of the parameters in the media type (name of the + parameter will be lower-cased). Example: `{charset: 'utf-8'}` + +Throws a `TypeError` if the object contains an invalid type or parameter names. + +## License + +[MIT](LICENSE) + +[ci-image]: https://badgen.net/github/checks/jshttp/content-type/master?label=ci +[ci-url]: https://github.com/jshttp/content-type/actions/workflows/ci.yml +[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/content-type/master +[coveralls-url]: https://coveralls.io/r/jshttp/content-type?branch=master +[node-image]: https://badgen.net/npm/node/content-type +[node-url]: https://nodejs.org/en/download +[npm-downloads-image]: https://badgen.net/npm/dm/content-type +[npm-url]: https://npmjs.org/package/content-type +[npm-version-image]: https://badgen.net/npm/v/content-type diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/index.js new file mode 100644 index 00000000..41840e7b --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/index.js @@ -0,0 +1,225 @@ +/*! + * content-type + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1 + * + * parameter = token "=" ( token / quoted-string ) + * token = 1*tchar + * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" + * / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" + * / DIGIT / ALPHA + * ; any VCHAR, except delimiters + * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE + * qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text + * obs-text = %x80-FF + * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) + */ +var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g // eslint-disable-line no-control-regex +var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/ // eslint-disable-line no-control-regex +var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/ + +/** + * RegExp to match quoted-pair in RFC 7230 sec 3.2.6 + * + * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) + * obs-text = %x80-FF + */ +var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g // eslint-disable-line no-control-regex + +/** + * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6 + */ +var QUOTE_REGEXP = /([\\"])/g + +/** + * RegExp to match type in RFC 7231 sec 3.1.1.1 + * + * media-type = type "/" subtype + * type = token + * subtype = token + */ +var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/ + +/** + * Module exports. + * @public + */ + +exports.format = format +exports.parse = parse + +/** + * Format object to media type. + * + * @param {object} obj + * @return {string} + * @public + */ + +function format (obj) { + if (!obj || typeof obj !== 'object') { + throw new TypeError('argument obj is required') + } + + var parameters = obj.parameters + var type = obj.type + + if (!type || !TYPE_REGEXP.test(type)) { + throw new TypeError('invalid type') + } + + var string = type + + // append parameters + if (parameters && typeof parameters === 'object') { + var param + var params = Object.keys(parameters).sort() + + for (var i = 0; i < params.length; i++) { + param = params[i] + + if (!TOKEN_REGEXP.test(param)) { + throw new TypeError('invalid parameter name') + } + + string += '; ' + param + '=' + qstring(parameters[param]) + } + } + + return string +} + +/** + * Parse media type to object. + * + * @param {string|object} string + * @return {Object} + * @public + */ + +function parse (string) { + if (!string) { + throw new TypeError('argument string is required') + } + + // support req/res-like objects as argument + var header = typeof string === 'object' + ? getcontenttype(string) + : string + + if (typeof header !== 'string') { + throw new TypeError('argument string is required to be a string') + } + + var index = header.indexOf(';') + var type = index !== -1 + ? header.slice(0, index).trim() + : header.trim() + + if (!TYPE_REGEXP.test(type)) { + throw new TypeError('invalid media type') + } + + var obj = new ContentType(type.toLowerCase()) + + // parse parameters + if (index !== -1) { + var key + var match + var value + + PARAM_REGEXP.lastIndex = index + + while ((match = PARAM_REGEXP.exec(header))) { + if (match.index !== index) { + throw new TypeError('invalid parameter format') + } + + index += match[0].length + key = match[1].toLowerCase() + value = match[2] + + if (value.charCodeAt(0) === 0x22 /* " */) { + // remove quotes + value = value.slice(1, -1) + + // remove escapes + if (value.indexOf('\\') !== -1) { + value = value.replace(QESC_REGEXP, '$1') + } + } + + obj.parameters[key] = value + } + + if (index !== header.length) { + throw new TypeError('invalid parameter format') + } + } + + return obj +} + +/** + * Get content-type from req/res objects. + * + * @param {object} + * @return {Object} + * @private + */ + +function getcontenttype (obj) { + var header + + if (typeof obj.getHeader === 'function') { + // res-like + header = obj.getHeader('content-type') + } else if (typeof obj.headers === 'object') { + // req-like + header = obj.headers && obj.headers['content-type'] + } + + if (typeof header !== 'string') { + throw new TypeError('content-type header is missing from object') + } + + return header +} + +/** + * Quote a string if necessary. + * + * @param {string} val + * @return {string} + * @private + */ + +function qstring (val) { + var str = String(val) + + // no need to quote tokens + if (TOKEN_REGEXP.test(str)) { + return str + } + + if (str.length > 0 && !TEXT_REGEXP.test(str)) { + throw new TypeError('invalid parameter value') + } + + return '"' + str.replace(QUOTE_REGEXP, '\\$1') + '"' +} + +/** + * Class to represent a content type. + * @private + */ +function ContentType (type) { + this.parameters = Object.create(null) + this.type = type +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/package.json new file mode 100644 index 00000000..9db19f63 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/content-type/package.json @@ -0,0 +1,42 @@ +{ + "name": "content-type", + "description": "Create and parse HTTP Content-Type header", + "version": "1.0.5", + "author": "Douglas Christopher Wilson ", + "license": "MIT", + "keywords": [ + "content-type", + "http", + "req", + "res", + "rfc7231" + ], + "repository": "jshttp/content-type", + "devDependencies": { + "deep-equal": "1.0.1", + "eslint": "8.32.0", + "eslint-config-standard": "15.0.1", + "eslint-plugin-import": "2.27.5", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "6.1.1", + "eslint-plugin-standard": "4.1.0", + "mocha": "10.2.0", + "nyc": "15.1.0" + }, + "files": [ + "LICENSE", + "HISTORY.md", + "README.md", + "index.js" + ], + "engines": { + "node": ">= 0.6" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --reporter spec --check-leaks --bail test/", + "test-ci": "nyc --reporter=lcovonly --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test", + "version": "node scripts/version-history.js && git add HISTORY.md" + } +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/.npmignore b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/.npmignore new file mode 100644 index 00000000..f1250e58 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/.npmignore @@ -0,0 +1,4 @@ +support +test +examples +*.sock diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/History.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/History.md new file mode 100644 index 00000000..78513cc3 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/History.md @@ -0,0 +1,38 @@ +1.0.6 / 2015-02-03 +================== + +* use `npm test` instead of `make test` to run tests +* clearer assertion messages when checking input + + +1.0.5 / 2014-09-05 +================== + +* add license to package.json + +1.0.4 / 2014-06-25 +================== + + * corrected avoidance of timing attacks (thanks @tenbits!) + +1.0.3 / 2014-01-28 +================== + + * [incorrect] fix for timing attacks + +1.0.2 / 2014-01-28 +================== + + * fix missing repository warning + * fix typo in test + +1.0.1 / 2013-04-15 +================== + + * Revert "Changed underlying HMAC algo. to sha512." + * Revert "Fix for timing attacks on MAC verification." + +0.0.1 / 2010-01-03 +================== + + * Initial release diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/Readme.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/Readme.md new file mode 100644 index 00000000..2559e841 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/Readme.md @@ -0,0 +1,42 @@ + +# cookie-signature + + Sign and unsign cookies. + +## Example + +```js +var cookie = require('cookie-signature'); + +var val = cookie.sign('hello', 'tobiiscool'); +val.should.equal('hello.DGDUkGlIkCzPz+C0B064FNgHdEjox7ch8tOBGslZ5QI'); + +var val = cookie.sign('hello', 'tobiiscool'); +cookie.unsign(val, 'tobiiscool').should.equal('hello'); +cookie.unsign(val, 'luna').should.be.false; +``` + +## License + +(The MIT License) + +Copyright (c) 2012 LearnBoost <tj@learnboost.com> + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/index.js new file mode 100644 index 00000000..b8c9463a --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/index.js @@ -0,0 +1,51 @@ +/** + * Module dependencies. + */ + +var crypto = require('crypto'); + +/** + * Sign the given `val` with `secret`. + * + * @param {String} val + * @param {String} secret + * @return {String} + * @api private + */ + +exports.sign = function(val, secret){ + if ('string' != typeof val) throw new TypeError("Cookie value must be provided as a string."); + if ('string' != typeof secret) throw new TypeError("Secret string must be provided."); + return val + '.' + crypto + .createHmac('sha256', secret) + .update(val) + .digest('base64') + .replace(/\=+$/, ''); +}; + +/** + * Unsign and decode the given `val` with `secret`, + * returning `false` if the signature is invalid. + * + * @param {String} val + * @param {String} secret + * @return {String|Boolean} + * @api private + */ + +exports.unsign = function(val, secret){ + if ('string' != typeof val) throw new TypeError("Signed cookie string must be provided."); + if ('string' != typeof secret) throw new TypeError("Secret string must be provided."); + var str = val.slice(0, val.lastIndexOf('.')) + , mac = exports.sign(str, secret); + + return sha1(mac) == sha1(val) ? str : false; +}; + +/** + * Private + */ + +function sha1(str){ + return crypto.createHash('sha1').update(str).digest('hex'); +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/package.json b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/package.json new file mode 100644 index 00000000..29c4498e --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie-signature/package.json @@ -0,0 +1,18 @@ +{ + "name": "cookie-signature", + "version": "1.0.6", + "description": "Sign and unsign cookies", + "keywords": ["cookie", "sign", "unsign"], + "author": "TJ Holowaychuk ", + "license": "MIT", + "repository": { "type": "git", "url": "https://github.com/visionmedia/node-cookie-signature.git"}, + "dependencies": {}, + "devDependencies": { + "mocha": "*", + "should": "*" + }, + "scripts": { + "test": "mocha --require should --reporter spec" + }, + "main": "index" +} diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/LICENSE b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/LICENSE new file mode 100644 index 00000000..058b6b4e --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/LICENSE @@ -0,0 +1,24 @@ +(The MIT License) + +Copyright (c) 2012-2014 Roman Shtylman +Copyright (c) 2015 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/README.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/README.md new file mode 100644 index 00000000..71fdac11 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/README.md @@ -0,0 +1,317 @@ +# cookie + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-url] +[![Node.js Version][node-image]][node-url] +[![Build Status][ci-image]][ci-url] +[![Coverage Status][coveralls-image]][coveralls-url] + +Basic HTTP cookie parser and serializer for HTTP servers. + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```sh +$ npm install cookie +``` + +## API + +```js +var cookie = require('cookie'); +``` + +### cookie.parse(str, options) + +Parse an HTTP `Cookie` header string and returning an object of all cookie name-value pairs. +The `str` argument is the string representing a `Cookie` header value and `options` is an +optional object containing additional parsing options. + +```js +var cookies = cookie.parse('foo=bar; equation=E%3Dmc%5E2'); +// { foo: 'bar', equation: 'E=mc^2' } +``` + +#### Options + +`cookie.parse` accepts these properties in the options object. + +##### decode + +Specifies a function that will be used to decode a cookie's value. Since the value of a cookie +has a limited character set (and must be a simple string), this function can be used to decode +a previously-encoded cookie value into a JavaScript string or other object. + +The default function is the global `decodeURIComponent`, which will decode any URL-encoded +sequences into their byte representations. + +**note** if an error is thrown from this function, the original, non-decoded cookie value will +be returned as the cookie's value. + +### cookie.serialize(name, value, options) + +Serialize a cookie name-value pair into a `Set-Cookie` header string. The `name` argument is the +name for the cookie, the `value` argument is the value to set the cookie to, and the `options` +argument is an optional object containing additional serialization options. + +```js +var setCookie = cookie.serialize('foo', 'bar'); +// foo=bar +``` + +#### Options + +`cookie.serialize` accepts these properties in the options object. + +##### domain + +Specifies the value for the [`Domain` `Set-Cookie` attribute][rfc-6265-5.2.3]. By default, no +domain is set, and most clients will consider the cookie to apply to only the current domain. + +##### encode + +Specifies a function that will be used to encode a cookie's value. Since value of a cookie +has a limited character set (and must be a simple string), this function can be used to encode +a value into a string suited for a cookie's value. + +The default function is the global `encodeURIComponent`, which will encode a JavaScript string +into UTF-8 byte sequences and then URL-encode any that fall outside of the cookie range. + +##### expires + +Specifies the `Date` object to be the value for the [`Expires` `Set-Cookie` attribute][rfc-6265-5.2.1]. +By default, no expiration is set, and most clients will consider this a "non-persistent cookie" and +will delete it on a condition like exiting a web browser application. + +**note** the [cookie storage model specification][rfc-6265-5.3] states that if both `expires` and +`maxAge` are set, then `maxAge` takes precedence, but it is possible not all clients by obey this, +so if both are set, they should point to the same date and time. + +##### httpOnly + +Specifies the `boolean` value for the [`HttpOnly` `Set-Cookie` attribute][rfc-6265-5.2.6]. When truthy, +the `HttpOnly` attribute is set, otherwise it is not. By default, the `HttpOnly` attribute is not set. + +**note** be careful when setting this to `true`, as compliant clients will not allow client-side +JavaScript to see the cookie in `document.cookie`. + +##### maxAge + +Specifies the `number` (in seconds) to be the value for the [`Max-Age` `Set-Cookie` attribute][rfc-6265-5.2.2]. +The given number will be converted to an integer by rounding down. By default, no maximum age is set. + +**note** the [cookie storage model specification][rfc-6265-5.3] states that if both `expires` and +`maxAge` are set, then `maxAge` takes precedence, but it is possible not all clients by obey this, +so if both are set, they should point to the same date and time. + +##### partitioned + +Specifies the `boolean` value for the [`Partitioned` `Set-Cookie`](rfc-cutler-httpbis-partitioned-cookies) +attribute. When truthy, the `Partitioned` attribute is set, otherwise it is not. By default, the +`Partitioned` attribute is not set. + +**note** This is an attribute that has not yet been fully standardized, and may change in the future. +This also means many clients may ignore this attribute until they understand it. + +More information about can be found in [the proposal](https://github.com/privacycg/CHIPS). + +##### path + +Specifies the value for the [`Path` `Set-Cookie` attribute][rfc-6265-5.2.4]. By default, the path +is considered the ["default path"][rfc-6265-5.1.4]. + +##### priority + +Specifies the `string` to be the value for the [`Priority` `Set-Cookie` attribute][rfc-west-cookie-priority-00-4.1]. + + - `'low'` will set the `Priority` attribute to `Low`. + - `'medium'` will set the `Priority` attribute to `Medium`, the default priority when not set. + - `'high'` will set the `Priority` attribute to `High`. + +More information about the different priority levels can be found in +[the specification][rfc-west-cookie-priority-00-4.1]. + +**note** This is an attribute that has not yet been fully standardized, and may change in the future. +This also means many clients may ignore this attribute until they understand it. + +##### sameSite + +Specifies the `boolean` or `string` to be the value for the [`SameSite` `Set-Cookie` attribute][rfc-6265bis-09-5.4.7]. + + - `true` will set the `SameSite` attribute to `Strict` for strict same site enforcement. + - `false` will not set the `SameSite` attribute. + - `'lax'` will set the `SameSite` attribute to `Lax` for lax same site enforcement. + - `'none'` will set the `SameSite` attribute to `None` for an explicit cross-site cookie. + - `'strict'` will set the `SameSite` attribute to `Strict` for strict same site enforcement. + +More information about the different enforcement levels can be found in +[the specification][rfc-6265bis-09-5.4.7]. + +**note** This is an attribute that has not yet been fully standardized, and may change in the future. +This also means many clients may ignore this attribute until they understand it. + +##### secure + +Specifies the `boolean` value for the [`Secure` `Set-Cookie` attribute][rfc-6265-5.2.5]. When truthy, +the `Secure` attribute is set, otherwise it is not. By default, the `Secure` attribute is not set. + +**note** be careful when setting this to `true`, as compliant clients will not send the cookie back to +the server in the future if the browser does not have an HTTPS connection. + +## Example + +The following example uses this module in conjunction with the Node.js core HTTP server +to prompt a user for their name and display it back on future visits. + +```js +var cookie = require('cookie'); +var escapeHtml = require('escape-html'); +var http = require('http'); +var url = require('url'); + +function onRequest(req, res) { + // Parse the query string + var query = url.parse(req.url, true, true).query; + + if (query && query.name) { + // Set a new cookie with the name + res.setHeader('Set-Cookie', cookie.serialize('name', String(query.name), { + httpOnly: true, + maxAge: 60 * 60 * 24 * 7 // 1 week + })); + + // Redirect back after setting cookie + res.statusCode = 302; + res.setHeader('Location', req.headers.referer || '/'); + res.end(); + return; + } + + // Parse the cookies on the request + var cookies = cookie.parse(req.headers.cookie || ''); + + // Get the visitor name set in the cookie + var name = cookies.name; + + res.setHeader('Content-Type', 'text/html; charset=UTF-8'); + + if (name) { + res.write('

Welcome back, ' + escapeHtml(name) + '!

'); + } else { + res.write('

Hello, new visitor!

'); + } + + res.write('
'); + res.write(' '); + res.end('
'); +} + +http.createServer(onRequest).listen(3000); +``` + +## Testing + +```sh +$ npm test +``` + +## Benchmark + +``` +$ npm run bench + +> cookie@0.5.0 bench +> node benchmark/index.js + + node@18.18.2 + acorn@8.10.0 + ada@2.6.0 + ares@1.19.1 + brotli@1.0.9 + cldr@43.1 + icu@73.2 + llhttp@6.0.11 + modules@108 + napi@9 + nghttp2@1.57.0 + nghttp3@0.7.0 + ngtcp2@0.8.1 + openssl@3.0.10+quic + simdutf@3.2.14 + tz@2023c + undici@5.26.3 + unicode@15.0 + uv@1.44.2 + uvwasi@0.0.18 + v8@10.2.154.26-node.26 + zlib@1.2.13.1-motley + +> node benchmark/parse-top.js + + cookie.parse - top sites + + 14 tests completed. + + parse accounts.google.com x 2,588,913 ops/sec ±0.74% (186 runs sampled) + parse apple.com x 2,370,002 ops/sec ±0.69% (186 runs sampled) + parse cloudflare.com x 2,213,102 ops/sec ±0.88% (188 runs sampled) + parse docs.google.com x 2,194,157 ops/sec ±1.03% (184 runs sampled) + parse drive.google.com x 2,265,084 ops/sec ±0.79% (187 runs sampled) + parse en.wikipedia.org x 457,099 ops/sec ±0.81% (186 runs sampled) + parse linkedin.com x 504,407 ops/sec ±0.89% (186 runs sampled) + parse maps.google.com x 1,230,959 ops/sec ±0.98% (186 runs sampled) + parse microsoft.com x 926,294 ops/sec ±0.88% (184 runs sampled) + parse play.google.com x 2,311,338 ops/sec ±0.83% (185 runs sampled) + parse support.google.com x 1,508,850 ops/sec ±0.86% (186 runs sampled) + parse www.google.com x 1,022,582 ops/sec ±1.32% (182 runs sampled) + parse youtu.be x 332,136 ops/sec ±1.02% (185 runs sampled) + parse youtube.com x 323,833 ops/sec ±0.77% (183 runs sampled) + +> node benchmark/parse.js + + cookie.parse - generic + + 6 tests completed. + + simple x 3,214,032 ops/sec ±1.61% (183 runs sampled) + decode x 587,237 ops/sec ±1.16% (187 runs sampled) + unquote x 2,954,618 ops/sec ±1.35% (183 runs sampled) + duplicates x 857,008 ops/sec ±0.89% (187 runs sampled) + 10 cookies x 292,133 ops/sec ±0.89% (187 runs sampled) + 100 cookies x 22,610 ops/sec ±0.68% (187 runs sampled) +``` + +## References + +- [RFC 6265: HTTP State Management Mechanism][rfc-6265] +- [Same-site Cookies][rfc-6265bis-09-5.4.7] + +[rfc-cutler-httpbis-partitioned-cookies]: https://tools.ietf.org/html/draft-cutler-httpbis-partitioned-cookies/ +[rfc-west-cookie-priority-00-4.1]: https://tools.ietf.org/html/draft-west-cookie-priority-00#section-4.1 +[rfc-6265bis-09-5.4.7]: https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-09#section-5.4.7 +[rfc-6265]: https://tools.ietf.org/html/rfc6265 +[rfc-6265-5.1.4]: https://tools.ietf.org/html/rfc6265#section-5.1.4 +[rfc-6265-5.2.1]: https://tools.ietf.org/html/rfc6265#section-5.2.1 +[rfc-6265-5.2.2]: https://tools.ietf.org/html/rfc6265#section-5.2.2 +[rfc-6265-5.2.3]: https://tools.ietf.org/html/rfc6265#section-5.2.3 +[rfc-6265-5.2.4]: https://tools.ietf.org/html/rfc6265#section-5.2.4 +[rfc-6265-5.2.5]: https://tools.ietf.org/html/rfc6265#section-5.2.5 +[rfc-6265-5.2.6]: https://tools.ietf.org/html/rfc6265#section-5.2.6 +[rfc-6265-5.3]: https://tools.ietf.org/html/rfc6265#section-5.3 + +## License + +[MIT](LICENSE) + +[ci-image]: https://badgen.net/github/checks/jshttp/cookie/master?label=ci +[ci-url]: https://github.com/jshttp/cookie/actions/workflows/ci.yml +[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/cookie/master +[coveralls-url]: https://coveralls.io/r/jshttp/cookie?branch=master +[node-image]: https://badgen.net/npm/node/cookie +[node-url]: https://nodejs.org/en/download +[npm-downloads-image]: https://badgen.net/npm/dm/cookie +[npm-url]: https://npmjs.org/package/cookie +[npm-version-image]: https://badgen.net/npm/v/cookie diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/SECURITY.md b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/SECURITY.md new file mode 100644 index 00000000..fd4a6c53 --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/SECURITY.md @@ -0,0 +1,25 @@ +# Security Policies and Procedures + +## Reporting a Bug + +The `cookie` team and community take all security bugs seriously. Thank +you for improving the security of the project. We appreciate your efforts and +responsible disclosure and will make every effort to acknowledge your +contributions. + +Report security bugs by emailing the current owner(s) of `cookie`. This +information can be found in the npm registry using the command +`npm owner ls cookie`. +If unsure or unable to get the information from the above, open an issue +in the [project issue tracker](https://github.com/jshttp/cookie/issues) +asking for the current contact information. + +To ensure the timely response to your report, please ensure that the entirety +of the report is contained within the email body and not solely behind a web +link or an attachment. + +At least one owner will acknowledge your email within 48 hours, and will send a +more detailed response within 48 hours indicating the next steps in handling +your report. After the initial reply to your report, the owners will +endeavor to keep you informed of the progress towards a fix and full +announcement, and may ask for additional information or guidance. diff --git a/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/index.js b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/index.js new file mode 100644 index 00000000..51a58cbe --- /dev/null +++ b/OneDrive/Desktop/SIT323/sit323-2025-prac5d/node_modules/cookie/index.js @@ -0,0 +1,334 @@ +/*! + * cookie + * Copyright(c) 2012-2014 Roman Shtylman + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module exports. + * @public + */ + +exports.parse = parse; +exports.serialize = serialize; + +/** + * Module variables. + * @private + */ + +var __toString = Object.prototype.toString + +/** + * RegExp to match cookie-name in RFC 6265 sec 4.1.1 + * This refers out to the obsoleted definition of token in RFC 2616 sec 2.2 + * which has been replaced by the token definition in RFC 7230 appendix B. + * + * cookie-name = token + * token = 1*tchar + * tchar = "!" / "#" / "$" / "%" / "&" / "'" / + * "*" / "+" / "-" / "." / "^" / "_" / + * "`" / "|" / "~" / DIGIT / ALPHA + */ + +var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; + +/** + * RegExp to match cookie-value in RFC 6265 sec 4.1.1 + * + * cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE ) + * cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E + * ; US-ASCII characters excluding CTLs, + * ; whitespace DQUOTE, comma, semicolon, + * ; and backslash + */ + +var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/; + +/** + * RegExp to match domain-value in RFC 6265 sec 4.1.1 + * + * domain-value = + * ; defined in [RFC1034], Section 3.5, as + * ; enhanced by [RFC1123], Section 2.1 + * =