diff --git a/backend/node_modules/.bin/eslint b/backend/node_modules/.bin/eslint index fa6f05e3..8d538fb1 100755 --- a/backend/node_modules/.bin/eslint +++ b/backend/node_modules/.bin/eslint @@ -56,19 +56,19 @@ esac basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? if [ -z "$NODE_PATH" ]; then - export NODE_PATH="$basedir_abs/../.pnpm/eslint@10.11.0/node_modules/eslint/node_modules:$basedir_abs/../.pnpm/eslint@10.11.0/node_modules:$basedir_abs/../.pnpm/node_modules" + export NODE_PATH="$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../.pnpm/node_modules" else - export NODE_PATH="$basedir_abs/../.pnpm/eslint@10.11.0/node_modules/eslint/node_modules:$basedir_abs/../.pnpm/eslint@10.11.0/node_modules:$basedir_abs/../.pnpm/node_modules:$NODE_PATH" + export NODE_PATH="$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../.pnpm/node_modules:$NODE_PATH" fi if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then - exec "$basedir/node.exe" "$basedir_win/../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js" "$@" + exec "$basedir/node.exe" "$basedir_win/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" elif [ -x "$basedir/node" ]; then - exec "$basedir/node" "$basedir_abs/../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js" "$@" + exec "$basedir/node" "$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" elif command -v node >/dev/null 2>&1; then - exec node "$basedir_abs/../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js" "$@" + exec node "$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then - exec node.exe "$basedir_win/../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js" "$@" + exec node.exe "$basedir_win/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" else - exec node "$basedir_abs/../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js" "$@" + exec node "$basedir_abs/../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" fi -# cmd-shim-target=../.pnpm/eslint@10.11.0/node_modules/eslint/bin/eslint.js +# cmd-shim-target=../.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.bin/jiti b/backend/node_modules/.bin/jiti new file mode 100755 index 00000000..cbb999b3 --- /dev/null +++ b/backend/node_modules/.bin/jiti @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../.pnpm/jiti@2.7.0/node_modules/jiti/node_modules:$basedir_abs/../.pnpm/jiti@2.7.0/node_modules:$basedir_abs/../.pnpm/node_modules" +else + export NODE_PATH="$basedir_abs/../.pnpm/jiti@2.7.0/node_modules/jiti/node_modules:$basedir_abs/../.pnpm/jiti@2.7.0/node_modules:$basedir_abs/../.pnpm/node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +else + exec node "$basedir_abs/../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +fi +# cmd-shim-target=../.pnpm/jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs diff --git a/backend/node_modules/.bin/vitest b/backend/node_modules/.bin/vitest new file mode 100755 index 00000000..7aa351d5 --- /dev/null +++ b/backend/node_modules/.bin/vitest @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/node_modules:$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules:$basedir_abs/../.pnpm/node_modules" +else + export NODE_PATH="$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/node_modules:$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules:$basedir_abs/../.pnpm/node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs" "$@" +else + exec node "$basedir_abs/../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs" "$@" +fi +# cmd-shim-target=../.pnpm/vitest@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vitest/vitest.mjs diff --git a/backend/node_modules/.modules.yaml b/backend/node_modules/.modules.yaml index caba79c3..db9be99a 100644 --- a/backend/node_modules/.modules.yaml +++ b/backend/node_modules/.modules.yaml @@ -60,7 +60,7 @@ "whatwg-mimetype@4.0.0": { "whatwg-mimetype": "private" }, - "@eslint-community/eslint-utils@4.10.1(eslint@10.11.0)": { + "@eslint-community/eslint-utils@4.10.1(eslint@10.11.0(jiti@2.7.0))": { "@eslint-community/eslint-utils": "private" }, "@eslint-community/regexpp@4.12.2": { @@ -174,21 +174,63 @@ "sift@17.1.3": { "sift": "private" }, - "@typescript-eslint/eslint-plugin@8.70.1(@typescript-eslint/parser@8.70.1(eslint@10.11.0)(typescript@6.0.3))(eslint@10.11.0)(typescript@6.0.3)": { + "@typescript-eslint/eslint-plugin@8.70.1(@typescript-eslint/parser@8.70.1(eslint@10.11.0(jiti@2.7.0))(typescript@6.0.3))(eslint@10.11.0(jiti@2.7.0))(typescript@6.0.3)": { "@typescript-eslint/eslint-plugin": "private" }, - "@typescript-eslint/parser@8.70.1(eslint@10.11.0)(typescript@6.0.3)": { + "@typescript-eslint/parser@8.70.1(eslint@10.11.0(jiti@2.7.0))(typescript@6.0.3)": { "@typescript-eslint/parser": "private" }, "@typescript-eslint/typescript-estree@8.70.1(typescript@6.0.3)": { "@typescript-eslint/typescript-estree": "private" }, - "@typescript-eslint/utils@8.70.1(eslint@10.11.0)(typescript@6.0.3)": { + "@typescript-eslint/utils@8.70.1(eslint@10.11.0(jiti@2.7.0))(typescript@6.0.3)": { "@typescript-eslint/utils": "private" }, "typescript@6.0.3": { "typescript": "private" }, + "@types/chai@5.2.3": { + "@types/chai": "private" + }, + "@vitest/mocker@5.0.2(vite@8.3.1(jiti@2.7.0))": { + "@vitest/mocker": "private" + }, + "chai@6.2.2": { + "chai": "private" + }, + "es-module-lexer@2.3.2": { + "es-module-lexer": "private" + }, + "expect-type@1.4.0": { + "expect-type": "private" + }, + "magic-string@1.4.2": { + "magic-string": "private" + }, + "obug@2.2.1": { + "obug": "private" + }, + "picomatch@4.0.7": { + "picomatch": "private" + }, + "std-env@4.2.0": { + "std-env": "private" + }, + "tinybench@6.2.0": { + "tinybench": "private" + }, + "tinyexec@1.3.1": { + "tinyexec": "private" + }, + "tinyglobby@0.2.17": { + "tinyglobby": "private" + }, + "vite@8.3.1(jiti@2.7.0)": { + "vite": "private" + }, + "why-is-node-running@3.2.2": { + "why-is-node-running": "private" + }, "@apollo/protobufjs@1.2.8": { "@apollo/protobufjs": "private" }, @@ -231,10 +273,16 @@ "@humanfs/types@0.15.0": { "@humanfs/types": "private" }, + "@types/deep-eql@4.0.2": { + "@types/deep-eql": "private" + }, + "assertion-error@2.0.1": { + "assertion-error": "private" + }, "@typescript-eslint/scope-manager@8.70.1": { "@typescript-eslint/scope-manager": "private" }, - "@typescript-eslint/type-utils@8.70.1(eslint@10.11.0)(typescript@6.0.3)": { + "@typescript-eslint/type-utils@8.70.1(eslint@10.11.0(jiti@2.7.0))(typescript@6.0.3)": { "@typescript-eslint/type-utils": "private" }, "@typescript-eslint/visitor-keys@8.70.1": { @@ -255,8 +303,14 @@ "semver@7.8.5": { "semver": "private" }, - "tinyglobby@0.2.17": { - "tinyglobby": "private" + "@jridgewell/trace-mapping@0.3.31": { + "@jridgewell/trace-mapping": "private" + }, + "@vitest/spy@5.0.2": { + "@vitest/spy": "private" + }, + "estree-walker@3.0.3": { + "estree-walker": "private" }, "fast-json-stable-stringify@2.1.0": { "fast-json-stable-stringify": "private" @@ -345,6 +399,9 @@ "is-extglob@2.1.1": { "is-extglob": "private" }, + "@jridgewell/sourcemap-codec@1.6.0": { + "@jridgewell/sourcemap-codec": "private" + }, "brace-expansion@5.0.12": { "brace-expansion": "private" }, @@ -372,6 +429,18 @@ "word-wrap@1.2.5": { "word-wrap": "private" }, + "fdir@6.5.0(picomatch@4.0.7)": { + "fdir": "private" + }, + "lightningcss@1.33.0": { + "lightningcss": "private" + }, + "postcss@8.5.28": { + "postcss": "private" + }, + "rolldown@1.2.11": { + "rolldown": "private" + }, "@protobufjs/aspromise@1.1.2": { "@protobufjs/aspromise": "private" }, @@ -420,6 +489,9 @@ "cross-inspect@1.0.1": { "cross-inspect": "private" }, + "@jridgewell/resolve-uri@3.1.2": { + "@jridgewell/resolve-uri": "private" + }, "sparse-bitfield@3.0.3": { "sparse-bitfield": "private" }, @@ -450,6 +522,12 @@ "safer-buffer@2.1.2": { "safer-buffer": "private" }, + "detect-libc@2.1.2": { + "detect-libc": "private" + }, + "lightningcss-linux-x64-gnu@1.33.0": { + "lightningcss-linux-x64-gnu": "private" + }, "p-locate@5.0.0": { "p-locate": "private" }, @@ -462,6 +540,15 @@ "ee-first@1.1.1": { "ee-first": "private" }, + "nanoid@3.3.19": { + "nanoid": "private" + }, + "picocolors@1.1.1": { + "picocolors": "private" + }, + "source-map-js@1.2.1": { + "source-map-js": "private" + }, "es-define-property@1.0.1": { "es-define-property": "private" }, @@ -471,6 +558,15 @@ "unpipe@1.0.0": { "unpipe": "private" }, + "@oxc-project/types@0.151.0": { + "@oxc-project/types": "private" + }, + "@rolldown/pluginutils@1.0.1": { + "@rolldown/pluginutils": "private" + }, + "@rolldown/binding-linux-x64-gnu@1.2.11": { + "@rolldown/binding-linux-x64-gnu": "private" + }, "safe-buffer@5.2.1": { "safe-buffer": "private" }, @@ -480,12 +576,6 @@ "shebang-regex@3.0.0": { "shebang-regex": "private" }, - "fdir@6.5.0(picomatch@4.0.7)": { - "fdir": "private" - }, - "picomatch@4.0.7": { - "picomatch": "private" - }, "media-typer@1.1.1": { "media-typer": "private" }, @@ -642,7 +732,33 @@ "pendingBuilds": [], "prunedAt": "Fri, 25 Sep 2026 12:50:33 GMT", "publicHoistPattern": [], - "skipped": [], + "skipped": [ + "@rolldown/binding-android-arm-eabi@1.2.11", + "@rolldown/binding-android-arm64@1.2.11", + "@rolldown/binding-darwin-arm64@1.2.11", + "@rolldown/binding-darwin-x64@1.2.11", + "@rolldown/binding-freebsd-x64@1.2.11", + "@rolldown/binding-linux-arm-gnueabihf@1.2.11", + "@rolldown/binding-linux-arm64-gnu@1.2.11", + "@rolldown/binding-linux-arm64-musl@1.2.11", + "@rolldown/binding-linux-ppc64-gnu@1.2.11", + "@rolldown/binding-linux-s390x-gnu@1.2.11", + "@rolldown/binding-linux-x64-musl@1.2.11", + "@rolldown/binding-openharmony-arm64@1.2.11", + "@rolldown/binding-win32-arm64-msvc@1.2.11", + "@rolldown/binding-win32-x64-msvc@1.2.11", + "fsevents@2.3.3", + "lightningcss-android-arm64@1.33.0", + "lightningcss-darwin-arm64@1.33.0", + "lightningcss-darwin-x64@1.33.0", + "lightningcss-freebsd-x64@1.33.0", + "lightningcss-linux-arm-gnueabihf@1.33.0", + "lightningcss-linux-arm64-gnu@1.33.0", + "lightningcss-linux-arm64-musl@1.33.0", + "lightningcss-linux-x64-musl@1.33.0", + "lightningcss-win32-arm64-msvc@1.33.0", + "lightningcss-win32-x64-msvc@1.33.0" + ], "storeDir": "/home/albert/.local/share/pnpm/store/v11", "virtualStoreDir": ".pnpm", "virtualStoreDirMaxLength": 120, diff --git a/backend/node_modules/.pnpm-workspace-state-v1.json b/backend/node_modules/.pnpm-workspace-state-v1.json index 78d1c307..90d59140 100644 --- a/backend/node_modules/.pnpm-workspace-state-v1.json +++ b/backend/node_modules/.pnpm-workspace-state-v1.json @@ -1,7 +1,7 @@ { - "lastValidatedTimestamp": 1790686450444, + "lastValidatedTimestamp": 1790691069045, "projects": { - "/home/albert/Documents/projects/webutvikling/project2/backend": { + "/home/albert/Documents/projects/project2/backend": { "name": "backend", "version": "1.0.0" } diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/LICENSE b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/LICENSE new file mode 100644 index 00000000..b607bb36 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/LICENSE @@ -0,0 +1,19 @@ +Copyright OpenJS Foundation and other contributors, + +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/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/README.md b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/README.md new file mode 100644 index 00000000..eae3d22e --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/README.md @@ -0,0 +1,103 @@ +[![npm version](https://img.shields.io/npm/v/@eslint/js.svg)](https://www.npmjs.com/package/@eslint/js) +[![Downloads](https://img.shields.io/npm/dm/@eslint/js.svg)](https://www.npmjs.com/package/@eslint/js) +[![Build Status](https://github.com/eslint/eslint/workflows/CI/badge.svg)](https://github.com/eslint/eslint/actions) +
+[![Open Collective Backers](https://img.shields.io/opencollective/backers/eslint)](https://opencollective.com/eslint) +[![Open Collective Sponsors](https://img.shields.io/opencollective/sponsors/eslint)](https://opencollective.com/eslint) + +# ESLint JavaScript Plugin + +[Website](https://eslint.org) | +[Configure ESLint](https://eslint.org/docs/latest/use/configure) | +[Rules](https://eslint.org/docs/rules/) | +[Contribute to ESLint](https://eslint.org/docs/latest/contribute) | +[Report Bugs](https://eslint.org/docs/latest/contribute/report-bugs) | +[Code of Conduct](https://eslint.org/conduct) | +[X](https://x.com/geteslint) | +[Discord](https://eslint.org/chat) | +[Mastodon](https://fosstodon.org/@eslint) | +[Bluesky](https://bsky.app/profile/eslint.org) + +The beginnings of separating out JavaScript-specific functionality from ESLint. + +Right now, this plugin contains two configurations: + +- `recommended` - enables the rules recommended by the ESLint team (the replacement for `"eslint:recommended"`) +- `all` - enables all ESLint rules (the replacement for `"eslint:all"`) + +## Installation + +You can install ESLint using npm or other package managers: + +```shell +npm install eslint -D +# or +yarn add eslint -D +# or +pnpm install eslint -D +# or +bun add eslint -D +``` + +Then install this plugin: + +```shell +npm install @eslint/js -D +# or +yarn add @eslint/js -D +# or +pnpm install @eslint/js -D +# or +bun add @eslint/js -D +``` + +## Usage + +Use in your `eslint.config.js` file anytime you want to extend one of the configs: + +```js +import { defineConfig } from "eslint/config"; +import js from "@eslint/js"; + +export default defineConfig([ + // apply recommended rules to JS files + { + name: "your-project/recommended-rules", + files: ["**/*.js"], + plugins: { + js, + }, + extends: ["js/recommended"], + }, + + // apply recommended rules to JS files with an override + { + name: "your-project/recommended-rules-with-override", + files: ["**/*.js"], + plugins: { + js, + }, + extends: ["js/recommended"], + rules: { + "no-unused-vars": "warn", + }, + }, + + // apply all rules to JS files + { + name: "your-project/all-rules", + files: ["**/*.js"], + plugins: { + js, + }, + extends: ["js/all"], + rules: { + "no-unused-vars": "warn", + }, + }, +]); +``` + +## License + +MIT diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/package.json b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/package.json new file mode 100644 index 00000000..3a86691d --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/package.json @@ -0,0 +1,44 @@ +{ + "name": "@eslint/js", + "version": "10.0.1", + "description": "ESLint JavaScript language implementation", + "funding": "https://eslint.org/donate", + "main": "./src/index.js", + "types": "./types/index.d.ts", + "scripts": { + "test:types": "tsc -p tests/types/tsconfig.json" + }, + "files": [ + "LICENSE", + "README.md", + "src", + "types" + ], + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/eslint/eslint.git", + "directory": "packages/js" + }, + "homepage": "https://eslint.org", + "bugs": "https://github.com/eslint/eslint/issues/", + "keywords": [ + "javascript", + "eslint-plugin", + "eslint" + ], + "license": "MIT", + "peerDependencies": { + "eslint": "^10.0.0" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } +} diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-all.js b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-all.js new file mode 100644 index 00000000..43ee2ae3 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-all.js @@ -0,0 +1,210 @@ +/* + * WARNING: This file is autogenerated using the tools/update-eslint-all.js + * script. Do not edit manually. + */ +"use strict"; + +module.exports = Object.freeze({ + name: "@eslint/js/all", + rules: Object.freeze({ + "accessor-pairs": "error", + "array-callback-return": "error", + "arrow-body-style": "error", + "block-scoped-var": "error", + "camelcase": "error", + "capitalized-comments": "error", + "class-methods-use-this": "error", + "complexity": "error", + "consistent-return": "error", + "consistent-this": "error", + "constructor-super": "error", + "curly": "error", + "default-case": "error", + "default-case-last": "error", + "default-param-last": "error", + "dot-notation": "error", + "eqeqeq": "error", + "for-direction": "error", + "func-name-matching": "error", + "func-names": "error", + "func-style": "error", + "getter-return": "error", + "grouped-accessor-pairs": "error", + "guard-for-in": "error", + "id-denylist": "error", + "id-length": "error", + "id-match": "error", + "init-declarations": "error", + "logical-assignment-operators": "error", + "max-classes-per-file": "error", + "max-depth": "error", + "max-lines": "error", + "max-lines-per-function": "error", + "max-nested-callbacks": "error", + "max-params": "error", + "max-statements": "error", + "new-cap": "error", + "no-alert": "error", + "no-array-constructor": "error", + "no-async-promise-executor": "error", + "no-await-in-loop": "error", + "no-bitwise": "error", + "no-caller": "error", + "no-case-declarations": "error", + "no-class-assign": "error", + "no-compare-neg-zero": "error", + "no-cond-assign": "error", + "no-console": "error", + "no-const-assign": "error", + "no-constant-binary-expression": "error", + "no-constant-condition": "error", + "no-constructor-return": "error", + "no-continue": "error", + "no-control-regex": "error", + "no-debugger": "error", + "no-delete-var": "error", + "no-div-regex": "error", + "no-dupe-args": "error", + "no-dupe-class-members": "error", + "no-dupe-else-if": "error", + "no-dupe-keys": "error", + "no-duplicate-case": "error", + "no-duplicate-imports": "error", + "no-else-return": "error", + "no-empty": "error", + "no-empty-character-class": "error", + "no-empty-function": "error", + "no-empty-pattern": "error", + "no-empty-static-block": "error", + "no-eq-null": "error", + "no-eval": "error", + "no-ex-assign": "error", + "no-extend-native": "error", + "no-extra-bind": "error", + "no-extra-boolean-cast": "error", + "no-extra-label": "error", + "no-fallthrough": "error", + "no-func-assign": "error", + "no-global-assign": "error", + "no-implicit-coercion": "error", + "no-implicit-globals": "error", + "no-implied-eval": "error", + "no-import-assign": "error", + "no-inline-comments": "error", + "no-inner-declarations": "error", + "no-invalid-regexp": "error", + "no-invalid-this": "error", + "no-irregular-whitespace": "error", + "no-iterator": "error", + "no-label-var": "error", + "no-labels": "error", + "no-lone-blocks": "error", + "no-lonely-if": "error", + "no-loop-func": "error", + "no-loss-of-precision": "error", + "no-magic-numbers": "error", + "no-misleading-character-class": "error", + "no-multi-assign": "error", + "no-multi-str": "error", + "no-negated-condition": "error", + "no-nested-ternary": "error", + "no-new": "error", + "no-new-func": "error", + "no-new-native-nonconstructor": "error", + "no-new-wrappers": "error", + "no-nonoctal-decimal-escape": "error", + "no-obj-calls": "error", + "no-object-constructor": "error", + "no-octal": "error", + "no-octal-escape": "error", + "no-param-reassign": "error", + "no-plusplus": "error", + "no-promise-executor-return": "error", + "no-proto": "error", + "no-prototype-builtins": "error", + "no-redeclare": "error", + "no-regex-spaces": "error", + "no-restricted-exports": "error", + "no-restricted-globals": "error", + "no-restricted-imports": "error", + "no-restricted-properties": "error", + "no-restricted-syntax": "error", + "no-return-assign": "error", + "no-script-url": "error", + "no-self-assign": "error", + "no-self-compare": "error", + "no-sequences": "error", + "no-setter-return": "error", + "no-shadow": "error", + "no-shadow-restricted-names": "error", + "no-sparse-arrays": "error", + "no-template-curly-in-string": "error", + "no-ternary": "error", + "no-this-before-super": "error", + "no-throw-literal": "error", + "no-unassigned-vars": "error", + "no-undef": "error", + "no-undef-init": "error", + "no-undefined": "error", + "no-underscore-dangle": "error", + "no-unexpected-multiline": "error", + "no-unmodified-loop-condition": "error", + "no-unneeded-ternary": "error", + "no-unreachable": "error", + "no-unreachable-loop": "error", + "no-unsafe-finally": "error", + "no-unsafe-negation": "error", + "no-unsafe-optional-chaining": "error", + "no-unused-expressions": "error", + "no-unused-labels": "error", + "no-unused-private-class-members": "error", + "no-unused-vars": "error", + "no-use-before-define": "error", + "no-useless-assignment": "error", + "no-useless-backreference": "error", + "no-useless-call": "error", + "no-useless-catch": "error", + "no-useless-computed-key": "error", + "no-useless-concat": "error", + "no-useless-constructor": "error", + "no-useless-escape": "error", + "no-useless-rename": "error", + "no-useless-return": "error", + "no-var": "error", + "no-void": "error", + "no-warning-comments": "error", + "no-with": "error", + "object-shorthand": "error", + "one-var": "error", + "operator-assignment": "error", + "prefer-arrow-callback": "error", + "prefer-const": "error", + "prefer-destructuring": "error", + "prefer-exponentiation-operator": "error", + "prefer-named-capture-group": "error", + "prefer-numeric-literals": "error", + "prefer-object-has-own": "error", + "prefer-object-spread": "error", + "prefer-promise-reject-errors": "error", + "prefer-regex-literals": "error", + "prefer-rest-params": "error", + "prefer-spread": "error", + "prefer-template": "error", + "preserve-caught-error": "error", + "radix": "error", + "require-atomic-updates": "error", + "require-await": "error", + "require-unicode-regexp": "error", + "require-yield": "error", + "sort-imports": "error", + "sort-keys": "error", + "sort-vars": "error", + "strict": "error", + "symbol-description": "error", + "unicode-bom": "error", + "use-isnan": "error", + "valid-typeof": "error", + "vars-on-top": "error", + "yoda": "error" + }) +}); diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-recommended.js b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-recommended.js new file mode 100644 index 00000000..fb27b4f6 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/configs/eslint-recommended.js @@ -0,0 +1,75 @@ +/* + * WARNING: This file is autogenerated using the tools/update-eslint-recommended.js + * script. Do not edit manually. + */ +"use strict"; + +module.exports = Object.freeze({ + name: "@eslint/js/recommended", + rules: Object.freeze({ + "constructor-super": "error", + "for-direction": "error", + "getter-return": "error", + "no-async-promise-executor": "error", + "no-case-declarations": "error", + "no-class-assign": "error", + "no-compare-neg-zero": "error", + "no-cond-assign": "error", + "no-const-assign": "error", + "no-constant-binary-expression": "error", + "no-constant-condition": "error", + "no-control-regex": "error", + "no-debugger": "error", + "no-delete-var": "error", + "no-dupe-args": "error", + "no-dupe-class-members": "error", + "no-dupe-else-if": "error", + "no-dupe-keys": "error", + "no-duplicate-case": "error", + "no-empty": "error", + "no-empty-character-class": "error", + "no-empty-pattern": "error", + "no-empty-static-block": "error", + "no-ex-assign": "error", + "no-extra-boolean-cast": "error", + "no-fallthrough": "error", + "no-func-assign": "error", + "no-global-assign": "error", + "no-import-assign": "error", + "no-invalid-regexp": "error", + "no-irregular-whitespace": "error", + "no-loss-of-precision": "error", + "no-misleading-character-class": "error", + "no-new-native-nonconstructor": "error", + "no-nonoctal-decimal-escape": "error", + "no-obj-calls": "error", + "no-octal": "error", + "no-prototype-builtins": "error", + "no-redeclare": "error", + "no-regex-spaces": "error", + "no-self-assign": "error", + "no-setter-return": "error", + "no-shadow-restricted-names": "error", + "no-sparse-arrays": "error", + "no-this-before-super": "error", + "no-unassigned-vars": "error", + "no-undef": "error", + "no-unexpected-multiline": "error", + "no-unreachable": "error", + "no-unsafe-finally": "error", + "no-unsafe-negation": "error", + "no-unsafe-optional-chaining": "error", + "no-unused-labels": "error", + "no-unused-private-class-members": "error", + "no-unused-vars": "error", + "no-useless-assignment": "error", + "no-useless-backreference": "error", + "no-useless-catch": "error", + "no-useless-escape": "error", + "no-with": "error", + "preserve-caught-error": "error", + "require-yield": "error", + "use-isnan": "error", + "valid-typeof": "error" + }), +}); diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/index.js b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/index.js new file mode 100644 index 00000000..ff6a21d8 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/src/index.js @@ -0,0 +1,23 @@ +/** + * @fileoverview Main package entrypoint. + * @author Nicholas C. Zakas + */ + +"use strict"; + +const { name, version } = require("../package.json"); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + meta: { + name, + version, + }, + configs: { + all: require("./configs/eslint-all"), + recommended: require("./configs/eslint-recommended"), + }, +}; diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/types/index.d.ts b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/types/index.d.ts new file mode 100644 index 00000000..d4921d8b --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint/js/types/index.d.ts @@ -0,0 +1,14 @@ +import type { Linter } from "eslint"; + +declare const js: { + readonly meta: { + readonly name: string; + readonly version: string; + }; + readonly configs: { + readonly recommended: { readonly rules: Readonly }; + readonly all: { readonly rules: Readonly }; + }; +}; + +export = js; diff --git a/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint+js@10.0.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/LICENSE b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/LICENSE new file mode 100644 index 00000000..883ee1f6 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Toru Nagashima + +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/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/README.md b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/README.md new file mode 100644 index 00000000..257954c9 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/README.md @@ -0,0 +1,37 @@ +# @eslint-community/eslint-utils + +[![npm version](https://img.shields.io/npm/v/@eslint-community/eslint-utils.svg)](https://www.npmjs.com/package/@eslint-community/eslint-utils) +[![Downloads/month](https://img.shields.io/npm/dm/@eslint-community/eslint-utils.svg)](http://www.npmtrends.com/@eslint-community/eslint-utils) +[![Build Status](https://github.com/eslint-community/eslint-utils/workflows/CI/badge.svg)](https://github.com/eslint-community/eslint-utils/actions) +[![Coverage Status](https://codecov.io/gh/eslint-community/eslint-utils/branch/main/graph/badge.svg)](https://codecov.io/gh/eslint-community/eslint-utils) + +## 🏁 Goal + +This package provides utility functions and classes for make ESLint custom rules. + +For examples: + +- [`getStaticValue`](https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue) evaluates static value on AST. +- [`ReferenceTracker`](https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class) checks the members of modules/globals as handling assignments and destructuring. + +## 📖 Usage + +See [documentation](https://eslint-community.github.io/eslint-utils). + +## 📰 Changelog + +See [releases](https://github.com/eslint-community/eslint-utils/releases). + +## ❤️ Contributing + +Welcome contributing! + +Please use GitHub's Issues/PRs. + +### Development Tools + +- `npm run test-coverage` runs tests and measures coverage. +- `npm run clean` removes the coverage result of `npm run test-coverage` command. +- `npm run coverage` shows the coverage result of the last `npm run test-coverage` command. +- `npm run lint` runs ESLint. +- `npm run watch` runs tests on each file change. diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.mts b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.mts new file mode 100644 index 00000000..8ad6f5c9 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.mts @@ -0,0 +1,217 @@ +import * as eslint from 'eslint'; +import { Rule, AST } from 'eslint'; +import * as estree from 'estree'; + +declare const READ: unique symbol; +declare const CALL: unique symbol; +declare const CONSTRUCT: unique symbol; +declare const ESM: unique symbol; +declare class ReferenceTracker { + constructor(globalScope: Scope$2, options?: { + mode?: "legacy" | "strict" | undefined; + globalObjectNames?: string[] | undefined; + } | undefined); + private variableStack; + private globalScope; + private mode; + private globalObjectNames; + iterateGlobalReferences(traceMap: TraceMap$2): IterableIterator>; + iterateCjsReferences(traceMap: TraceMap$2): IterableIterator>; + iterateEsmReferences(traceMap: TraceMap$2): IterableIterator>; + iteratePropertyReferences(node: Expression, traceMap: TraceMap$2): IterableIterator>; + private _iterateVariableReferences; + private _iteratePropertyReferences; + private _iterateLhsReferences; + private _iterateImportReferences; +} +declare namespace ReferenceTracker { + export { READ }; + export { CALL }; + export { CONSTRUCT }; + export { ESM }; +} +type Scope$2 = eslint.Scope.Scope; +type Expression = estree.Expression; +type TraceMap$2 = TraceMap$1; +type TrackedReferences$2 = TrackedReferences$1; + +type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1; +type StaticValueProvided$1 = { + optional?: undefined; + value: unknown; +}; +type StaticValueOptional$1 = { + optional?: true; + value: undefined; +}; +type ReferenceTrackerOptions$1 = { + globalObjectNames?: string[]; + mode?: "legacy" | "strict"; +}; +type TraceMap$1 = { + [i: string]: TraceMapObject; +}; +type TraceMapObject = { + [i: string]: TraceMapObject; + [CALL]?: T; + [CONSTRUCT]?: T; + [READ]?: T; + [ESM]?: boolean; +}; +type TrackedReferences$1 = { + info: T; + node: Rule.Node; + path: string[]; + type: typeof CALL | typeof CONSTRUCT | typeof READ; +}; +type HasSideEffectOptions$1 = { + considerGetters?: boolean; + considerImplicitTypeConversion?: boolean; +}; +type PunctuatorToken = AST.Token & { + type: "Punctuator"; + value: Value; +}; +type ArrowToken$1 = PunctuatorToken<"=>">; +type CommaToken$1 = PunctuatorToken<",">; +type SemicolonToken$1 = PunctuatorToken<";">; +type ColonToken$1 = PunctuatorToken<":">; +type OpeningParenToken$1 = PunctuatorToken<"(">; +type ClosingParenToken$1 = PunctuatorToken<")">; +type OpeningBracketToken$1 = PunctuatorToken<"[">; +type ClosingBracketToken$1 = PunctuatorToken<"]">; +type OpeningBraceToken$1 = PunctuatorToken<"{">; +type ClosingBraceToken$1 = PunctuatorToken<"}">; + +declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null; +type Scope$1 = eslint.Scope.Scope; +type Variable = eslint.Scope.Variable; +type Identifier = estree.Identifier; + +declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null; +type SourceCode$2 = eslint.SourceCode; +type FunctionNode$1 = estree.Function; +type SourceLocation = estree.SourceLocation; + +declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string; +type FunctionNode = estree.Function; + +declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope; +type Scope = eslint.Scope.Scope; +type Node$4 = estree.Node; + +declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined; +type MemberExpression = estree.MemberExpression; +type MethodDefinition = estree.MethodDefinition; +type Property = estree.Property; +type PropertyDefinition = estree.PropertyDefinition; + +declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null; +type StaticValue$1 = StaticValue$2; +type Node$3 = estree.Node; + +declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null; +type Node$2 = estree.Node; + +declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean; +type Node$1 = estree.Node; +type SourceCode$1 = eslint.SourceCode; + +declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1; +declare function isCommaToken(token: CommentOrToken): token is CommaToken$1; +declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1; +declare function isColonToken(token: CommentOrToken): token is ColonToken$1; +declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1; +declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1; +declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1; +declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1; +declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1; +declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1; +declare function isCommentToken(token: CommentOrToken): token is estree.Comment; +declare function isNotArrowToken(arg0: CommentOrToken): boolean; +declare function isNotCommaToken(arg0: CommentOrToken): boolean; +declare function isNotSemicolonToken(arg0: CommentOrToken): boolean; +declare function isNotColonToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean; +declare function isNotClosingParenToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean; +declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean; +declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean; +declare function isNotCommentToken(arg0: CommentOrToken): boolean; +type Token = eslint.AST.Token; +type Comment = estree.Comment; +type CommentOrToken = Comment | Token; + +declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean; +type Node = estree.Node; +type SourceCode = eslint.SourceCode; + +declare class PatternMatcher { + constructor(pattern: RegExp, options?: { + escaped?: boolean | undefined; + } | undefined); + execAll(str: string): IterableIterator; + test(str: string): boolean; + [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string; +} + +declare namespace _default { + export { CALL }; + export { CONSTRUCT }; + export { ESM }; + export { findVariable }; + export { getFunctionHeadLocation }; + export { getFunctionNameWithKind }; + export { getInnermostScope }; + export { getPropertyName }; + export { getStaticValue }; + export { getStringIfConstant }; + export { hasSideEffect }; + export { isArrowToken }; + export { isClosingBraceToken }; + export { isClosingBracketToken }; + export { isClosingParenToken }; + export { isColonToken }; + export { isCommaToken }; + export { isCommentToken }; + export { isNotArrowToken }; + export { isNotClosingBraceToken }; + export { isNotClosingBracketToken }; + export { isNotClosingParenToken }; + export { isNotColonToken }; + export { isNotCommaToken }; + export { isNotCommentToken }; + export { isNotOpeningBraceToken }; + export { isNotOpeningBracketToken }; + export { isNotOpeningParenToken }; + export { isNotSemicolonToken }; + export { isOpeningBraceToken }; + export { isOpeningBracketToken }; + export { isOpeningParenToken }; + export { isParenthesized }; + export { isSemicolonToken }; + export { PatternMatcher }; + export { READ }; + export { ReferenceTracker }; +} + +type StaticValue = StaticValue$2; +type StaticValueOptional = StaticValueOptional$1; +type StaticValueProvided = StaticValueProvided$1; +type ReferenceTrackerOptions = ReferenceTrackerOptions$1; +type TraceMap = TraceMap$1; +type TrackedReferences = TrackedReferences$1; +type HasSideEffectOptions = HasSideEffectOptions$1; +type ArrowToken = ArrowToken$1; +type CommaToken = CommaToken$1; +type SemicolonToken = SemicolonToken$1; +type ColonToken = ColonToken$1; +type OpeningParenToken = OpeningParenToken$1; +type ClosingParenToken = ClosingParenToken$1; +type OpeningBracketToken = OpeningBracketToken$1; +type ClosingBracketToken = ClosingBracketToken$1; +type OpeningBraceToken = OpeningBraceToken$1; +type ClosingBraceToken = ClosingBraceToken$1; + +export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken }; diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.ts b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.ts new file mode 100644 index 00000000..8ad6f5c9 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.d.ts @@ -0,0 +1,217 @@ +import * as eslint from 'eslint'; +import { Rule, AST } from 'eslint'; +import * as estree from 'estree'; + +declare const READ: unique symbol; +declare const CALL: unique symbol; +declare const CONSTRUCT: unique symbol; +declare const ESM: unique symbol; +declare class ReferenceTracker { + constructor(globalScope: Scope$2, options?: { + mode?: "legacy" | "strict" | undefined; + globalObjectNames?: string[] | undefined; + } | undefined); + private variableStack; + private globalScope; + private mode; + private globalObjectNames; + iterateGlobalReferences(traceMap: TraceMap$2): IterableIterator>; + iterateCjsReferences(traceMap: TraceMap$2): IterableIterator>; + iterateEsmReferences(traceMap: TraceMap$2): IterableIterator>; + iteratePropertyReferences(node: Expression, traceMap: TraceMap$2): IterableIterator>; + private _iterateVariableReferences; + private _iteratePropertyReferences; + private _iterateLhsReferences; + private _iterateImportReferences; +} +declare namespace ReferenceTracker { + export { READ }; + export { CALL }; + export { CONSTRUCT }; + export { ESM }; +} +type Scope$2 = eslint.Scope.Scope; +type Expression = estree.Expression; +type TraceMap$2 = TraceMap$1; +type TrackedReferences$2 = TrackedReferences$1; + +type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1; +type StaticValueProvided$1 = { + optional?: undefined; + value: unknown; +}; +type StaticValueOptional$1 = { + optional?: true; + value: undefined; +}; +type ReferenceTrackerOptions$1 = { + globalObjectNames?: string[]; + mode?: "legacy" | "strict"; +}; +type TraceMap$1 = { + [i: string]: TraceMapObject; +}; +type TraceMapObject = { + [i: string]: TraceMapObject; + [CALL]?: T; + [CONSTRUCT]?: T; + [READ]?: T; + [ESM]?: boolean; +}; +type TrackedReferences$1 = { + info: T; + node: Rule.Node; + path: string[]; + type: typeof CALL | typeof CONSTRUCT | typeof READ; +}; +type HasSideEffectOptions$1 = { + considerGetters?: boolean; + considerImplicitTypeConversion?: boolean; +}; +type PunctuatorToken = AST.Token & { + type: "Punctuator"; + value: Value; +}; +type ArrowToken$1 = PunctuatorToken<"=>">; +type CommaToken$1 = PunctuatorToken<",">; +type SemicolonToken$1 = PunctuatorToken<";">; +type ColonToken$1 = PunctuatorToken<":">; +type OpeningParenToken$1 = PunctuatorToken<"(">; +type ClosingParenToken$1 = PunctuatorToken<")">; +type OpeningBracketToken$1 = PunctuatorToken<"[">; +type ClosingBracketToken$1 = PunctuatorToken<"]">; +type OpeningBraceToken$1 = PunctuatorToken<"{">; +type ClosingBraceToken$1 = PunctuatorToken<"}">; + +declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null; +type Scope$1 = eslint.Scope.Scope; +type Variable = eslint.Scope.Variable; +type Identifier = estree.Identifier; + +declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null; +type SourceCode$2 = eslint.SourceCode; +type FunctionNode$1 = estree.Function; +type SourceLocation = estree.SourceLocation; + +declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string; +type FunctionNode = estree.Function; + +declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope; +type Scope = eslint.Scope.Scope; +type Node$4 = estree.Node; + +declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined; +type MemberExpression = estree.MemberExpression; +type MethodDefinition = estree.MethodDefinition; +type Property = estree.Property; +type PropertyDefinition = estree.PropertyDefinition; + +declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null; +type StaticValue$1 = StaticValue$2; +type Node$3 = estree.Node; + +declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null; +type Node$2 = estree.Node; + +declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean; +type Node$1 = estree.Node; +type SourceCode$1 = eslint.SourceCode; + +declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1; +declare function isCommaToken(token: CommentOrToken): token is CommaToken$1; +declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1; +declare function isColonToken(token: CommentOrToken): token is ColonToken$1; +declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1; +declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1; +declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1; +declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1; +declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1; +declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1; +declare function isCommentToken(token: CommentOrToken): token is estree.Comment; +declare function isNotArrowToken(arg0: CommentOrToken): boolean; +declare function isNotCommaToken(arg0: CommentOrToken): boolean; +declare function isNotSemicolonToken(arg0: CommentOrToken): boolean; +declare function isNotColonToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean; +declare function isNotClosingParenToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean; +declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean; +declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean; +declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean; +declare function isNotCommentToken(arg0: CommentOrToken): boolean; +type Token = eslint.AST.Token; +type Comment = estree.Comment; +type CommentOrToken = Comment | Token; + +declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean; +type Node = estree.Node; +type SourceCode = eslint.SourceCode; + +declare class PatternMatcher { + constructor(pattern: RegExp, options?: { + escaped?: boolean | undefined; + } | undefined); + execAll(str: string): IterableIterator; + test(str: string): boolean; + [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string; +} + +declare namespace _default { + export { CALL }; + export { CONSTRUCT }; + export { ESM }; + export { findVariable }; + export { getFunctionHeadLocation }; + export { getFunctionNameWithKind }; + export { getInnermostScope }; + export { getPropertyName }; + export { getStaticValue }; + export { getStringIfConstant }; + export { hasSideEffect }; + export { isArrowToken }; + export { isClosingBraceToken }; + export { isClosingBracketToken }; + export { isClosingParenToken }; + export { isColonToken }; + export { isCommaToken }; + export { isCommentToken }; + export { isNotArrowToken }; + export { isNotClosingBraceToken }; + export { isNotClosingBracketToken }; + export { isNotClosingParenToken }; + export { isNotColonToken }; + export { isNotCommaToken }; + export { isNotCommentToken }; + export { isNotOpeningBraceToken }; + export { isNotOpeningBracketToken }; + export { isNotOpeningParenToken }; + export { isNotSemicolonToken }; + export { isOpeningBraceToken }; + export { isOpeningBracketToken }; + export { isOpeningParenToken }; + export { isParenthesized }; + export { isSemicolonToken }; + export { PatternMatcher }; + export { READ }; + export { ReferenceTracker }; +} + +type StaticValue = StaticValue$2; +type StaticValueOptional = StaticValueOptional$1; +type StaticValueProvided = StaticValueProvided$1; +type ReferenceTrackerOptions = ReferenceTrackerOptions$1; +type TraceMap = TraceMap$1; +type TrackedReferences = TrackedReferences$1; +type HasSideEffectOptions = HasSideEffectOptions$1; +type ArrowToken = ArrowToken$1; +type CommaToken = CommaToken$1; +type SemicolonToken = SemicolonToken$1; +type ColonToken = ColonToken$1; +type OpeningParenToken = OpeningParenToken$1; +type ClosingParenToken = ClosingParenToken$1; +type OpeningBracketToken = OpeningBracketToken$1; +type ClosingBracketToken = ClosingBracketToken$1; +type OpeningBraceToken = OpeningBraceToken$1; +type ClosingBraceToken = ClosingBraceToken$1; + +export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken }; diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js new file mode 100644 index 00000000..8c11601e --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js @@ -0,0 +1,2620 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var eslintVisitorKeys = require('eslint-visitor-keys'); + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").Node} Node */ + +/** + * Get the innermost scope which contains a given location. + * @param {Scope} initialScope The initial scope to search. + * @param {Node} node The location to search. + * @returns {Scope} The innermost scope. + */ +function getInnermostScope(initialScope, node) { + const location = /** @type {[number, number]} */ (node.range)[0]; + + let scope = initialScope; + let found = false; + do { + found = false; + for (const childScope of scope.childScopes) { + const range = /** @type {[number, number]} */ ( + childScope.block.range + ); + + if (range[0] <= location && location < range[1]) { + scope = childScope; + found = true; + break + } + } + } while (found) + + return scope +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Find the variable of a given name. + * @param {Scope} initialScope The scope to start finding. + * @param {string|Identifier} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node. + * @returns {Variable|null} The found variable or null. + */ +function findVariable(initialScope, nameOrNode) { + let name = ""; + /** @type {Scope|null} */ + let scope = initialScope; + + if (typeof nameOrNode === "string") { + name = nameOrNode; + } else { + name = nameOrNode.name; + scope = getInnermostScope(scope, nameOrNode); + } + + while (scope != null) { + const variable = scope.set.get(name); + if (variable != null) { + return variable + } + scope = scope.upper; + } + + return null +} + +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("estree").Comment} Comment */ +/** @typedef {import("./types.mjs").ArrowToken} ArrowToken */ +/** @typedef {import("./types.mjs").CommaToken} CommaToken */ +/** @typedef {import("./types.mjs").SemicolonToken} SemicolonToken */ +/** @typedef {import("./types.mjs").ColonToken} ColonToken */ +/** @typedef {import("./types.mjs").OpeningParenToken} OpeningParenToken */ +/** @typedef {import("./types.mjs").ClosingParenToken} ClosingParenToken */ +/** @typedef {import("./types.mjs").OpeningBracketToken} OpeningBracketToken */ +/** @typedef {import("./types.mjs").ClosingBracketToken} ClosingBracketToken */ +/** @typedef {import("./types.mjs").OpeningBraceToken} OpeningBraceToken */ +/** @typedef {import("./types.mjs").ClosingBraceToken} ClosingBraceToken */ +/** + * @template {string} Value + * @typedef {import("./types.mjs").PunctuatorToken} PunctuatorToken + */ + +/** @typedef {Comment | Token} CommentOrToken */ + +/** + * Creates the negate function of the given function. + * @param {function(CommentOrToken):boolean} f - The function to negate. + * @returns {function(CommentOrToken):boolean} Negated function. + */ +function negate(f) { + return (token) => !f(token) +} + +/** + * Checks if the given token is a PunctuatorToken with the given value + * @template {string} Value + * @param {CommentOrToken} token - The token to check. + * @param {Value} value - The value to check. + * @returns {token is PunctuatorToken} `true` if the token is a PunctuatorToken with the given value. + */ +function isPunctuatorTokenWithValue(token, value) { + return token.type === "Punctuator" && token.value === value +} + +/** + * Checks if the given token is an arrow token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ArrowToken} `true` if the token is an arrow token. + */ +function isArrowToken(token) { + return isPunctuatorTokenWithValue(token, "=>") +} + +/** + * Checks if the given token is a comma token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is CommaToken} `true` if the token is a comma token. + */ +function isCommaToken(token) { + return isPunctuatorTokenWithValue(token, ",") +} + +/** + * Checks if the given token is a semicolon token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is SemicolonToken} `true` if the token is a semicolon token. + */ +function isSemicolonToken(token) { + return isPunctuatorTokenWithValue(token, ";") +} + +/** + * Checks if the given token is a colon token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ColonToken} `true` if the token is a colon token. + */ +function isColonToken(token) { + return isPunctuatorTokenWithValue(token, ":") +} + +/** + * Checks if the given token is an opening parenthesis token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token. + */ +function isOpeningParenToken(token) { + return isPunctuatorTokenWithValue(token, "(") +} + +/** + * Checks if the given token is a closing parenthesis token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token. + */ +function isClosingParenToken(token) { + return isPunctuatorTokenWithValue(token, ")") +} + +/** + * Checks if the given token is an opening square bracket token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token. + */ +function isOpeningBracketToken(token) { + return isPunctuatorTokenWithValue(token, "[") +} + +/** + * Checks if the given token is a closing square bracket token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token. + */ +function isClosingBracketToken(token) { + return isPunctuatorTokenWithValue(token, "]") +} + +/** + * Checks if the given token is an opening brace token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token. + */ +function isOpeningBraceToken(token) { + return isPunctuatorTokenWithValue(token, "{") +} + +/** + * Checks if the given token is a closing brace token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token. + */ +function isClosingBraceToken(token) { + return isPunctuatorTokenWithValue(token, "}") +} + +/** + * Checks if the given token is a comment token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is Comment} `true` if the token is a comment token. + */ +function isCommentToken(token) { + return ["Block", "Line", "Shebang"].includes(token.type) +} + +const isNotArrowToken = negate(isArrowToken); +const isNotCommaToken = negate(isCommaToken); +const isNotSemicolonToken = negate(isSemicolonToken); +const isNotColonToken = negate(isColonToken); +const isNotOpeningParenToken = negate(isOpeningParenToken); +const isNotClosingParenToken = negate(isClosingParenToken); +const isNotOpeningBracketToken = negate(isOpeningBracketToken); +const isNotClosingBracketToken = negate(isClosingBracketToken); +const isNotOpeningBraceToken = negate(isOpeningBraceToken); +const isNotClosingBraceToken = negate(isClosingBraceToken); +const isNotCommentToken = negate(isCommentToken); + +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("estree").Function} FunctionNode */ +/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */ +/** @typedef {import("estree").FunctionExpression} FunctionExpression */ +/** @typedef {import("estree").SourceLocation} SourceLocation */ +/** @typedef {import("estree").Position} Position */ + +/** + * Get the `(` token of the given function node. + * @param {FunctionExpression | FunctionDeclaration} node - The function node to get. + * @param {SourceCode} sourceCode - The source code object to get tokens. + * @returns {Token} `(` token. + */ +function getOpeningParenOfParams(node, sourceCode) { + return node.id + ? /** @type {Token} */ ( + sourceCode.getTokenAfter(node.id, isOpeningParenToken) + ) + : /** @type {Token} */ ( + sourceCode.getFirstToken(node, isOpeningParenToken) + ) +} + +/** + * Get the location of the given function node for reporting. + * @param {FunctionNode} node - The function node to get. + * @param {SourceCode} sourceCode - The source code object to get tokens. + * @returns {SourceLocation|null} The location of the function node for reporting. + */ +function getFunctionHeadLocation(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + /** @type {Position|null} */ + let start = null; + /** @type {Position|null} */ + let end = null; + + if (node.type === "ArrowFunctionExpression") { + const arrowToken = /** @type {Token} */ ( + sourceCode.getTokenBefore(node.body, isArrowToken) + ); + + start = arrowToken.loc.start; + end = arrowToken.loc.end; + } else if ( + parent && + (parent.type === "Property" || + parent.type === "MethodDefinition" || + parent.type === "PropertyDefinition") + ) { + start = /** @type {SourceLocation} */ (parent.loc).start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } else { + start = /** @type {SourceLocation} */ (node.loc).start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + + return { + start: { ...start }, + end: { ...end }, + } +} + +/* globals self, window */ +/** @typedef {import("./types.mjs").StaticValue} StaticValue */ +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */ +/** @typedef {import("@typescript-eslint/types").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */ +/** @typedef {import("@typescript-eslint/types").TSESTree.MemberExpression} MemberExpression */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Property} Property */ +/** @typedef {import("@typescript-eslint/types").TSESTree.RegExpLiteral} RegExpLiteral */ +/** @typedef {import("@typescript-eslint/types").TSESTree.BigIntLiteral} BigIntLiteral */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Literal} Literal */ + +const globalObject = + typeof globalThis !== "undefined" + ? globalThis + : // @ts-ignore + typeof self !== "undefined" + ? // @ts-ignore + self + : // @ts-ignore + typeof window !== "undefined" + ? // @ts-ignore + window + : typeof global !== "undefined" + ? global + : {}; + +const builtinNames = Object.freeze( + new Set([ + "Array", + "ArrayBuffer", + "BigInt", + "BigInt64Array", + "BigUint64Array", + "Boolean", + "DataView", + "Date", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "Float32Array", + "Float64Array", + "Function", + "Infinity", + "Int16Array", + "Int32Array", + "Int8Array", + "isFinite", + "isNaN", + "isPrototypeOf", + "JSON", + "Map", + "Math", + "NaN", + "Number", + "Object", + "parseFloat", + "parseInt", + "Promise", + "Proxy", + "Reflect", + "RegExp", + "Set", + "String", + "Symbol", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray", + "undefined", + "unescape", + "WeakMap", + "WeakSet", + ]), +); +const callAllowed = new Set( + [ + Array.isArray, + Array.of, + Array.prototype.at, + Array.prototype.concat, + Array.prototype.entries, + Array.prototype.every, + Array.prototype.filter, + Array.prototype.find, + Array.prototype.findIndex, + Array.prototype.flat, + Array.prototype.includes, + Array.prototype.indexOf, + Array.prototype.join, + Array.prototype.keys, + Array.prototype.lastIndexOf, + Array.prototype.slice, + Array.prototype.some, + Array.prototype.toString, + Array.prototype.values, + typeof BigInt === "function" ? BigInt : undefined, + Boolean, + Date, + Date.parse, + decodeURI, + decodeURIComponent, + encodeURI, + encodeURIComponent, + escape, + isFinite, + isNaN, + // @ts-ignore + isPrototypeOf, + Map, + Map.prototype.entries, + Map.prototype.get, + Map.prototype.has, + Map.prototype.keys, + Map.prototype.values, + .../** @type {(keyof typeof Math)[]} */ ( + Object.getOwnPropertyNames(Math) + ) + .filter((k) => k !== "random") + .map((k) => Math[k]) + .filter((f) => typeof f === "function"), + Number, + Number.isFinite, + Number.isNaN, + Number.parseFloat, + Number.parseInt, + Number.prototype.toExponential, + Number.prototype.toFixed, + Number.prototype.toPrecision, + Number.prototype.toString, + Object, + Object.entries, + Object.is, + Object.isExtensible, + Object.isFrozen, + Object.isSealed, + Object.keys, + Object.values, + parseFloat, + parseInt, + RegExp, + Set, + Set.prototype.entries, + Set.prototype.has, + Set.prototype.keys, + Set.prototype.values, + String, + String.fromCharCode, + String.fromCodePoint, + String.raw, + String.prototype.at, + String.prototype.charAt, + String.prototype.charCodeAt, + String.prototype.codePointAt, + String.prototype.concat, + String.prototype.endsWith, + String.prototype.includes, + String.prototype.indexOf, + String.prototype.lastIndexOf, + String.prototype.normalize, + String.prototype.padEnd, + String.prototype.padStart, + String.prototype.slice, + String.prototype.startsWith, + String.prototype.substr, + String.prototype.substring, + String.prototype.toLowerCase, + String.prototype.toString, + String.prototype.toUpperCase, + String.prototype.trim, + String.prototype.trimEnd, + String.prototype.trimLeft, + String.prototype.trimRight, + String.prototype.trimStart, + Symbol.for, + Symbol.keyFor, + unescape, + ].filter((f) => typeof f === "function"), +); +const callPassThrough = new Set([ + Object.freeze, + Object.preventExtensions, + Object.seal, +]); + +/** @type {ReadonlyArray]>} */ +const getterAllowed = [ + [Map, new Set(["size"])], + [ + RegExp, + new Set([ + "dotAll", + "flags", + "global", + "hasIndices", + "ignoreCase", + "multiline", + "source", + "sticky", + "unicode", + ]), + ], + [Set, new Set(["size"])], +]; + +/** + * Get the property descriptor. + * @param {object} object The object to get. + * @param {string|number|symbol} name The property name to get. + */ +function getPropertyDescriptor(object, name) { + let x = object; + while ((typeof x === "object" || typeof x === "function") && x !== null) { + const d = Object.getOwnPropertyDescriptor(x, name); + if (d) { + return d + } + x = Object.getPrototypeOf(x); + } + return null +} + +/** + * Check if a property is getter or not. + * @param {object} object The object to check. + * @param {string|number|symbol} name The property name to check. + */ +function isGetter(object, name) { + const d = getPropertyDescriptor(object, name); + return d != null && d.get != null +} + +/** + * Get the element values of a given node list. + * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values. + * @param {Scope|undefined|null} initialScope The initial scope to find variables. + * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null. + */ +function getElementValues(nodeList, initialScope) { + const valueList = []; + + for (let i = 0; i < nodeList.length; ++i) { + const elementNode = nodeList[i]; + + if (elementNode == null) { + valueList.length = i + 1; + } else if (elementNode.type === "SpreadElement") { + const argument = getStaticValueR(elementNode.argument, initialScope); + if (argument == null) { + return null + } + valueList.push(.../** @type {Iterable} */ (argument.value)); + } else { + const element = getStaticValueR(elementNode, initialScope); + if (element == null) { + return null + } + valueList.push(element.value); + } + } + + return valueList +} + +/** + * Checks if a variable is a built-in global. + * @param {Variable|null} variable The variable to check. + * @returns {variable is Variable & {defs:[]}} + */ +function isBuiltinGlobal(variable) { + return ( + variable != null && + variable.defs.length === 0 && + builtinNames.has(variable.name) && + variable.name in globalObject + ) +} + +/** + * Checks if a variable can be considered as a constant. + * @param {Variable} variable + * @returns {variable is Variable & {defs: [import("eslint").Scope.Definition & { type: "Variable" }]}} True if the variable can be considered as a constant. + */ +function canBeConsideredConst(variable) { + if (variable.defs.length !== 1) { + return false + } + const def = variable.defs[0]; + return Boolean( + def.parent && + def.type === "Variable" && + (def.parent.kind === "const" || isEffectivelyConst(variable)), + ) +} + +/** + * Returns whether the given variable is never written to after initialization. + * @param {Variable} variable + * @returns {boolean} + */ +function isEffectivelyConst(variable) { + const refs = variable.references; + + const inits = refs.filter((r) => r.init).length; + const reads = refs.filter((r) => r.isReadOnly()).length; + if (inits === 1 && reads + inits === refs.length) { + // there is only one init and all other references only read + return true + } + return false +} + +/** + * Checks if a variable has mutation in its property. + * @param {Variable} variable The variable to check. + * @param {Scope|null} initialScope The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {boolean} True if the variable has mutation in its property. + */ +function hasMutationInProperty(variable, initialScope) { + for (const ref of variable.references) { + let node = /** @type {TSESTreeNode} */ (ref.identifier); + while (node && node.parent && node.parent.type === "MemberExpression") { + node = node.parent; + } + if (!node || !node.parent) { + continue + } + if ( + (node.parent.type === "AssignmentExpression" && + node.parent.left === node) || + (node.parent.type === "UpdateExpression" && + node.parent.argument === node) + ) { + // This is a mutation. + return true + } + if ( + node.parent.type === "CallExpression" && + node.parent.callee === node && + node.type === "MemberExpression" + ) { + const methodName = getStaticPropertyNameValue(node, initialScope); + if (isNameOfMutationArrayMethod(methodName)) { + // This is a mutation. + return true + } + } + } + return false + + /** + * Checks if a method name is one of the mutation array methods. + * @param {StaticValue|null} methodName The method name to check. + * @returns {boolean} True if the method name is a mutation array method. + */ + function isNameOfMutationArrayMethod(methodName) { + if (methodName == null || methodName.value == null) { + return false + } + const name = methodName.value; + return ( + name === "copyWithin" || + name === "fill" || + name === "pop" || + name === "push" || + name === "reverse" || + name === "shift" || + name === "sort" || + name === "splice" || + name === "unshift" + ) + } +} + +/** + * @template {TSESTreeNodeTypes} T + * @callback VisitorCallback + * @param {TSESTreeNode & { type: T }} node + * @param {Scope|undefined|null} initialScope + * @returns {StaticValue | null} + */ +/** + * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback } } Operations + */ +/** + * @type {Operations} + */ +const operations = Object.freeze({ + ArrayExpression(node, initialScope) { + const elements = getElementValues(node.elements, initialScope); + return elements != null ? { value: elements } : null + }, + + AssignmentExpression(node, initialScope) { + if (node.operator === "=") { + return getStaticValueR(node.right, initialScope) + } + return null + }, + + //eslint-disable-next-line complexity + BinaryExpression(node, initialScope) { + if (node.operator === "in" || node.operator === "instanceof") { + // Not supported. + return null + } + + const left = getStaticValueR(node.left, initialScope); + const right = getStaticValueR(node.right, initialScope); + if (left != null && right != null) { + switch (node.operator) { + case "==": + return { value: left.value == right.value } //eslint-disable-line eqeqeq + case "!=": + return { value: left.value != right.value } //eslint-disable-line eqeqeq + case "===": + return { value: left.value === right.value } + case "!==": + return { value: left.value !== right.value } + case "<": + return { + value: + /** @type {any} */ (left.value) < + /** @type {any} */ (right.value), + } + case "<=": + return { + value: + /** @type {any} */ (left.value) <= + /** @type {any} */ (right.value), + } + case ">": + return { + value: + /** @type {any} */ (left.value) > + /** @type {any} */ (right.value), + } + case ">=": + return { + value: + /** @type {any} */ (left.value) >= + /** @type {any} */ (right.value), + } + case "<<": + return { + value: + /** @type {any} */ (left.value) << + /** @type {any} */ (right.value), + } + case ">>": + return { + value: + /** @type {any} */ (left.value) >> + /** @type {any} */ (right.value), + } + case ">>>": + return { + value: + /** @type {any} */ (left.value) >>> + /** @type {any} */ (right.value), + } + case "+": + return { + value: + /** @type {any} */ (left.value) + + /** @type {any} */ (right.value), + } + case "-": + return { + value: + /** @type {any} */ (left.value) - + /** @type {any} */ (right.value), + } + case "*": + return { + value: + /** @type {any} */ (left.value) * + /** @type {any} */ (right.value), + } + case "/": + return { + value: + /** @type {any} */ (left.value) / + /** @type {any} */ (right.value), + } + case "%": + return { + value: + /** @type {any} */ (left.value) % + /** @type {any} */ (right.value), + } + case "**": + return { + value: + /** @type {any} */ (left.value) ** + /** @type {any} */ (right.value), + } + case "|": + return { + value: + /** @type {any} */ (left.value) | + /** @type {any} */ (right.value), + } + case "^": + return { + value: + /** @type {any} */ (left.value) ^ + /** @type {any} */ (right.value), + } + case "&": + return { + value: + /** @type {any} */ (left.value) & + /** @type {any} */ (right.value), + } + + // no default + } + } + + return null + }, + + CallExpression(node, initialScope) { + const calleeNode = node.callee; + const args = getElementValues(node.arguments, initialScope); + + if (args != null) { + if (calleeNode.type === "MemberExpression") { + if (calleeNode.property.type === "PrivateIdentifier") { + return null + } + const object = getStaticValueR(calleeNode.object, initialScope); + if (object != null) { + if ( + object.value == null && + (object.optional || node.optional) + ) { + return { value: undefined, optional: true } + } + const property = getStaticPropertyNameValue( + calleeNode, + initialScope, + ); + + if (property != null) { + const receiver = + /** @type {Record any>} */ ( + object.value + ); + const methodName = /** @type {PropertyKey} */ ( + property.value + ); + if (callAllowed.has(receiver[methodName])) { + return { + value: receiver[methodName](...args), + } + } + if (callPassThrough.has(receiver[methodName])) { + return { value: args[0] } + } + } + } + } else { + const callee = getStaticValueR(calleeNode, initialScope); + if (callee != null) { + if (callee.value == null && node.optional) { + return { value: undefined, optional: true } + } + const func = /** @type {(...args: any[]) => any} */ ( + callee.value + ); + if (callAllowed.has(func)) { + return { value: func(...args) } + } + if (callPassThrough.has(func)) { + return { value: args[0] } + } + } + } + } + + return null + }, + + ConditionalExpression(node, initialScope) { + const test = getStaticValueR(node.test, initialScope); + if (test != null) { + return test.value + ? getStaticValueR(node.consequent, initialScope) + : getStaticValueR(node.alternate, initialScope) + } + return null + }, + + ExpressionStatement(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + + Identifier(node, initialScope) { + if (initialScope != null) { + const variable = findVariable(initialScope, node); + + if (variable != null) { + // Built-in globals. + if (isBuiltinGlobal(variable)) { + return { value: globalObject[variable.name] } + } + + // Constants. + if (canBeConsideredConst(variable)) { + const def = variable.defs[0]; + if ( + // TODO(mysticatea): don't support destructuring here. + def.node.id.type === "Identifier" + ) { + const init = getStaticValueR( + def.node.init, + initialScope, + ); + if ( + init && + typeof init.value === "object" && + init.value !== null + ) { + if (hasMutationInProperty(variable, initialScope)) { + // This variable has mutation in its property. + return null + } + } + return init + } + } + } + } + return null + }, + + Literal(node) { + const literal = + /** @type {Partial & Partial & Partial} */ ( + node + ); + //istanbul ignore if : this is implementation-specific behavior. + if ( + (literal.regex != null || literal.bigint != null) && + literal.value == null + ) { + // It was a RegExp/BigInt literal, but Node.js didn't support it. + return null + } + return { value: literal.value } + }, + + LogicalExpression(node, initialScope) { + const left = getStaticValueR(node.left, initialScope); + if (left != null) { + if ( + (node.operator === "||" && Boolean(left.value) === true) || + (node.operator === "&&" && Boolean(left.value) === false) || + (node.operator === "??" && left.value != null) + ) { + return left + } + + const right = getStaticValueR(node.right, initialScope); + if (right != null) { + return right + } + } + + return null + }, + + MemberExpression(node, initialScope) { + if (node.property.type === "PrivateIdentifier") { + return null + } + const object = getStaticValueR(node.object, initialScope); + if (object != null) { + if (object.value == null && (object.optional || node.optional)) { + return { value: undefined, optional: true } + } + const property = getStaticPropertyNameValue(node, initialScope); + + if (property != null) { + if ( + !isGetter( + /** @type {object} */ (object.value), + /** @type {PropertyKey} */ (property.value), + ) + ) { + return { + value: /** @type {Record} */ ( + object.value + )[/** @type {PropertyKey} */ (property.value)], + } + } + + for (const [classFn, allowed] of getterAllowed) { + if ( + object.value instanceof classFn && + allowed.has(/** @type {string} */ (property.value)) + ) { + return { + value: /** @type {Record} */ ( + object.value + )[/** @type {PropertyKey} */ (property.value)], + } + } + } + } + } + return null + }, + + ChainExpression(node, initialScope) { + const expression = getStaticValueR(node.expression, initialScope); + if (expression != null) { + return { value: expression.value } + } + return null + }, + + NewExpression(node, initialScope) { + const callee = getStaticValueR(node.callee, initialScope); + const args = getElementValues(node.arguments, initialScope); + + if (callee != null && args != null) { + const Func = /** @type {new (...args: any[]) => any} */ ( + callee.value + ); + if (callAllowed.has(Func)) { + return { value: new Func(...args) } + } + } + + return null + }, + + ObjectExpression(node, initialScope) { + /** @type {Record} */ + const object = {}; + + for (const propertyNode of node.properties) { + if (propertyNode.type === "Property") { + if (propertyNode.kind !== "init") { + return null + } + const key = getStaticPropertyNameValue( + propertyNode, + initialScope, + ); + const value = getStaticValueR(propertyNode.value, initialScope); + if (key == null || value == null) { + return null + } + object[/** @type {PropertyKey} */ (key.value)] = value.value; + } else if ( + propertyNode.type === "SpreadElement" || + // @ts-expect-error -- Backward compatibility + propertyNode.type === "ExperimentalSpreadProperty" + ) { + const argument = getStaticValueR( + propertyNode.argument, + initialScope, + ); + if (argument == null) { + return null + } + Object.assign(object, argument.value); + } else { + return null + } + } + + return { value: object } + }, + + SequenceExpression(node, initialScope) { + const last = node.expressions[node.expressions.length - 1]; + return getStaticValueR(last, initialScope) + }, + + TaggedTemplateExpression(node, initialScope) { + const tag = getStaticValueR(node.tag, initialScope); + const expressions = getElementValues( + node.quasi.expressions, + initialScope, + ); + + if (tag != null && expressions != null) { + const func = /** @type {(...args: any[]) => any} */ (tag.value); + /** @type {any[] & { raw?: string[] }} */ + const strings = node.quasi.quasis.map((q) => q.value.cooked); + strings.raw = node.quasi.quasis.map((q) => q.value.raw); + + if (func === String.raw) { + return { value: func(strings, ...expressions) } + } + } + + return null + }, + + TemplateLiteral(node, initialScope) { + const expressions = getElementValues(node.expressions, initialScope); + if (expressions != null) { + let value = node.quasis[0].value.cooked; + for (let i = 0; i < expressions.length; ++i) { + value += expressions[i]; + value += /** @type {string} */ (node.quasis[i + 1].value.cooked); + } + return { value } + } + return null + }, + + UnaryExpression(node, initialScope) { + if (node.operator === "delete") { + // Not supported. + return null + } + if (node.operator === "void") { + return { value: undefined } + } + + const arg = getStaticValueR(node.argument, initialScope); + if (arg != null) { + switch (node.operator) { + case "-": + return { value: -(/** @type {any} */ (arg.value)) } + case "+": + return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion + case "!": + return { value: !arg.value } + case "~": + return { value: ~(/** @type {any} */ (arg.value)) } + case "typeof": + return { value: typeof arg.value } + + // no default + } + } + + return null + }, + TSAsExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSSatisfiesExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSTypeAssertion(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSNonNullExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSInstantiationExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, +}); + +/** + * Get the value of a given node if it's a static value. + * @param {Node|TSESTreeNode|null|undefined} node The node to get. + * @param {Scope|undefined|null} initialScope The scope to start finding variable. + * @returns {StaticValue|null} The static value of the node, or `null`. + */ +function getStaticValueR(node, initialScope) { + if (node != null && Object.hasOwnProperty.call(operations, node.type)) { + return /** @type {VisitorCallback} */ (operations[node.type])( + /** @type {TSESTreeNode} */ (node), + initialScope, + ) + } + return null +} + +/** + * Get the static value of property name from a MemberExpression node or a Property node. + * @param {MemberExpression|Property} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {StaticValue|null} The static value of the property name of the node, or `null`. + */ +function getStaticPropertyNameValue(node, initialScope) { + const nameNode = node.type === "Property" ? node.key : node.property; + + if (node.computed) { + return getStaticValueR(nameNode, initialScope) + } + + if (nameNode.type === "Identifier") { + return { value: nameNode.name } + } + + if (nameNode.type === "Literal") { + if (/** @type {Partial} */ (nameNode).bigint) { + return { value: /** @type {BigIntLiteral} */ (nameNode).bigint } + } + return { value: String(nameNode.value) } + } + + return null +} + +/** + * Get the value of a given node if it's a static value. + * @param {Node} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible. + * @returns {StaticValue | null} The static value of the node, or `null`. + */ +function getStaticValue(node, initialScope = null) { + try { + return getStaticValueR(node, initialScope) + } catch (_error) { + return null + } +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("estree").RegExpLiteral} RegExpLiteral */ +/** @typedef {import("estree").BigIntLiteral} BigIntLiteral */ +/** @typedef {import("estree").SimpleLiteral} SimpleLiteral */ + +/** + * Get the value of a given node if it's a literal or a template literal. + * @param {Node} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant. + * @returns {string|null} The value of the node, or `null`. + */ +function getStringIfConstant(node, initialScope = null) { + // Handle the literals that the platform doesn't support natively. + if (node && node.type === "Literal" && node.value === null) { + const literal = + /** @type {Partial & Partial & Partial} */ ( + node + ); + if (literal.regex) { + return `/${literal.regex.pattern}/${literal.regex.flags}` + } + if (literal.bigint) { + return literal.bigint + } + } + + const evaluated = getStaticValue(node, initialScope); + + if (evaluated) { + // `String(Symbol.prototype)` throws error + try { + return String(evaluated.value) + } catch { + // No op + } + } + + return null +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").MemberExpression} MemberExpression */ +/** @typedef {import("estree").MethodDefinition} MethodDefinition */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Get the property name from a MemberExpression node or a Property node. + * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} node The node to get. + * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {string|null|undefined} The property name of the node. + */ +function getPropertyName(node, initialScope) { + switch (node.type) { + case "MemberExpression": + if (node.computed) { + return getStringIfConstant(node.property, initialScope) + } + if (node.property.type === "PrivateIdentifier") { + return null + } + return /** @type {Partial} */ (node.property).name + + case "Property": + case "MethodDefinition": + case "PropertyDefinition": + if (node.computed) { + return getStringIfConstant(node.key, initialScope) + } + if (node.key.type === "Literal") { + return String(node.key.value) + } + if (node.key.type === "PrivateIdentifier") { + return null + } + return /** @type {Partial} */ (node.key).name + } + + return null +} + +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("estree").Function} FunctionNode */ +/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */ +/** @typedef {import("estree").FunctionExpression} FunctionExpression */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Get the name and kind of the given function node. + * @param {FunctionNode} node - The function node to get. + * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys. + * @returns {string} The name and kind of the function node. + */ +// eslint-disable-next-line complexity +function getFunctionNameWithKind(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + if (!parent) { + return "" + } + + const tokens = []; + const isObjectMethod = parent.type === "Property" && parent.value === node; + const isClassMethod = + parent.type === "MethodDefinition" && parent.value === node; + const isClassFieldMethod = + parent.type === "PropertyDefinition" && parent.value === node; + + // Modifiers. + if (isClassMethod || isClassFieldMethod) { + if (parent.static) { + tokens.push("static"); + } + if (parent.key.type === "PrivateIdentifier") { + tokens.push("private"); + } + } + if (node.async) { + tokens.push("async"); + } + if (node.generator) { + tokens.push("generator"); + } + + // Kinds. + if (isObjectMethod || isClassMethod) { + if (parent.kind === "constructor") { + return "constructor" + } + if (parent.kind === "get") { + tokens.push("getter"); + } else if (parent.kind === "set") { + tokens.push("setter"); + } else { + tokens.push("method"); + } + } else if (isClassFieldMethod) { + tokens.push("method"); + } else { + if (node.type === "ArrowFunctionExpression") { + tokens.push("arrow"); + } + tokens.push("function"); + } + + // Names. + if (isObjectMethod || isClassMethod || isClassFieldMethod) { + if (parent.key.type === "PrivateIdentifier") { + tokens.push(`#${parent.key.name}`); + } else { + const name = getPropertyName(parent); + if (name) { + tokens.push(`'${name}'`); + } else if (sourceCode) { + const keyText = sourceCode.getText(parent.key); + if (!keyText.includes("\n")) { + tokens.push(`[${keyText}]`); + } + } + } + } else if (hasId(node)) { + tokens.push(`'${node.id.name}'`); + } else if ( + parent.type === "VariableDeclarator" && + parent.id && + parent.id.type === "Identifier" + ) { + tokens.push(`'${parent.id.name}'`); + } else if ( + (parent.type === "AssignmentExpression" || + parent.type === "AssignmentPattern") && + parent.left && + parent.left.type === "Identifier" + ) { + tokens.push(`'${parent.left.name}'`); + } else if ( + parent.type === "ExportDefaultDeclaration" && + parent.declaration === node + ) { + tokens.push("'default'"); + } + + return tokens.join(" ") +} + +/** + * @param {FunctionNode} node + * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }} + */ +function hasId(node) { + return Boolean( + /** @type {Partial} */ (node) + .id, + ) +} + +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("./types.mjs").HasSideEffectOptions} HasSideEffectOptions */ +/** @typedef {import("estree").BinaryExpression} BinaryExpression */ +/** @typedef {import("estree").MemberExpression} MemberExpression */ +/** @typedef {import("estree").MethodDefinition} MethodDefinition */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */ +/** @typedef {import("estree").UnaryExpression} UnaryExpression */ + +const typeConversionBinaryOps = Object.freeze( + new Set([ + "==", + "!=", + "<", + "<=", + ">", + ">=", + "<<", + ">>", + ">>>", + "+", + "-", + "*", + "/", + "%", + "|", + "^", + "&", + "in", + ]), +); +const typeConversionUnaryOps = Object.freeze(new Set(["-", "+", "!", "~"])); + +/** + * Check whether the given value is an ASTNode or not. + * @param {any} x The value to check. + * @returns {x is Node} `true` if the value is an ASTNode. + */ +function isNode(x) { + return x !== null && typeof x === "object" && typeof x.type === "string" +} + +const visitor = Object.freeze( + Object.assign(Object.create(null), { + /** + * @param {Node} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + $visit(node, options, visitorKeys) { + const { type } = node; + + if (typeof (/** @type {any} */ (this)[type]) === "function") { + return /** @type {any} */ (this)[type]( + node, + options, + visitorKeys, + ) + } + + return this.$visitChildren(node, options, visitorKeys) + }, + + /** + * @param {Node} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + $visitChildren(node, options, visitorKeys) { + const { type } = node; + + for (const key of /** @type {(keyof Node)[]} */ ( + visitorKeys[type] || eslintVisitorKeys.getKeys(node) + )) { + const value = node[key]; + + if (Array.isArray(value)) { + for (const element of value) { + if ( + isNode(element) && + this.$visit(element, options, visitorKeys) + ) { + return true + } + } + } else if ( + isNode(value) && + this.$visit(value, options, visitorKeys) + ) { + return true + } + } + + return false + }, + + ArrowFunctionExpression() { + return false + }, + AssignmentExpression() { + return true + }, + AwaitExpression() { + return true + }, + /** + * @param {BinaryExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + BinaryExpression(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + typeConversionBinaryOps.has(node.operator) && + (node.left.type !== "Literal" || node.right.type !== "Literal") + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + CallExpression() { + return true + }, + FunctionExpression() { + return false + }, + ImportExpression() { + return true + }, + /** + * @param {MemberExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + MemberExpression(node, options, visitorKeys) { + if (options.considerGetters) { + return true + } + if ( + options.considerImplicitTypeConversion && + node.computed && + node.property.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {MethodDefinition} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + MethodDefinition(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + NewExpression() { + return true + }, + /** + * @param {Property} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + Property(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {PropertyDefinition} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + PropertyDefinition(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {UnaryExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + UnaryExpression(node, options, visitorKeys) { + if (node.operator === "delete") { + return true + } + if ( + options.considerImplicitTypeConversion && + typeConversionUnaryOps.has(node.operator) && + node.argument.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + UpdateExpression() { + return true + }, + YieldExpression() { + return true + }, + }), +); + +/** + * Check whether a given node has any side effect or not. + * @param {Node} node The node to get. + * @param {SourceCode} sourceCode The source code object. + * @param {HasSideEffectOptions} [options] The option object. + * @returns {boolean} `true` if the node has a certain side effect. + */ +function hasSideEffect(node, sourceCode, options = {}) { + const { considerGetters = false, considerImplicitTypeConversion = false } = + options; + return visitor.$visit( + node, + { considerGetters, considerImplicitTypeConversion }, + sourceCode.visitorKeys || eslintVisitorKeys.KEYS, + ) +} + +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("@typescript-eslint/types").TSESTree.NewExpression} TSNewExpression */ +/** @typedef {import("@typescript-eslint/types").TSESTree.CallExpression} TSCallExpression */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("eslint").Rule.Node} RuleNode */ + +/** + * Get the left parenthesis of the parent node syntax if it exists. + * E.g., `if (a) {}` then the `(`. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {Token|null} The left parenthesis of the parent node syntax + */ +// eslint-disable-next-line complexity +function getParentSyntaxParen(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + if (!parent) { + return null + } + + switch (parent.type) { + case "CallExpression": + case "NewExpression": + if (parent.arguments.length === 1 && parent.arguments[0] === node) { + return sourceCode.getTokenAfter( + // @ts-expect-error https://github.com/typescript-eslint/typescript-eslint/pull/5384 + parent.typeArguments || + /** @type {RuleNode} */ ( + /** @type {unknown} */ ( + /** @type {TSNewExpression | TSCallExpression} */ ( + parent + ).typeParameters + ) + ) || + parent.callee, + isOpeningParenToken, + ) + } + return null + + case "DoWhileStatement": + if (parent.test === node) { + return sourceCode.getTokenAfter( + parent.body, + isOpeningParenToken, + ) + } + return null + + case "IfStatement": + case "WhileStatement": + if (parent.test === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "ImportExpression": + if (parent.source === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "SwitchStatement": + if (parent.discriminant === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "WithStatement": + if (parent.object === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + default: + return null + } +} + +/** + * Check whether a given node is parenthesized or not. + * @param {number} times The number of parantheses. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {boolean} `true` if the node is parenthesized the given times. + */ +/** + * Check whether a given node is parenthesized or not. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {boolean} `true` if the node is parenthesized. + */ +/** + * Check whether a given node is parenthesized or not. + * @param {Node|number} timesOrNode The first parameter. + * @param {Node|SourceCode} nodeOrSourceCode The second parameter. + * @param {SourceCode} [optionalSourceCode] The third parameter. + * @returns {boolean} `true` if the node is parenthesized. + */ +function isParenthesized( + timesOrNode, + nodeOrSourceCode, + optionalSourceCode, +) { + /** @type {number} */ + let times, + /** @type {RuleNode} */ + node, + /** @type {SourceCode} */ + sourceCode, + maybeLeftParen, + maybeRightParen; + if (typeof timesOrNode === "number") { + times = timesOrNode | 0; + node = /** @type {RuleNode} */ (nodeOrSourceCode); + sourceCode = /** @type {SourceCode} */ (optionalSourceCode); + if (!(times >= 1)) { + throw new TypeError("'times' should be a positive integer.") + } + } else { + times = 1; + node = /** @type {RuleNode} */ (timesOrNode); + sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode); + } + + if ( + node == null || + // `Program` can't be parenthesized + node.parent == null || + // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}` + (node.parent.type === "CatchClause" && node.parent.param === node) + ) { + return false + } + + maybeLeftParen = maybeRightParen = node; + do { + maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen); + maybeRightParen = sourceCode.getTokenAfter(maybeRightParen); + } while ( + maybeLeftParen != null && + maybeRightParen != null && + isOpeningParenToken(maybeLeftParen) && + isClosingParenToken(maybeRightParen) && + // Avoid false positive such as `if (a) {}` + maybeLeftParen !== getParentSyntaxParen(node, sourceCode) && + --times > 0 + ) + + return times === 0 +} + +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ + +const placeholder = /\$(?:[$&`']|[1-9][0-9]?)/gu; + +/** @type {WeakMap} */ +const internal = new WeakMap(); + +/** + * Check whether a given character is escaped or not. + * @param {string} str The string to check. + * @param {number} index The location of the character to check. + * @returns {boolean} `true` if the character is escaped. + */ +function isEscaped(str, index) { + let escaped = false; + for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) { + escaped = !escaped; + } + return escaped +} + +/** + * Replace a given string by a given matcher. + * @param {PatternMatcher} matcher The pattern matcher. + * @param {string} str The string to be replaced. + * @param {string} replacement The new substring to replace each matched part. + * @returns {string} The replaced string. + */ +function replaceS(matcher, str, replacement) { + const chunks = []; + let index = 0; + + /** + * @param {string} key The placeholder. + * @param {RegExpExecArray} match The matched information. + * @returns {string} The replaced string. + */ + function replacer(key, match) { + switch (key) { + case "$$": + return "$" + case "$&": + return match[0] + case "$`": + return str.slice(0, match.index) + case "$'": + return str.slice(match.index + match[0].length) + default: { + const i = key.slice(1); + if (i in match) { + return match[/** @type {any} */ (i)] + } + return key + } + } + } + + for (const match of matcher.execAll(str)) { + chunks.push(str.slice(index, match.index)); + chunks.push( + replacement.replace(placeholder, (key) => replacer(key, match)), + ); + index = match.index + match[0].length; + } + chunks.push(str.slice(index)); + + return chunks.join("") +} + +/** + * Replace a given string by a given matcher. + * @param {PatternMatcher} matcher The pattern matcher. + * @param {string} str The string to be replaced. + * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part. + * @returns {string} The replaced string. + */ +function replaceF(matcher, str, replace) { + const chunks = []; + let index = 0; + + for (const match of matcher.execAll(str)) { + chunks.push(str.slice(index, match.index)); + chunks.push( + String( + replace( + .../** @type {[string, ...string[]]} */ ( + /** @type {string[]} */ (match) + ), + match.index, + match.input, + ), + ), + ); + index = match.index + match[0].length; + } + chunks.push(str.slice(index)); + + return chunks.join("") +} + +/** + * The class to find patterns as considering escape sequences. + */ +class PatternMatcher { + /** + * Initialize this matcher. + * @param {RegExp} pattern The pattern to match. + * @param {{escaped?:boolean}} [options] The options. + */ + constructor(pattern, options = {}) { + const { escaped = false } = options; + if (!(pattern instanceof RegExp)) { + throw new TypeError("'pattern' should be a RegExp instance.") + } + if (!pattern.flags.includes("g")) { + throw new Error("'pattern' should contains 'g' flag.") + } + + internal.set(this, { + pattern: new RegExp(pattern.source, pattern.flags), + escaped: Boolean(escaped), + }); + } + + /** + * Find the pattern in a given string. + * @param {string} str The string to find. + * @returns {IterableIterator} The iterator which iterate the matched information. + */ + *execAll(str) { + const { pattern, escaped } = + /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this)); + let match = null; + let lastIndex = 0; + + pattern.lastIndex = 0; + while ((match = pattern.exec(str)) != null) { + if (escaped || !isEscaped(str, match.index)) { + lastIndex = pattern.lastIndex; + yield match; + pattern.lastIndex = lastIndex; + } + } + } + + /** + * Check whether the pattern is found in a given string. + * @param {string} str The string to check. + * @returns {boolean} `true` if the pattern was found in the string. + */ + test(str) { + const it = this.execAll(str); + const ret = it.next(); + return !ret.done + } + + /** + * Replace a given string. + * @param {string} str The string to be replaced. + * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`. + * @returns {string} The replaced string. + */ + [Symbol.replace](str, replacer) { + return typeof replacer === "function" + ? replaceF(this, String(str), replacer) + : replaceS(this, String(str), String(replacer)) + } +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("estree").Pattern} Pattern */ +/** @typedef {import("estree").Identifier} Identifier */ +/** @typedef {import("estree").SimpleCallExpression} CallExpression */ +/** @typedef {import("estree").Program} Program */ +/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */ +/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */ +/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */ +/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */ +/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */ +/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */ +/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */ +/** @typedef {import("estree").ExportSpecifier} ExportSpecifier */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */ +/** @typedef {import("estree").Literal} Literal */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */ +/** @typedef {import("./types.mjs").ReferenceTrackerOptions} ReferenceTrackerOptions */ +/** + * @template T + * @typedef {import("./types.mjs").TraceMap} TraceMap + */ +/** + * @template T + * @typedef {import("./types.mjs").TraceMapObject} TraceMapObject + */ +/** + * @template T + * @typedef {import("./types.mjs").TrackedReferences} TrackedReferences + */ + +const IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u; + +/** + * Check whether a given node is an import node or not. + * @param {Node} node + * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node. + */ +function isHasSource(node) { + return ( + IMPORT_TYPE.test(node.type) && + /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ ( + node + ).source != null + ) +} +const has = + /** @type {(traceMap: TraceMap, v: T) => v is (string extends T ? string : T)} */ ( + Function.call.bind(Object.hasOwnProperty) + ); + +const READ = Symbol("read"); +const CALL = Symbol("call"); +const CONSTRUCT = Symbol("construct"); +const ESM = Symbol("esm"); + +const requireCall = { require: { [CALL]: true } }; + +/** + * Check whether a given variable is modified or not. + * @param {Variable|undefined} variable The variable to check. + * @returns {boolean} `true` if the variable is modified. + */ +function isModifiedGlobal(variable) { + return ( + variable == null || + variable.defs.length !== 0 || + variable.references.some((r) => r.isWrite()) + ) +} + +/** + * Check if the value of a given node is passed through to the parent syntax as-is. + * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through. + * @param {Node} node A node to check. + * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through. + */ +function isPassThrough(node) { + const parent = /** @type {TSESTreeNode} */ (node).parent; + + if (parent) { + switch (parent.type) { + case "ConditionalExpression": + return parent.consequent === node || parent.alternate === node + case "LogicalExpression": + return true + case "SequenceExpression": + return ( + parent.expressions[parent.expressions.length - 1] === node + ) + case "ChainExpression": + return true + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + case "TSInstantiationExpression": + return true + + default: + return false + } + } + return false +} + +/** + * The reference tracker. + */ +class ReferenceTracker { + /** + * Initialize this tracker. + * @param {Scope} globalScope The global scope. + * @param {object} [options] The options. + * @param {"legacy"|"strict"} [options.mode="strict"] The mode to determine the ImportDeclaration's behavior for CJS modules. + * @param {string[]} [options.globalObjectNames=["global","globalThis","self","window"]] The variable names for Global Object. + */ + constructor(globalScope, options = {}) { + const { + mode = "strict", + globalObjectNames = ["global", "globalThis", "self", "window"], + } = options; + /** @private @type {Variable[]} */ + this.variableStack = []; + /** @private */ + this.globalScope = globalScope; + /** @private */ + this.mode = mode; + /** @private */ + this.globalObjectNames = globalObjectNames.slice(0); + } + + /** + * Iterate the references of global variables. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateGlobalReferences(traceMap) { + for (const key of Object.keys(traceMap)) { + const nextTraceMap = traceMap[key]; + const path = [key]; + const variable = this.globalScope.set.get(key); + + if (isModifiedGlobal(variable)) { + continue + } + + yield* this._iterateVariableReferences( + /** @type {Variable} */ (variable), + path, + nextTraceMap, + true, + ); + } + + for (const key of this.globalObjectNames) { + /** @type {string[]} */ + const path = []; + const variable = this.globalScope.set.get(key); + + if (isModifiedGlobal(variable)) { + continue + } + + yield* this._iterateVariableReferences( + /** @type {Variable} */ (variable), + path, + traceMap, + false, + ); + } + } + + /** + * Iterate the references of CommonJS modules. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateCjsReferences(traceMap) { + for (const { node } of this.iterateGlobalReferences(requireCall)) { + const key = getStringIfConstant( + /** @type {CallExpression} */ (node).arguments[0], + ); + if (key == null || !has(traceMap, key)) { + continue + } + + const nextTraceMap = traceMap[key]; + const path = [key]; + + if (nextTraceMap[READ]) { + yield { + node, + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iteratePropertyReferences( + /** @type {CallExpression} */ (node), + path, + nextTraceMap, + ); + } + } + + /** + * Iterate the references of ES modules. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateEsmReferences(traceMap) { + const programNode = /** @type {Program} */ (this.globalScope.block); + + for (const node of programNode.body) { + if (!isHasSource(node)) { + continue + } + const moduleId = /** @type {string} */ (node.source.value); + + if (!has(traceMap, moduleId)) { + continue + } + const nextTraceMap = traceMap[moduleId]; + const path = [moduleId]; + + if (nextTraceMap[READ]) { + yield { + // eslint-disable-next-line object-shorthand -- apply type + node: /** @type {RuleNode} */ (node), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + + if (node.type === "ExportAllDeclaration") { + for (const key of Object.keys(nextTraceMap)) { + const exportTraceMap = nextTraceMap[key]; + if (exportTraceMap[READ]) { + yield { + // eslint-disable-next-line object-shorthand -- apply type + node: /** @type {RuleNode} */ (node), + path: path.concat(key), + type: READ, + info: exportTraceMap[READ], + }; + } + } + } else { + for (const specifier of node.specifiers) { + const esm = has(nextTraceMap, ESM); + const it = this._iterateImportReferences( + specifier, + path, + esm + ? nextTraceMap + : this.mode === "legacy" + ? { default: nextTraceMap, ...nextTraceMap } + : { default: nextTraceMap }, + ); + + if (esm) { + yield* it; + } else { + for (const report of it) { + report.path = report.path.filter(exceptDefault); + if ( + report.path.length >= 2 || + report.type !== READ + ) { + yield report; + } + } + } + } + } + } + } + + /** + * Iterate the property references for a given expression AST node. + * @template T + * @param {Expression} node The expression AST node to iterate property references. + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate property references. + */ + *iteratePropertyReferences(node, traceMap) { + yield* this._iteratePropertyReferences(node, [], traceMap); + } + + /** + * Iterate the references for a given variable. + * @private + * @template T + * @param {Variable} variable The variable to iterate that references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @param {boolean} shouldReport = The flag to report those references. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateVariableReferences(variable, path, traceMap, shouldReport) { + if (this.variableStack.includes(variable)) { + return + } + this.variableStack.push(variable); + try { + for (const reference of variable.references) { + if (!reference.isRead()) { + continue + } + const node = /** @type {RuleNode & Identifier} */ ( + reference.identifier + ); + + if (shouldReport && traceMap[READ]) { + yield { node, path, type: READ, info: traceMap[READ] }; + } + yield* this._iteratePropertyReferences(node, path, traceMap); + } + } finally { + this.variableStack.pop(); + } + } + + /** + * Iterate the references for a given AST node. + * @private + * @template T + * @param {Expression} rootNode The AST node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + //eslint-disable-next-line complexity + *_iteratePropertyReferences(rootNode, path, traceMap) { + let node = rootNode; + while (isPassThrough(node)) { + node = node.parent; + } + + const parent = /** @type {RuleNode} */ (node).parent; + if (!parent) { + return + } + if (parent.type === "MemberExpression") { + if (parent.object === node) { + const key = getPropertyName(parent); + if (key == null || !has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: parent, + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iteratePropertyReferences( + parent, + path, + nextTraceMap, + ); + } + return + } + if (parent.type === "CallExpression") { + if (parent.callee === node && traceMap[CALL]) { + yield { node: parent, path, type: CALL, info: traceMap[CALL] }; + } + return + } + if (parent.type === "NewExpression") { + if (parent.callee === node && traceMap[CONSTRUCT]) { + yield { + node: parent, + path, + type: CONSTRUCT, + info: traceMap[CONSTRUCT], + }; + } + return + } + if (parent.type === "AssignmentExpression") { + if (parent.right === node) { + yield* this._iterateLhsReferences(parent.left, path, traceMap); + yield* this._iteratePropertyReferences(parent, path, traceMap); + } + return + } + if (parent.type === "AssignmentPattern") { + if (parent.right === node) { + yield* this._iterateLhsReferences(parent.left, path, traceMap); + } + return + } + if (parent.type === "VariableDeclarator") { + if (parent.init === node) { + yield* this._iterateLhsReferences(parent.id, path, traceMap); + } + } + } + + /** + * Iterate the references for a given Pattern node. + * @private + * @template T + * @param {Pattern} patternNode The Pattern node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateLhsReferences(patternNode, path, traceMap) { + if (patternNode.type === "Identifier") { + const variable = findVariable(this.globalScope, patternNode); + if (variable != null) { + yield* this._iterateVariableReferences( + variable, + path, + traceMap, + false, + ); + } + return + } + if (patternNode.type === "ObjectPattern") { + for (const property of patternNode.properties) { + const key = getPropertyName( + /** @type {AssignmentProperty} */ (property), + ); + + if (key == null || !has(traceMap, key)) { + continue + } + + const nextPath = path.concat(key); + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (property), + path: nextPath, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iterateLhsReferences( + /** @type {AssignmentProperty} */ (property).value, + nextPath, + nextTraceMap, + ); + } + return + } + if (patternNode.type === "AssignmentPattern") { + yield* this._iterateLhsReferences(patternNode.left, path, traceMap); + } + } + + /** + * Iterate the references for a given ModuleSpecifier node. + * @private + * @template T + * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateImportReferences(specifierNode, path, traceMap) { + const type = specifierNode.type; + + if (type === "ImportSpecifier" || type === "ImportDefaultSpecifier") { + const key = + type === "ImportDefaultSpecifier" + ? "default" + : specifierNode.imported.type === "Identifier" + ? specifierNode.imported.name + : specifierNode.imported.value; + if (!has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (specifierNode), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iterateVariableReferences( + /** @type {Variable} */ ( + findVariable(this.globalScope, specifierNode.local) + ), + path, + nextTraceMap, + false, + ); + + return + } + + if (type === "ImportNamespaceSpecifier") { + yield* this._iterateVariableReferences( + /** @type {Variable} */ ( + findVariable(this.globalScope, specifierNode.local) + ), + path, + traceMap, + false, + ); + return + } + + if (type === "ExportSpecifier") { + const key = + specifierNode.local.type === "Identifier" + ? specifierNode.local.name + : specifierNode.local.value; + if (!has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (specifierNode), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + } + } +} + +ReferenceTracker.READ = READ; +ReferenceTracker.CALL = CALL; +ReferenceTracker.CONSTRUCT = CONSTRUCT; +ReferenceTracker.ESM = ESM; + +/** + * This is a predicate function for Array#filter. + * @param {string} name A name part. + * @param {number} index The index of the name. + * @returns {boolean} `false` if it's default. + */ +function exceptDefault(name, index) { + return !(index === 1 && name === "default") +} + +/** @typedef {import("./types.mjs").StaticValue} StaticValue */ + +var index = { + CALL, + CONSTRUCT, + ESM, + findVariable, + getFunctionHeadLocation, + getFunctionNameWithKind, + getInnermostScope, + getPropertyName, + getStaticValue, + getStringIfConstant, + hasSideEffect, + isArrowToken, + isClosingBraceToken, + isClosingBracketToken, + isClosingParenToken, + isColonToken, + isCommaToken, + isCommentToken, + isNotArrowToken, + isNotClosingBraceToken, + isNotClosingBracketToken, + isNotClosingParenToken, + isNotColonToken, + isNotCommaToken, + isNotCommentToken, + isNotOpeningBraceToken, + isNotOpeningBracketToken, + isNotOpeningParenToken, + isNotSemicolonToken, + isOpeningBraceToken, + isOpeningBracketToken, + isOpeningParenToken, + isParenthesized, + isSemicolonToken, + PatternMatcher, + READ, + ReferenceTracker, +}; + +exports.CALL = CALL; +exports.CONSTRUCT = CONSTRUCT; +exports.ESM = ESM; +exports.PatternMatcher = PatternMatcher; +exports.READ = READ; +exports.ReferenceTracker = ReferenceTracker; +exports["default"] = index; +exports.findVariable = findVariable; +exports.getFunctionHeadLocation = getFunctionHeadLocation; +exports.getFunctionNameWithKind = getFunctionNameWithKind; +exports.getInnermostScope = getInnermostScope; +exports.getPropertyName = getPropertyName; +exports.getStaticValue = getStaticValue; +exports.getStringIfConstant = getStringIfConstant; +exports.hasSideEffect = hasSideEffect; +exports.isArrowToken = isArrowToken; +exports.isClosingBraceToken = isClosingBraceToken; +exports.isClosingBracketToken = isClosingBracketToken; +exports.isClosingParenToken = isClosingParenToken; +exports.isColonToken = isColonToken; +exports.isCommaToken = isCommaToken; +exports.isCommentToken = isCommentToken; +exports.isNotArrowToken = isNotArrowToken; +exports.isNotClosingBraceToken = isNotClosingBraceToken; +exports.isNotClosingBracketToken = isNotClosingBracketToken; +exports.isNotClosingParenToken = isNotClosingParenToken; +exports.isNotColonToken = isNotColonToken; +exports.isNotCommaToken = isNotCommaToken; +exports.isNotCommentToken = isNotCommentToken; +exports.isNotOpeningBraceToken = isNotOpeningBraceToken; +exports.isNotOpeningBracketToken = isNotOpeningBracketToken; +exports.isNotOpeningParenToken = isNotOpeningParenToken; +exports.isNotSemicolonToken = isNotSemicolonToken; +exports.isOpeningBraceToken = isOpeningBraceToken; +exports.isOpeningBracketToken = isOpeningBracketToken; +exports.isOpeningParenToken = isOpeningParenToken; +exports.isParenthesized = isParenthesized; +exports.isSemicolonToken = isSemicolonToken; +//# sourceMappingURL=index.js.map diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js.map b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js.map new file mode 100644 index 00000000..913c5398 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["src/get-innermost-scope.mjs","src/find-variable.mjs","src/token-predicate.mjs","src/get-function-head-location.mjs","src/get-static-value.mjs","src/get-string-if-constant.mjs","src/get-property-name.mjs","src/get-function-name-with-kind.mjs","src/has-side-effect.mjs","src/is-parenthesized.mjs","src/pattern-matcher.mjs","src/reference-tracker.mjs","src/index.mjs"],"sourcesContent":["/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").Node} Node */\n\n/**\n * Get the innermost scope which contains a given location.\n * @param {Scope} initialScope The initial scope to search.\n * @param {Node} node The location to search.\n * @returns {Scope} The innermost scope.\n */\nexport function getInnermostScope(initialScope, node) {\n const location = /** @type {[number, number]} */ (node.range)[0]\n\n let scope = initialScope\n let found = false\n do {\n found = false\n for (const childScope of scope.childScopes) {\n const range = /** @type {[number, number]} */ (\n childScope.block.range\n )\n\n if (range[0] <= location && location < range[1]) {\n scope = childScope\n found = true\n break\n }\n }\n } while (found)\n\n return scope\n}\n","import { getInnermostScope } from \"./get-innermost-scope.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Find the variable of a given name.\n * @param {Scope} initialScope The scope to start finding.\n * @param {string|Identifier} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.\n * @returns {Variable|null} The found variable or null.\n */\nexport function findVariable(initialScope, nameOrNode) {\n let name = \"\"\n /** @type {Scope|null} */\n let scope = initialScope\n\n if (typeof nameOrNode === \"string\") {\n name = nameOrNode\n } else {\n name = nameOrNode.name\n scope = getInnermostScope(scope, nameOrNode)\n }\n\n while (scope != null) {\n const variable = scope.set.get(name)\n if (variable != null) {\n return variable\n }\n scope = scope.upper\n }\n\n return null\n}\n","/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"estree\").Comment} Comment */\n/** @typedef {import(\"./types.mjs\").ArrowToken} ArrowToken */\n/** @typedef {import(\"./types.mjs\").CommaToken} CommaToken */\n/** @typedef {import(\"./types.mjs\").SemicolonToken} SemicolonToken */\n/** @typedef {import(\"./types.mjs\").ColonToken} ColonToken */\n/** @typedef {import(\"./types.mjs\").OpeningParenToken} OpeningParenToken */\n/** @typedef {import(\"./types.mjs\").ClosingParenToken} ClosingParenToken */\n/** @typedef {import(\"./types.mjs\").OpeningBracketToken} OpeningBracketToken */\n/** @typedef {import(\"./types.mjs\").ClosingBracketToken} ClosingBracketToken */\n/** @typedef {import(\"./types.mjs\").OpeningBraceToken} OpeningBraceToken */\n/** @typedef {import(\"./types.mjs\").ClosingBraceToken} ClosingBraceToken */\n/**\n * @template {string} Value\n * @typedef {import(\"./types.mjs\").PunctuatorToken} PunctuatorToken\n */\n\n/** @typedef {Comment | Token} CommentOrToken */\n\n/**\n * Creates the negate function of the given function.\n * @param {function(CommentOrToken):boolean} f - The function to negate.\n * @returns {function(CommentOrToken):boolean} Negated function.\n */\nfunction negate(f) {\n return (token) => !f(token)\n}\n\n/**\n * Checks if the given token is a PunctuatorToken with the given value\n * @template {string} Value\n * @param {CommentOrToken} token - The token to check.\n * @param {Value} value - The value to check.\n * @returns {token is PunctuatorToken} `true` if the token is a PunctuatorToken with the given value.\n */\nfunction isPunctuatorTokenWithValue(token, value) {\n return token.type === \"Punctuator\" && token.value === value\n}\n\n/**\n * Checks if the given token is an arrow token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ArrowToken} `true` if the token is an arrow token.\n */\nexport function isArrowToken(token) {\n return isPunctuatorTokenWithValue(token, \"=>\")\n}\n\n/**\n * Checks if the given token is a comma token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is CommaToken} `true` if the token is a comma token.\n */\nexport function isCommaToken(token) {\n return isPunctuatorTokenWithValue(token, \",\")\n}\n\n/**\n * Checks if the given token is a semicolon token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is SemicolonToken} `true` if the token is a semicolon token.\n */\nexport function isSemicolonToken(token) {\n return isPunctuatorTokenWithValue(token, \";\")\n}\n\n/**\n * Checks if the given token is a colon token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ColonToken} `true` if the token is a colon token.\n */\nexport function isColonToken(token) {\n return isPunctuatorTokenWithValue(token, \":\")\n}\n\n/**\n * Checks if the given token is an opening parenthesis token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token.\n */\nexport function isOpeningParenToken(token) {\n return isPunctuatorTokenWithValue(token, \"(\")\n}\n\n/**\n * Checks if the given token is a closing parenthesis token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token.\n */\nexport function isClosingParenToken(token) {\n return isPunctuatorTokenWithValue(token, \")\")\n}\n\n/**\n * Checks if the given token is an opening square bracket token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token.\n */\nexport function isOpeningBracketToken(token) {\n return isPunctuatorTokenWithValue(token, \"[\")\n}\n\n/**\n * Checks if the given token is a closing square bracket token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token.\n */\nexport function isClosingBracketToken(token) {\n return isPunctuatorTokenWithValue(token, \"]\")\n}\n\n/**\n * Checks if the given token is an opening brace token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token.\n */\nexport function isOpeningBraceToken(token) {\n return isPunctuatorTokenWithValue(token, \"{\")\n}\n\n/**\n * Checks if the given token is a closing brace token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token.\n */\nexport function isClosingBraceToken(token) {\n return isPunctuatorTokenWithValue(token, \"}\")\n}\n\n/**\n * Checks if the given token is a comment token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is Comment} `true` if the token is a comment token.\n */\nexport function isCommentToken(token) {\n return [\"Block\", \"Line\", \"Shebang\"].includes(token.type)\n}\n\nexport const isNotArrowToken = negate(isArrowToken)\nexport const isNotCommaToken = negate(isCommaToken)\nexport const isNotSemicolonToken = negate(isSemicolonToken)\nexport const isNotColonToken = negate(isColonToken)\nexport const isNotOpeningParenToken = negate(isOpeningParenToken)\nexport const isNotClosingParenToken = negate(isClosingParenToken)\nexport const isNotOpeningBracketToken = negate(isOpeningBracketToken)\nexport const isNotClosingBracketToken = negate(isClosingBracketToken)\nexport const isNotOpeningBraceToken = negate(isOpeningBraceToken)\nexport const isNotClosingBraceToken = negate(isClosingBraceToken)\nexport const isNotCommentToken = negate(isCommentToken)\n","import { isArrowToken, isOpeningParenToken } from \"./token-predicate.mjs\"\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"estree\").Function} FunctionNode */\n/** @typedef {import(\"estree\").FunctionDeclaration} FunctionDeclaration */\n/** @typedef {import(\"estree\").FunctionExpression} FunctionExpression */\n/** @typedef {import(\"estree\").SourceLocation} SourceLocation */\n/** @typedef {import(\"estree\").Position} Position */\n\n/**\n * Get the `(` token of the given function node.\n * @param {FunctionExpression | FunctionDeclaration} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {Token} `(` token.\n */\nfunction getOpeningParenOfParams(node, sourceCode) {\n return node.id\n ? /** @type {Token} */ (\n sourceCode.getTokenAfter(node.id, isOpeningParenToken)\n )\n : /** @type {Token} */ (\n sourceCode.getFirstToken(node, isOpeningParenToken)\n )\n}\n\n/**\n * Get the location of the given function node for reporting.\n * @param {FunctionNode} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {SourceLocation|null} The location of the function node for reporting.\n */\nexport function getFunctionHeadLocation(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n /** @type {Position|null} */\n let start = null\n /** @type {Position|null} */\n let end = null\n\n if (node.type === \"ArrowFunctionExpression\") {\n const arrowToken = /** @type {Token} */ (\n sourceCode.getTokenBefore(node.body, isArrowToken)\n )\n\n start = arrowToken.loc.start\n end = arrowToken.loc.end\n } else if (\n parent &&\n (parent.type === \"Property\" ||\n parent.type === \"MethodDefinition\" ||\n parent.type === \"PropertyDefinition\")\n ) {\n start = /** @type {SourceLocation} */ (parent.loc).start\n end = getOpeningParenOfParams(node, sourceCode).loc.start\n } else {\n start = /** @type {SourceLocation} */ (node.loc).start\n end = getOpeningParenOfParams(node, sourceCode).loc.start\n }\n\n return {\n start: { ...start },\n end: { ...end },\n }\n}\n","/* globals self, window */\n\nimport { findVariable } from \"./find-variable.mjs\"\n/** @typedef {import(\"./types.mjs\").StaticValue} StaticValue */\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Node} TSESTreeNode */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.MemberExpression} MemberExpression */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Property} Property */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.RegExpLiteral} RegExpLiteral */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.BigIntLiteral} BigIntLiteral */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Literal} Literal */\n\nconst globalObject =\n typeof globalThis !== \"undefined\"\n ? globalThis\n : // @ts-ignore\n typeof self !== \"undefined\"\n ? // @ts-ignore\n self\n : // @ts-ignore\n typeof window !== \"undefined\"\n ? // @ts-ignore\n window\n : typeof global !== \"undefined\"\n ? global\n : {}\n\nconst builtinNames = Object.freeze(\n new Set([\n \"Array\",\n \"ArrayBuffer\",\n \"BigInt\",\n \"BigInt64Array\",\n \"BigUint64Array\",\n \"Boolean\",\n \"DataView\",\n \"Date\",\n \"decodeURI\",\n \"decodeURIComponent\",\n \"encodeURI\",\n \"encodeURIComponent\",\n \"escape\",\n \"Float32Array\",\n \"Float64Array\",\n \"Function\",\n \"Infinity\",\n \"Int16Array\",\n \"Int32Array\",\n \"Int8Array\",\n \"isFinite\",\n \"isNaN\",\n \"isPrototypeOf\",\n \"JSON\",\n \"Map\",\n \"Math\",\n \"NaN\",\n \"Number\",\n \"Object\",\n \"parseFloat\",\n \"parseInt\",\n \"Promise\",\n \"Proxy\",\n \"Reflect\",\n \"RegExp\",\n \"Set\",\n \"String\",\n \"Symbol\",\n \"Uint16Array\",\n \"Uint32Array\",\n \"Uint8Array\",\n \"Uint8ClampedArray\",\n \"undefined\",\n \"unescape\",\n \"WeakMap\",\n \"WeakSet\",\n ]),\n)\nconst callAllowed = new Set(\n [\n Array.isArray,\n Array.of,\n Array.prototype.at,\n Array.prototype.concat,\n Array.prototype.entries,\n Array.prototype.every,\n Array.prototype.filter,\n Array.prototype.find,\n Array.prototype.findIndex,\n Array.prototype.flat,\n Array.prototype.includes,\n Array.prototype.indexOf,\n Array.prototype.join,\n Array.prototype.keys,\n Array.prototype.lastIndexOf,\n Array.prototype.slice,\n Array.prototype.some,\n Array.prototype.toString,\n Array.prototype.values,\n typeof BigInt === \"function\" ? BigInt : undefined,\n Boolean,\n Date,\n Date.parse,\n decodeURI,\n decodeURIComponent,\n encodeURI,\n encodeURIComponent,\n escape,\n isFinite,\n isNaN,\n // @ts-ignore\n isPrototypeOf,\n Map,\n Map.prototype.entries,\n Map.prototype.get,\n Map.prototype.has,\n Map.prototype.keys,\n Map.prototype.values,\n .../** @type {(keyof typeof Math)[]} */ (\n Object.getOwnPropertyNames(Math)\n )\n .filter((k) => k !== \"random\")\n .map((k) => Math[k])\n .filter((f) => typeof f === \"function\"),\n Number,\n Number.isFinite,\n Number.isNaN,\n Number.parseFloat,\n Number.parseInt,\n Number.prototype.toExponential,\n Number.prototype.toFixed,\n Number.prototype.toPrecision,\n Number.prototype.toString,\n Object,\n Object.entries,\n Object.is,\n Object.isExtensible,\n Object.isFrozen,\n Object.isSealed,\n Object.keys,\n Object.values,\n parseFloat,\n parseInt,\n RegExp,\n Set,\n Set.prototype.entries,\n Set.prototype.has,\n Set.prototype.keys,\n Set.prototype.values,\n String,\n String.fromCharCode,\n String.fromCodePoint,\n String.raw,\n String.prototype.at,\n String.prototype.charAt,\n String.prototype.charCodeAt,\n String.prototype.codePointAt,\n String.prototype.concat,\n String.prototype.endsWith,\n String.prototype.includes,\n String.prototype.indexOf,\n String.prototype.lastIndexOf,\n String.prototype.normalize,\n String.prototype.padEnd,\n String.prototype.padStart,\n String.prototype.slice,\n String.prototype.startsWith,\n String.prototype.substr,\n String.prototype.substring,\n String.prototype.toLowerCase,\n String.prototype.toString,\n String.prototype.toUpperCase,\n String.prototype.trim,\n String.prototype.trimEnd,\n String.prototype.trimLeft,\n String.prototype.trimRight,\n String.prototype.trimStart,\n Symbol.for,\n Symbol.keyFor,\n unescape,\n ].filter((f) => typeof f === \"function\"),\n)\nconst callPassThrough = new Set([\n Object.freeze,\n Object.preventExtensions,\n Object.seal,\n])\n\n/** @type {ReadonlyArray]>} */\nconst getterAllowed = [\n [Map, new Set([\"size\"])],\n [\n RegExp,\n new Set([\n \"dotAll\",\n \"flags\",\n \"global\",\n \"hasIndices\",\n \"ignoreCase\",\n \"multiline\",\n \"source\",\n \"sticky\",\n \"unicode\",\n ]),\n ],\n [Set, new Set([\"size\"])],\n]\n\n/**\n * Get the property descriptor.\n * @param {object} object The object to get.\n * @param {string|number|symbol} name The property name to get.\n */\nfunction getPropertyDescriptor(object, name) {\n let x = object\n while ((typeof x === \"object\" || typeof x === \"function\") && x !== null) {\n const d = Object.getOwnPropertyDescriptor(x, name)\n if (d) {\n return d\n }\n x = Object.getPrototypeOf(x)\n }\n return null\n}\n\n/**\n * Check if a property is getter or not.\n * @param {object} object The object to check.\n * @param {string|number|symbol} name The property name to check.\n */\nfunction isGetter(object, name) {\n const d = getPropertyDescriptor(object, name)\n return d != null && d.get != null\n}\n\n/**\n * Get the element values of a given node list.\n * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values.\n * @param {Scope|undefined|null} initialScope The initial scope to find variables.\n * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.\n */\nfunction getElementValues(nodeList, initialScope) {\n const valueList = []\n\n for (let i = 0; i < nodeList.length; ++i) {\n const elementNode = nodeList[i]\n\n if (elementNode == null) {\n valueList.length = i + 1\n } else if (elementNode.type === \"SpreadElement\") {\n const argument = getStaticValueR(elementNode.argument, initialScope)\n if (argument == null) {\n return null\n }\n valueList.push(.../** @type {Iterable} */ (argument.value))\n } else {\n const element = getStaticValueR(elementNode, initialScope)\n if (element == null) {\n return null\n }\n valueList.push(element.value)\n }\n }\n\n return valueList\n}\n\n/**\n * Checks if a variable is a built-in global.\n * @param {Variable|null} variable The variable to check.\n * @returns {variable is Variable & {defs:[]}}\n */\nfunction isBuiltinGlobal(variable) {\n return (\n variable != null &&\n variable.defs.length === 0 &&\n builtinNames.has(variable.name) &&\n variable.name in globalObject\n )\n}\n\n/**\n * Checks if a variable can be considered as a constant.\n * @param {Variable} variable\n * @returns {variable is Variable & {defs: [import(\"eslint\").Scope.Definition & { type: \"Variable\" }]}} True if the variable can be considered as a constant.\n */\nfunction canBeConsideredConst(variable) {\n if (variable.defs.length !== 1) {\n return false\n }\n const def = variable.defs[0]\n return Boolean(\n def.parent &&\n def.type === \"Variable\" &&\n (def.parent.kind === \"const\" || isEffectivelyConst(variable)),\n )\n}\n\n/**\n * Returns whether the given variable is never written to after initialization.\n * @param {Variable} variable\n * @returns {boolean}\n */\nfunction isEffectivelyConst(variable) {\n const refs = variable.references\n\n const inits = refs.filter((r) => r.init).length\n const reads = refs.filter((r) => r.isReadOnly()).length\n if (inits === 1 && reads + inits === refs.length) {\n // there is only one init and all other references only read\n return true\n }\n return false\n}\n\n/**\n * Checks if a variable has mutation in its property.\n * @param {Variable} variable The variable to check.\n * @param {Scope|null} initialScope The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {boolean} True if the variable has mutation in its property.\n */\nfunction hasMutationInProperty(variable, initialScope) {\n for (const ref of variable.references) {\n let node = /** @type {TSESTreeNode} */ (ref.identifier)\n while (node && node.parent && node.parent.type === \"MemberExpression\") {\n node = node.parent\n }\n if (!node || !node.parent) {\n continue\n }\n if (\n (node.parent.type === \"AssignmentExpression\" &&\n node.parent.left === node) ||\n (node.parent.type === \"UpdateExpression\" &&\n node.parent.argument === node)\n ) {\n // This is a mutation.\n return true\n }\n if (\n node.parent.type === \"CallExpression\" &&\n node.parent.callee === node &&\n node.type === \"MemberExpression\"\n ) {\n const methodName = getStaticPropertyNameValue(node, initialScope)\n if (isNameOfMutationArrayMethod(methodName)) {\n // This is a mutation.\n return true\n }\n }\n }\n return false\n\n /**\n * Checks if a method name is one of the mutation array methods.\n * @param {StaticValue|null} methodName The method name to check.\n * @returns {boolean} True if the method name is a mutation array method.\n */\n function isNameOfMutationArrayMethod(methodName) {\n if (methodName == null || methodName.value == null) {\n return false\n }\n const name = methodName.value\n return (\n name === \"copyWithin\" ||\n name === \"fill\" ||\n name === \"pop\" ||\n name === \"push\" ||\n name === \"reverse\" ||\n name === \"shift\" ||\n name === \"sort\" ||\n name === \"splice\" ||\n name === \"unshift\"\n )\n }\n}\n\n/**\n * @template {TSESTreeNodeTypes} T\n * @callback VisitorCallback\n * @param {TSESTreeNode & { type: T }} node\n * @param {Scope|undefined|null} initialScope\n * @returns {StaticValue | null}\n */\n/**\n * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback } } Operations\n */\n/**\n * @type {Operations}\n */\nconst operations = Object.freeze({\n ArrayExpression(node, initialScope) {\n const elements = getElementValues(node.elements, initialScope)\n return elements != null ? { value: elements } : null\n },\n\n AssignmentExpression(node, initialScope) {\n if (node.operator === \"=\") {\n return getStaticValueR(node.right, initialScope)\n }\n return null\n },\n\n //eslint-disable-next-line complexity\n BinaryExpression(node, initialScope) {\n if (node.operator === \"in\" || node.operator === \"instanceof\") {\n // Not supported.\n return null\n }\n\n const left = getStaticValueR(node.left, initialScope)\n const right = getStaticValueR(node.right, initialScope)\n if (left != null && right != null) {\n switch (node.operator) {\n case \"==\":\n return { value: left.value == right.value } //eslint-disable-line eqeqeq\n case \"!=\":\n return { value: left.value != right.value } //eslint-disable-line eqeqeq\n case \"===\":\n return { value: left.value === right.value }\n case \"!==\":\n return { value: left.value !== right.value }\n case \"<\":\n return {\n value:\n /** @type {any} */ (left.value) <\n /** @type {any} */ (right.value),\n }\n case \"<=\":\n return {\n value:\n /** @type {any} */ (left.value) <=\n /** @type {any} */ (right.value),\n }\n case \">\":\n return {\n value:\n /** @type {any} */ (left.value) >\n /** @type {any} */ (right.value),\n }\n case \">=\":\n return {\n value:\n /** @type {any} */ (left.value) >=\n /** @type {any} */ (right.value),\n }\n case \"<<\":\n return {\n value:\n /** @type {any} */ (left.value) <<\n /** @type {any} */ (right.value),\n }\n case \">>\":\n return {\n value:\n /** @type {any} */ (left.value) >>\n /** @type {any} */ (right.value),\n }\n case \">>>\":\n return {\n value:\n /** @type {any} */ (left.value) >>>\n /** @type {any} */ (right.value),\n }\n case \"+\":\n return {\n value:\n /** @type {any} */ (left.value) +\n /** @type {any} */ (right.value),\n }\n case \"-\":\n return {\n value:\n /** @type {any} */ (left.value) -\n /** @type {any} */ (right.value),\n }\n case \"*\":\n return {\n value:\n /** @type {any} */ (left.value) *\n /** @type {any} */ (right.value),\n }\n case \"/\":\n return {\n value:\n /** @type {any} */ (left.value) /\n /** @type {any} */ (right.value),\n }\n case \"%\":\n return {\n value:\n /** @type {any} */ (left.value) %\n /** @type {any} */ (right.value),\n }\n case \"**\":\n return {\n value:\n /** @type {any} */ (left.value) **\n /** @type {any} */ (right.value),\n }\n case \"|\":\n return {\n value:\n /** @type {any} */ (left.value) |\n /** @type {any} */ (right.value),\n }\n case \"^\":\n return {\n value:\n /** @type {any} */ (left.value) ^\n /** @type {any} */ (right.value),\n }\n case \"&\":\n return {\n value:\n /** @type {any} */ (left.value) &\n /** @type {any} */ (right.value),\n }\n\n // no default\n }\n }\n\n return null\n },\n\n CallExpression(node, initialScope) {\n const calleeNode = node.callee\n const args = getElementValues(node.arguments, initialScope)\n\n if (args != null) {\n if (calleeNode.type === \"MemberExpression\") {\n if (calleeNode.property.type === \"PrivateIdentifier\") {\n return null\n }\n const object = getStaticValueR(calleeNode.object, initialScope)\n if (object != null) {\n if (\n object.value == null &&\n (object.optional || node.optional)\n ) {\n return { value: undefined, optional: true }\n }\n const property = getStaticPropertyNameValue(\n calleeNode,\n initialScope,\n )\n\n if (property != null) {\n const receiver =\n /** @type {Record any>} */ (\n object.value\n )\n const methodName = /** @type {PropertyKey} */ (\n property.value\n )\n if (callAllowed.has(receiver[methodName])) {\n return {\n value: receiver[methodName](...args),\n }\n }\n if (callPassThrough.has(receiver[methodName])) {\n return { value: args[0] }\n }\n }\n }\n } else {\n const callee = getStaticValueR(calleeNode, initialScope)\n if (callee != null) {\n if (callee.value == null && node.optional) {\n return { value: undefined, optional: true }\n }\n const func = /** @type {(...args: any[]) => any} */ (\n callee.value\n )\n if (callAllowed.has(func)) {\n return { value: func(...args) }\n }\n if (callPassThrough.has(func)) {\n return { value: args[0] }\n }\n }\n }\n }\n\n return null\n },\n\n ConditionalExpression(node, initialScope) {\n const test = getStaticValueR(node.test, initialScope)\n if (test != null) {\n return test.value\n ? getStaticValueR(node.consequent, initialScope)\n : getStaticValueR(node.alternate, initialScope)\n }\n return null\n },\n\n ExpressionStatement(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n\n Identifier(node, initialScope) {\n if (initialScope != null) {\n const variable = findVariable(initialScope, node)\n\n if (variable != null) {\n // Built-in globals.\n if (isBuiltinGlobal(variable)) {\n return { value: globalObject[variable.name] }\n }\n\n // Constants.\n if (canBeConsideredConst(variable)) {\n const def = variable.defs[0]\n if (\n // TODO(mysticatea): don't support destructuring here.\n def.node.id.type === \"Identifier\"\n ) {\n const init = getStaticValueR(\n def.node.init,\n initialScope,\n )\n if (\n init &&\n typeof init.value === \"object\" &&\n init.value !== null\n ) {\n if (hasMutationInProperty(variable, initialScope)) {\n // This variable has mutation in its property.\n return null\n }\n }\n return init\n }\n }\n }\n }\n return null\n },\n\n Literal(node) {\n const literal =\n /** @type {Partial & Partial & Partial} */ (\n node\n )\n //istanbul ignore if : this is implementation-specific behavior.\n if (\n (literal.regex != null || literal.bigint != null) &&\n literal.value == null\n ) {\n // It was a RegExp/BigInt literal, but Node.js didn't support it.\n return null\n }\n return { value: literal.value }\n },\n\n LogicalExpression(node, initialScope) {\n const left = getStaticValueR(node.left, initialScope)\n if (left != null) {\n if (\n (node.operator === \"||\" && Boolean(left.value) === true) ||\n (node.operator === \"&&\" && Boolean(left.value) === false) ||\n (node.operator === \"??\" && left.value != null)\n ) {\n return left\n }\n\n const right = getStaticValueR(node.right, initialScope)\n if (right != null) {\n return right\n }\n }\n\n return null\n },\n\n MemberExpression(node, initialScope) {\n if (node.property.type === \"PrivateIdentifier\") {\n return null\n }\n const object = getStaticValueR(node.object, initialScope)\n if (object != null) {\n if (object.value == null && (object.optional || node.optional)) {\n return { value: undefined, optional: true }\n }\n const property = getStaticPropertyNameValue(node, initialScope)\n\n if (property != null) {\n if (\n !isGetter(\n /** @type {object} */ (object.value),\n /** @type {PropertyKey} */ (property.value),\n )\n ) {\n return {\n value: /** @type {Record} */ (\n object.value\n )[/** @type {PropertyKey} */ (property.value)],\n }\n }\n\n for (const [classFn, allowed] of getterAllowed) {\n if (\n object.value instanceof classFn &&\n allowed.has(/** @type {string} */ (property.value))\n ) {\n return {\n value: /** @type {Record} */ (\n object.value\n )[/** @type {PropertyKey} */ (property.value)],\n }\n }\n }\n }\n }\n return null\n },\n\n ChainExpression(node, initialScope) {\n const expression = getStaticValueR(node.expression, initialScope)\n if (expression != null) {\n return { value: expression.value }\n }\n return null\n },\n\n NewExpression(node, initialScope) {\n const callee = getStaticValueR(node.callee, initialScope)\n const args = getElementValues(node.arguments, initialScope)\n\n if (callee != null && args != null) {\n const Func = /** @type {new (...args: any[]) => any} */ (\n callee.value\n )\n if (callAllowed.has(Func)) {\n return { value: new Func(...args) }\n }\n }\n\n return null\n },\n\n ObjectExpression(node, initialScope) {\n /** @type {Record} */\n const object = {}\n\n for (const propertyNode of node.properties) {\n if (propertyNode.type === \"Property\") {\n if (propertyNode.kind !== \"init\") {\n return null\n }\n const key = getStaticPropertyNameValue(\n propertyNode,\n initialScope,\n )\n const value = getStaticValueR(propertyNode.value, initialScope)\n if (key == null || value == null) {\n return null\n }\n object[/** @type {PropertyKey} */ (key.value)] = value.value\n } else if (\n propertyNode.type === \"SpreadElement\" ||\n // @ts-expect-error -- Backward compatibility\n propertyNode.type === \"ExperimentalSpreadProperty\"\n ) {\n const argument = getStaticValueR(\n propertyNode.argument,\n initialScope,\n )\n if (argument == null) {\n return null\n }\n Object.assign(object, argument.value)\n } else {\n return null\n }\n }\n\n return { value: object }\n },\n\n SequenceExpression(node, initialScope) {\n const last = node.expressions[node.expressions.length - 1]\n return getStaticValueR(last, initialScope)\n },\n\n TaggedTemplateExpression(node, initialScope) {\n const tag = getStaticValueR(node.tag, initialScope)\n const expressions = getElementValues(\n node.quasi.expressions,\n initialScope,\n )\n\n if (tag != null && expressions != null) {\n const func = /** @type {(...args: any[]) => any} */ (tag.value)\n /** @type {any[] & { raw?: string[] }} */\n const strings = node.quasi.quasis.map((q) => q.value.cooked)\n strings.raw = node.quasi.quasis.map((q) => q.value.raw)\n\n if (func === String.raw) {\n return { value: func(strings, ...expressions) }\n }\n }\n\n return null\n },\n\n TemplateLiteral(node, initialScope) {\n const expressions = getElementValues(node.expressions, initialScope)\n if (expressions != null) {\n let value = node.quasis[0].value.cooked\n for (let i = 0; i < expressions.length; ++i) {\n value += expressions[i]\n value += /** @type {string} */ (node.quasis[i + 1].value.cooked)\n }\n return { value }\n }\n return null\n },\n\n UnaryExpression(node, initialScope) {\n if (node.operator === \"delete\") {\n // Not supported.\n return null\n }\n if (node.operator === \"void\") {\n return { value: undefined }\n }\n\n const arg = getStaticValueR(node.argument, initialScope)\n if (arg != null) {\n switch (node.operator) {\n case \"-\":\n return { value: -(/** @type {any} */ (arg.value)) }\n case \"+\":\n return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion\n case \"!\":\n return { value: !arg.value }\n case \"~\":\n return { value: ~(/** @type {any} */ (arg.value)) }\n case \"typeof\":\n return { value: typeof arg.value }\n\n // no default\n }\n }\n\n return null\n },\n TSAsExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSSatisfiesExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSTypeAssertion(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSNonNullExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSInstantiationExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n})\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node|TSESTreeNode|null|undefined} node The node to get.\n * @param {Scope|undefined|null} initialScope The scope to start finding variable.\n * @returns {StaticValue|null} The static value of the node, or `null`.\n */\nfunction getStaticValueR(node, initialScope) {\n if (node != null && Object.hasOwnProperty.call(operations, node.type)) {\n return /** @type {VisitorCallback} */ (operations[node.type])(\n /** @type {TSESTreeNode} */ (node),\n initialScope,\n )\n }\n return null\n}\n\n/**\n * Get the static value of property name from a MemberExpression node or a Property node.\n * @param {MemberExpression|Property} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {StaticValue|null} The static value of the property name of the node, or `null`.\n */\nfunction getStaticPropertyNameValue(node, initialScope) {\n const nameNode = node.type === \"Property\" ? node.key : node.property\n\n if (node.computed) {\n return getStaticValueR(nameNode, initialScope)\n }\n\n if (nameNode.type === \"Identifier\") {\n return { value: nameNode.name }\n }\n\n if (nameNode.type === \"Literal\") {\n if (/** @type {Partial} */ (nameNode).bigint) {\n return { value: /** @type {BigIntLiteral} */ (nameNode).bigint }\n }\n return { value: String(nameNode.value) }\n }\n\n return null\n}\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.\n * @returns {StaticValue | null} The static value of the node, or `null`.\n */\nexport function getStaticValue(node, initialScope = null) {\n try {\n return getStaticValueR(node, initialScope)\n } catch (_error) {\n return null\n }\n}\n","import { getStaticValue } from \"./get-static-value.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"estree\").RegExpLiteral} RegExpLiteral */\n/** @typedef {import(\"estree\").BigIntLiteral} BigIntLiteral */\n/** @typedef {import(\"estree\").SimpleLiteral} SimpleLiteral */\n\n/**\n * Get the value of a given node if it's a literal or a template literal.\n * @param {Node} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.\n * @returns {string|null} The value of the node, or `null`.\n */\nexport function getStringIfConstant(node, initialScope = null) {\n // Handle the literals that the platform doesn't support natively.\n if (node && node.type === \"Literal\" && node.value === null) {\n const literal =\n /** @type {Partial & Partial & Partial} */ (\n node\n )\n if (literal.regex) {\n return `/${literal.regex.pattern}/${literal.regex.flags}`\n }\n if (literal.bigint) {\n return literal.bigint\n }\n }\n\n const evaluated = getStaticValue(node, initialScope)\n\n if (evaluated) {\n // `String(Symbol.prototype)` throws error\n try {\n return String(evaluated.value)\n } catch {\n // No op\n }\n }\n\n return null\n}\n","import { getStringIfConstant } from \"./get-string-if-constant.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").MemberExpression} MemberExpression */\n/** @typedef {import(\"estree\").MethodDefinition} MethodDefinition */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").PropertyDefinition} PropertyDefinition */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Get the property name from a MemberExpression node or a Property node.\n * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} node The node to get.\n * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {string|null|undefined} The property name of the node.\n */\nexport function getPropertyName(node, initialScope) {\n switch (node.type) {\n case \"MemberExpression\":\n if (node.computed) {\n return getStringIfConstant(node.property, initialScope)\n }\n if (node.property.type === \"PrivateIdentifier\") {\n return null\n }\n return /** @type {Partial} */ (node.property).name\n\n case \"Property\":\n case \"MethodDefinition\":\n case \"PropertyDefinition\":\n if (node.computed) {\n return getStringIfConstant(node.key, initialScope)\n }\n if (node.key.type === \"Literal\") {\n return String(node.key.value)\n }\n if (node.key.type === \"PrivateIdentifier\") {\n return null\n }\n return /** @type {Partial} */ (node.key).name\n\n default:\n break\n }\n\n return null\n}\n","import { getPropertyName } from \"./get-property-name.mjs\"\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"estree\").Function} FunctionNode */\n/** @typedef {import(\"estree\").FunctionDeclaration} FunctionDeclaration */\n/** @typedef {import(\"estree\").FunctionExpression} FunctionExpression */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Get the name and kind of the given function node.\n * @param {FunctionNode} node - The function node to get.\n * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys.\n * @returns {string} The name and kind of the function node.\n */\n// eslint-disable-next-line complexity\nexport function getFunctionNameWithKind(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n if (!parent) {\n return \"\"\n }\n\n const tokens = []\n const isObjectMethod = parent.type === \"Property\" && parent.value === node\n const isClassMethod =\n parent.type === \"MethodDefinition\" && parent.value === node\n const isClassFieldMethod =\n parent.type === \"PropertyDefinition\" && parent.value === node\n\n // Modifiers.\n if (isClassMethod || isClassFieldMethod) {\n if (parent.static) {\n tokens.push(\"static\")\n }\n if (parent.key.type === \"PrivateIdentifier\") {\n tokens.push(\"private\")\n }\n }\n if (node.async) {\n tokens.push(\"async\")\n }\n if (node.generator) {\n tokens.push(\"generator\")\n }\n\n // Kinds.\n if (isObjectMethod || isClassMethod) {\n if (parent.kind === \"constructor\") {\n return \"constructor\"\n }\n if (parent.kind === \"get\") {\n tokens.push(\"getter\")\n } else if (parent.kind === \"set\") {\n tokens.push(\"setter\")\n } else {\n tokens.push(\"method\")\n }\n } else if (isClassFieldMethod) {\n tokens.push(\"method\")\n } else {\n if (node.type === \"ArrowFunctionExpression\") {\n tokens.push(\"arrow\")\n }\n tokens.push(\"function\")\n }\n\n // Names.\n if (isObjectMethod || isClassMethod || isClassFieldMethod) {\n if (parent.key.type === \"PrivateIdentifier\") {\n tokens.push(`#${parent.key.name}`)\n } else {\n const name = getPropertyName(parent)\n if (name) {\n tokens.push(`'${name}'`)\n } else if (sourceCode) {\n const keyText = sourceCode.getText(parent.key)\n if (!keyText.includes(\"\\n\")) {\n tokens.push(`[${keyText}]`)\n }\n }\n }\n } else if (hasId(node)) {\n tokens.push(`'${node.id.name}'`)\n } else if (\n parent.type === \"VariableDeclarator\" &&\n parent.id &&\n parent.id.type === \"Identifier\"\n ) {\n tokens.push(`'${parent.id.name}'`)\n } else if (\n (parent.type === \"AssignmentExpression\" ||\n parent.type === \"AssignmentPattern\") &&\n parent.left &&\n parent.left.type === \"Identifier\"\n ) {\n tokens.push(`'${parent.left.name}'`)\n } else if (\n parent.type === \"ExportDefaultDeclaration\" &&\n parent.declaration === node\n ) {\n tokens.push(\"'default'\")\n }\n\n return tokens.join(\" \")\n}\n\n/**\n * @param {FunctionNode} node\n * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }}\n */\nfunction hasId(node) {\n return Boolean(\n /** @type {Partial} */ (node)\n .id,\n )\n}\n","import { getKeys, KEYS } from \"eslint-visitor-keys\"\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"./types.mjs\").HasSideEffectOptions} HasSideEffectOptions */\n/** @typedef {import(\"estree\").BinaryExpression} BinaryExpression */\n/** @typedef {import(\"estree\").MemberExpression} MemberExpression */\n/** @typedef {import(\"estree\").MethodDefinition} MethodDefinition */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").PropertyDefinition} PropertyDefinition */\n/** @typedef {import(\"estree\").UnaryExpression} UnaryExpression */\n\nconst typeConversionBinaryOps = Object.freeze(\n new Set([\n \"==\",\n \"!=\",\n \"<\",\n \"<=\",\n \">\",\n \">=\",\n \"<<\",\n \">>\",\n \">>>\",\n \"+\",\n \"-\",\n \"*\",\n \"/\",\n \"%\",\n \"|\",\n \"^\",\n \"&\",\n \"in\",\n ]),\n)\nconst typeConversionUnaryOps = Object.freeze(new Set([\"-\", \"+\", \"!\", \"~\"]))\n\n/**\n * Check whether the given value is an ASTNode or not.\n * @param {any} x The value to check.\n * @returns {x is Node} `true` if the value is an ASTNode.\n */\nfunction isNode(x) {\n return x !== null && typeof x === \"object\" && typeof x.type === \"string\"\n}\n\nconst visitor = Object.freeze(\n Object.assign(Object.create(null), {\n /**\n * @param {Node} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n $visit(node, options, visitorKeys) {\n const { type } = node\n\n if (typeof (/** @type {any} */ (this)[type]) === \"function\") {\n return /** @type {any} */ (this)[type](\n node,\n options,\n visitorKeys,\n )\n }\n\n return this.$visitChildren(node, options, visitorKeys)\n },\n\n /**\n * @param {Node} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n $visitChildren(node, options, visitorKeys) {\n const { type } = node\n\n for (const key of /** @type {(keyof Node)[]} */ (\n visitorKeys[type] || getKeys(node)\n )) {\n const value = node[key]\n\n if (Array.isArray(value)) {\n for (const element of value) {\n if (\n isNode(element) &&\n this.$visit(element, options, visitorKeys)\n ) {\n return true\n }\n }\n } else if (\n isNode(value) &&\n this.$visit(value, options, visitorKeys)\n ) {\n return true\n }\n }\n\n return false\n },\n\n ArrowFunctionExpression() {\n return false\n },\n AssignmentExpression() {\n return true\n },\n AwaitExpression() {\n return true\n },\n /**\n * @param {BinaryExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n BinaryExpression(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n typeConversionBinaryOps.has(node.operator) &&\n (node.left.type !== \"Literal\" || node.right.type !== \"Literal\")\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n CallExpression() {\n return true\n },\n FunctionExpression() {\n return false\n },\n ImportExpression() {\n return true\n },\n /**\n * @param {MemberExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n MemberExpression(node, options, visitorKeys) {\n if (options.considerGetters) {\n return true\n }\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.property.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {MethodDefinition} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n MethodDefinition(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n NewExpression() {\n return true\n },\n /**\n * @param {Property} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n Property(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {PropertyDefinition} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n PropertyDefinition(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {UnaryExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n UnaryExpression(node, options, visitorKeys) {\n if (node.operator === \"delete\") {\n return true\n }\n if (\n options.considerImplicitTypeConversion &&\n typeConversionUnaryOps.has(node.operator) &&\n node.argument.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n UpdateExpression() {\n return true\n },\n YieldExpression() {\n return true\n },\n }),\n)\n\n/**\n * Check whether a given node has any side effect or not.\n * @param {Node} node The node to get.\n * @param {SourceCode} sourceCode The source code object.\n * @param {HasSideEffectOptions} [options] The option object.\n * @returns {boolean} `true` if the node has a certain side effect.\n */\nexport function hasSideEffect(node, sourceCode, options = {}) {\n const { considerGetters = false, considerImplicitTypeConversion = false } =\n options\n return visitor.$visit(\n node,\n { considerGetters, considerImplicitTypeConversion },\n sourceCode.visitorKeys || KEYS,\n )\n}\n","import { isClosingParenToken, isOpeningParenToken } from \"./token-predicate.mjs\"\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.NewExpression} TSNewExpression */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.CallExpression} TSCallExpression */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n\n/**\n * Get the left parenthesis of the parent node syntax if it exists.\n * E.g., `if (a) {}` then the `(`.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {Token|null} The left parenthesis of the parent node syntax\n */\n// eslint-disable-next-line complexity\nfunction getParentSyntaxParen(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n if (!parent) {\n return null\n }\n\n switch (parent.type) {\n case \"CallExpression\":\n case \"NewExpression\":\n if (parent.arguments.length === 1 && parent.arguments[0] === node) {\n return sourceCode.getTokenAfter(\n // @ts-expect-error https://github.com/typescript-eslint/typescript-eslint/pull/5384\n parent.typeArguments ||\n /** @type {RuleNode} */ (\n /** @type {unknown} */ (\n /** @type {TSNewExpression | TSCallExpression} */ (\n parent\n ).typeParameters\n )\n ) ||\n parent.callee,\n isOpeningParenToken,\n )\n }\n return null\n\n case \"DoWhileStatement\":\n if (parent.test === node) {\n return sourceCode.getTokenAfter(\n parent.body,\n isOpeningParenToken,\n )\n }\n return null\n\n case \"IfStatement\":\n case \"WhileStatement\":\n if (parent.test === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"ImportExpression\":\n if (parent.source === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"SwitchStatement\":\n if (parent.discriminant === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"WithStatement\":\n if (parent.object === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n default:\n return null\n }\n}\n\n/**\n * Check whether a given node is parenthesized or not.\n * @param {number} times The number of parantheses.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized the given times.\n */\n/**\n * Check whether a given node is parenthesized or not.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized.\n */\n/**\n * Check whether a given node is parenthesized or not.\n * @param {Node|number} timesOrNode The first parameter.\n * @param {Node|SourceCode} nodeOrSourceCode The second parameter.\n * @param {SourceCode} [optionalSourceCode] The third parameter.\n * @returns {boolean} `true` if the node is parenthesized.\n */\nexport function isParenthesized(\n timesOrNode,\n nodeOrSourceCode,\n optionalSourceCode,\n) {\n /** @type {number} */\n let times,\n /** @type {RuleNode} */\n node,\n /** @type {SourceCode} */\n sourceCode,\n maybeLeftParen,\n maybeRightParen\n if (typeof timesOrNode === \"number\") {\n times = timesOrNode | 0\n node = /** @type {RuleNode} */ (nodeOrSourceCode)\n sourceCode = /** @type {SourceCode} */ (optionalSourceCode)\n if (!(times >= 1)) {\n throw new TypeError(\"'times' should be a positive integer.\")\n }\n } else {\n times = 1\n node = /** @type {RuleNode} */ (timesOrNode)\n sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode)\n }\n\n if (\n node == null ||\n // `Program` can't be parenthesized\n node.parent == null ||\n // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`\n (node.parent.type === \"CatchClause\" && node.parent.param === node)\n ) {\n return false\n }\n\n maybeLeftParen = maybeRightParen = node\n do {\n maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen)\n maybeRightParen = sourceCode.getTokenAfter(maybeRightParen)\n } while (\n maybeLeftParen != null &&\n maybeRightParen != null &&\n isOpeningParenToken(maybeLeftParen) &&\n isClosingParenToken(maybeRightParen) &&\n // Avoid false positive such as `if (a) {}`\n maybeLeftParen !== getParentSyntaxParen(node, sourceCode) &&\n --times > 0\n )\n\n return times === 0\n}\n","/**\n * @author Toru Nagashima \n * See LICENSE file in root directory for full license.\n */\n\nconst placeholder = /\\$(?:[$&`']|[1-9][0-9]?)/gu\n\n/** @type {WeakMap} */\nconst internal = new WeakMap()\n\n/**\n * Check whether a given character is escaped or not.\n * @param {string} str The string to check.\n * @param {number} index The location of the character to check.\n * @returns {boolean} `true` if the character is escaped.\n */\nfunction isEscaped(str, index) {\n let escaped = false\n for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) {\n escaped = !escaped\n }\n return escaped\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {string} replacement The new substring to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceS(matcher, str, replacement) {\n const chunks = []\n let index = 0\n\n /**\n * @param {string} key The placeholder.\n * @param {RegExpExecArray} match The matched information.\n * @returns {string} The replaced string.\n */\n function replacer(key, match) {\n switch (key) {\n case \"$$\":\n return \"$\"\n case \"$&\":\n return match[0]\n case \"$`\":\n return str.slice(0, match.index)\n case \"$'\":\n return str.slice(match.index + match[0].length)\n default: {\n const i = key.slice(1)\n if (i in match) {\n return match[/** @type {any} */ (i)]\n }\n return key\n }\n }\n }\n\n for (const match of matcher.execAll(str)) {\n chunks.push(str.slice(index, match.index))\n chunks.push(\n replacement.replace(placeholder, (key) => replacer(key, match)),\n )\n index = match.index + match[0].length\n }\n chunks.push(str.slice(index))\n\n return chunks.join(\"\")\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceF(matcher, str, replace) {\n const chunks = []\n let index = 0\n\n for (const match of matcher.execAll(str)) {\n chunks.push(str.slice(index, match.index))\n chunks.push(\n String(\n replace(\n .../** @type {[string, ...string[]]} */ (\n /** @type {string[]} */ (match)\n ),\n match.index,\n match.input,\n ),\n ),\n )\n index = match.index + match[0].length\n }\n chunks.push(str.slice(index))\n\n return chunks.join(\"\")\n}\n\n/**\n * The class to find patterns as considering escape sequences.\n */\nexport class PatternMatcher {\n /**\n * Initialize this matcher.\n * @param {RegExp} pattern The pattern to match.\n * @param {{escaped?:boolean}} [options] The options.\n */\n constructor(pattern, options = {}) {\n const { escaped = false } = options\n if (!(pattern instanceof RegExp)) {\n throw new TypeError(\"'pattern' should be a RegExp instance.\")\n }\n if (!pattern.flags.includes(\"g\")) {\n throw new Error(\"'pattern' should contains 'g' flag.\")\n }\n\n internal.set(this, {\n pattern: new RegExp(pattern.source, pattern.flags),\n escaped: Boolean(escaped),\n })\n }\n\n /**\n * Find the pattern in a given string.\n * @param {string} str The string to find.\n * @returns {IterableIterator} The iterator which iterate the matched information.\n */\n *execAll(str) {\n const { pattern, escaped } =\n /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this))\n let match = null\n let lastIndex = 0\n\n pattern.lastIndex = 0\n while ((match = pattern.exec(str)) != null) {\n if (escaped || !isEscaped(str, match.index)) {\n lastIndex = pattern.lastIndex\n yield match\n pattern.lastIndex = lastIndex\n }\n }\n }\n\n /**\n * Check whether the pattern is found in a given string.\n * @param {string} str The string to check.\n * @returns {boolean} `true` if the pattern was found in the string.\n */\n test(str) {\n const it = this.execAll(str)\n const ret = it.next()\n return !ret.done\n }\n\n /**\n * Replace a given string.\n * @param {string} str The string to be replaced.\n * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.\n * @returns {string} The replaced string.\n */\n [Symbol.replace](str, replacer) {\n return typeof replacer === \"function\"\n ? replaceF(this, String(str), replacer)\n : replaceS(this, String(str), String(replacer))\n }\n}\n","import { findVariable } from \"./find-variable.mjs\"\nimport { getPropertyName } from \"./get-property-name.mjs\"\nimport { getStringIfConstant } from \"./get-string-if-constant.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"estree\").Expression} Expression */\n/** @typedef {import(\"estree\").Pattern} Pattern */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n/** @typedef {import(\"estree\").SimpleCallExpression} CallExpression */\n/** @typedef {import(\"estree\").Program} Program */\n/** @typedef {import(\"estree\").ImportDeclaration} ImportDeclaration */\n/** @typedef {import(\"estree\").ExportAllDeclaration} ExportAllDeclaration */\n/** @typedef {import(\"estree\").ExportDefaultDeclaration} ExportDefaultDeclaration */\n/** @typedef {import(\"estree\").ExportNamedDeclaration} ExportNamedDeclaration */\n/** @typedef {import(\"estree\").ImportSpecifier} ImportSpecifier */\n/** @typedef {import(\"estree\").ImportDefaultSpecifier} ImportDefaultSpecifier */\n/** @typedef {import(\"estree\").ImportNamespaceSpecifier} ImportNamespaceSpecifier */\n/** @typedef {import(\"estree\").ExportSpecifier} ExportSpecifier */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").AssignmentProperty} AssignmentProperty */\n/** @typedef {import(\"estree\").Literal} Literal */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Node} TSESTreeNode */\n/** @typedef {import(\"./types.mjs\").ReferenceTrackerOptions} ReferenceTrackerOptions */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMap} TraceMap\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMapObject} TraceMapObject\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TrackedReferences} TrackedReferences\n */\n\nconst IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u\n\n/**\n * Check whether a given node is an import node or not.\n * @param {Node} node\n * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node.\n */\nfunction isHasSource(node) {\n return (\n IMPORT_TYPE.test(node.type) &&\n /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ (\n node\n ).source != null\n )\n}\nconst has =\n /** @type {(traceMap: TraceMap, v: T) => v is (string extends T ? string : T)} */ (\n Function.call.bind(Object.hasOwnProperty)\n )\n\nexport const READ = Symbol(\"read\")\nexport const CALL = Symbol(\"call\")\nexport const CONSTRUCT = Symbol(\"construct\")\nexport const ESM = Symbol(\"esm\")\n\nconst requireCall = { require: { [CALL]: true } }\n\n/**\n * Check whether a given variable is modified or not.\n * @param {Variable|undefined} variable The variable to check.\n * @returns {boolean} `true` if the variable is modified.\n */\nfunction isModifiedGlobal(variable) {\n return (\n variable == null ||\n variable.defs.length !== 0 ||\n variable.references.some((r) => r.isWrite())\n )\n}\n\n/**\n * Check if the value of a given node is passed through to the parent syntax as-is.\n * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.\n * @param {Node} node A node to check.\n * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through.\n */\nfunction isPassThrough(node) {\n const parent = /** @type {TSESTreeNode} */ (node).parent\n\n if (parent) {\n switch (parent.type) {\n case \"ConditionalExpression\":\n return parent.consequent === node || parent.alternate === node\n case \"LogicalExpression\":\n return true\n case \"SequenceExpression\":\n return (\n parent.expressions[parent.expressions.length - 1] === node\n )\n case \"ChainExpression\":\n return true\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n case \"TSInstantiationExpression\":\n return true\n\n default:\n return false\n }\n }\n return false\n}\n\n/**\n * The reference tracker.\n */\nexport class ReferenceTracker {\n /**\n * Initialize this tracker.\n * @param {Scope} globalScope The global scope.\n * @param {object} [options] The options.\n * @param {\"legacy\"|\"strict\"} [options.mode=\"strict\"] The mode to determine the ImportDeclaration's behavior for CJS modules.\n * @param {string[]} [options.globalObjectNames=[\"global\",\"globalThis\",\"self\",\"window\"]] The variable names for Global Object.\n */\n constructor(globalScope, options = {}) {\n const {\n mode = \"strict\",\n globalObjectNames = [\"global\", \"globalThis\", \"self\", \"window\"],\n } = options\n /** @private @type {Variable[]} */\n this.variableStack = []\n /** @private */\n this.globalScope = globalScope\n /** @private */\n this.mode = mode\n /** @private */\n this.globalObjectNames = globalObjectNames.slice(0)\n }\n\n /**\n * Iterate the references of global variables.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateGlobalReferences(traceMap) {\n for (const key of Object.keys(traceMap)) {\n const nextTraceMap = traceMap[key]\n const path = [key]\n const variable = this.globalScope.set.get(key)\n\n if (isModifiedGlobal(variable)) {\n continue\n }\n\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (variable),\n path,\n nextTraceMap,\n true,\n )\n }\n\n for (const key of this.globalObjectNames) {\n /** @type {string[]} */\n const path = []\n const variable = this.globalScope.set.get(key)\n\n if (isModifiedGlobal(variable)) {\n continue\n }\n\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (variable),\n path,\n traceMap,\n false,\n )\n }\n }\n\n /**\n * Iterate the references of CommonJS modules.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateCjsReferences(traceMap) {\n for (const { node } of this.iterateGlobalReferences(requireCall)) {\n const key = getStringIfConstant(\n /** @type {CallExpression} */ (node).arguments[0],\n )\n if (key == null || !has(traceMap, key)) {\n continue\n }\n\n const nextTraceMap = traceMap[key]\n const path = [key]\n\n if (nextTraceMap[READ]) {\n yield {\n node,\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iteratePropertyReferences(\n /** @type {CallExpression} */ (node),\n path,\n nextTraceMap,\n )\n }\n }\n\n /**\n * Iterate the references of ES modules.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateEsmReferences(traceMap) {\n const programNode = /** @type {Program} */ (this.globalScope.block)\n\n for (const node of programNode.body) {\n if (!isHasSource(node)) {\n continue\n }\n const moduleId = /** @type {string} */ (node.source.value)\n\n if (!has(traceMap, moduleId)) {\n continue\n }\n const nextTraceMap = traceMap[moduleId]\n const path = [moduleId]\n\n if (nextTraceMap[READ]) {\n yield {\n // eslint-disable-next-line object-shorthand -- apply type\n node: /** @type {RuleNode} */ (node),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n\n if (node.type === \"ExportAllDeclaration\") {\n for (const key of Object.keys(nextTraceMap)) {\n const exportTraceMap = nextTraceMap[key]\n if (exportTraceMap[READ]) {\n yield {\n // eslint-disable-next-line object-shorthand -- apply type\n node: /** @type {RuleNode} */ (node),\n path: path.concat(key),\n type: READ,\n info: exportTraceMap[READ],\n }\n }\n }\n } else {\n for (const specifier of node.specifiers) {\n const esm = has(nextTraceMap, ESM)\n const it = this._iterateImportReferences(\n specifier,\n path,\n esm\n ? nextTraceMap\n : this.mode === \"legacy\"\n ? { default: nextTraceMap, ...nextTraceMap }\n : { default: nextTraceMap },\n )\n\n if (esm) {\n yield* it\n } else {\n for (const report of it) {\n report.path = report.path.filter(exceptDefault)\n if (\n report.path.length >= 2 ||\n report.type !== READ\n ) {\n yield report\n }\n }\n }\n }\n }\n }\n }\n\n /**\n * Iterate the property references for a given expression AST node.\n * @template T\n * @param {Expression} node The expression AST node to iterate property references.\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate property references.\n */\n *iteratePropertyReferences(node, traceMap) {\n yield* this._iteratePropertyReferences(node, [], traceMap)\n }\n\n /**\n * Iterate the references for a given variable.\n * @private\n * @template T\n * @param {Variable} variable The variable to iterate that references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @param {boolean} shouldReport = The flag to report those references.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateVariableReferences(variable, path, traceMap, shouldReport) {\n if (this.variableStack.includes(variable)) {\n return\n }\n this.variableStack.push(variable)\n try {\n for (const reference of variable.references) {\n if (!reference.isRead()) {\n continue\n }\n const node = /** @type {RuleNode & Identifier} */ (\n reference.identifier\n )\n\n if (shouldReport && traceMap[READ]) {\n yield { node, path, type: READ, info: traceMap[READ] }\n }\n yield* this._iteratePropertyReferences(node, path, traceMap)\n }\n } finally {\n this.variableStack.pop()\n }\n }\n\n /**\n * Iterate the references for a given AST node.\n * @private\n * @template T\n * @param {Expression} rootNode The AST node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n //eslint-disable-next-line complexity\n *_iteratePropertyReferences(rootNode, path, traceMap) {\n let node = rootNode\n while (isPassThrough(node)) {\n node = node.parent\n }\n\n const parent = /** @type {RuleNode} */ (node).parent\n if (!parent) {\n return\n }\n if (parent.type === \"MemberExpression\") {\n if (parent.object === node) {\n const key = getPropertyName(parent)\n if (key == null || !has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: parent,\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iteratePropertyReferences(\n parent,\n path,\n nextTraceMap,\n )\n }\n return\n }\n if (parent.type === \"CallExpression\") {\n if (parent.callee === node && traceMap[CALL]) {\n yield { node: parent, path, type: CALL, info: traceMap[CALL] }\n }\n return\n }\n if (parent.type === \"NewExpression\") {\n if (parent.callee === node && traceMap[CONSTRUCT]) {\n yield {\n node: parent,\n path,\n type: CONSTRUCT,\n info: traceMap[CONSTRUCT],\n }\n }\n return\n }\n if (parent.type === \"AssignmentExpression\") {\n if (parent.right === node) {\n yield* this._iterateLhsReferences(parent.left, path, traceMap)\n yield* this._iteratePropertyReferences(parent, path, traceMap)\n }\n return\n }\n if (parent.type === \"AssignmentPattern\") {\n if (parent.right === node) {\n yield* this._iterateLhsReferences(parent.left, path, traceMap)\n }\n return\n }\n if (parent.type === \"VariableDeclarator\") {\n if (parent.init === node) {\n yield* this._iterateLhsReferences(parent.id, path, traceMap)\n }\n }\n }\n\n /**\n * Iterate the references for a given Pattern node.\n * @private\n * @template T\n * @param {Pattern} patternNode The Pattern node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateLhsReferences(patternNode, path, traceMap) {\n if (patternNode.type === \"Identifier\") {\n const variable = findVariable(this.globalScope, patternNode)\n if (variable != null) {\n yield* this._iterateVariableReferences(\n variable,\n path,\n traceMap,\n false,\n )\n }\n return\n }\n if (patternNode.type === \"ObjectPattern\") {\n for (const property of patternNode.properties) {\n const key = getPropertyName(\n /** @type {AssignmentProperty} */ (property),\n )\n\n if (key == null || !has(traceMap, key)) {\n continue\n }\n\n const nextPath = path.concat(key)\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (property),\n path: nextPath,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iterateLhsReferences(\n /** @type {AssignmentProperty} */ (property).value,\n nextPath,\n nextTraceMap,\n )\n }\n return\n }\n if (patternNode.type === \"AssignmentPattern\") {\n yield* this._iterateLhsReferences(patternNode.left, path, traceMap)\n }\n }\n\n /**\n * Iterate the references for a given ModuleSpecifier node.\n * @private\n * @template T\n * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateImportReferences(specifierNode, path, traceMap) {\n const type = specifierNode.type\n\n if (type === \"ImportSpecifier\" || type === \"ImportDefaultSpecifier\") {\n const key =\n type === \"ImportDefaultSpecifier\"\n ? \"default\"\n : specifierNode.imported.type === \"Identifier\"\n ? specifierNode.imported.name\n : specifierNode.imported.value\n if (!has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (specifierNode),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (\n findVariable(this.globalScope, specifierNode.local)\n ),\n path,\n nextTraceMap,\n false,\n )\n\n return\n }\n\n if (type === \"ImportNamespaceSpecifier\") {\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (\n findVariable(this.globalScope, specifierNode.local)\n ),\n path,\n traceMap,\n false,\n )\n return\n }\n\n if (type === \"ExportSpecifier\") {\n const key =\n specifierNode.local.type === \"Identifier\"\n ? specifierNode.local.name\n : specifierNode.local.value\n if (!has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (specifierNode),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n }\n }\n}\n\nReferenceTracker.READ = READ\nReferenceTracker.CALL = CALL\nReferenceTracker.CONSTRUCT = CONSTRUCT\nReferenceTracker.ESM = ESM\n\n/**\n * This is a predicate function for Array#filter.\n * @param {string} name A name part.\n * @param {number} index The index of the name.\n * @returns {boolean} `false` if it's default.\n */\nfunction exceptDefault(name, index) {\n return !(index === 1 && name === \"default\")\n}\n","/** @typedef {import(\"./types.mjs\").StaticValue} StaticValue */\n/** @typedef {import(\"./types.mjs\").StaticValueOptional} StaticValueOptional */\n/** @typedef {import(\"./types.mjs\").StaticValueProvided} StaticValueProvided */\n/** @typedef {import(\"./types.mjs\").ReferenceTrackerOptions} ReferenceTrackerOptions */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMap} TraceMap\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TrackedReferences} TrackedReferences\n */\n/** @typedef {import(\"./types.mjs\").HasSideEffectOptions} HasSideEffectOptions */\n/** @typedef {import(\"./types.mjs\").ArrowToken} ArrowToken */\n/** @typedef {import(\"./types.mjs\").CommaToken} CommaToken */\n/** @typedef {import(\"./types.mjs\").SemicolonToken} SemicolonToken */\n/** @typedef {import(\"./types.mjs\").ColonToken} ColonToken */\n/** @typedef {import(\"./types.mjs\").OpeningParenToken} OpeningParenToken */\n/** @typedef {import(\"./types.mjs\").ClosingParenToken} ClosingParenToken */\n/** @typedef {import(\"./types.mjs\").OpeningBracketToken} OpeningBracketToken */\n/** @typedef {import(\"./types.mjs\").ClosingBracketToken} ClosingBracketToken */\n/** @typedef {import(\"./types.mjs\").OpeningBraceToken} OpeningBraceToken */\n/** @typedef {import(\"./types.mjs\").ClosingBraceToken} ClosingBraceToken */\n\nimport { findVariable } from \"./find-variable.mjs\"\nimport { getFunctionHeadLocation } from \"./get-function-head-location.mjs\"\nimport { getFunctionNameWithKind } from \"./get-function-name-with-kind.mjs\"\nimport { getInnermostScope } from \"./get-innermost-scope.mjs\"\nimport { getPropertyName } from \"./get-property-name.mjs\"\nimport { getStaticValue } from \"./get-static-value.mjs\"\nimport { getStringIfConstant } from \"./get-string-if-constant.mjs\"\nimport { hasSideEffect } from \"./has-side-effect.mjs\"\nimport { isParenthesized } from \"./is-parenthesized.mjs\"\nimport { PatternMatcher } from \"./pattern-matcher.mjs\"\nimport {\n CALL,\n CONSTRUCT,\n ESM,\n READ,\n ReferenceTracker,\n} from \"./reference-tracker.mjs\"\nimport {\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isSemicolonToken,\n} from \"./token-predicate.mjs\"\n\nexport default {\n CALL,\n CONSTRUCT,\n ESM,\n findVariable,\n getFunctionHeadLocation,\n getFunctionNameWithKind,\n getInnermostScope,\n getPropertyName,\n getStaticValue,\n getStringIfConstant,\n hasSideEffect,\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isParenthesized,\n isSemicolonToken,\n PatternMatcher,\n READ,\n ReferenceTracker,\n}\nexport {\n CALL,\n CONSTRUCT,\n ESM,\n findVariable,\n getFunctionHeadLocation,\n getFunctionNameWithKind,\n getInnermostScope,\n getPropertyName,\n getStaticValue,\n getStringIfConstant,\n hasSideEffect,\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isParenthesized,\n isSemicolonToken,\n PatternMatcher,\n READ,\n ReferenceTracker,\n}\n"],"names":["getKeys","KEYS"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,iBAAiB,CAAC,YAAY,EAAE,IAAI,EAAE;AACtD,IAAI,MAAM,QAAQ,mCAAmC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAC;AACpE;AACA,IAAI,IAAI,KAAK,GAAG,aAAY;AAC5B,IAAI,IAAI,KAAK,GAAG,MAAK;AACrB,IAAI,GAAG;AACP,QAAQ,KAAK,GAAG,MAAK;AACrB,QAAQ,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE;AACpD,YAAY,MAAM,KAAK;AACvB,gBAAgB,UAAU,CAAC,KAAK,CAAC,KAAK;AACtC,cAAa;AACb;AACA,YAAY,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,QAAQ,IAAI,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE;AAC7D,gBAAgB,KAAK,GAAG,WAAU;AAClC,gBAAgB,KAAK,GAAG,KAAI;AAC5B,gBAAgB,KAAK;AACrB,aAAa;AACb,SAAS;AACT,KAAK,QAAQ,KAAK,CAAC;AACnB;AACA,IAAI,OAAO,KAAK;AAChB;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,YAAY,EAAE,UAAU,EAAE;AACvD,IAAI,IAAI,IAAI,GAAG,GAAE;AACjB;AACA,IAAI,IAAI,KAAK,GAAG,aAAY;AAC5B;AACA,IAAI,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;AACxC,QAAQ,IAAI,GAAG,WAAU;AACzB,KAAK,MAAM;AACX,QAAQ,IAAI,GAAG,UAAU,CAAC,KAAI;AAC9B,QAAQ,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAC;AACpD,KAAK;AACL;AACA,IAAI,OAAO,KAAK,IAAI,IAAI,EAAE;AAC1B,QAAQ,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAC;AAC5C,QAAQ,IAAI,QAAQ,IAAI,IAAI,EAAE;AAC9B,YAAY,OAAO,QAAQ;AAC3B,SAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,MAAK;AAC3B,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,CAAC,EAAE;AACnB,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,0BAA0B,CAAC,KAAK,EAAE,KAAK,EAAE;AAClD,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK;AAC/D,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC;AAClD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gBAAgB,CAAC,KAAK,EAAE;AACxC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,qBAAqB,CAAC,KAAK,EAAE;AAC7C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,qBAAqB,CAAC,KAAK,EAAE;AAC7C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,KAAK,EAAE;AACtC,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC;AAC5D,CAAC;AACD;AACY,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAC;AAC/C,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,wBAAwB,GAAG,MAAM,CAAC,qBAAqB,EAAC;AACzD,MAAC,wBAAwB,GAAG,MAAM,CAAC,qBAAqB,EAAC;AACzD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,iBAAiB,GAAG,MAAM,CAAC,cAAc;;ACnJtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AACnD,IAAI,OAAO,IAAI,CAAC,EAAE;AAClB;AACA,cAAc,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,EAAE,mBAAmB,CAAC;AACpE;AACA;AACA,cAAc,UAAU,CAAC,aAAa,CAAC,IAAI,EAAE,mBAAmB,CAAC;AACjE,WAAW;AACX,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AAC1D,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA;AACA,IAAI,IAAI,KAAK,GAAG,KAAI;AACpB;AACA,IAAI,IAAI,GAAG,GAAG,KAAI;AAClB;AACA,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,yBAAyB,EAAE;AACjD,QAAQ,MAAM,UAAU;AACxB,YAAY,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;AAC9D,UAAS;AACT;AACA,QAAQ,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,MAAK;AACpC,QAAQ,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,IAAG;AAChC,KAAK,MAAM;AACX,QAAQ,MAAM;AACd,SAAS,MAAM,CAAC,IAAI,KAAK,UAAU;AACnC,YAAY,MAAM,CAAC,IAAI,KAAK,kBAAkB;AAC9C,YAAY,MAAM,CAAC,IAAI,KAAK,oBAAoB,CAAC;AACjD,MAAM;AACN,QAAQ,KAAK,iCAAiC,CAAC,MAAM,CAAC,GAAG,EAAE,MAAK;AAChE,QAAQ,GAAG,GAAG,uBAAuB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,MAAK;AACjE,KAAK,MAAM;AACX,QAAQ,KAAK,iCAAiC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAK;AAC9D,QAAQ,GAAG,GAAG,uBAAuB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,MAAK;AACjE,KAAK;AACL;AACA,IAAI,OAAO;AACX,QAAQ,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE;AAC3B,QAAQ,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE;AACvB,KAAK;AACL;;AChEA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,YAAY;AAClB,IAAI,OAAO,UAAU,KAAK,WAAW;AACrC,UAAU,UAAU;AACpB;AACA,QAAQ,OAAO,IAAI,KAAK,WAAW;AACnC;AACA,UAAU,IAAI;AACd;AACA,QAAQ,OAAO,MAAM,KAAK,WAAW;AACrC;AACA,UAAU,MAAM;AAChB,UAAU,OAAO,MAAM,KAAK,WAAW;AACvC,UAAU,MAAM;AAChB,UAAU,GAAE;AACZ;AACA,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM;AAClC,IAAI,IAAI,GAAG,CAAC;AACZ,QAAQ,OAAO;AACf,QAAQ,aAAa;AACrB,QAAQ,QAAQ;AAChB,QAAQ,eAAe;AACvB,QAAQ,gBAAgB;AACxB,QAAQ,SAAS;AACjB,QAAQ,UAAU;AAClB,QAAQ,MAAM;AACd,QAAQ,WAAW;AACnB,QAAQ,oBAAoB;AAC5B,QAAQ,WAAW;AACnB,QAAQ,oBAAoB;AAC5B,QAAQ,QAAQ;AAChB,QAAQ,cAAc;AACtB,QAAQ,cAAc;AACtB,QAAQ,UAAU;AAClB,QAAQ,UAAU;AAClB,QAAQ,YAAY;AACpB,QAAQ,YAAY;AACpB,QAAQ,WAAW;AACnB,QAAQ,UAAU;AAClB,QAAQ,OAAO;AACf,QAAQ,eAAe;AACvB,QAAQ,MAAM;AACd,QAAQ,KAAK;AACb,QAAQ,MAAM;AACd,QAAQ,KAAK;AACb,QAAQ,QAAQ;AAChB,QAAQ,QAAQ;AAChB,QAAQ,YAAY;AACpB,QAAQ,UAAU;AAClB,QAAQ,SAAS;AACjB,QAAQ,OAAO;AACf,QAAQ,SAAS;AACjB,QAAQ,QAAQ;AAChB,QAAQ,KAAK;AACb,QAAQ,QAAQ;AAChB,QAAQ,QAAQ;AAChB,QAAQ,aAAa;AACrB,QAAQ,aAAa;AACrB,QAAQ,YAAY;AACpB,QAAQ,mBAAmB;AAC3B,QAAQ,WAAW;AACnB,QAAQ,UAAU;AAClB,QAAQ,SAAS;AACjB,QAAQ,SAAS;AACjB,KAAK,CAAC;AACN,EAAC;AACD,MAAM,WAAW,GAAG,IAAI,GAAG;AAC3B,IAAI;AACJ,QAAQ,KAAK,CAAC,OAAO;AACrB,QAAQ,KAAK,CAAC,EAAE;AAChB,QAAQ,KAAK,CAAC,SAAS,CAAC,EAAE;AAC1B,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,KAAK,CAAC,SAAS,CAAC,OAAO;AAC/B,QAAQ,KAAK,CAAC,SAAS,CAAC,KAAK;AAC7B,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,SAAS;AACjC,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,QAAQ;AAChC,QAAQ,KAAK,CAAC,SAAS,CAAC,OAAO;AAC/B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,WAAW;AACnC,QAAQ,KAAK,CAAC,SAAS,CAAC,KAAK;AAC7B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,QAAQ;AAChC,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,OAAO,MAAM,KAAK,UAAU,GAAG,MAAM,GAAG,SAAS;AACzD,QAAQ,OAAO;AACf,QAAQ,IAAI;AACZ,QAAQ,IAAI,CAAC,KAAK;AAClB,QAAQ,SAAS;AACjB,QAAQ,kBAAkB;AAC1B,QAAQ,SAAS;AACjB,QAAQ,kBAAkB;AAC1B,QAAQ,MAAM;AACd,QAAQ,QAAQ;AAChB,QAAQ,KAAK;AACb;AACA,QAAQ,aAAa;AACrB,QAAQ,GAAG;AACX,QAAQ,GAAG,CAAC,SAAS,CAAC,OAAO;AAC7B,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,IAAI;AAC1B,QAAQ,GAAG,CAAC,SAAS,CAAC,MAAM;AAC5B,QAAQ,wCAAwC;AAChD,YAAY,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC;AAC5C;AACA,aAAa,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC;AAC1C,aAAa,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;AAChC,aAAa,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,UAAU,CAAC;AACnD,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,KAAK;AACpB,QAAQ,MAAM,CAAC,UAAU;AACzB,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,SAAS,CAAC,aAAa;AACtC,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,OAAO;AACtB,QAAQ,MAAM,CAAC,EAAE;AACjB,QAAQ,MAAM,CAAC,YAAY;AAC3B,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,IAAI;AACnB,QAAQ,MAAM,CAAC,MAAM;AACrB,QAAQ,UAAU;AAClB,QAAQ,QAAQ;AAChB,QAAQ,MAAM;AACd,QAAQ,GAAG;AACX,QAAQ,GAAG,CAAC,SAAS,CAAC,OAAO;AAC7B,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,IAAI;AAC1B,QAAQ,GAAG,CAAC,SAAS,CAAC,MAAM;AAC5B,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,YAAY;AAC3B,QAAQ,MAAM,CAAC,aAAa;AAC5B,QAAQ,MAAM,CAAC,GAAG;AAClB,QAAQ,MAAM,CAAC,SAAS,CAAC,EAAE;AAC3B,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,UAAU;AACnC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,KAAK;AAC9B,QAAQ,MAAM,CAAC,SAAS,CAAC,UAAU;AACnC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,IAAI;AAC7B,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,GAAG;AAClB,QAAQ,MAAM,CAAC,MAAM;AACrB,QAAQ,QAAQ;AAChB,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,UAAU,CAAC;AAC5C,EAAC;AACD,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;AAChC,IAAI,MAAM,CAAC,MAAM;AACjB,IAAI,MAAM,CAAC,iBAAiB;AAC5B,IAAI,MAAM,CAAC,IAAI;AACf,CAAC,EAAC;AACF;AACA;AACA,MAAM,aAAa,GAAG;AACtB,IAAI,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5B,IAAI;AACJ,QAAQ,MAAM;AACd,QAAQ,IAAI,GAAG,CAAC;AAChB,YAAY,QAAQ;AACpB,YAAY,OAAO;AACnB,YAAY,QAAQ;AACpB,YAAY,YAAY;AACxB,YAAY,YAAY;AACxB,YAAY,WAAW;AACvB,YAAY,QAAQ;AACpB,YAAY,QAAQ;AACpB,YAAY,SAAS;AACrB,SAAS,CAAC;AACV,KAAK;AACL,IAAI,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5B,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAE;AAC7C,IAAI,IAAI,CAAC,GAAG,OAAM;AAClB,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,UAAU,KAAK,CAAC,KAAK,IAAI,EAAE;AAC7E,QAAQ,MAAM,CAAC,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAC;AAC1D,QAAQ,IAAI,CAAC,EAAE;AACf,YAAY,OAAO,CAAC;AACpB,SAAS;AACT,QAAQ,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,EAAC;AACpC,KAAK;AACL,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE;AAChC,IAAI,MAAM,CAAC,GAAG,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAC;AACjD,IAAI,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI;AACrC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE;AAClD,IAAI,MAAM,SAAS,GAAG,GAAE;AACxB;AACA,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;AAC9C,QAAQ,MAAM,WAAW,GAAG,QAAQ,CAAC,CAAC,EAAC;AACvC;AACA,QAAQ,IAAI,WAAW,IAAI,IAAI,EAAE;AACjC,YAAY,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,EAAC;AACpC,SAAS,MAAM,IAAI,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE;AACzD,YAAY,MAAM,QAAQ,GAAG,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAC;AAChF,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,SAAS,CAAC,IAAI,CAAC,iCAAiC,QAAQ,CAAC,KAAK,CAAC,EAAC;AAC5E,SAAS,MAAM;AACf,YAAY,MAAM,OAAO,GAAG,eAAe,CAAC,WAAW,EAAE,YAAY,EAAC;AACtE,YAAY,IAAI,OAAO,IAAI,IAAI,EAAE;AACjC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAC;AACzC,SAAS;AACT,KAAK;AACL;AACA,IAAI,OAAO,SAAS;AACpB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,QAAQ,EAAE;AACnC,IAAI;AACJ,QAAQ,QAAQ,IAAI,IAAI;AACxB,QAAQ,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;AAClC,QAAQ,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;AACvC,QAAQ,QAAQ,CAAC,IAAI,IAAI,YAAY;AACrC,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,oBAAoB,CAAC,QAAQ,EAAE;AACxC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;AACpC,QAAQ,OAAO,KAAK;AACpB,KAAK;AACL,IAAI,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC;AAChC,IAAI,OAAO,OAAO;AAClB,QAAQ,GAAG,CAAC,MAAM;AAClB,YAAY,GAAG,CAAC,IAAI,KAAK,UAAU;AACnC,aAAa,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,IAAI,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AACzE,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,kBAAkB,CAAC,QAAQ,EAAE;AACtC,IAAI,MAAM,IAAI,GAAG,QAAQ,CAAC,WAAU;AACpC;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,OAAM;AACnD,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,OAAM;AAC3D,IAAI,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,GAAG,KAAK,KAAK,IAAI,CAAC,MAAM,EAAE;AACtD;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL,IAAI,OAAO,KAAK;AAChB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,QAAQ,EAAE,YAAY,EAAE;AACvD,IAAI,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,UAAU,EAAE;AAC3C,QAAQ,IAAI,IAAI,gCAAgC,GAAG,CAAC,UAAU,EAAC;AAC/D,QAAQ,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE;AAC/E,YAAY,IAAI,GAAG,IAAI,CAAC,OAAM;AAC9B,SAAS;AACT,QAAQ,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AACnC,YAAY,QAAQ;AACpB,SAAS;AACT,QAAQ;AACR,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;AACxD,gBAAgB,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI;AACzC,aAAa,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;AACpD,gBAAgB,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,IAAI,CAAC;AAC9C,UAAU;AACV;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ;AACR,YAAY,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,gBAAgB;AACjD,YAAY,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI;AACvC,YAAY,IAAI,CAAC,IAAI,KAAK,kBAAkB;AAC5C,UAAU;AACV,YAAY,MAAM,UAAU,GAAG,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7E,YAAY,IAAI,2BAA2B,CAAC,UAAU,CAAC,EAAE;AACzD;AACA,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,SAAS;AACT,KAAK;AACL,IAAI,OAAO,KAAK;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,2BAA2B,CAAC,UAAU,EAAE;AACrD,QAAQ,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,KAAK,IAAI,IAAI,EAAE;AAC5D,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,MAAM,IAAI,GAAG,UAAU,CAAC,MAAK;AACrC,QAAQ;AACR,YAAY,IAAI,KAAK,YAAY;AACjC,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,KAAK;AAC1B,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,SAAS;AAC9B,YAAY,IAAI,KAAK,OAAO;AAC5B,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,QAAQ;AAC7B,YAAY,IAAI,KAAK,SAAS;AAC9B,SAAS;AACT,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC;AACjC,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAC;AACtE,QAAQ,OAAO,QAAQ,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI;AAC5D,KAAK;AACL;AACA,IAAI,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC7C,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE;AACnC,YAAY,OAAO,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC;AAC5D,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY,EAAE;AACtE;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAC;AAC/D,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,EAAE;AAC3C,YAAY,QAAQ,IAAI,CAAC,QAAQ;AACjC,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;AAC/D,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;AAC/D,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE;AAChE,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE;AAChE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE;AACvC,QAAQ,MAAM,UAAU,GAAG,IAAI,CAAC,OAAM;AACtC,QAAQ,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,EAAC;AACnE;AACA,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY,IAAI,UAAU,CAAC,IAAI,KAAK,kBAAkB,EAAE;AACxD,gBAAgB,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACtE,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,MAAM,GAAG,eAAe,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,EAAC;AAC/E,gBAAgB,IAAI,MAAM,IAAI,IAAI,EAAE;AACpC,oBAAoB;AACpB,wBAAwB,MAAM,CAAC,KAAK,IAAI,IAAI;AAC5C,yBAAyB,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;AAC1D,sBAAsB;AACtB,wBAAwB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AACnE,qBAAqB;AACrB,oBAAoB,MAAM,QAAQ,GAAG,0BAA0B;AAC/D,wBAAwB,UAAU;AAClC,wBAAwB,YAAY;AACpC,sBAAqB;AACrB;AACA,oBAAoB,IAAI,QAAQ,IAAI,IAAI,EAAE;AAC1C,wBAAwB,MAAM,QAAQ;AACtC;AACA,gCAAgC,MAAM,CAAC,KAAK;AAC5C,8BAA6B;AAC7B,wBAAwB,MAAM,UAAU;AACxC,4BAA4B,QAAQ,CAAC,KAAK;AAC1C,0BAAyB;AACzB,wBAAwB,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE;AACnE,4BAA4B,OAAO;AACnC,gCAAgC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC;AACpE,6BAA6B;AAC7B,yBAAyB;AACzB,wBAAwB,IAAI,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE;AACvE,4BAA4B,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE;AACrD,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa,MAAM;AACnB,gBAAgB,MAAM,MAAM,GAAG,eAAe,CAAC,UAAU,EAAE,YAAY,EAAC;AACxE,gBAAgB,IAAI,MAAM,IAAI,IAAI,EAAE;AACpC,oBAAoB,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/D,wBAAwB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AACnE,qBAAqB;AACrB,oBAAoB,MAAM,IAAI;AAC9B,wBAAwB,MAAM,CAAC,KAAK;AACpC,sBAAqB;AACrB,oBAAoB,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AAC/C,wBAAwB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE;AACvD,qBAAqB;AACrB,oBAAoB,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACnD,wBAAwB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE;AACjD,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC9C,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY,OAAO,IAAI,CAAC,KAAK;AAC7B,kBAAkB,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAChE,kBAAkB,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC;AAC/D,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC5C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL;AACA,IAAI,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE;AACnC,QAAQ,IAAI,YAAY,IAAI,IAAI,EAAE;AAClC,YAAY,MAAM,QAAQ,GAAG,YAAY,CAAC,YAAY,EAAE,IAAI,EAAC;AAC7D;AACA,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC;AACA,gBAAgB,IAAI,eAAe,CAAC,QAAQ,CAAC,EAAE;AAC/C,oBAAoB,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACjE,iBAAiB;AACjB;AACA;AACA,gBAAgB,IAAI,oBAAoB,CAAC,QAAQ,CAAC,EAAE;AACpD,oBAAoB,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC;AAChD,oBAAoB;AACpB;AACA,wBAAwB,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,YAAY;AACzD,sBAAsB;AACtB,wBAAwB,MAAM,IAAI,GAAG,eAAe;AACpD,4BAA4B,GAAG,CAAC,IAAI,CAAC,IAAI;AACzC,4BAA4B,YAAY;AACxC,0BAAyB;AACzB,wBAAwB;AACxB,4BAA4B,IAAI;AAChC,4BAA4B,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ;AAC1D,4BAA4B,IAAI,CAAC,KAAK,KAAK,IAAI;AAC/C,0BAA0B;AAC1B,4BAA4B,IAAI,qBAAqB,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE;AAC/E;AACA,gCAAgC,OAAO,IAAI;AAC3C,6BAA6B;AAC7B,yBAAyB;AACzB,wBAAwB,OAAO,IAAI;AACnC,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,OAAO,CAAC,IAAI,EAAE;AAClB,QAAQ,MAAM,OAAO;AACrB;AACA,gBAAgB,IAAI;AACpB,cAAa;AACb;AACA,QAAQ;AACR,YAAY,CAAC,OAAO,CAAC,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,MAAM,IAAI,IAAI;AAC5D,YAAY,OAAO,CAAC,KAAK,IAAI,IAAI;AACjC,UAAU;AACV;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;AACvC,KAAK;AACL;AACA,IAAI,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC1C,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY;AACZ,gBAAgB,CAAC,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI;AACvE,iBAAiB,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AACzE,iBAAiB,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;AAC9D,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb;AACA,YAAY,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAC;AACnE,YAAY,IAAI,KAAK,IAAI,IAAI,EAAE;AAC/B,gBAAgB,OAAO,KAAK;AAC5B,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACxD,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAC;AACjE,QAAQ,IAAI,MAAM,IAAI,IAAI,EAAE;AAC5B,YAAY,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,KAAK,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC5E,gBAAgB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AAC3D,aAAa;AACb,YAAY,MAAM,QAAQ,GAAG,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAC;AAC3E;AACA,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB;AAChB,oBAAoB,CAAC,QAAQ;AAC7B,+CAA+C,MAAM,CAAC,KAAK;AAC3D,oDAAoD,QAAQ,CAAC,KAAK;AAClE,qBAAqB;AACrB,kBAAkB;AAClB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK,8CAA8C;AAC3E,4BAA4B,MAAM,CAAC,KAAK;AACxC,sDAAsD,QAAQ,CAAC,KAAK,EAAE;AACtE,qBAAqB;AACrB,iBAAiB;AACjB;AACA,gBAAgB,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,aAAa,EAAE;AAChE,oBAAoB;AACpB,wBAAwB,MAAM,CAAC,KAAK,YAAY,OAAO;AACvD,wBAAwB,OAAO,CAAC,GAAG,wBAAwB,QAAQ,CAAC,KAAK,EAAE;AAC3E,sBAAsB;AACtB,wBAAwB,OAAO;AAC/B,4BAA4B,KAAK,8CAA8C;AAC/E,gCAAgC,MAAM,CAAC,KAAK;AAC5C,0DAA0D,QAAQ,CAAC,KAAK,EAAE;AAC1E,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,EAAC;AACzE,QAAQ,IAAI,UAAU,IAAI,IAAI,EAAE;AAChC,YAAY,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE;AAC9C,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE;AACtC,QAAQ,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAC;AACjE,QAAQ,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,EAAC;AACnE;AACA,QAAQ,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE;AAC5C,YAAY,MAAM,IAAI;AACtB,gBAAgB,MAAM,CAAC,KAAK;AAC5B,cAAa;AACb,YAAY,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACvC,gBAAgB,OAAO,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE;AACnD,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC;AACA,QAAQ,MAAM,MAAM,GAAG,GAAE;AACzB;AACA,QAAQ,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,UAAU,EAAE;AACpD,YAAY,IAAI,YAAY,CAAC,IAAI,KAAK,UAAU,EAAE;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,KAAK,MAAM,EAAE;AAClD,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,GAAG,GAAG,0BAA0B;AACtD,oBAAoB,YAAY;AAChC,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,gBAAgB,MAAM,KAAK,GAAG,eAAe,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,EAAC;AAC/E,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,EAAE;AAClD,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,6BAA6B,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,MAAK;AAC5E,aAAa,MAAM;AACnB,gBAAgB,YAAY,CAAC,IAAI,KAAK,eAAe;AACrD;AACA,gBAAgB,YAAY,CAAC,IAAI,KAAK,4BAA4B;AAClE,cAAc;AACd,gBAAgB,MAAM,QAAQ,GAAG,eAAe;AAChD,oBAAoB,YAAY,CAAC,QAAQ;AACzC,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,gBAAgB,IAAI,QAAQ,IAAI,IAAI,EAAE;AACtC,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,EAAC;AACrD,aAAa,MAAM;AACnB,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE;AAChC,KAAK;AACL;AACA,IAAI,kBAAkB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC3C,QAAQ,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAC;AAClE,QAAQ,OAAO,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC;AAClD,KAAK;AACL;AACA,IAAI,wBAAwB,CAAC,IAAI,EAAE,YAAY,EAAE;AACjD,QAAQ,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,EAAC;AAC3D,QAAQ,MAAM,WAAW,GAAG,gBAAgB;AAC5C,YAAY,IAAI,CAAC,KAAK,CAAC,WAAW;AAClC,YAAY,YAAY;AACxB,UAAS;AACT;AACA,QAAQ,IAAI,GAAG,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,EAAE;AAChD,YAAY,MAAM,IAAI,2CAA2C,GAAG,CAAC,KAAK,EAAC;AAC3E;AACA,YAAY,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,EAAC;AACxE,YAAY,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,EAAC;AACnE;AACA,YAAY,IAAI,IAAI,KAAK,MAAM,CAAC,GAAG,EAAE;AACrC,gBAAgB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,WAAW,CAAC,EAAE;AAC/D,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,EAAC;AAC5E,QAAQ,IAAI,WAAW,IAAI,IAAI,EAAE;AACjC,YAAY,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAM;AACnD,YAAY,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;AACzD,gBAAgB,KAAK,IAAI,WAAW,CAAC,CAAC,EAAC;AACvC,gBAAgB,KAAK,2BAA2B,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAC;AAChF,aAAa;AACb,YAAY,OAAO,EAAE,KAAK,EAAE;AAC5B,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE;AACxC;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,MAAM,EAAE;AACtC,YAAY,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE;AACvC,SAAS;AACT;AACA,QAAQ,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAC;AAChE,QAAQ,IAAI,GAAG,IAAI,IAAI,EAAE;AACzB,YAAY,QAAQ,IAAI,CAAC,QAAQ;AACjC,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE;AAChD,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,QAAQ;AAC7B,oBAAoB,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,KAAK,EAAE;AACtD;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL,IAAI,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE;AACvC,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC9C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC5C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,yBAAyB,CAAC,IAAI,EAAE,YAAY,EAAE;AAClD,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,CAAC,EAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AAC7C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;AAC3E,QAAQ,2CAA2C,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;AACzE,yCAAyC,IAAI;AAC7C,YAAY,YAAY;AACxB,SAAS;AACT,KAAK;AACL,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAE;AACxD,IAAI,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,KAAK,UAAU,GAAG,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,SAAQ;AACxE;AACA,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;AACvB,QAAQ,OAAO,eAAe,CAAC,QAAQ,EAAE,YAAY,CAAC;AACtD,KAAK;AACL;AACA,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE;AACxC,QAAQ,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE;AACvC,KAAK;AACL;AACA,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,EAAE;AACrC,QAAQ,0CAA0C,CAAC,QAAQ,EAAE,MAAM,EAAE;AACrE,YAAY,OAAO,EAAE,KAAK,+BAA+B,CAAC,QAAQ,EAAE,MAAM,EAAE;AAC5E,SAAS;AACT,QAAQ,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;AAChD,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,EAAE;AAC1D,IAAI,IAAI;AACR,QAAQ,OAAO,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC;AAClD,KAAK,CAAC,OAAO,MAAM,EAAE;AACrB,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;;AC35BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,EAAE;AAC/D;AACA,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE;AAChE,QAAQ,MAAM,OAAO;AACrB;AACA,gBAAgB,IAAI;AACpB,cAAa;AACb,QAAQ,IAAI,OAAO,CAAC,KAAK,EAAE;AAC3B,YAAY,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACrE,SAAS;AACT,QAAQ,IAAI,OAAO,CAAC,MAAM,EAAE;AAC5B,YAAY,OAAO,OAAO,CAAC,MAAM;AACjC,SAAS;AACT,KAAK;AACL;AACA,IAAI,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,EAAC;AACxD;AACA,IAAI,IAAI,SAAS,EAAE;AACnB;AACA,QAAQ,IAAI;AACZ,YAAY,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC;AAC1C,SAAS,CAAC,MAAM;AAChB;AACA,SAAS;AACT,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACpD,IAAI,QAAQ,IAAI,CAAC,IAAI;AACrB,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,OAAO,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC;AACvE,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AAC5D,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,0CAA0C,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI;AAC1E;AACA,QAAQ,KAAK,UAAU,CAAC;AACxB,QAAQ,KAAK,kBAAkB,CAAC;AAChC,QAAQ,KAAK,oBAAoB;AACjC,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,OAAO,mBAAmB,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC;AAClE,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE;AAC7C,gBAAgB,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;AAC7C,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACvD,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,0CAA0C,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI;AAIrE,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AAC1D,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA,IAAI,IAAI,CAAC,MAAM,EAAE;AACjB,QAAQ,OAAO,EAAE;AACjB,KAAK;AACL;AACA,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AAC9E,IAAI,MAAM,aAAa;AACvB,QAAQ,MAAM,CAAC,IAAI,KAAK,kBAAkB,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AACnE,IAAI,MAAM,kBAAkB;AAC5B,QAAQ,MAAM,CAAC,IAAI,KAAK,oBAAoB,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AACrE;AACA;AACA,IAAI,IAAI,aAAa,IAAI,kBAAkB,EAAE;AAC7C,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;AAC3B,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,SAAS,EAAC;AAClC,SAAS;AACT,KAAK;AACL,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;AACpB,QAAQ,MAAM,CAAC,IAAI,CAAC,OAAO,EAAC;AAC5B,KAAK;AACL,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE;AACxB,QAAQ,MAAM,CAAC,IAAI,CAAC,WAAW,EAAC;AAChC,KAAK;AACL;AACA;AACA,IAAI,IAAI,cAAc,IAAI,aAAa,EAAE;AACzC,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,EAAE;AAC3C,YAAY,OAAO,aAAa;AAChC,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,EAAE;AACnC,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,EAAE;AAC1C,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS,MAAM;AACf,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS;AACT,KAAK,MAAM,IAAI,kBAAkB,EAAE;AACnC,QAAQ,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AAC7B,KAAK,MAAM;AACX,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,yBAAyB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,OAAO,EAAC;AAChC,SAAS;AACT,QAAQ,MAAM,CAAC,IAAI,CAAC,UAAU,EAAC;AAC/B,KAAK;AACL;AACA;AACA,IAAI,IAAI,cAAc,IAAI,aAAa,IAAI,kBAAkB,EAAE;AAC/D,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAC;AAC9C,SAAS,MAAM;AACf,YAAY,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,EAAC;AAChD,YAAY,IAAI,IAAI,EAAE;AACtB,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAC;AACxC,aAAa,MAAM,IAAI,UAAU,EAAE;AACnC,gBAAgB,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAC;AAC9D,gBAAgB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AAC7C,oBAAoB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAC;AAC/C,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;AAC5B,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AACxC,KAAK,MAAM;AACX,QAAQ,MAAM,CAAC,IAAI,KAAK,oBAAoB;AAC5C,QAAQ,MAAM,CAAC,EAAE;AACjB,QAAQ,MAAM,CAAC,EAAE,CAAC,IAAI,KAAK,YAAY;AACvC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AAC1C,KAAK,MAAM;AACX,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;AAC/C,YAAY,MAAM,CAAC,IAAI,KAAK,mBAAmB;AAC/C,QAAQ,MAAM,CAAC,IAAI;AACnB,QAAQ,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY;AACzC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AAC5C,KAAK,MAAM;AACX,QAAQ,MAAM,CAAC,IAAI,KAAK,0BAA0B;AAClD,QAAQ,MAAM,CAAC,WAAW,KAAK,IAAI;AACnC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,WAAW,EAAC;AAChC,KAAK;AACL;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;AAC3B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,IAAI,EAAE;AACrB,IAAI,OAAO,OAAO;AAClB,yEAAyE,CAAC,IAAI;AAC9E,aAAa,EAAE;AACf,KAAK;AACL;;AClHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM;AAC7C,IAAI,IAAI,GAAG,CAAC;AACZ,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,KAAK;AACb,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,KAAK,CAAC;AACN,EAAC;AACD,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAC;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,CAAC,EAAE;AACnB,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;AAC5E,CAAC;AACD;AACA,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM;AAC7B,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;AACvC;AACA;AACA;AACA;AACA;AACA,QAAQ,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AAC3C,YAAY,MAAM,EAAE,IAAI,EAAE,GAAG,KAAI;AACjC;AACA,YAAY,IAAI,2BAA2B,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,UAAU,EAAE;AACzE,gBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,CAAC;AACtD,oBAAoB,IAAI;AACxB,oBAAoB,OAAO;AAC3B,oBAAoB,WAAW;AAC/B,iBAAiB;AACjB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACnD,YAAY,MAAM,EAAE,IAAI,EAAE,GAAG,KAAI;AACjC;AACA,YAAY,KAAK,MAAM,GAAG;AAC1B,gBAAgB,WAAW,CAAC,IAAI,CAAC,IAAIA,yBAAO,CAAC,IAAI,CAAC;AAClD,eAAe;AACf,gBAAgB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAC;AACvC;AACA,gBAAgB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AAC1C,oBAAoB,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE;AACjD,wBAAwB;AACxB,4BAA4B,MAAM,CAAC,OAAO,CAAC;AAC3C,4BAA4B,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC;AACtE,0BAA0B;AAC1B,4BAA4B,OAAO,IAAI;AACvC,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB,MAAM;AACvB,oBAAoB,MAAM,CAAC,KAAK,CAAC;AACjC,oBAAoB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC;AAC5D,kBAAkB;AAClB,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,aAAa;AACb;AACA,YAAY,OAAO,KAAK;AACxB,SAAS;AACT;AACA,QAAQ,uBAAuB,GAAG;AAClC,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,oBAAoB,GAAG;AAC/B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,eAAe,GAAG;AAC1B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;AAC1D,iBAAiB,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAC/E,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,cAAc,GAAG;AACzB,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,kBAAkB,GAAG;AAC7B,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,gBAAgB,GAAG;AAC3B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE;AACzC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;AAChD,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,aAAa,GAAG;AACxB,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AAC7C,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACvD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACpD,YAAY,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE;AAC5C,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;AACzD,gBAAgB,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;AAChD,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,gBAAgB,GAAG;AAC3B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,eAAe,GAAG;AAC1B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,KAAK,CAAC;AACN,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,GAAG,EAAE,EAAE;AAC9D,IAAI,MAAM,EAAE,eAAe,GAAG,KAAK,EAAE,8BAA8B,GAAG,KAAK,EAAE;AAC7E,QAAQ,QAAO;AACf,IAAI,OAAO,OAAO,CAAC,MAAM;AACzB,QAAQ,IAAI;AACZ,QAAQ,EAAE,eAAe,EAAE,8BAA8B,EAAE;AAC3D,QAAQ,UAAU,CAAC,WAAW,IAAIC,sBAAI;AACtC,KAAK;AACL;;AC9OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE;AAChD,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA,IAAI,IAAI,CAAC,MAAM,EAAE;AACjB,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,QAAQ,MAAM,CAAC,IAAI;AACvB,QAAQ,KAAK,gBAAgB,CAAC;AAC9B,QAAQ,KAAK,eAAe;AAC5B,YAAY,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;AAC/E,gBAAgB,OAAO,UAAU,CAAC,aAAa;AAC/C;AACA,oBAAoB,MAAM,CAAC,aAAa;AACxC;AACA;AACA,kFAAkF;AAClF,oCAAoC,MAAM;AAC1C,kCAAkC,cAAc;AAChD;AACA,yBAAyB;AACzB,wBAAwB,MAAM,CAAC,MAAM;AACrC,oBAAoB,mBAAmB;AACvC,iBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,UAAU,CAAC,aAAa;AAC/C,oBAAoB,MAAM,CAAC,IAAI;AAC/B,oBAAoB,mBAAmB;AACvC,iBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,aAAa,CAAC;AAC3B,QAAQ,KAAK,gBAAgB;AAC7B,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,iBAAiB;AAC9B,YAAY,IAAI,MAAM,CAAC,YAAY,KAAK,IAAI,EAAE;AAC9C,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,eAAe;AAC5B,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ;AACR,YAAY,OAAO,IAAI;AACvB,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe;AAC/B,IAAI,WAAW;AACf,IAAI,gBAAgB;AACpB,IAAI,kBAAkB;AACtB,EAAE;AACF;AACA,IAAI,IAAI,KAAK;AACb;AACA,QAAQ,IAAI;AACZ;AACA,QAAQ,UAAU;AAClB,QAAQ,cAAc;AACtB,QAAQ,gBAAe;AACvB,IAAI,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE;AACzC,QAAQ,KAAK,GAAG,WAAW,GAAG,EAAC;AAC/B,QAAQ,IAAI,4BAA4B,gBAAgB,EAAC;AACzD,QAAQ,UAAU,8BAA8B,kBAAkB,EAAC;AACnE,QAAQ,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE;AAC3B,YAAY,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC;AACxE,SAAS;AACT,KAAK,MAAM;AACX,QAAQ,KAAK,GAAG,EAAC;AACjB,QAAQ,IAAI,4BAA4B,WAAW,EAAC;AACpD,QAAQ,UAAU,8BAA8B,gBAAgB,EAAC;AACjE,KAAK;AACL;AACA,IAAI;AACJ,QAAQ,IAAI,IAAI,IAAI;AACpB;AACA,QAAQ,IAAI,CAAC,MAAM,IAAI,IAAI;AAC3B;AACA,SAAS,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI,CAAC;AAC1E,MAAM;AACN,QAAQ,OAAO,KAAK;AACpB,KAAK;AACL;AACA,IAAI,cAAc,GAAG,eAAe,GAAG,KAAI;AAC3C,IAAI,GAAG;AACP,QAAQ,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC,cAAc,EAAC;AAClE,QAAQ,eAAe,GAAG,UAAU,CAAC,aAAa,CAAC,eAAe,EAAC;AACnE,KAAK;AACL,QAAQ,cAAc,IAAI,IAAI;AAC9B,QAAQ,eAAe,IAAI,IAAI;AAC/B,QAAQ,mBAAmB,CAAC,cAAc,CAAC;AAC3C,QAAQ,mBAAmB,CAAC,eAAe,CAAC;AAC5C;AACA,QAAQ,cAAc,KAAK,oBAAoB,CAAC,IAAI,EAAE,UAAU,CAAC;AACjE,QAAQ,EAAE,KAAK,GAAG,CAAC;AACnB,KAAK;AACL;AACA,IAAI,OAAO,KAAK,KAAK,CAAC;AACtB;;ACzJA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,6BAA4B;AAChD;AACA;AACA,MAAM,QAAQ,GAAG,IAAI,OAAO,GAAE;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE;AAC/B,IAAI,IAAI,OAAO,GAAG,MAAK;AACvB,IAAI,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC,EAAE;AACvE,QAAQ,OAAO,GAAG,CAAC,QAAO;AAC1B,KAAK;AACL,IAAI,OAAO,OAAO;AAClB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE;AAC7C,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,IAAI,KAAK,GAAG,EAAC;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE;AAClC,QAAQ,QAAQ,GAAG;AACnB,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG;AAC1B,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,KAAK,CAAC,CAAC,CAAC;AAC/B,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;AAChD,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC/D,YAAY,SAAS;AACrB,gBAAgB,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAC;AACtC,gBAAgB,IAAI,CAAC,IAAI,KAAK,EAAE;AAChC,oBAAoB,OAAO,KAAK,qBAAqB,CAAC,EAAE;AACxD,iBAAiB;AACjB,gBAAgB,OAAO,GAAG;AAC1B,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA,IAAI,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;AAC9C,QAAQ,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAC;AAClD,QAAQ,MAAM,CAAC,IAAI;AACnB,YAAY,WAAW,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAC3E,UAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAM;AAC7C,KAAK;AACL,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC;AACjC;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE;AACzC,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,IAAI,KAAK,GAAG,EAAC;AACjB;AACA,IAAI,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;AAC9C,QAAQ,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAC;AAClD,QAAQ,MAAM,CAAC,IAAI;AACnB,YAAY,MAAM;AAClB,gBAAgB,OAAO;AACvB,oBAAoB;AACpB,iDAAiD,KAAK;AACtD,qBAAqB;AACrB,oBAAoB,KAAK,CAAC,KAAK;AAC/B,oBAAoB,KAAK,CAAC,KAAK;AAC/B,iBAAiB;AACjB,aAAa;AACb,UAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAM;AAC7C,KAAK;AACL,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC;AACjC;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACO,MAAM,cAAc,CAAC;AAC5B;AACA;AACA;AACA;AACA;AACA,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,EAAE,EAAE;AACvC,QAAQ,MAAM,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,QAAO;AAC3C,QAAQ,IAAI,EAAE,OAAO,YAAY,MAAM,CAAC,EAAE;AAC1C,YAAY,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACzE,SAAS;AACT,QAAQ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AAC1C,YAAY,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC;AAClE,SAAS;AACT;AACA,QAAQ,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE;AAC3B,YAAY,OAAO,EAAE,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC;AAC9D,YAAY,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;AACrC,SAAS,EAAC;AACV,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE;AAClB,QAAQ,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE;AAClC,6DAA6D,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAC;AAChF,QAAQ,IAAI,KAAK,GAAG,KAAI;AACxB,QAAQ,IAAI,SAAS,GAAG,EAAC;AACzB;AACA,QAAQ,OAAO,CAAC,SAAS,GAAG,EAAC;AAC7B,QAAQ,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;AACpD,YAAY,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE;AACzD,gBAAgB,SAAS,GAAG,OAAO,CAAC,UAAS;AAC7C,gBAAgB,MAAM,MAAK;AAC3B,gBAAgB,OAAO,CAAC,SAAS,GAAG,UAAS;AAC7C,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,IAAI,CAAC,GAAG,EAAE;AACd,QAAQ,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAC;AACpC,QAAQ,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,GAAE;AAC7B,QAAQ,OAAO,CAAC,GAAG,CAAC,IAAI;AACxB,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE;AACpC,QAAQ,OAAO,OAAO,QAAQ,KAAK,UAAU;AAC7C,cAAc,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;AACnD,cAAc,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC3D,KAAK;AACL;;ACvKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,uDAAsD;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,WAAW,CAAC,IAAI,EAAE;AAC3B,IAAI;AACJ,QAAQ,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACnC,qFAAqF;AACrF,YAAY,IAAI;AAChB,UAAU,MAAM,IAAI,IAAI;AACxB,KAAK;AACL,CAAC;AACD,MAAM,GAAG;AACT;AACA,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;AACjD,MAAK;AACL;AACY,MAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAC;AACtB,MAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAC;AACtB,MAAC,SAAS,GAAG,MAAM,CAAC,WAAW,EAAC;AAChC,MAAC,GAAG,GAAG,MAAM,CAAC,KAAK,EAAC;AAChC;AACA,MAAM,WAAW,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,GAAG,IAAI,EAAE,GAAE;AACjD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,gBAAgB,CAAC,QAAQ,EAAE;AACpC,IAAI;AACJ,QAAQ,QAAQ,IAAI,IAAI;AACxB,QAAQ,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;AAClC,QAAQ,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AACpD,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,aAAa,CAAC,IAAI,EAAE;AAC7B,IAAI,MAAM,MAAM,+BAA+B,CAAC,IAAI,EAAE,OAAM;AAC5D;AACA,IAAI,IAAI,MAAM,EAAE;AAChB,QAAQ,QAAQ,MAAM,CAAC,IAAI;AAC3B,YAAY,KAAK,uBAAuB;AACxC,gBAAgB,OAAO,MAAM,CAAC,UAAU,KAAK,IAAI,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI;AAC9E,YAAY,KAAK,mBAAmB;AACpC,gBAAgB,OAAO,IAAI;AAC3B,YAAY,KAAK,oBAAoB;AACrC,gBAAgB;AAChB,oBAAoB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;AAC9E,iBAAiB;AACjB,YAAY,KAAK,iBAAiB;AAClC,gBAAgB,OAAO,IAAI;AAC3B,YAAY,KAAK,gBAAgB,CAAC;AAClC,YAAY,KAAK,uBAAuB,CAAC;AACzC,YAAY,KAAK,iBAAiB,CAAC;AACnC,YAAY,KAAK,qBAAqB,CAAC;AACvC,YAAY,KAAK,2BAA2B;AAC5C,gBAAgB,OAAO,IAAI;AAC3B;AACA,YAAY;AACZ,gBAAgB,OAAO,KAAK;AAC5B,SAAS;AACT,KAAK;AACL,IAAI,OAAO,KAAK;AAChB,CAAC;AACD;AACA;AACA;AACA;AACO,MAAM,gBAAgB,CAAC;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,WAAW,CAAC,WAAW,EAAE,OAAO,GAAG,EAAE,EAAE;AAC3C,QAAQ,MAAM;AACd,YAAY,IAAI,GAAG,QAAQ;AAC3B,YAAY,iBAAiB,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC;AAC1E,SAAS,GAAG,QAAO;AACnB;AACA,QAAQ,IAAI,CAAC,aAAa,GAAG,GAAE;AAC/B;AACA,QAAQ,IAAI,CAAC,WAAW,GAAG,YAAW;AACtC;AACA,QAAQ,IAAI,CAAC,IAAI,GAAG,KAAI;AACxB;AACA,QAAQ,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAAC;AAC3D,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE;AACvC,QAAQ,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACjD,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,MAAM,IAAI,GAAG,CAAC,GAAG,EAAC;AAC9B,YAAY,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAC;AAC1D;AACA,YAAY,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE;AAC5C,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,yCAAyC,QAAQ;AACjD,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,gBAAgB,IAAI;AACpB,cAAa;AACb,SAAS;AACT;AACA,QAAQ,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,iBAAiB,EAAE;AAClD;AACA,YAAY,MAAM,IAAI,GAAG,GAAE;AAC3B,YAAY,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAC;AAC1D;AACA,YAAY,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE;AAC5C,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,yCAAyC,QAAQ;AACjD,gBAAgB,IAAI;AACpB,gBAAgB,QAAQ;AACxB,gBAAgB,KAAK;AACrB,cAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;AACpC,QAAQ,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,EAAE;AAC1E,YAAY,MAAM,GAAG,GAAG,mBAAmB;AAC3C,8CAA8C,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;AACjE,cAAa;AACb,YAAY,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACpD,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,MAAM,IAAI,GAAG,CAAC,GAAG,EAAC;AAC9B;AACA,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI;AACxB,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,+CAA+C,IAAI;AACnD,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,cAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;AACpC,QAAQ,MAAM,WAAW,2BAA2B,IAAI,CAAC,WAAW,CAAC,KAAK,EAAC;AAC3E;AACA,QAAQ,KAAK,MAAM,IAAI,IAAI,WAAW,CAAC,IAAI,EAAE;AAC7C,YAAY,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,QAAQ;AACxB,aAAa;AACb,YAAY,MAAM,QAAQ,0BAA0B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAC;AACtE;AACA,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;AAC1C,gBAAgB,QAAQ;AACxB,aAAa;AACb,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAC;AACnD,YAAY,MAAM,IAAI,GAAG,CAAC,QAAQ,EAAC;AACnC;AACA,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB;AACA,oBAAoB,IAAI,2BAA2B,IAAI,CAAC;AACxD,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb;AACA,YAAY,IAAI,IAAI,CAAC,IAAI,KAAK,sBAAsB,EAAE;AACtD,gBAAgB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;AAC7D,oBAAoB,MAAM,cAAc,GAAG,YAAY,CAAC,GAAG,EAAC;AAC5D,oBAAoB,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE;AAC9C,wBAAwB,MAAM;AAC9B;AACA,4BAA4B,IAAI,2BAA2B,IAAI,CAAC;AAChE,4BAA4B,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;AAClD,4BAA4B,IAAI,EAAE,IAAI;AACtC,4BAA4B,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AACtD,0BAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa,MAAM;AACnB,gBAAgB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;AACzD,oBAAoB,MAAM,GAAG,GAAG,GAAG,CAAC,YAAY,EAAE,GAAG,EAAC;AACtD,oBAAoB,MAAM,EAAE,GAAG,IAAI,CAAC,wBAAwB;AAC5D,wBAAwB,SAAS;AACjC,wBAAwB,IAAI;AAC5B,wBAAwB,GAAG;AAC3B,8BAA8B,YAAY;AAC1C,8BAA8B,IAAI,CAAC,IAAI,KAAK,QAAQ;AACpD,8BAA8B,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE;AACxE,8BAA8B,EAAE,OAAO,EAAE,YAAY,EAAE;AACvD,sBAAqB;AACrB;AACA,oBAAoB,IAAI,GAAG,EAAE;AAC7B,wBAAwB,OAAO,GAAE;AACjC,qBAAqB,MAAM;AAC3B,wBAAwB,KAAK,MAAM,MAAM,IAAI,EAAE,EAAE;AACjD,4BAA4B,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,EAAC;AAC3E,4BAA4B;AAC5B,gCAAgC,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC;AACvD,gCAAgC,MAAM,CAAC,IAAI,KAAK,IAAI;AACpD,8BAA8B;AAC9B,gCAAgC,MAAM,OAAM;AAC5C,6BAA6B;AAC7B,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE;AAC/C,QAAQ,OAAO,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAC;AAClE,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,0BAA0B,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE;AACxE,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;AACnD,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAC;AACzC,QAAQ,IAAI;AACZ,YAAY,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE;AACzD,gBAAgB,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE;AACzC,oBAAoB,QAAQ;AAC5B,iBAAiB;AACjB,gBAAgB,MAAM,IAAI;AAC1B,oBAAoB,SAAS,CAAC,UAAU;AACxC,kBAAiB;AACjB;AACA,gBAAgB,IAAI,YAAY,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE;AACpD,oBAAoB,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAE;AAC1E,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC5E,aAAa;AACb,SAAS,SAAS;AAClB,YAAY,IAAI,CAAC,aAAa,CAAC,GAAG,GAAE;AACpC,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,0BAA0B,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE;AAC1D,QAAQ,IAAI,IAAI,GAAG,SAAQ;AAC3B,QAAQ,OAAO,aAAa,CAAC,IAAI,CAAC,EAAE;AACpC,YAAY,IAAI,GAAG,IAAI,CAAC,OAAM;AAC9B,SAAS;AACT;AACA,QAAQ,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AAC5D,QAAQ,IAAI,CAAC,MAAM,EAAE;AACrB,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE;AAChD,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,MAAM,GAAG,GAAG,eAAe,CAAC,MAAM,EAAC;AACnD,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACxD,oBAAoB,MAAM;AAC1B,iBAAiB;AACjB;AACA,gBAAgB,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACvC,gBAAgB,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACxC,oBAAoB,MAAM;AAC1B,wBAAwB,IAAI,EAAE,MAAM;AACpC,wBAAwB,IAAI;AAC5B,wBAAwB,IAAI,EAAE,IAAI;AAClC,wBAAwB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAChD,sBAAqB;AACrB,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,0BAA0B;AACtD,oBAAoB,MAAM;AAC1B,oBAAoB,IAAI;AACxB,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,EAAE;AAC9C,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE;AAC1D,gBAAgB,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAE;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,eAAe,EAAE;AAC7C,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE;AAC/D,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,EAAE,MAAM;AAChC,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,SAAS;AACnC,oBAAoB,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC;AAC7C,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,sBAAsB,EAAE;AACpD,YAAY,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;AACvC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,gBAAgB,OAAO,IAAI,CAAC,0BAA0B,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACjD,YAAY,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;AACvC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB,EAAE;AAClD,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC5E,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE;AACxD,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,YAAY,EAAE;AAC/C,YAAY,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAC;AACxE,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB,OAAO,IAAI,CAAC,0BAA0B;AACtD,oBAAoB,QAAQ;AAC5B,oBAAoB,IAAI;AACxB,oBAAoB,QAAQ;AAC5B,oBAAoB,KAAK;AACzB,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE;AAClD,YAAY,KAAK,MAAM,QAAQ,IAAI,WAAW,CAAC,UAAU,EAAE;AAC3D,gBAAgB,MAAM,GAAG,GAAG,eAAe;AAC3C,uDAAuD,QAAQ;AAC/D,kBAAiB;AACjB;AACA,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACxD,oBAAoB,QAAQ;AAC5B,iBAAiB;AACjB;AACA,gBAAgB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACjD,gBAAgB,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACxC,oBAAoB,MAAM;AAC1B,wBAAwB,IAAI,2BAA2B,QAAQ,CAAC;AAChE,wBAAwB,IAAI,EAAE,QAAQ;AACtC,wBAAwB,IAAI,EAAE,IAAI;AAClC,wBAAwB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAChD,sBAAqB;AACrB,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,qBAAqB;AACjD,sDAAsD,CAAC,QAAQ,EAAE,KAAK;AACtE,oBAAoB,QAAQ;AAC5B,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACtD,YAAY,OAAO,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC/E,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,wBAAwB,CAAC,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE;AAC7D,QAAQ,MAAM,IAAI,GAAG,aAAa,CAAC,KAAI;AACvC;AACA,QAAQ,IAAI,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,wBAAwB,EAAE;AAC7E,YAAY,MAAM,GAAG;AACrB,gBAAgB,IAAI,KAAK,wBAAwB;AACjD,sBAAsB,SAAS;AAC/B,sBAAsB,aAAa,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;AAClE,sBAAsB,aAAa,CAAC,QAAQ,CAAC,IAAI;AACjD,sBAAsB,aAAa,CAAC,QAAQ,CAAC,MAAK;AAClD,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACrC,gBAAgB,MAAM;AACtB,aAAa;AACb;AACA,YAAY,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACnC,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,2BAA2B,aAAa,CAAC;AACjE,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD;AACA,oBAAoB,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,KAAK,CAAC;AACvE;AACA,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,gBAAgB,KAAK;AACrB,cAAa;AACb;AACA,YAAY,MAAM;AAClB,SAAS;AACT;AACA,QAAQ,IAAI,IAAI,KAAK,0BAA0B,EAAE;AACjD,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD;AACA,oBAAoB,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,KAAK,CAAC;AACvE;AACA,gBAAgB,IAAI;AACpB,gBAAgB,QAAQ;AACxB,gBAAgB,KAAK;AACrB,cAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT;AACA,QAAQ,IAAI,IAAI,KAAK,iBAAiB,EAAE;AACxC,YAAY,MAAM,GAAG;AACrB,gBAAgB,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY;AACzD,sBAAsB,aAAa,CAAC,KAAK,CAAC,IAAI;AAC9C,sBAAsB,aAAa,CAAC,KAAK,CAAC,MAAK;AAC/C,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACrC,gBAAgB,MAAM;AACtB,aAAa;AACb;AACA,YAAY,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACnC,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,2BAA2B,aAAa,CAAC;AACjE,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK;AACL,CAAC;AACD;AACA,gBAAgB,CAAC,IAAI,GAAG,KAAI;AAC5B,gBAAgB,CAAC,IAAI,GAAG,KAAI;AAC5B,gBAAgB,CAAC,SAAS,GAAG,UAAS;AACtC,gBAAgB,CAAC,GAAG,GAAG,IAAG;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE;AACpC,IAAI,OAAO,EAAE,KAAK,KAAK,CAAC,IAAI,IAAI,KAAK,SAAS,CAAC;AAC/C;;ACrjBA;AAiEA;AACA,YAAe;AACf,IAAI,IAAI;AACR,IAAI,SAAS;AACb,IAAI,GAAG;AACP,IAAI,YAAY;AAChB,IAAI,uBAAuB;AAC3B,IAAI,uBAAuB;AAC3B,IAAI,iBAAiB;AACrB,IAAI,eAAe;AACnB,IAAI,cAAc;AAClB,IAAI,mBAAmB;AACvB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,mBAAmB;AACvB,IAAI,YAAY;AAChB,IAAI,YAAY;AAChB,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,sBAAsB;AAC1B,IAAI,wBAAwB;AAC5B,IAAI,sBAAsB;AAC1B,IAAI,eAAe;AACnB,IAAI,eAAe;AACnB,IAAI,iBAAiB;AACrB,IAAI,sBAAsB;AAC1B,IAAI,wBAAwB;AAC5B,IAAI,sBAAsB;AAC1B,IAAI,mBAAmB;AACvB,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,mBAAmB;AACvB,IAAI,eAAe;AACnB,IAAI,gBAAgB;AACpB,IAAI,cAAc;AAClB,IAAI,IAAI;AACR,IAAI,gBAAgB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs new file mode 100644 index 00000000..057aff81 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs @@ -0,0 +1,2579 @@ +import { getKeys, KEYS } from 'eslint-visitor-keys'; + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").Node} Node */ + +/** + * Get the innermost scope which contains a given location. + * @param {Scope} initialScope The initial scope to search. + * @param {Node} node The location to search. + * @returns {Scope} The innermost scope. + */ +function getInnermostScope(initialScope, node) { + const location = /** @type {[number, number]} */ (node.range)[0]; + + let scope = initialScope; + let found = false; + do { + found = false; + for (const childScope of scope.childScopes) { + const range = /** @type {[number, number]} */ ( + childScope.block.range + ); + + if (range[0] <= location && location < range[1]) { + scope = childScope; + found = true; + break + } + } + } while (found) + + return scope +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Find the variable of a given name. + * @param {Scope} initialScope The scope to start finding. + * @param {string|Identifier} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node. + * @returns {Variable|null} The found variable or null. + */ +function findVariable(initialScope, nameOrNode) { + let name = ""; + /** @type {Scope|null} */ + let scope = initialScope; + + if (typeof nameOrNode === "string") { + name = nameOrNode; + } else { + name = nameOrNode.name; + scope = getInnermostScope(scope, nameOrNode); + } + + while (scope != null) { + const variable = scope.set.get(name); + if (variable != null) { + return variable + } + scope = scope.upper; + } + + return null +} + +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("estree").Comment} Comment */ +/** @typedef {import("./types.mjs").ArrowToken} ArrowToken */ +/** @typedef {import("./types.mjs").CommaToken} CommaToken */ +/** @typedef {import("./types.mjs").SemicolonToken} SemicolonToken */ +/** @typedef {import("./types.mjs").ColonToken} ColonToken */ +/** @typedef {import("./types.mjs").OpeningParenToken} OpeningParenToken */ +/** @typedef {import("./types.mjs").ClosingParenToken} ClosingParenToken */ +/** @typedef {import("./types.mjs").OpeningBracketToken} OpeningBracketToken */ +/** @typedef {import("./types.mjs").ClosingBracketToken} ClosingBracketToken */ +/** @typedef {import("./types.mjs").OpeningBraceToken} OpeningBraceToken */ +/** @typedef {import("./types.mjs").ClosingBraceToken} ClosingBraceToken */ +/** + * @template {string} Value + * @typedef {import("./types.mjs").PunctuatorToken} PunctuatorToken + */ + +/** @typedef {Comment | Token} CommentOrToken */ + +/** + * Creates the negate function of the given function. + * @param {function(CommentOrToken):boolean} f - The function to negate. + * @returns {function(CommentOrToken):boolean} Negated function. + */ +function negate(f) { + return (token) => !f(token) +} + +/** + * Checks if the given token is a PunctuatorToken with the given value + * @template {string} Value + * @param {CommentOrToken} token - The token to check. + * @param {Value} value - The value to check. + * @returns {token is PunctuatorToken} `true` if the token is a PunctuatorToken with the given value. + */ +function isPunctuatorTokenWithValue(token, value) { + return token.type === "Punctuator" && token.value === value +} + +/** + * Checks if the given token is an arrow token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ArrowToken} `true` if the token is an arrow token. + */ +function isArrowToken(token) { + return isPunctuatorTokenWithValue(token, "=>") +} + +/** + * Checks if the given token is a comma token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is CommaToken} `true` if the token is a comma token. + */ +function isCommaToken(token) { + return isPunctuatorTokenWithValue(token, ",") +} + +/** + * Checks if the given token is a semicolon token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is SemicolonToken} `true` if the token is a semicolon token. + */ +function isSemicolonToken(token) { + return isPunctuatorTokenWithValue(token, ";") +} + +/** + * Checks if the given token is a colon token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ColonToken} `true` if the token is a colon token. + */ +function isColonToken(token) { + return isPunctuatorTokenWithValue(token, ":") +} + +/** + * Checks if the given token is an opening parenthesis token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token. + */ +function isOpeningParenToken(token) { + return isPunctuatorTokenWithValue(token, "(") +} + +/** + * Checks if the given token is a closing parenthesis token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token. + */ +function isClosingParenToken(token) { + return isPunctuatorTokenWithValue(token, ")") +} + +/** + * Checks if the given token is an opening square bracket token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token. + */ +function isOpeningBracketToken(token) { + return isPunctuatorTokenWithValue(token, "[") +} + +/** + * Checks if the given token is a closing square bracket token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token. + */ +function isClosingBracketToken(token) { + return isPunctuatorTokenWithValue(token, "]") +} + +/** + * Checks if the given token is an opening brace token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token. + */ +function isOpeningBraceToken(token) { + return isPunctuatorTokenWithValue(token, "{") +} + +/** + * Checks if the given token is a closing brace token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token. + */ +function isClosingBraceToken(token) { + return isPunctuatorTokenWithValue(token, "}") +} + +/** + * Checks if the given token is a comment token or not. + * @param {CommentOrToken} token - The token to check. + * @returns {token is Comment} `true` if the token is a comment token. + */ +function isCommentToken(token) { + return ["Block", "Line", "Shebang"].includes(token.type) +} + +const isNotArrowToken = negate(isArrowToken); +const isNotCommaToken = negate(isCommaToken); +const isNotSemicolonToken = negate(isSemicolonToken); +const isNotColonToken = negate(isColonToken); +const isNotOpeningParenToken = negate(isOpeningParenToken); +const isNotClosingParenToken = negate(isClosingParenToken); +const isNotOpeningBracketToken = negate(isOpeningBracketToken); +const isNotClosingBracketToken = negate(isClosingBracketToken); +const isNotOpeningBraceToken = negate(isOpeningBraceToken); +const isNotClosingBraceToken = negate(isClosingBraceToken); +const isNotCommentToken = negate(isCommentToken); + +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("estree").Function} FunctionNode */ +/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */ +/** @typedef {import("estree").FunctionExpression} FunctionExpression */ +/** @typedef {import("estree").SourceLocation} SourceLocation */ +/** @typedef {import("estree").Position} Position */ + +/** + * Get the `(` token of the given function node. + * @param {FunctionExpression | FunctionDeclaration} node - The function node to get. + * @param {SourceCode} sourceCode - The source code object to get tokens. + * @returns {Token} `(` token. + */ +function getOpeningParenOfParams(node, sourceCode) { + return node.id + ? /** @type {Token} */ ( + sourceCode.getTokenAfter(node.id, isOpeningParenToken) + ) + : /** @type {Token} */ ( + sourceCode.getFirstToken(node, isOpeningParenToken) + ) +} + +/** + * Get the location of the given function node for reporting. + * @param {FunctionNode} node - The function node to get. + * @param {SourceCode} sourceCode - The source code object to get tokens. + * @returns {SourceLocation|null} The location of the function node for reporting. + */ +function getFunctionHeadLocation(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + /** @type {Position|null} */ + let start = null; + /** @type {Position|null} */ + let end = null; + + if (node.type === "ArrowFunctionExpression") { + const arrowToken = /** @type {Token} */ ( + sourceCode.getTokenBefore(node.body, isArrowToken) + ); + + start = arrowToken.loc.start; + end = arrowToken.loc.end; + } else if ( + parent && + (parent.type === "Property" || + parent.type === "MethodDefinition" || + parent.type === "PropertyDefinition") + ) { + start = /** @type {SourceLocation} */ (parent.loc).start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } else { + start = /** @type {SourceLocation} */ (node.loc).start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + + return { + start: { ...start }, + end: { ...end }, + } +} + +/* globals self, window */ +/** @typedef {import("./types.mjs").StaticValue} StaticValue */ +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */ +/** @typedef {import("@typescript-eslint/types").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */ +/** @typedef {import("@typescript-eslint/types").TSESTree.MemberExpression} MemberExpression */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Property} Property */ +/** @typedef {import("@typescript-eslint/types").TSESTree.RegExpLiteral} RegExpLiteral */ +/** @typedef {import("@typescript-eslint/types").TSESTree.BigIntLiteral} BigIntLiteral */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Literal} Literal */ + +const globalObject = + typeof globalThis !== "undefined" + ? globalThis + : // @ts-ignore + typeof self !== "undefined" + ? // @ts-ignore + self + : // @ts-ignore + typeof window !== "undefined" + ? // @ts-ignore + window + : typeof global !== "undefined" + ? global + : {}; + +const builtinNames = Object.freeze( + new Set([ + "Array", + "ArrayBuffer", + "BigInt", + "BigInt64Array", + "BigUint64Array", + "Boolean", + "DataView", + "Date", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "Float32Array", + "Float64Array", + "Function", + "Infinity", + "Int16Array", + "Int32Array", + "Int8Array", + "isFinite", + "isNaN", + "isPrototypeOf", + "JSON", + "Map", + "Math", + "NaN", + "Number", + "Object", + "parseFloat", + "parseInt", + "Promise", + "Proxy", + "Reflect", + "RegExp", + "Set", + "String", + "Symbol", + "Uint16Array", + "Uint32Array", + "Uint8Array", + "Uint8ClampedArray", + "undefined", + "unescape", + "WeakMap", + "WeakSet", + ]), +); +const callAllowed = new Set( + [ + Array.isArray, + Array.of, + Array.prototype.at, + Array.prototype.concat, + Array.prototype.entries, + Array.prototype.every, + Array.prototype.filter, + Array.prototype.find, + Array.prototype.findIndex, + Array.prototype.flat, + Array.prototype.includes, + Array.prototype.indexOf, + Array.prototype.join, + Array.prototype.keys, + Array.prototype.lastIndexOf, + Array.prototype.slice, + Array.prototype.some, + Array.prototype.toString, + Array.prototype.values, + typeof BigInt === "function" ? BigInt : undefined, + Boolean, + Date, + Date.parse, + decodeURI, + decodeURIComponent, + encodeURI, + encodeURIComponent, + escape, + isFinite, + isNaN, + // @ts-ignore + isPrototypeOf, + Map, + Map.prototype.entries, + Map.prototype.get, + Map.prototype.has, + Map.prototype.keys, + Map.prototype.values, + .../** @type {(keyof typeof Math)[]} */ ( + Object.getOwnPropertyNames(Math) + ) + .filter((k) => k !== "random") + .map((k) => Math[k]) + .filter((f) => typeof f === "function"), + Number, + Number.isFinite, + Number.isNaN, + Number.parseFloat, + Number.parseInt, + Number.prototype.toExponential, + Number.prototype.toFixed, + Number.prototype.toPrecision, + Number.prototype.toString, + Object, + Object.entries, + Object.is, + Object.isExtensible, + Object.isFrozen, + Object.isSealed, + Object.keys, + Object.values, + parseFloat, + parseInt, + RegExp, + Set, + Set.prototype.entries, + Set.prototype.has, + Set.prototype.keys, + Set.prototype.values, + String, + String.fromCharCode, + String.fromCodePoint, + String.raw, + String.prototype.at, + String.prototype.charAt, + String.prototype.charCodeAt, + String.prototype.codePointAt, + String.prototype.concat, + String.prototype.endsWith, + String.prototype.includes, + String.prototype.indexOf, + String.prototype.lastIndexOf, + String.prototype.normalize, + String.prototype.padEnd, + String.prototype.padStart, + String.prototype.slice, + String.prototype.startsWith, + String.prototype.substr, + String.prototype.substring, + String.prototype.toLowerCase, + String.prototype.toString, + String.prototype.toUpperCase, + String.prototype.trim, + String.prototype.trimEnd, + String.prototype.trimLeft, + String.prototype.trimRight, + String.prototype.trimStart, + Symbol.for, + Symbol.keyFor, + unescape, + ].filter((f) => typeof f === "function"), +); +const callPassThrough = new Set([ + Object.freeze, + Object.preventExtensions, + Object.seal, +]); + +/** @type {ReadonlyArray]>} */ +const getterAllowed = [ + [Map, new Set(["size"])], + [ + RegExp, + new Set([ + "dotAll", + "flags", + "global", + "hasIndices", + "ignoreCase", + "multiline", + "source", + "sticky", + "unicode", + ]), + ], + [Set, new Set(["size"])], +]; + +/** + * Get the property descriptor. + * @param {object} object The object to get. + * @param {string|number|symbol} name The property name to get. + */ +function getPropertyDescriptor(object, name) { + let x = object; + while ((typeof x === "object" || typeof x === "function") && x !== null) { + const d = Object.getOwnPropertyDescriptor(x, name); + if (d) { + return d + } + x = Object.getPrototypeOf(x); + } + return null +} + +/** + * Check if a property is getter or not. + * @param {object} object The object to check. + * @param {string|number|symbol} name The property name to check. + */ +function isGetter(object, name) { + const d = getPropertyDescriptor(object, name); + return d != null && d.get != null +} + +/** + * Get the element values of a given node list. + * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values. + * @param {Scope|undefined|null} initialScope The initial scope to find variables. + * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null. + */ +function getElementValues(nodeList, initialScope) { + const valueList = []; + + for (let i = 0; i < nodeList.length; ++i) { + const elementNode = nodeList[i]; + + if (elementNode == null) { + valueList.length = i + 1; + } else if (elementNode.type === "SpreadElement") { + const argument = getStaticValueR(elementNode.argument, initialScope); + if (argument == null) { + return null + } + valueList.push(.../** @type {Iterable} */ (argument.value)); + } else { + const element = getStaticValueR(elementNode, initialScope); + if (element == null) { + return null + } + valueList.push(element.value); + } + } + + return valueList +} + +/** + * Checks if a variable is a built-in global. + * @param {Variable|null} variable The variable to check. + * @returns {variable is Variable & {defs:[]}} + */ +function isBuiltinGlobal(variable) { + return ( + variable != null && + variable.defs.length === 0 && + builtinNames.has(variable.name) && + variable.name in globalObject + ) +} + +/** + * Checks if a variable can be considered as a constant. + * @param {Variable} variable + * @returns {variable is Variable & {defs: [import("eslint").Scope.Definition & { type: "Variable" }]}} True if the variable can be considered as a constant. + */ +function canBeConsideredConst(variable) { + if (variable.defs.length !== 1) { + return false + } + const def = variable.defs[0]; + return Boolean( + def.parent && + def.type === "Variable" && + (def.parent.kind === "const" || isEffectivelyConst(variable)), + ) +} + +/** + * Returns whether the given variable is never written to after initialization. + * @param {Variable} variable + * @returns {boolean} + */ +function isEffectivelyConst(variable) { + const refs = variable.references; + + const inits = refs.filter((r) => r.init).length; + const reads = refs.filter((r) => r.isReadOnly()).length; + if (inits === 1 && reads + inits === refs.length) { + // there is only one init and all other references only read + return true + } + return false +} + +/** + * Checks if a variable has mutation in its property. + * @param {Variable} variable The variable to check. + * @param {Scope|null} initialScope The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {boolean} True if the variable has mutation in its property. + */ +function hasMutationInProperty(variable, initialScope) { + for (const ref of variable.references) { + let node = /** @type {TSESTreeNode} */ (ref.identifier); + while (node && node.parent && node.parent.type === "MemberExpression") { + node = node.parent; + } + if (!node || !node.parent) { + continue + } + if ( + (node.parent.type === "AssignmentExpression" && + node.parent.left === node) || + (node.parent.type === "UpdateExpression" && + node.parent.argument === node) + ) { + // This is a mutation. + return true + } + if ( + node.parent.type === "CallExpression" && + node.parent.callee === node && + node.type === "MemberExpression" + ) { + const methodName = getStaticPropertyNameValue(node, initialScope); + if (isNameOfMutationArrayMethod(methodName)) { + // This is a mutation. + return true + } + } + } + return false + + /** + * Checks if a method name is one of the mutation array methods. + * @param {StaticValue|null} methodName The method name to check. + * @returns {boolean} True if the method name is a mutation array method. + */ + function isNameOfMutationArrayMethod(methodName) { + if (methodName == null || methodName.value == null) { + return false + } + const name = methodName.value; + return ( + name === "copyWithin" || + name === "fill" || + name === "pop" || + name === "push" || + name === "reverse" || + name === "shift" || + name === "sort" || + name === "splice" || + name === "unshift" + ) + } +} + +/** + * @template {TSESTreeNodeTypes} T + * @callback VisitorCallback + * @param {TSESTreeNode & { type: T }} node + * @param {Scope|undefined|null} initialScope + * @returns {StaticValue | null} + */ +/** + * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback } } Operations + */ +/** + * @type {Operations} + */ +const operations = Object.freeze({ + ArrayExpression(node, initialScope) { + const elements = getElementValues(node.elements, initialScope); + return elements != null ? { value: elements } : null + }, + + AssignmentExpression(node, initialScope) { + if (node.operator === "=") { + return getStaticValueR(node.right, initialScope) + } + return null + }, + + //eslint-disable-next-line complexity + BinaryExpression(node, initialScope) { + if (node.operator === "in" || node.operator === "instanceof") { + // Not supported. + return null + } + + const left = getStaticValueR(node.left, initialScope); + const right = getStaticValueR(node.right, initialScope); + if (left != null && right != null) { + switch (node.operator) { + case "==": + return { value: left.value == right.value } //eslint-disable-line eqeqeq + case "!=": + return { value: left.value != right.value } //eslint-disable-line eqeqeq + case "===": + return { value: left.value === right.value } + case "!==": + return { value: left.value !== right.value } + case "<": + return { + value: + /** @type {any} */ (left.value) < + /** @type {any} */ (right.value), + } + case "<=": + return { + value: + /** @type {any} */ (left.value) <= + /** @type {any} */ (right.value), + } + case ">": + return { + value: + /** @type {any} */ (left.value) > + /** @type {any} */ (right.value), + } + case ">=": + return { + value: + /** @type {any} */ (left.value) >= + /** @type {any} */ (right.value), + } + case "<<": + return { + value: + /** @type {any} */ (left.value) << + /** @type {any} */ (right.value), + } + case ">>": + return { + value: + /** @type {any} */ (left.value) >> + /** @type {any} */ (right.value), + } + case ">>>": + return { + value: + /** @type {any} */ (left.value) >>> + /** @type {any} */ (right.value), + } + case "+": + return { + value: + /** @type {any} */ (left.value) + + /** @type {any} */ (right.value), + } + case "-": + return { + value: + /** @type {any} */ (left.value) - + /** @type {any} */ (right.value), + } + case "*": + return { + value: + /** @type {any} */ (left.value) * + /** @type {any} */ (right.value), + } + case "/": + return { + value: + /** @type {any} */ (left.value) / + /** @type {any} */ (right.value), + } + case "%": + return { + value: + /** @type {any} */ (left.value) % + /** @type {any} */ (right.value), + } + case "**": + return { + value: + /** @type {any} */ (left.value) ** + /** @type {any} */ (right.value), + } + case "|": + return { + value: + /** @type {any} */ (left.value) | + /** @type {any} */ (right.value), + } + case "^": + return { + value: + /** @type {any} */ (left.value) ^ + /** @type {any} */ (right.value), + } + case "&": + return { + value: + /** @type {any} */ (left.value) & + /** @type {any} */ (right.value), + } + + // no default + } + } + + return null + }, + + CallExpression(node, initialScope) { + const calleeNode = node.callee; + const args = getElementValues(node.arguments, initialScope); + + if (args != null) { + if (calleeNode.type === "MemberExpression") { + if (calleeNode.property.type === "PrivateIdentifier") { + return null + } + const object = getStaticValueR(calleeNode.object, initialScope); + if (object != null) { + if ( + object.value == null && + (object.optional || node.optional) + ) { + return { value: undefined, optional: true } + } + const property = getStaticPropertyNameValue( + calleeNode, + initialScope, + ); + + if (property != null) { + const receiver = + /** @type {Record any>} */ ( + object.value + ); + const methodName = /** @type {PropertyKey} */ ( + property.value + ); + if (callAllowed.has(receiver[methodName])) { + return { + value: receiver[methodName](...args), + } + } + if (callPassThrough.has(receiver[methodName])) { + return { value: args[0] } + } + } + } + } else { + const callee = getStaticValueR(calleeNode, initialScope); + if (callee != null) { + if (callee.value == null && node.optional) { + return { value: undefined, optional: true } + } + const func = /** @type {(...args: any[]) => any} */ ( + callee.value + ); + if (callAllowed.has(func)) { + return { value: func(...args) } + } + if (callPassThrough.has(func)) { + return { value: args[0] } + } + } + } + } + + return null + }, + + ConditionalExpression(node, initialScope) { + const test = getStaticValueR(node.test, initialScope); + if (test != null) { + return test.value + ? getStaticValueR(node.consequent, initialScope) + : getStaticValueR(node.alternate, initialScope) + } + return null + }, + + ExpressionStatement(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + + Identifier(node, initialScope) { + if (initialScope != null) { + const variable = findVariable(initialScope, node); + + if (variable != null) { + // Built-in globals. + if (isBuiltinGlobal(variable)) { + return { value: globalObject[variable.name] } + } + + // Constants. + if (canBeConsideredConst(variable)) { + const def = variable.defs[0]; + if ( + // TODO(mysticatea): don't support destructuring here. + def.node.id.type === "Identifier" + ) { + const init = getStaticValueR( + def.node.init, + initialScope, + ); + if ( + init && + typeof init.value === "object" && + init.value !== null + ) { + if (hasMutationInProperty(variable, initialScope)) { + // This variable has mutation in its property. + return null + } + } + return init + } + } + } + } + return null + }, + + Literal(node) { + const literal = + /** @type {Partial & Partial & Partial} */ ( + node + ); + //istanbul ignore if : this is implementation-specific behavior. + if ( + (literal.regex != null || literal.bigint != null) && + literal.value == null + ) { + // It was a RegExp/BigInt literal, but Node.js didn't support it. + return null + } + return { value: literal.value } + }, + + LogicalExpression(node, initialScope) { + const left = getStaticValueR(node.left, initialScope); + if (left != null) { + if ( + (node.operator === "||" && Boolean(left.value) === true) || + (node.operator === "&&" && Boolean(left.value) === false) || + (node.operator === "??" && left.value != null) + ) { + return left + } + + const right = getStaticValueR(node.right, initialScope); + if (right != null) { + return right + } + } + + return null + }, + + MemberExpression(node, initialScope) { + if (node.property.type === "PrivateIdentifier") { + return null + } + const object = getStaticValueR(node.object, initialScope); + if (object != null) { + if (object.value == null && (object.optional || node.optional)) { + return { value: undefined, optional: true } + } + const property = getStaticPropertyNameValue(node, initialScope); + + if (property != null) { + if ( + !isGetter( + /** @type {object} */ (object.value), + /** @type {PropertyKey} */ (property.value), + ) + ) { + return { + value: /** @type {Record} */ ( + object.value + )[/** @type {PropertyKey} */ (property.value)], + } + } + + for (const [classFn, allowed] of getterAllowed) { + if ( + object.value instanceof classFn && + allowed.has(/** @type {string} */ (property.value)) + ) { + return { + value: /** @type {Record} */ ( + object.value + )[/** @type {PropertyKey} */ (property.value)], + } + } + } + } + } + return null + }, + + ChainExpression(node, initialScope) { + const expression = getStaticValueR(node.expression, initialScope); + if (expression != null) { + return { value: expression.value } + } + return null + }, + + NewExpression(node, initialScope) { + const callee = getStaticValueR(node.callee, initialScope); + const args = getElementValues(node.arguments, initialScope); + + if (callee != null && args != null) { + const Func = /** @type {new (...args: any[]) => any} */ ( + callee.value + ); + if (callAllowed.has(Func)) { + return { value: new Func(...args) } + } + } + + return null + }, + + ObjectExpression(node, initialScope) { + /** @type {Record} */ + const object = {}; + + for (const propertyNode of node.properties) { + if (propertyNode.type === "Property") { + if (propertyNode.kind !== "init") { + return null + } + const key = getStaticPropertyNameValue( + propertyNode, + initialScope, + ); + const value = getStaticValueR(propertyNode.value, initialScope); + if (key == null || value == null) { + return null + } + object[/** @type {PropertyKey} */ (key.value)] = value.value; + } else if ( + propertyNode.type === "SpreadElement" || + // @ts-expect-error -- Backward compatibility + propertyNode.type === "ExperimentalSpreadProperty" + ) { + const argument = getStaticValueR( + propertyNode.argument, + initialScope, + ); + if (argument == null) { + return null + } + Object.assign(object, argument.value); + } else { + return null + } + } + + return { value: object } + }, + + SequenceExpression(node, initialScope) { + const last = node.expressions[node.expressions.length - 1]; + return getStaticValueR(last, initialScope) + }, + + TaggedTemplateExpression(node, initialScope) { + const tag = getStaticValueR(node.tag, initialScope); + const expressions = getElementValues( + node.quasi.expressions, + initialScope, + ); + + if (tag != null && expressions != null) { + const func = /** @type {(...args: any[]) => any} */ (tag.value); + /** @type {any[] & { raw?: string[] }} */ + const strings = node.quasi.quasis.map((q) => q.value.cooked); + strings.raw = node.quasi.quasis.map((q) => q.value.raw); + + if (func === String.raw) { + return { value: func(strings, ...expressions) } + } + } + + return null + }, + + TemplateLiteral(node, initialScope) { + const expressions = getElementValues(node.expressions, initialScope); + if (expressions != null) { + let value = node.quasis[0].value.cooked; + for (let i = 0; i < expressions.length; ++i) { + value += expressions[i]; + value += /** @type {string} */ (node.quasis[i + 1].value.cooked); + } + return { value } + } + return null + }, + + UnaryExpression(node, initialScope) { + if (node.operator === "delete") { + // Not supported. + return null + } + if (node.operator === "void") { + return { value: undefined } + } + + const arg = getStaticValueR(node.argument, initialScope); + if (arg != null) { + switch (node.operator) { + case "-": + return { value: -(/** @type {any} */ (arg.value)) } + case "+": + return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion + case "!": + return { value: !arg.value } + case "~": + return { value: ~(/** @type {any} */ (arg.value)) } + case "typeof": + return { value: typeof arg.value } + + // no default + } + } + + return null + }, + TSAsExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSSatisfiesExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSTypeAssertion(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSNonNullExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, + TSInstantiationExpression(node, initialScope) { + return getStaticValueR(node.expression, initialScope) + }, +}); + +/** + * Get the value of a given node if it's a static value. + * @param {Node|TSESTreeNode|null|undefined} node The node to get. + * @param {Scope|undefined|null} initialScope The scope to start finding variable. + * @returns {StaticValue|null} The static value of the node, or `null`. + */ +function getStaticValueR(node, initialScope) { + if (node != null && Object.hasOwnProperty.call(operations, node.type)) { + return /** @type {VisitorCallback} */ (operations[node.type])( + /** @type {TSESTreeNode} */ (node), + initialScope, + ) + } + return null +} + +/** + * Get the static value of property name from a MemberExpression node or a Property node. + * @param {MemberExpression|Property} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {StaticValue|null} The static value of the property name of the node, or `null`. + */ +function getStaticPropertyNameValue(node, initialScope) { + const nameNode = node.type === "Property" ? node.key : node.property; + + if (node.computed) { + return getStaticValueR(nameNode, initialScope) + } + + if (nameNode.type === "Identifier") { + return { value: nameNode.name } + } + + if (nameNode.type === "Literal") { + if (/** @type {Partial} */ (nameNode).bigint) { + return { value: /** @type {BigIntLiteral} */ (nameNode).bigint } + } + return { value: String(nameNode.value) } + } + + return null +} + +/** + * Get the value of a given node if it's a static value. + * @param {Node} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible. + * @returns {StaticValue | null} The static value of the node, or `null`. + */ +function getStaticValue(node, initialScope = null) { + try { + return getStaticValueR(node, initialScope) + } catch (_error) { + return null + } +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("estree").RegExpLiteral} RegExpLiteral */ +/** @typedef {import("estree").BigIntLiteral} BigIntLiteral */ +/** @typedef {import("estree").SimpleLiteral} SimpleLiteral */ + +/** + * Get the value of a given node if it's a literal or a template literal. + * @param {Node} node The node to get. + * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant. + * @returns {string|null} The value of the node, or `null`. + */ +function getStringIfConstant(node, initialScope = null) { + // Handle the literals that the platform doesn't support natively. + if (node && node.type === "Literal" && node.value === null) { + const literal = + /** @type {Partial & Partial & Partial} */ ( + node + ); + if (literal.regex) { + return `/${literal.regex.pattern}/${literal.regex.flags}` + } + if (literal.bigint) { + return literal.bigint + } + } + + const evaluated = getStaticValue(node, initialScope); + + if (evaluated) { + // `String(Symbol.prototype)` throws error + try { + return String(evaluated.value) + } catch { + // No op + } + } + + return null +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("estree").MemberExpression} MemberExpression */ +/** @typedef {import("estree").MethodDefinition} MethodDefinition */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Get the property name from a MemberExpression node or a Property node. + * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} node The node to get. + * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it. + * @returns {string|null|undefined} The property name of the node. + */ +function getPropertyName(node, initialScope) { + switch (node.type) { + case "MemberExpression": + if (node.computed) { + return getStringIfConstant(node.property, initialScope) + } + if (node.property.type === "PrivateIdentifier") { + return null + } + return /** @type {Partial} */ (node.property).name + + case "Property": + case "MethodDefinition": + case "PropertyDefinition": + if (node.computed) { + return getStringIfConstant(node.key, initialScope) + } + if (node.key.type === "Literal") { + return String(node.key.value) + } + if (node.key.type === "PrivateIdentifier") { + return null + } + return /** @type {Partial} */ (node.key).name + } + + return null +} + +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("estree").Function} FunctionNode */ +/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */ +/** @typedef {import("estree").FunctionExpression} FunctionExpression */ +/** @typedef {import("estree").Identifier} Identifier */ + +/** + * Get the name and kind of the given function node. + * @param {FunctionNode} node - The function node to get. + * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys. + * @returns {string} The name and kind of the function node. + */ +// eslint-disable-next-line complexity +function getFunctionNameWithKind(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + if (!parent) { + return "" + } + + const tokens = []; + const isObjectMethod = parent.type === "Property" && parent.value === node; + const isClassMethod = + parent.type === "MethodDefinition" && parent.value === node; + const isClassFieldMethod = + parent.type === "PropertyDefinition" && parent.value === node; + + // Modifiers. + if (isClassMethod || isClassFieldMethod) { + if (parent.static) { + tokens.push("static"); + } + if (parent.key.type === "PrivateIdentifier") { + tokens.push("private"); + } + } + if (node.async) { + tokens.push("async"); + } + if (node.generator) { + tokens.push("generator"); + } + + // Kinds. + if (isObjectMethod || isClassMethod) { + if (parent.kind === "constructor") { + return "constructor" + } + if (parent.kind === "get") { + tokens.push("getter"); + } else if (parent.kind === "set") { + tokens.push("setter"); + } else { + tokens.push("method"); + } + } else if (isClassFieldMethod) { + tokens.push("method"); + } else { + if (node.type === "ArrowFunctionExpression") { + tokens.push("arrow"); + } + tokens.push("function"); + } + + // Names. + if (isObjectMethod || isClassMethod || isClassFieldMethod) { + if (parent.key.type === "PrivateIdentifier") { + tokens.push(`#${parent.key.name}`); + } else { + const name = getPropertyName(parent); + if (name) { + tokens.push(`'${name}'`); + } else if (sourceCode) { + const keyText = sourceCode.getText(parent.key); + if (!keyText.includes("\n")) { + tokens.push(`[${keyText}]`); + } + } + } + } else if (hasId(node)) { + tokens.push(`'${node.id.name}'`); + } else if ( + parent.type === "VariableDeclarator" && + parent.id && + parent.id.type === "Identifier" + ) { + tokens.push(`'${parent.id.name}'`); + } else if ( + (parent.type === "AssignmentExpression" || + parent.type === "AssignmentPattern") && + parent.left && + parent.left.type === "Identifier" + ) { + tokens.push(`'${parent.left.name}'`); + } else if ( + parent.type === "ExportDefaultDeclaration" && + parent.declaration === node + ) { + tokens.push("'default'"); + } + + return tokens.join(" ") +} + +/** + * @param {FunctionNode} node + * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }} + */ +function hasId(node) { + return Boolean( + /** @type {Partial} */ (node) + .id, + ) +} + +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("./types.mjs").HasSideEffectOptions} HasSideEffectOptions */ +/** @typedef {import("estree").BinaryExpression} BinaryExpression */ +/** @typedef {import("estree").MemberExpression} MemberExpression */ +/** @typedef {import("estree").MethodDefinition} MethodDefinition */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */ +/** @typedef {import("estree").UnaryExpression} UnaryExpression */ + +const typeConversionBinaryOps = Object.freeze( + new Set([ + "==", + "!=", + "<", + "<=", + ">", + ">=", + "<<", + ">>", + ">>>", + "+", + "-", + "*", + "/", + "%", + "|", + "^", + "&", + "in", + ]), +); +const typeConversionUnaryOps = Object.freeze(new Set(["-", "+", "!", "~"])); + +/** + * Check whether the given value is an ASTNode or not. + * @param {any} x The value to check. + * @returns {x is Node} `true` if the value is an ASTNode. + */ +function isNode(x) { + return x !== null && typeof x === "object" && typeof x.type === "string" +} + +const visitor = Object.freeze( + Object.assign(Object.create(null), { + /** + * @param {Node} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + $visit(node, options, visitorKeys) { + const { type } = node; + + if (typeof (/** @type {any} */ (this)[type]) === "function") { + return /** @type {any} */ (this)[type]( + node, + options, + visitorKeys, + ) + } + + return this.$visitChildren(node, options, visitorKeys) + }, + + /** + * @param {Node} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + $visitChildren(node, options, visitorKeys) { + const { type } = node; + + for (const key of /** @type {(keyof Node)[]} */ ( + visitorKeys[type] || getKeys(node) + )) { + const value = node[key]; + + if (Array.isArray(value)) { + for (const element of value) { + if ( + isNode(element) && + this.$visit(element, options, visitorKeys) + ) { + return true + } + } + } else if ( + isNode(value) && + this.$visit(value, options, visitorKeys) + ) { + return true + } + } + + return false + }, + + ArrowFunctionExpression() { + return false + }, + AssignmentExpression() { + return true + }, + AwaitExpression() { + return true + }, + /** + * @param {BinaryExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + BinaryExpression(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + typeConversionBinaryOps.has(node.operator) && + (node.left.type !== "Literal" || node.right.type !== "Literal") + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + CallExpression() { + return true + }, + FunctionExpression() { + return false + }, + ImportExpression() { + return true + }, + /** + * @param {MemberExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + MemberExpression(node, options, visitorKeys) { + if (options.considerGetters) { + return true + } + if ( + options.considerImplicitTypeConversion && + node.computed && + node.property.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {MethodDefinition} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + MethodDefinition(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + NewExpression() { + return true + }, + /** + * @param {Property} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + Property(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {PropertyDefinition} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + PropertyDefinition(node, options, visitorKeys) { + if ( + options.considerImplicitTypeConversion && + node.computed && + node.key.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + /** + * @param {UnaryExpression} node + * @param {HasSideEffectOptions} options + * @param {Record} visitorKeys + */ + UnaryExpression(node, options, visitorKeys) { + if (node.operator === "delete") { + return true + } + if ( + options.considerImplicitTypeConversion && + typeConversionUnaryOps.has(node.operator) && + node.argument.type !== "Literal" + ) { + return true + } + return this.$visitChildren(node, options, visitorKeys) + }, + UpdateExpression() { + return true + }, + YieldExpression() { + return true + }, + }), +); + +/** + * Check whether a given node has any side effect or not. + * @param {Node} node The node to get. + * @param {SourceCode} sourceCode The source code object. + * @param {HasSideEffectOptions} [options] The option object. + * @returns {boolean} `true` if the node has a certain side effect. + */ +function hasSideEffect(node, sourceCode, options = {}) { + const { considerGetters = false, considerImplicitTypeConversion = false } = + options; + return visitor.$visit( + node, + { considerGetters, considerImplicitTypeConversion }, + sourceCode.visitorKeys || KEYS, + ) +} + +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("@typescript-eslint/types").TSESTree.NewExpression} TSNewExpression */ +/** @typedef {import("@typescript-eslint/types").TSESTree.CallExpression} TSCallExpression */ +/** @typedef {import("eslint").SourceCode} SourceCode */ +/** @typedef {import("eslint").AST.Token} Token */ +/** @typedef {import("eslint").Rule.Node} RuleNode */ + +/** + * Get the left parenthesis of the parent node syntax if it exists. + * E.g., `if (a) {}` then the `(`. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {Token|null} The left parenthesis of the parent node syntax + */ +// eslint-disable-next-line complexity +function getParentSyntaxParen(node, sourceCode) { + const parent = /** @type {RuleNode} */ (node).parent; + + if (!parent) { + return null + } + + switch (parent.type) { + case "CallExpression": + case "NewExpression": + if (parent.arguments.length === 1 && parent.arguments[0] === node) { + return sourceCode.getTokenAfter( + // @ts-expect-error https://github.com/typescript-eslint/typescript-eslint/pull/5384 + parent.typeArguments || + /** @type {RuleNode} */ ( + /** @type {unknown} */ ( + /** @type {TSNewExpression | TSCallExpression} */ ( + parent + ).typeParameters + ) + ) || + parent.callee, + isOpeningParenToken, + ) + } + return null + + case "DoWhileStatement": + if (parent.test === node) { + return sourceCode.getTokenAfter( + parent.body, + isOpeningParenToken, + ) + } + return null + + case "IfStatement": + case "WhileStatement": + if (parent.test === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "ImportExpression": + if (parent.source === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "SwitchStatement": + if (parent.discriminant === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + case "WithStatement": + if (parent.object === node) { + return sourceCode.getFirstToken(parent, 1) + } + return null + + default: + return null + } +} + +/** + * Check whether a given node is parenthesized or not. + * @param {number} times The number of parantheses. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {boolean} `true` if the node is parenthesized the given times. + */ +/** + * Check whether a given node is parenthesized or not. + * @param {Node} node The AST node to check. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {boolean} `true` if the node is parenthesized. + */ +/** + * Check whether a given node is parenthesized or not. + * @param {Node|number} timesOrNode The first parameter. + * @param {Node|SourceCode} nodeOrSourceCode The second parameter. + * @param {SourceCode} [optionalSourceCode] The third parameter. + * @returns {boolean} `true` if the node is parenthesized. + */ +function isParenthesized( + timesOrNode, + nodeOrSourceCode, + optionalSourceCode, +) { + /** @type {number} */ + let times, + /** @type {RuleNode} */ + node, + /** @type {SourceCode} */ + sourceCode, + maybeLeftParen, + maybeRightParen; + if (typeof timesOrNode === "number") { + times = timesOrNode | 0; + node = /** @type {RuleNode} */ (nodeOrSourceCode); + sourceCode = /** @type {SourceCode} */ (optionalSourceCode); + if (!(times >= 1)) { + throw new TypeError("'times' should be a positive integer.") + } + } else { + times = 1; + node = /** @type {RuleNode} */ (timesOrNode); + sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode); + } + + if ( + node == null || + // `Program` can't be parenthesized + node.parent == null || + // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}` + (node.parent.type === "CatchClause" && node.parent.param === node) + ) { + return false + } + + maybeLeftParen = maybeRightParen = node; + do { + maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen); + maybeRightParen = sourceCode.getTokenAfter(maybeRightParen); + } while ( + maybeLeftParen != null && + maybeRightParen != null && + isOpeningParenToken(maybeLeftParen) && + isClosingParenToken(maybeRightParen) && + // Avoid false positive such as `if (a) {}` + maybeLeftParen !== getParentSyntaxParen(node, sourceCode) && + --times > 0 + ) + + return times === 0 +} + +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ + +const placeholder = /\$(?:[$&`']|[1-9][0-9]?)/gu; + +/** @type {WeakMap} */ +const internal = new WeakMap(); + +/** + * Check whether a given character is escaped or not. + * @param {string} str The string to check. + * @param {number} index The location of the character to check. + * @returns {boolean} `true` if the character is escaped. + */ +function isEscaped(str, index) { + let escaped = false; + for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) { + escaped = !escaped; + } + return escaped +} + +/** + * Replace a given string by a given matcher. + * @param {PatternMatcher} matcher The pattern matcher. + * @param {string} str The string to be replaced. + * @param {string} replacement The new substring to replace each matched part. + * @returns {string} The replaced string. + */ +function replaceS(matcher, str, replacement) { + const chunks = []; + let index = 0; + + /** + * @param {string} key The placeholder. + * @param {RegExpExecArray} match The matched information. + * @returns {string} The replaced string. + */ + function replacer(key, match) { + switch (key) { + case "$$": + return "$" + case "$&": + return match[0] + case "$`": + return str.slice(0, match.index) + case "$'": + return str.slice(match.index + match[0].length) + default: { + const i = key.slice(1); + if (i in match) { + return match[/** @type {any} */ (i)] + } + return key + } + } + } + + for (const match of matcher.execAll(str)) { + chunks.push(str.slice(index, match.index)); + chunks.push( + replacement.replace(placeholder, (key) => replacer(key, match)), + ); + index = match.index + match[0].length; + } + chunks.push(str.slice(index)); + + return chunks.join("") +} + +/** + * Replace a given string by a given matcher. + * @param {PatternMatcher} matcher The pattern matcher. + * @param {string} str The string to be replaced. + * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part. + * @returns {string} The replaced string. + */ +function replaceF(matcher, str, replace) { + const chunks = []; + let index = 0; + + for (const match of matcher.execAll(str)) { + chunks.push(str.slice(index, match.index)); + chunks.push( + String( + replace( + .../** @type {[string, ...string[]]} */ ( + /** @type {string[]} */ (match) + ), + match.index, + match.input, + ), + ), + ); + index = match.index + match[0].length; + } + chunks.push(str.slice(index)); + + return chunks.join("") +} + +/** + * The class to find patterns as considering escape sequences. + */ +class PatternMatcher { + /** + * Initialize this matcher. + * @param {RegExp} pattern The pattern to match. + * @param {{escaped?:boolean}} [options] The options. + */ + constructor(pattern, options = {}) { + const { escaped = false } = options; + if (!(pattern instanceof RegExp)) { + throw new TypeError("'pattern' should be a RegExp instance.") + } + if (!pattern.flags.includes("g")) { + throw new Error("'pattern' should contains 'g' flag.") + } + + internal.set(this, { + pattern: new RegExp(pattern.source, pattern.flags), + escaped: Boolean(escaped), + }); + } + + /** + * Find the pattern in a given string. + * @param {string} str The string to find. + * @returns {IterableIterator} The iterator which iterate the matched information. + */ + *execAll(str) { + const { pattern, escaped } = + /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this)); + let match = null; + let lastIndex = 0; + + pattern.lastIndex = 0; + while ((match = pattern.exec(str)) != null) { + if (escaped || !isEscaped(str, match.index)) { + lastIndex = pattern.lastIndex; + yield match; + pattern.lastIndex = lastIndex; + } + } + } + + /** + * Check whether the pattern is found in a given string. + * @param {string} str The string to check. + * @returns {boolean} `true` if the pattern was found in the string. + */ + test(str) { + const it = this.execAll(str); + const ret = it.next(); + return !ret.done + } + + /** + * Replace a given string. + * @param {string} str The string to be replaced. + * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`. + * @returns {string} The replaced string. + */ + [Symbol.replace](str, replacer) { + return typeof replacer === "function" + ? replaceF(this, String(str), replacer) + : replaceS(this, String(str), String(replacer)) + } +} + +/** @typedef {import("eslint").Scope.Scope} Scope */ +/** @typedef {import("eslint").Scope.Variable} Variable */ +/** @typedef {import("eslint").Rule.Node} RuleNode */ +/** @typedef {import("estree").Node} Node */ +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("estree").Pattern} Pattern */ +/** @typedef {import("estree").Identifier} Identifier */ +/** @typedef {import("estree").SimpleCallExpression} CallExpression */ +/** @typedef {import("estree").Program} Program */ +/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */ +/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */ +/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */ +/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */ +/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */ +/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */ +/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */ +/** @typedef {import("estree").ExportSpecifier} ExportSpecifier */ +/** @typedef {import("estree").Property} Property */ +/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */ +/** @typedef {import("estree").Literal} Literal */ +/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */ +/** @typedef {import("./types.mjs").ReferenceTrackerOptions} ReferenceTrackerOptions */ +/** + * @template T + * @typedef {import("./types.mjs").TraceMap} TraceMap + */ +/** + * @template T + * @typedef {import("./types.mjs").TraceMapObject} TraceMapObject + */ +/** + * @template T + * @typedef {import("./types.mjs").TrackedReferences} TrackedReferences + */ + +const IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u; + +/** + * Check whether a given node is an import node or not. + * @param {Node} node + * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node. + */ +function isHasSource(node) { + return ( + IMPORT_TYPE.test(node.type) && + /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ ( + node + ).source != null + ) +} +const has = + /** @type {(traceMap: TraceMap, v: T) => v is (string extends T ? string : T)} */ ( + Function.call.bind(Object.hasOwnProperty) + ); + +const READ = Symbol("read"); +const CALL = Symbol("call"); +const CONSTRUCT = Symbol("construct"); +const ESM = Symbol("esm"); + +const requireCall = { require: { [CALL]: true } }; + +/** + * Check whether a given variable is modified or not. + * @param {Variable|undefined} variable The variable to check. + * @returns {boolean} `true` if the variable is modified. + */ +function isModifiedGlobal(variable) { + return ( + variable == null || + variable.defs.length !== 0 || + variable.references.some((r) => r.isWrite()) + ) +} + +/** + * Check if the value of a given node is passed through to the parent syntax as-is. + * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through. + * @param {Node} node A node to check. + * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through. + */ +function isPassThrough(node) { + const parent = /** @type {TSESTreeNode} */ (node).parent; + + if (parent) { + switch (parent.type) { + case "ConditionalExpression": + return parent.consequent === node || parent.alternate === node + case "LogicalExpression": + return true + case "SequenceExpression": + return ( + parent.expressions[parent.expressions.length - 1] === node + ) + case "ChainExpression": + return true + case "TSAsExpression": + case "TSSatisfiesExpression": + case "TSTypeAssertion": + case "TSNonNullExpression": + case "TSInstantiationExpression": + return true + + default: + return false + } + } + return false +} + +/** + * The reference tracker. + */ +class ReferenceTracker { + /** + * Initialize this tracker. + * @param {Scope} globalScope The global scope. + * @param {object} [options] The options. + * @param {"legacy"|"strict"} [options.mode="strict"] The mode to determine the ImportDeclaration's behavior for CJS modules. + * @param {string[]} [options.globalObjectNames=["global","globalThis","self","window"]] The variable names for Global Object. + */ + constructor(globalScope, options = {}) { + const { + mode = "strict", + globalObjectNames = ["global", "globalThis", "self", "window"], + } = options; + /** @private @type {Variable[]} */ + this.variableStack = []; + /** @private */ + this.globalScope = globalScope; + /** @private */ + this.mode = mode; + /** @private */ + this.globalObjectNames = globalObjectNames.slice(0); + } + + /** + * Iterate the references of global variables. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateGlobalReferences(traceMap) { + for (const key of Object.keys(traceMap)) { + const nextTraceMap = traceMap[key]; + const path = [key]; + const variable = this.globalScope.set.get(key); + + if (isModifiedGlobal(variable)) { + continue + } + + yield* this._iterateVariableReferences( + /** @type {Variable} */ (variable), + path, + nextTraceMap, + true, + ); + } + + for (const key of this.globalObjectNames) { + /** @type {string[]} */ + const path = []; + const variable = this.globalScope.set.get(key); + + if (isModifiedGlobal(variable)) { + continue + } + + yield* this._iterateVariableReferences( + /** @type {Variable} */ (variable), + path, + traceMap, + false, + ); + } + } + + /** + * Iterate the references of CommonJS modules. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateCjsReferences(traceMap) { + for (const { node } of this.iterateGlobalReferences(requireCall)) { + const key = getStringIfConstant( + /** @type {CallExpression} */ (node).arguments[0], + ); + if (key == null || !has(traceMap, key)) { + continue + } + + const nextTraceMap = traceMap[key]; + const path = [key]; + + if (nextTraceMap[READ]) { + yield { + node, + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iteratePropertyReferences( + /** @type {CallExpression} */ (node), + path, + nextTraceMap, + ); + } + } + + /** + * Iterate the references of ES modules. + * @template T + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *iterateEsmReferences(traceMap) { + const programNode = /** @type {Program} */ (this.globalScope.block); + + for (const node of programNode.body) { + if (!isHasSource(node)) { + continue + } + const moduleId = /** @type {string} */ (node.source.value); + + if (!has(traceMap, moduleId)) { + continue + } + const nextTraceMap = traceMap[moduleId]; + const path = [moduleId]; + + if (nextTraceMap[READ]) { + yield { + // eslint-disable-next-line object-shorthand -- apply type + node: /** @type {RuleNode} */ (node), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + + if (node.type === "ExportAllDeclaration") { + for (const key of Object.keys(nextTraceMap)) { + const exportTraceMap = nextTraceMap[key]; + if (exportTraceMap[READ]) { + yield { + // eslint-disable-next-line object-shorthand -- apply type + node: /** @type {RuleNode} */ (node), + path: path.concat(key), + type: READ, + info: exportTraceMap[READ], + }; + } + } + } else { + for (const specifier of node.specifiers) { + const esm = has(nextTraceMap, ESM); + const it = this._iterateImportReferences( + specifier, + path, + esm + ? nextTraceMap + : this.mode === "legacy" + ? { default: nextTraceMap, ...nextTraceMap } + : { default: nextTraceMap }, + ); + + if (esm) { + yield* it; + } else { + for (const report of it) { + report.path = report.path.filter(exceptDefault); + if ( + report.path.length >= 2 || + report.type !== READ + ) { + yield report; + } + } + } + } + } + } + } + + /** + * Iterate the property references for a given expression AST node. + * @template T + * @param {Expression} node The expression AST node to iterate property references. + * @param {TraceMap} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate property references. + */ + *iteratePropertyReferences(node, traceMap) { + yield* this._iteratePropertyReferences(node, [], traceMap); + } + + /** + * Iterate the references for a given variable. + * @private + * @template T + * @param {Variable} variable The variable to iterate that references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @param {boolean} shouldReport = The flag to report those references. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateVariableReferences(variable, path, traceMap, shouldReport) { + if (this.variableStack.includes(variable)) { + return + } + this.variableStack.push(variable); + try { + for (const reference of variable.references) { + if (!reference.isRead()) { + continue + } + const node = /** @type {RuleNode & Identifier} */ ( + reference.identifier + ); + + if (shouldReport && traceMap[READ]) { + yield { node, path, type: READ, info: traceMap[READ] }; + } + yield* this._iteratePropertyReferences(node, path, traceMap); + } + } finally { + this.variableStack.pop(); + } + } + + /** + * Iterate the references for a given AST node. + * @private + * @template T + * @param {Expression} rootNode The AST node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + //eslint-disable-next-line complexity + *_iteratePropertyReferences(rootNode, path, traceMap) { + let node = rootNode; + while (isPassThrough(node)) { + node = node.parent; + } + + const parent = /** @type {RuleNode} */ (node).parent; + if (!parent) { + return + } + if (parent.type === "MemberExpression") { + if (parent.object === node) { + const key = getPropertyName(parent); + if (key == null || !has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: parent, + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iteratePropertyReferences( + parent, + path, + nextTraceMap, + ); + } + return + } + if (parent.type === "CallExpression") { + if (parent.callee === node && traceMap[CALL]) { + yield { node: parent, path, type: CALL, info: traceMap[CALL] }; + } + return + } + if (parent.type === "NewExpression") { + if (parent.callee === node && traceMap[CONSTRUCT]) { + yield { + node: parent, + path, + type: CONSTRUCT, + info: traceMap[CONSTRUCT], + }; + } + return + } + if (parent.type === "AssignmentExpression") { + if (parent.right === node) { + yield* this._iterateLhsReferences(parent.left, path, traceMap); + yield* this._iteratePropertyReferences(parent, path, traceMap); + } + return + } + if (parent.type === "AssignmentPattern") { + if (parent.right === node) { + yield* this._iterateLhsReferences(parent.left, path, traceMap); + } + return + } + if (parent.type === "VariableDeclarator") { + if (parent.init === node) { + yield* this._iterateLhsReferences(parent.id, path, traceMap); + } + } + } + + /** + * Iterate the references for a given Pattern node. + * @private + * @template T + * @param {Pattern} patternNode The Pattern node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateLhsReferences(patternNode, path, traceMap) { + if (patternNode.type === "Identifier") { + const variable = findVariable(this.globalScope, patternNode); + if (variable != null) { + yield* this._iterateVariableReferences( + variable, + path, + traceMap, + false, + ); + } + return + } + if (patternNode.type === "ObjectPattern") { + for (const property of patternNode.properties) { + const key = getPropertyName( + /** @type {AssignmentProperty} */ (property), + ); + + if (key == null || !has(traceMap, key)) { + continue + } + + const nextPath = path.concat(key); + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (property), + path: nextPath, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iterateLhsReferences( + /** @type {AssignmentProperty} */ (property).value, + nextPath, + nextTraceMap, + ); + } + return + } + if (patternNode.type === "AssignmentPattern") { + yield* this._iterateLhsReferences(patternNode.left, path, traceMap); + } + } + + /** + * Iterate the references for a given ModuleSpecifier node. + * @private + * @template T + * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references. + * @param {string[]} path The current path. + * @param {TraceMapObject} traceMap The trace map. + * @returns {IterableIterator>} The iterator to iterate references. + */ + *_iterateImportReferences(specifierNode, path, traceMap) { + const type = specifierNode.type; + + if (type === "ImportSpecifier" || type === "ImportDefaultSpecifier") { + const key = + type === "ImportDefaultSpecifier" + ? "default" + : specifierNode.imported.type === "Identifier" + ? specifierNode.imported.name + : specifierNode.imported.value; + if (!has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (specifierNode), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + yield* this._iterateVariableReferences( + /** @type {Variable} */ ( + findVariable(this.globalScope, specifierNode.local) + ), + path, + nextTraceMap, + false, + ); + + return + } + + if (type === "ImportNamespaceSpecifier") { + yield* this._iterateVariableReferences( + /** @type {Variable} */ ( + findVariable(this.globalScope, specifierNode.local) + ), + path, + traceMap, + false, + ); + return + } + + if (type === "ExportSpecifier") { + const key = + specifierNode.local.type === "Identifier" + ? specifierNode.local.name + : specifierNode.local.value; + if (!has(traceMap, key)) { + return + } + + path = path.concat(key); //eslint-disable-line no-param-reassign + const nextTraceMap = traceMap[key]; + if (nextTraceMap[READ]) { + yield { + node: /** @type {RuleNode} */ (specifierNode), + path, + type: READ, + info: nextTraceMap[READ], + }; + } + } + } +} + +ReferenceTracker.READ = READ; +ReferenceTracker.CALL = CALL; +ReferenceTracker.CONSTRUCT = CONSTRUCT; +ReferenceTracker.ESM = ESM; + +/** + * This is a predicate function for Array#filter. + * @param {string} name A name part. + * @param {number} index The index of the name. + * @returns {boolean} `false` if it's default. + */ +function exceptDefault(name, index) { + return !(index === 1 && name === "default") +} + +/** @typedef {import("./types.mjs").StaticValue} StaticValue */ + +var index = { + CALL, + CONSTRUCT, + ESM, + findVariable, + getFunctionHeadLocation, + getFunctionNameWithKind, + getInnermostScope, + getPropertyName, + getStaticValue, + getStringIfConstant, + hasSideEffect, + isArrowToken, + isClosingBraceToken, + isClosingBracketToken, + isClosingParenToken, + isColonToken, + isCommaToken, + isCommentToken, + isNotArrowToken, + isNotClosingBraceToken, + isNotClosingBracketToken, + isNotClosingParenToken, + isNotColonToken, + isNotCommaToken, + isNotCommentToken, + isNotOpeningBraceToken, + isNotOpeningBracketToken, + isNotOpeningParenToken, + isNotSemicolonToken, + isOpeningBraceToken, + isOpeningBracketToken, + isOpeningParenToken, + isParenthesized, + isSemicolonToken, + PatternMatcher, + READ, + ReferenceTracker, +}; + +export { CALL, CONSTRUCT, ESM, PatternMatcher, READ, ReferenceTracker, index as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken }; +//# sourceMappingURL=index.mjs.map diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs.map b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs.map new file mode 100644 index 00000000..1a934ddf --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/index.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"index.mjs","sources":["src/get-innermost-scope.mjs","src/find-variable.mjs","src/token-predicate.mjs","src/get-function-head-location.mjs","src/get-static-value.mjs","src/get-string-if-constant.mjs","src/get-property-name.mjs","src/get-function-name-with-kind.mjs","src/has-side-effect.mjs","src/is-parenthesized.mjs","src/pattern-matcher.mjs","src/reference-tracker.mjs","src/index.mjs"],"sourcesContent":["/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").Node} Node */\n\n/**\n * Get the innermost scope which contains a given location.\n * @param {Scope} initialScope The initial scope to search.\n * @param {Node} node The location to search.\n * @returns {Scope} The innermost scope.\n */\nexport function getInnermostScope(initialScope, node) {\n const location = /** @type {[number, number]} */ (node.range)[0]\n\n let scope = initialScope\n let found = false\n do {\n found = false\n for (const childScope of scope.childScopes) {\n const range = /** @type {[number, number]} */ (\n childScope.block.range\n )\n\n if (range[0] <= location && location < range[1]) {\n scope = childScope\n found = true\n break\n }\n }\n } while (found)\n\n return scope\n}\n","import { getInnermostScope } from \"./get-innermost-scope.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Find the variable of a given name.\n * @param {Scope} initialScope The scope to start finding.\n * @param {string|Identifier} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.\n * @returns {Variable|null} The found variable or null.\n */\nexport function findVariable(initialScope, nameOrNode) {\n let name = \"\"\n /** @type {Scope|null} */\n let scope = initialScope\n\n if (typeof nameOrNode === \"string\") {\n name = nameOrNode\n } else {\n name = nameOrNode.name\n scope = getInnermostScope(scope, nameOrNode)\n }\n\n while (scope != null) {\n const variable = scope.set.get(name)\n if (variable != null) {\n return variable\n }\n scope = scope.upper\n }\n\n return null\n}\n","/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"estree\").Comment} Comment */\n/** @typedef {import(\"./types.mjs\").ArrowToken} ArrowToken */\n/** @typedef {import(\"./types.mjs\").CommaToken} CommaToken */\n/** @typedef {import(\"./types.mjs\").SemicolonToken} SemicolonToken */\n/** @typedef {import(\"./types.mjs\").ColonToken} ColonToken */\n/** @typedef {import(\"./types.mjs\").OpeningParenToken} OpeningParenToken */\n/** @typedef {import(\"./types.mjs\").ClosingParenToken} ClosingParenToken */\n/** @typedef {import(\"./types.mjs\").OpeningBracketToken} OpeningBracketToken */\n/** @typedef {import(\"./types.mjs\").ClosingBracketToken} ClosingBracketToken */\n/** @typedef {import(\"./types.mjs\").OpeningBraceToken} OpeningBraceToken */\n/** @typedef {import(\"./types.mjs\").ClosingBraceToken} ClosingBraceToken */\n/**\n * @template {string} Value\n * @typedef {import(\"./types.mjs\").PunctuatorToken} PunctuatorToken\n */\n\n/** @typedef {Comment | Token} CommentOrToken */\n\n/**\n * Creates the negate function of the given function.\n * @param {function(CommentOrToken):boolean} f - The function to negate.\n * @returns {function(CommentOrToken):boolean} Negated function.\n */\nfunction negate(f) {\n return (token) => !f(token)\n}\n\n/**\n * Checks if the given token is a PunctuatorToken with the given value\n * @template {string} Value\n * @param {CommentOrToken} token - The token to check.\n * @param {Value} value - The value to check.\n * @returns {token is PunctuatorToken} `true` if the token is a PunctuatorToken with the given value.\n */\nfunction isPunctuatorTokenWithValue(token, value) {\n return token.type === \"Punctuator\" && token.value === value\n}\n\n/**\n * Checks if the given token is an arrow token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ArrowToken} `true` if the token is an arrow token.\n */\nexport function isArrowToken(token) {\n return isPunctuatorTokenWithValue(token, \"=>\")\n}\n\n/**\n * Checks if the given token is a comma token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is CommaToken} `true` if the token is a comma token.\n */\nexport function isCommaToken(token) {\n return isPunctuatorTokenWithValue(token, \",\")\n}\n\n/**\n * Checks if the given token is a semicolon token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is SemicolonToken} `true` if the token is a semicolon token.\n */\nexport function isSemicolonToken(token) {\n return isPunctuatorTokenWithValue(token, \";\")\n}\n\n/**\n * Checks if the given token is a colon token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ColonToken} `true` if the token is a colon token.\n */\nexport function isColonToken(token) {\n return isPunctuatorTokenWithValue(token, \":\")\n}\n\n/**\n * Checks if the given token is an opening parenthesis token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningParenToken} `true` if the token is an opening parenthesis token.\n */\nexport function isOpeningParenToken(token) {\n return isPunctuatorTokenWithValue(token, \"(\")\n}\n\n/**\n * Checks if the given token is a closing parenthesis token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingParenToken} `true` if the token is a closing parenthesis token.\n */\nexport function isClosingParenToken(token) {\n return isPunctuatorTokenWithValue(token, \")\")\n}\n\n/**\n * Checks if the given token is an opening square bracket token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningBracketToken} `true` if the token is an opening square bracket token.\n */\nexport function isOpeningBracketToken(token) {\n return isPunctuatorTokenWithValue(token, \"[\")\n}\n\n/**\n * Checks if the given token is a closing square bracket token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingBracketToken} `true` if the token is a closing square bracket token.\n */\nexport function isClosingBracketToken(token) {\n return isPunctuatorTokenWithValue(token, \"]\")\n}\n\n/**\n * Checks if the given token is an opening brace token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is OpeningBraceToken} `true` if the token is an opening brace token.\n */\nexport function isOpeningBraceToken(token) {\n return isPunctuatorTokenWithValue(token, \"{\")\n}\n\n/**\n * Checks if the given token is a closing brace token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ClosingBraceToken} `true` if the token is a closing brace token.\n */\nexport function isClosingBraceToken(token) {\n return isPunctuatorTokenWithValue(token, \"}\")\n}\n\n/**\n * Checks if the given token is a comment token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is Comment} `true` if the token is a comment token.\n */\nexport function isCommentToken(token) {\n return [\"Block\", \"Line\", \"Shebang\"].includes(token.type)\n}\n\nexport const isNotArrowToken = negate(isArrowToken)\nexport const isNotCommaToken = negate(isCommaToken)\nexport const isNotSemicolonToken = negate(isSemicolonToken)\nexport const isNotColonToken = negate(isColonToken)\nexport const isNotOpeningParenToken = negate(isOpeningParenToken)\nexport const isNotClosingParenToken = negate(isClosingParenToken)\nexport const isNotOpeningBracketToken = negate(isOpeningBracketToken)\nexport const isNotClosingBracketToken = negate(isClosingBracketToken)\nexport const isNotOpeningBraceToken = negate(isOpeningBraceToken)\nexport const isNotClosingBraceToken = negate(isClosingBraceToken)\nexport const isNotCommentToken = negate(isCommentToken)\n","import { isArrowToken, isOpeningParenToken } from \"./token-predicate.mjs\"\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"estree\").Function} FunctionNode */\n/** @typedef {import(\"estree\").FunctionDeclaration} FunctionDeclaration */\n/** @typedef {import(\"estree\").FunctionExpression} FunctionExpression */\n/** @typedef {import(\"estree\").SourceLocation} SourceLocation */\n/** @typedef {import(\"estree\").Position} Position */\n\n/**\n * Get the `(` token of the given function node.\n * @param {FunctionExpression | FunctionDeclaration} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {Token} `(` token.\n */\nfunction getOpeningParenOfParams(node, sourceCode) {\n return node.id\n ? /** @type {Token} */ (\n sourceCode.getTokenAfter(node.id, isOpeningParenToken)\n )\n : /** @type {Token} */ (\n sourceCode.getFirstToken(node, isOpeningParenToken)\n )\n}\n\n/**\n * Get the location of the given function node for reporting.\n * @param {FunctionNode} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {SourceLocation|null} The location of the function node for reporting.\n */\nexport function getFunctionHeadLocation(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n /** @type {Position|null} */\n let start = null\n /** @type {Position|null} */\n let end = null\n\n if (node.type === \"ArrowFunctionExpression\") {\n const arrowToken = /** @type {Token} */ (\n sourceCode.getTokenBefore(node.body, isArrowToken)\n )\n\n start = arrowToken.loc.start\n end = arrowToken.loc.end\n } else if (\n parent &&\n (parent.type === \"Property\" ||\n parent.type === \"MethodDefinition\" ||\n parent.type === \"PropertyDefinition\")\n ) {\n start = /** @type {SourceLocation} */ (parent.loc).start\n end = getOpeningParenOfParams(node, sourceCode).loc.start\n } else {\n start = /** @type {SourceLocation} */ (node.loc).start\n end = getOpeningParenOfParams(node, sourceCode).loc.start\n }\n\n return {\n start: { ...start },\n end: { ...end },\n }\n}\n","/* globals self, window */\n\nimport { findVariable } from \"./find-variable.mjs\"\n/** @typedef {import(\"./types.mjs\").StaticValue} StaticValue */\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Node} TSESTreeNode */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.MemberExpression} MemberExpression */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Property} Property */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.RegExpLiteral} RegExpLiteral */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.BigIntLiteral} BigIntLiteral */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Literal} Literal */\n\nconst globalObject =\n typeof globalThis !== \"undefined\"\n ? globalThis\n : // @ts-ignore\n typeof self !== \"undefined\"\n ? // @ts-ignore\n self\n : // @ts-ignore\n typeof window !== \"undefined\"\n ? // @ts-ignore\n window\n : typeof global !== \"undefined\"\n ? global\n : {}\n\nconst builtinNames = Object.freeze(\n new Set([\n \"Array\",\n \"ArrayBuffer\",\n \"BigInt\",\n \"BigInt64Array\",\n \"BigUint64Array\",\n \"Boolean\",\n \"DataView\",\n \"Date\",\n \"decodeURI\",\n \"decodeURIComponent\",\n \"encodeURI\",\n \"encodeURIComponent\",\n \"escape\",\n \"Float32Array\",\n \"Float64Array\",\n \"Function\",\n \"Infinity\",\n \"Int16Array\",\n \"Int32Array\",\n \"Int8Array\",\n \"isFinite\",\n \"isNaN\",\n \"isPrototypeOf\",\n \"JSON\",\n \"Map\",\n \"Math\",\n \"NaN\",\n \"Number\",\n \"Object\",\n \"parseFloat\",\n \"parseInt\",\n \"Promise\",\n \"Proxy\",\n \"Reflect\",\n \"RegExp\",\n \"Set\",\n \"String\",\n \"Symbol\",\n \"Uint16Array\",\n \"Uint32Array\",\n \"Uint8Array\",\n \"Uint8ClampedArray\",\n \"undefined\",\n \"unescape\",\n \"WeakMap\",\n \"WeakSet\",\n ]),\n)\nconst callAllowed = new Set(\n [\n Array.isArray,\n Array.of,\n Array.prototype.at,\n Array.prototype.concat,\n Array.prototype.entries,\n Array.prototype.every,\n Array.prototype.filter,\n Array.prototype.find,\n Array.prototype.findIndex,\n Array.prototype.flat,\n Array.prototype.includes,\n Array.prototype.indexOf,\n Array.prototype.join,\n Array.prototype.keys,\n Array.prototype.lastIndexOf,\n Array.prototype.slice,\n Array.prototype.some,\n Array.prototype.toString,\n Array.prototype.values,\n typeof BigInt === \"function\" ? BigInt : undefined,\n Boolean,\n Date,\n Date.parse,\n decodeURI,\n decodeURIComponent,\n encodeURI,\n encodeURIComponent,\n escape,\n isFinite,\n isNaN,\n // @ts-ignore\n isPrototypeOf,\n Map,\n Map.prototype.entries,\n Map.prototype.get,\n Map.prototype.has,\n Map.prototype.keys,\n Map.prototype.values,\n .../** @type {(keyof typeof Math)[]} */ (\n Object.getOwnPropertyNames(Math)\n )\n .filter((k) => k !== \"random\")\n .map((k) => Math[k])\n .filter((f) => typeof f === \"function\"),\n Number,\n Number.isFinite,\n Number.isNaN,\n Number.parseFloat,\n Number.parseInt,\n Number.prototype.toExponential,\n Number.prototype.toFixed,\n Number.prototype.toPrecision,\n Number.prototype.toString,\n Object,\n Object.entries,\n Object.is,\n Object.isExtensible,\n Object.isFrozen,\n Object.isSealed,\n Object.keys,\n Object.values,\n parseFloat,\n parseInt,\n RegExp,\n Set,\n Set.prototype.entries,\n Set.prototype.has,\n Set.prototype.keys,\n Set.prototype.values,\n String,\n String.fromCharCode,\n String.fromCodePoint,\n String.raw,\n String.prototype.at,\n String.prototype.charAt,\n String.prototype.charCodeAt,\n String.prototype.codePointAt,\n String.prototype.concat,\n String.prototype.endsWith,\n String.prototype.includes,\n String.prototype.indexOf,\n String.prototype.lastIndexOf,\n String.prototype.normalize,\n String.prototype.padEnd,\n String.prototype.padStart,\n String.prototype.slice,\n String.prototype.startsWith,\n String.prototype.substr,\n String.prototype.substring,\n String.prototype.toLowerCase,\n String.prototype.toString,\n String.prototype.toUpperCase,\n String.prototype.trim,\n String.prototype.trimEnd,\n String.prototype.trimLeft,\n String.prototype.trimRight,\n String.prototype.trimStart,\n Symbol.for,\n Symbol.keyFor,\n unescape,\n ].filter((f) => typeof f === \"function\"),\n)\nconst callPassThrough = new Set([\n Object.freeze,\n Object.preventExtensions,\n Object.seal,\n])\n\n/** @type {ReadonlyArray]>} */\nconst getterAllowed = [\n [Map, new Set([\"size\"])],\n [\n RegExp,\n new Set([\n \"dotAll\",\n \"flags\",\n \"global\",\n \"hasIndices\",\n \"ignoreCase\",\n \"multiline\",\n \"source\",\n \"sticky\",\n \"unicode\",\n ]),\n ],\n [Set, new Set([\"size\"])],\n]\n\n/**\n * Get the property descriptor.\n * @param {object} object The object to get.\n * @param {string|number|symbol} name The property name to get.\n */\nfunction getPropertyDescriptor(object, name) {\n let x = object\n while ((typeof x === \"object\" || typeof x === \"function\") && x !== null) {\n const d = Object.getOwnPropertyDescriptor(x, name)\n if (d) {\n return d\n }\n x = Object.getPrototypeOf(x)\n }\n return null\n}\n\n/**\n * Check if a property is getter or not.\n * @param {object} object The object to check.\n * @param {string|number|symbol} name The property name to check.\n */\nfunction isGetter(object, name) {\n const d = getPropertyDescriptor(object, name)\n return d != null && d.get != null\n}\n\n/**\n * Get the element values of a given node list.\n * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values.\n * @param {Scope|undefined|null} initialScope The initial scope to find variables.\n * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.\n */\nfunction getElementValues(nodeList, initialScope) {\n const valueList = []\n\n for (let i = 0; i < nodeList.length; ++i) {\n const elementNode = nodeList[i]\n\n if (elementNode == null) {\n valueList.length = i + 1\n } else if (elementNode.type === \"SpreadElement\") {\n const argument = getStaticValueR(elementNode.argument, initialScope)\n if (argument == null) {\n return null\n }\n valueList.push(.../** @type {Iterable} */ (argument.value))\n } else {\n const element = getStaticValueR(elementNode, initialScope)\n if (element == null) {\n return null\n }\n valueList.push(element.value)\n }\n }\n\n return valueList\n}\n\n/**\n * Checks if a variable is a built-in global.\n * @param {Variable|null} variable The variable to check.\n * @returns {variable is Variable & {defs:[]}}\n */\nfunction isBuiltinGlobal(variable) {\n return (\n variable != null &&\n variable.defs.length === 0 &&\n builtinNames.has(variable.name) &&\n variable.name in globalObject\n )\n}\n\n/**\n * Checks if a variable can be considered as a constant.\n * @param {Variable} variable\n * @returns {variable is Variable & {defs: [import(\"eslint\").Scope.Definition & { type: \"Variable\" }]}} True if the variable can be considered as a constant.\n */\nfunction canBeConsideredConst(variable) {\n if (variable.defs.length !== 1) {\n return false\n }\n const def = variable.defs[0]\n return Boolean(\n def.parent &&\n def.type === \"Variable\" &&\n (def.parent.kind === \"const\" || isEffectivelyConst(variable)),\n )\n}\n\n/**\n * Returns whether the given variable is never written to after initialization.\n * @param {Variable} variable\n * @returns {boolean}\n */\nfunction isEffectivelyConst(variable) {\n const refs = variable.references\n\n const inits = refs.filter((r) => r.init).length\n const reads = refs.filter((r) => r.isReadOnly()).length\n if (inits === 1 && reads + inits === refs.length) {\n // there is only one init and all other references only read\n return true\n }\n return false\n}\n\n/**\n * Checks if a variable has mutation in its property.\n * @param {Variable} variable The variable to check.\n * @param {Scope|null} initialScope The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {boolean} True if the variable has mutation in its property.\n */\nfunction hasMutationInProperty(variable, initialScope) {\n for (const ref of variable.references) {\n let node = /** @type {TSESTreeNode} */ (ref.identifier)\n while (node && node.parent && node.parent.type === \"MemberExpression\") {\n node = node.parent\n }\n if (!node || !node.parent) {\n continue\n }\n if (\n (node.parent.type === \"AssignmentExpression\" &&\n node.parent.left === node) ||\n (node.parent.type === \"UpdateExpression\" &&\n node.parent.argument === node)\n ) {\n // This is a mutation.\n return true\n }\n if (\n node.parent.type === \"CallExpression\" &&\n node.parent.callee === node &&\n node.type === \"MemberExpression\"\n ) {\n const methodName = getStaticPropertyNameValue(node, initialScope)\n if (isNameOfMutationArrayMethod(methodName)) {\n // This is a mutation.\n return true\n }\n }\n }\n return false\n\n /**\n * Checks if a method name is one of the mutation array methods.\n * @param {StaticValue|null} methodName The method name to check.\n * @returns {boolean} True if the method name is a mutation array method.\n */\n function isNameOfMutationArrayMethod(methodName) {\n if (methodName == null || methodName.value == null) {\n return false\n }\n const name = methodName.value\n return (\n name === \"copyWithin\" ||\n name === \"fill\" ||\n name === \"pop\" ||\n name === \"push\" ||\n name === \"reverse\" ||\n name === \"shift\" ||\n name === \"sort\" ||\n name === \"splice\" ||\n name === \"unshift\"\n )\n }\n}\n\n/**\n * @template {TSESTreeNodeTypes} T\n * @callback VisitorCallback\n * @param {TSESTreeNode & { type: T }} node\n * @param {Scope|undefined|null} initialScope\n * @returns {StaticValue | null}\n */\n/**\n * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback } } Operations\n */\n/**\n * @type {Operations}\n */\nconst operations = Object.freeze({\n ArrayExpression(node, initialScope) {\n const elements = getElementValues(node.elements, initialScope)\n return elements != null ? { value: elements } : null\n },\n\n AssignmentExpression(node, initialScope) {\n if (node.operator === \"=\") {\n return getStaticValueR(node.right, initialScope)\n }\n return null\n },\n\n //eslint-disable-next-line complexity\n BinaryExpression(node, initialScope) {\n if (node.operator === \"in\" || node.operator === \"instanceof\") {\n // Not supported.\n return null\n }\n\n const left = getStaticValueR(node.left, initialScope)\n const right = getStaticValueR(node.right, initialScope)\n if (left != null && right != null) {\n switch (node.operator) {\n case \"==\":\n return { value: left.value == right.value } //eslint-disable-line eqeqeq\n case \"!=\":\n return { value: left.value != right.value } //eslint-disable-line eqeqeq\n case \"===\":\n return { value: left.value === right.value }\n case \"!==\":\n return { value: left.value !== right.value }\n case \"<\":\n return {\n value:\n /** @type {any} */ (left.value) <\n /** @type {any} */ (right.value),\n }\n case \"<=\":\n return {\n value:\n /** @type {any} */ (left.value) <=\n /** @type {any} */ (right.value),\n }\n case \">\":\n return {\n value:\n /** @type {any} */ (left.value) >\n /** @type {any} */ (right.value),\n }\n case \">=\":\n return {\n value:\n /** @type {any} */ (left.value) >=\n /** @type {any} */ (right.value),\n }\n case \"<<\":\n return {\n value:\n /** @type {any} */ (left.value) <<\n /** @type {any} */ (right.value),\n }\n case \">>\":\n return {\n value:\n /** @type {any} */ (left.value) >>\n /** @type {any} */ (right.value),\n }\n case \">>>\":\n return {\n value:\n /** @type {any} */ (left.value) >>>\n /** @type {any} */ (right.value),\n }\n case \"+\":\n return {\n value:\n /** @type {any} */ (left.value) +\n /** @type {any} */ (right.value),\n }\n case \"-\":\n return {\n value:\n /** @type {any} */ (left.value) -\n /** @type {any} */ (right.value),\n }\n case \"*\":\n return {\n value:\n /** @type {any} */ (left.value) *\n /** @type {any} */ (right.value),\n }\n case \"/\":\n return {\n value:\n /** @type {any} */ (left.value) /\n /** @type {any} */ (right.value),\n }\n case \"%\":\n return {\n value:\n /** @type {any} */ (left.value) %\n /** @type {any} */ (right.value),\n }\n case \"**\":\n return {\n value:\n /** @type {any} */ (left.value) **\n /** @type {any} */ (right.value),\n }\n case \"|\":\n return {\n value:\n /** @type {any} */ (left.value) |\n /** @type {any} */ (right.value),\n }\n case \"^\":\n return {\n value:\n /** @type {any} */ (left.value) ^\n /** @type {any} */ (right.value),\n }\n case \"&\":\n return {\n value:\n /** @type {any} */ (left.value) &\n /** @type {any} */ (right.value),\n }\n\n // no default\n }\n }\n\n return null\n },\n\n CallExpression(node, initialScope) {\n const calleeNode = node.callee\n const args = getElementValues(node.arguments, initialScope)\n\n if (args != null) {\n if (calleeNode.type === \"MemberExpression\") {\n if (calleeNode.property.type === \"PrivateIdentifier\") {\n return null\n }\n const object = getStaticValueR(calleeNode.object, initialScope)\n if (object != null) {\n if (\n object.value == null &&\n (object.optional || node.optional)\n ) {\n return { value: undefined, optional: true }\n }\n const property = getStaticPropertyNameValue(\n calleeNode,\n initialScope,\n )\n\n if (property != null) {\n const receiver =\n /** @type {Record any>} */ (\n object.value\n )\n const methodName = /** @type {PropertyKey} */ (\n property.value\n )\n if (callAllowed.has(receiver[methodName])) {\n return {\n value: receiver[methodName](...args),\n }\n }\n if (callPassThrough.has(receiver[methodName])) {\n return { value: args[0] }\n }\n }\n }\n } else {\n const callee = getStaticValueR(calleeNode, initialScope)\n if (callee != null) {\n if (callee.value == null && node.optional) {\n return { value: undefined, optional: true }\n }\n const func = /** @type {(...args: any[]) => any} */ (\n callee.value\n )\n if (callAllowed.has(func)) {\n return { value: func(...args) }\n }\n if (callPassThrough.has(func)) {\n return { value: args[0] }\n }\n }\n }\n }\n\n return null\n },\n\n ConditionalExpression(node, initialScope) {\n const test = getStaticValueR(node.test, initialScope)\n if (test != null) {\n return test.value\n ? getStaticValueR(node.consequent, initialScope)\n : getStaticValueR(node.alternate, initialScope)\n }\n return null\n },\n\n ExpressionStatement(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n\n Identifier(node, initialScope) {\n if (initialScope != null) {\n const variable = findVariable(initialScope, node)\n\n if (variable != null) {\n // Built-in globals.\n if (isBuiltinGlobal(variable)) {\n return { value: globalObject[variable.name] }\n }\n\n // Constants.\n if (canBeConsideredConst(variable)) {\n const def = variable.defs[0]\n if (\n // TODO(mysticatea): don't support destructuring here.\n def.node.id.type === \"Identifier\"\n ) {\n const init = getStaticValueR(\n def.node.init,\n initialScope,\n )\n if (\n init &&\n typeof init.value === \"object\" &&\n init.value !== null\n ) {\n if (hasMutationInProperty(variable, initialScope)) {\n // This variable has mutation in its property.\n return null\n }\n }\n return init\n }\n }\n }\n }\n return null\n },\n\n Literal(node) {\n const literal =\n /** @type {Partial & Partial & Partial} */ (\n node\n )\n //istanbul ignore if : this is implementation-specific behavior.\n if (\n (literal.regex != null || literal.bigint != null) &&\n literal.value == null\n ) {\n // It was a RegExp/BigInt literal, but Node.js didn't support it.\n return null\n }\n return { value: literal.value }\n },\n\n LogicalExpression(node, initialScope) {\n const left = getStaticValueR(node.left, initialScope)\n if (left != null) {\n if (\n (node.operator === \"||\" && Boolean(left.value) === true) ||\n (node.operator === \"&&\" && Boolean(left.value) === false) ||\n (node.operator === \"??\" && left.value != null)\n ) {\n return left\n }\n\n const right = getStaticValueR(node.right, initialScope)\n if (right != null) {\n return right\n }\n }\n\n return null\n },\n\n MemberExpression(node, initialScope) {\n if (node.property.type === \"PrivateIdentifier\") {\n return null\n }\n const object = getStaticValueR(node.object, initialScope)\n if (object != null) {\n if (object.value == null && (object.optional || node.optional)) {\n return { value: undefined, optional: true }\n }\n const property = getStaticPropertyNameValue(node, initialScope)\n\n if (property != null) {\n if (\n !isGetter(\n /** @type {object} */ (object.value),\n /** @type {PropertyKey} */ (property.value),\n )\n ) {\n return {\n value: /** @type {Record} */ (\n object.value\n )[/** @type {PropertyKey} */ (property.value)],\n }\n }\n\n for (const [classFn, allowed] of getterAllowed) {\n if (\n object.value instanceof classFn &&\n allowed.has(/** @type {string} */ (property.value))\n ) {\n return {\n value: /** @type {Record} */ (\n object.value\n )[/** @type {PropertyKey} */ (property.value)],\n }\n }\n }\n }\n }\n return null\n },\n\n ChainExpression(node, initialScope) {\n const expression = getStaticValueR(node.expression, initialScope)\n if (expression != null) {\n return { value: expression.value }\n }\n return null\n },\n\n NewExpression(node, initialScope) {\n const callee = getStaticValueR(node.callee, initialScope)\n const args = getElementValues(node.arguments, initialScope)\n\n if (callee != null && args != null) {\n const Func = /** @type {new (...args: any[]) => any} */ (\n callee.value\n )\n if (callAllowed.has(Func)) {\n return { value: new Func(...args) }\n }\n }\n\n return null\n },\n\n ObjectExpression(node, initialScope) {\n /** @type {Record} */\n const object = {}\n\n for (const propertyNode of node.properties) {\n if (propertyNode.type === \"Property\") {\n if (propertyNode.kind !== \"init\") {\n return null\n }\n const key = getStaticPropertyNameValue(\n propertyNode,\n initialScope,\n )\n const value = getStaticValueR(propertyNode.value, initialScope)\n if (key == null || value == null) {\n return null\n }\n object[/** @type {PropertyKey} */ (key.value)] = value.value\n } else if (\n propertyNode.type === \"SpreadElement\" ||\n // @ts-expect-error -- Backward compatibility\n propertyNode.type === \"ExperimentalSpreadProperty\"\n ) {\n const argument = getStaticValueR(\n propertyNode.argument,\n initialScope,\n )\n if (argument == null) {\n return null\n }\n Object.assign(object, argument.value)\n } else {\n return null\n }\n }\n\n return { value: object }\n },\n\n SequenceExpression(node, initialScope) {\n const last = node.expressions[node.expressions.length - 1]\n return getStaticValueR(last, initialScope)\n },\n\n TaggedTemplateExpression(node, initialScope) {\n const tag = getStaticValueR(node.tag, initialScope)\n const expressions = getElementValues(\n node.quasi.expressions,\n initialScope,\n )\n\n if (tag != null && expressions != null) {\n const func = /** @type {(...args: any[]) => any} */ (tag.value)\n /** @type {any[] & { raw?: string[] }} */\n const strings = node.quasi.quasis.map((q) => q.value.cooked)\n strings.raw = node.quasi.quasis.map((q) => q.value.raw)\n\n if (func === String.raw) {\n return { value: func(strings, ...expressions) }\n }\n }\n\n return null\n },\n\n TemplateLiteral(node, initialScope) {\n const expressions = getElementValues(node.expressions, initialScope)\n if (expressions != null) {\n let value = node.quasis[0].value.cooked\n for (let i = 0; i < expressions.length; ++i) {\n value += expressions[i]\n value += /** @type {string} */ (node.quasis[i + 1].value.cooked)\n }\n return { value }\n }\n return null\n },\n\n UnaryExpression(node, initialScope) {\n if (node.operator === \"delete\") {\n // Not supported.\n return null\n }\n if (node.operator === \"void\") {\n return { value: undefined }\n }\n\n const arg = getStaticValueR(node.argument, initialScope)\n if (arg != null) {\n switch (node.operator) {\n case \"-\":\n return { value: -(/** @type {any} */ (arg.value)) }\n case \"+\":\n return { value: +(/** @type {any} */ (arg.value)) } //eslint-disable-line no-implicit-coercion\n case \"!\":\n return { value: !arg.value }\n case \"~\":\n return { value: ~(/** @type {any} */ (arg.value)) }\n case \"typeof\":\n return { value: typeof arg.value }\n\n // no default\n }\n }\n\n return null\n },\n TSAsExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSSatisfiesExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSTypeAssertion(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSNonNullExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n TSInstantiationExpression(node, initialScope) {\n return getStaticValueR(node.expression, initialScope)\n },\n})\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node|TSESTreeNode|null|undefined} node The node to get.\n * @param {Scope|undefined|null} initialScope The scope to start finding variable.\n * @returns {StaticValue|null} The static value of the node, or `null`.\n */\nfunction getStaticValueR(node, initialScope) {\n if (node != null && Object.hasOwnProperty.call(operations, node.type)) {\n return /** @type {VisitorCallback} */ (operations[node.type])(\n /** @type {TSESTreeNode} */ (node),\n initialScope,\n )\n }\n return null\n}\n\n/**\n * Get the static value of property name from a MemberExpression node or a Property node.\n * @param {MemberExpression|Property} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {StaticValue|null} The static value of the property name of the node, or `null`.\n */\nfunction getStaticPropertyNameValue(node, initialScope) {\n const nameNode = node.type === \"Property\" ? node.key : node.property\n\n if (node.computed) {\n return getStaticValueR(nameNode, initialScope)\n }\n\n if (nameNode.type === \"Identifier\") {\n return { value: nameNode.name }\n }\n\n if (nameNode.type === \"Literal\") {\n if (/** @type {Partial} */ (nameNode).bigint) {\n return { value: /** @type {BigIntLiteral} */ (nameNode).bigint }\n }\n return { value: String(nameNode.value) }\n }\n\n return null\n}\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.\n * @returns {StaticValue | null} The static value of the node, or `null`.\n */\nexport function getStaticValue(node, initialScope = null) {\n try {\n return getStaticValueR(node, initialScope)\n } catch (_error) {\n return null\n }\n}\n","import { getStaticValue } from \"./get-static-value.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"estree\").RegExpLiteral} RegExpLiteral */\n/** @typedef {import(\"estree\").BigIntLiteral} BigIntLiteral */\n/** @typedef {import(\"estree\").SimpleLiteral} SimpleLiteral */\n\n/**\n * Get the value of a given node if it's a literal or a template literal.\n * @param {Node} node The node to get.\n * @param {Scope|null} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.\n * @returns {string|null} The value of the node, or `null`.\n */\nexport function getStringIfConstant(node, initialScope = null) {\n // Handle the literals that the platform doesn't support natively.\n if (node && node.type === \"Literal\" && node.value === null) {\n const literal =\n /** @type {Partial & Partial & Partial} */ (\n node\n )\n if (literal.regex) {\n return `/${literal.regex.pattern}/${literal.regex.flags}`\n }\n if (literal.bigint) {\n return literal.bigint\n }\n }\n\n const evaluated = getStaticValue(node, initialScope)\n\n if (evaluated) {\n // `String(Symbol.prototype)` throws error\n try {\n return String(evaluated.value)\n } catch {\n // No op\n }\n }\n\n return null\n}\n","import { getStringIfConstant } from \"./get-string-if-constant.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").MemberExpression} MemberExpression */\n/** @typedef {import(\"estree\").MethodDefinition} MethodDefinition */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").PropertyDefinition} PropertyDefinition */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Get the property name from a MemberExpression node or a Property node.\n * @param {MemberExpression | MethodDefinition | Property | PropertyDefinition} node The node to get.\n * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {string|null|undefined} The property name of the node.\n */\nexport function getPropertyName(node, initialScope) {\n switch (node.type) {\n case \"MemberExpression\":\n if (node.computed) {\n return getStringIfConstant(node.property, initialScope)\n }\n if (node.property.type === \"PrivateIdentifier\") {\n return null\n }\n return /** @type {Partial} */ (node.property).name\n\n case \"Property\":\n case \"MethodDefinition\":\n case \"PropertyDefinition\":\n if (node.computed) {\n return getStringIfConstant(node.key, initialScope)\n }\n if (node.key.type === \"Literal\") {\n return String(node.key.value)\n }\n if (node.key.type === \"PrivateIdentifier\") {\n return null\n }\n return /** @type {Partial} */ (node.key).name\n\n default:\n break\n }\n\n return null\n}\n","import { getPropertyName } from \"./get-property-name.mjs\"\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"estree\").Function} FunctionNode */\n/** @typedef {import(\"estree\").FunctionDeclaration} FunctionDeclaration */\n/** @typedef {import(\"estree\").FunctionExpression} FunctionExpression */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Get the name and kind of the given function node.\n * @param {FunctionNode} node - The function node to get.\n * @param {SourceCode} [sourceCode] The source code object to get the code of computed property keys.\n * @returns {string} The name and kind of the function node.\n */\n// eslint-disable-next-line complexity\nexport function getFunctionNameWithKind(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n if (!parent) {\n return \"\"\n }\n\n const tokens = []\n const isObjectMethod = parent.type === \"Property\" && parent.value === node\n const isClassMethod =\n parent.type === \"MethodDefinition\" && parent.value === node\n const isClassFieldMethod =\n parent.type === \"PropertyDefinition\" && parent.value === node\n\n // Modifiers.\n if (isClassMethod || isClassFieldMethod) {\n if (parent.static) {\n tokens.push(\"static\")\n }\n if (parent.key.type === \"PrivateIdentifier\") {\n tokens.push(\"private\")\n }\n }\n if (node.async) {\n tokens.push(\"async\")\n }\n if (node.generator) {\n tokens.push(\"generator\")\n }\n\n // Kinds.\n if (isObjectMethod || isClassMethod) {\n if (parent.kind === \"constructor\") {\n return \"constructor\"\n }\n if (parent.kind === \"get\") {\n tokens.push(\"getter\")\n } else if (parent.kind === \"set\") {\n tokens.push(\"setter\")\n } else {\n tokens.push(\"method\")\n }\n } else if (isClassFieldMethod) {\n tokens.push(\"method\")\n } else {\n if (node.type === \"ArrowFunctionExpression\") {\n tokens.push(\"arrow\")\n }\n tokens.push(\"function\")\n }\n\n // Names.\n if (isObjectMethod || isClassMethod || isClassFieldMethod) {\n if (parent.key.type === \"PrivateIdentifier\") {\n tokens.push(`#${parent.key.name}`)\n } else {\n const name = getPropertyName(parent)\n if (name) {\n tokens.push(`'${name}'`)\n } else if (sourceCode) {\n const keyText = sourceCode.getText(parent.key)\n if (!keyText.includes(\"\\n\")) {\n tokens.push(`[${keyText}]`)\n }\n }\n }\n } else if (hasId(node)) {\n tokens.push(`'${node.id.name}'`)\n } else if (\n parent.type === \"VariableDeclarator\" &&\n parent.id &&\n parent.id.type === \"Identifier\"\n ) {\n tokens.push(`'${parent.id.name}'`)\n } else if (\n (parent.type === \"AssignmentExpression\" ||\n parent.type === \"AssignmentPattern\") &&\n parent.left &&\n parent.left.type === \"Identifier\"\n ) {\n tokens.push(`'${parent.left.name}'`)\n } else if (\n parent.type === \"ExportDefaultDeclaration\" &&\n parent.declaration === node\n ) {\n tokens.push(\"'default'\")\n }\n\n return tokens.join(\" \")\n}\n\n/**\n * @param {FunctionNode} node\n * @returns {node is FunctionDeclaration | FunctionExpression & { id: Identifier }}\n */\nfunction hasId(node) {\n return Boolean(\n /** @type {Partial} */ (node)\n .id,\n )\n}\n","import { getKeys, KEYS } from \"eslint-visitor-keys\"\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"./types.mjs\").HasSideEffectOptions} HasSideEffectOptions */\n/** @typedef {import(\"estree\").BinaryExpression} BinaryExpression */\n/** @typedef {import(\"estree\").MemberExpression} MemberExpression */\n/** @typedef {import(\"estree\").MethodDefinition} MethodDefinition */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").PropertyDefinition} PropertyDefinition */\n/** @typedef {import(\"estree\").UnaryExpression} UnaryExpression */\n\nconst typeConversionBinaryOps = Object.freeze(\n new Set([\n \"==\",\n \"!=\",\n \"<\",\n \"<=\",\n \">\",\n \">=\",\n \"<<\",\n \">>\",\n \">>>\",\n \"+\",\n \"-\",\n \"*\",\n \"/\",\n \"%\",\n \"|\",\n \"^\",\n \"&\",\n \"in\",\n ]),\n)\nconst typeConversionUnaryOps = Object.freeze(new Set([\"-\", \"+\", \"!\", \"~\"]))\n\n/**\n * Check whether the given value is an ASTNode or not.\n * @param {any} x The value to check.\n * @returns {x is Node} `true` if the value is an ASTNode.\n */\nfunction isNode(x) {\n return x !== null && typeof x === \"object\" && typeof x.type === \"string\"\n}\n\nconst visitor = Object.freeze(\n Object.assign(Object.create(null), {\n /**\n * @param {Node} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n $visit(node, options, visitorKeys) {\n const { type } = node\n\n if (typeof (/** @type {any} */ (this)[type]) === \"function\") {\n return /** @type {any} */ (this)[type](\n node,\n options,\n visitorKeys,\n )\n }\n\n return this.$visitChildren(node, options, visitorKeys)\n },\n\n /**\n * @param {Node} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n $visitChildren(node, options, visitorKeys) {\n const { type } = node\n\n for (const key of /** @type {(keyof Node)[]} */ (\n visitorKeys[type] || getKeys(node)\n )) {\n const value = node[key]\n\n if (Array.isArray(value)) {\n for (const element of value) {\n if (\n isNode(element) &&\n this.$visit(element, options, visitorKeys)\n ) {\n return true\n }\n }\n } else if (\n isNode(value) &&\n this.$visit(value, options, visitorKeys)\n ) {\n return true\n }\n }\n\n return false\n },\n\n ArrowFunctionExpression() {\n return false\n },\n AssignmentExpression() {\n return true\n },\n AwaitExpression() {\n return true\n },\n /**\n * @param {BinaryExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n BinaryExpression(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n typeConversionBinaryOps.has(node.operator) &&\n (node.left.type !== \"Literal\" || node.right.type !== \"Literal\")\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n CallExpression() {\n return true\n },\n FunctionExpression() {\n return false\n },\n ImportExpression() {\n return true\n },\n /**\n * @param {MemberExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n MemberExpression(node, options, visitorKeys) {\n if (options.considerGetters) {\n return true\n }\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.property.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {MethodDefinition} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n MethodDefinition(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n NewExpression() {\n return true\n },\n /**\n * @param {Property} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n Property(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {PropertyDefinition} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n PropertyDefinition(node, options, visitorKeys) {\n if (\n options.considerImplicitTypeConversion &&\n node.computed &&\n node.key.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n /**\n * @param {UnaryExpression} node\n * @param {HasSideEffectOptions} options\n * @param {Record} visitorKeys\n */\n UnaryExpression(node, options, visitorKeys) {\n if (node.operator === \"delete\") {\n return true\n }\n if (\n options.considerImplicitTypeConversion &&\n typeConversionUnaryOps.has(node.operator) &&\n node.argument.type !== \"Literal\"\n ) {\n return true\n }\n return this.$visitChildren(node, options, visitorKeys)\n },\n UpdateExpression() {\n return true\n },\n YieldExpression() {\n return true\n },\n }),\n)\n\n/**\n * Check whether a given node has any side effect or not.\n * @param {Node} node The node to get.\n * @param {SourceCode} sourceCode The source code object.\n * @param {HasSideEffectOptions} [options] The option object.\n * @returns {boolean} `true` if the node has a certain side effect.\n */\nexport function hasSideEffect(node, sourceCode, options = {}) {\n const { considerGetters = false, considerImplicitTypeConversion = false } =\n options\n return visitor.$visit(\n node,\n { considerGetters, considerImplicitTypeConversion },\n sourceCode.visitorKeys || KEYS,\n )\n}\n","import { isClosingParenToken, isOpeningParenToken } from \"./token-predicate.mjs\"\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.NewExpression} TSNewExpression */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.CallExpression} TSCallExpression */\n/** @typedef {import(\"eslint\").SourceCode} SourceCode */\n/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n\n/**\n * Get the left parenthesis of the parent node syntax if it exists.\n * E.g., `if (a) {}` then the `(`.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {Token|null} The left parenthesis of the parent node syntax\n */\n// eslint-disable-next-line complexity\nfunction getParentSyntaxParen(node, sourceCode) {\n const parent = /** @type {RuleNode} */ (node).parent\n\n if (!parent) {\n return null\n }\n\n switch (parent.type) {\n case \"CallExpression\":\n case \"NewExpression\":\n if (parent.arguments.length === 1 && parent.arguments[0] === node) {\n return sourceCode.getTokenAfter(\n // @ts-expect-error https://github.com/typescript-eslint/typescript-eslint/pull/5384\n parent.typeArguments ||\n /** @type {RuleNode} */ (\n /** @type {unknown} */ (\n /** @type {TSNewExpression | TSCallExpression} */ (\n parent\n ).typeParameters\n )\n ) ||\n parent.callee,\n isOpeningParenToken,\n )\n }\n return null\n\n case \"DoWhileStatement\":\n if (parent.test === node) {\n return sourceCode.getTokenAfter(\n parent.body,\n isOpeningParenToken,\n )\n }\n return null\n\n case \"IfStatement\":\n case \"WhileStatement\":\n if (parent.test === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"ImportExpression\":\n if (parent.source === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"SwitchStatement\":\n if (parent.discriminant === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n case \"WithStatement\":\n if (parent.object === node) {\n return sourceCode.getFirstToken(parent, 1)\n }\n return null\n\n default:\n return null\n }\n}\n\n/**\n * Check whether a given node is parenthesized or not.\n * @param {number} times The number of parantheses.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized the given times.\n */\n/**\n * Check whether a given node is parenthesized or not.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized.\n */\n/**\n * Check whether a given node is parenthesized or not.\n * @param {Node|number} timesOrNode The first parameter.\n * @param {Node|SourceCode} nodeOrSourceCode The second parameter.\n * @param {SourceCode} [optionalSourceCode] The third parameter.\n * @returns {boolean} `true` if the node is parenthesized.\n */\nexport function isParenthesized(\n timesOrNode,\n nodeOrSourceCode,\n optionalSourceCode,\n) {\n /** @type {number} */\n let times,\n /** @type {RuleNode} */\n node,\n /** @type {SourceCode} */\n sourceCode,\n maybeLeftParen,\n maybeRightParen\n if (typeof timesOrNode === \"number\") {\n times = timesOrNode | 0\n node = /** @type {RuleNode} */ (nodeOrSourceCode)\n sourceCode = /** @type {SourceCode} */ (optionalSourceCode)\n if (!(times >= 1)) {\n throw new TypeError(\"'times' should be a positive integer.\")\n }\n } else {\n times = 1\n node = /** @type {RuleNode} */ (timesOrNode)\n sourceCode = /** @type {SourceCode} */ (nodeOrSourceCode)\n }\n\n if (\n node == null ||\n // `Program` can't be parenthesized\n node.parent == null ||\n // `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`\n (node.parent.type === \"CatchClause\" && node.parent.param === node)\n ) {\n return false\n }\n\n maybeLeftParen = maybeRightParen = node\n do {\n maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen)\n maybeRightParen = sourceCode.getTokenAfter(maybeRightParen)\n } while (\n maybeLeftParen != null &&\n maybeRightParen != null &&\n isOpeningParenToken(maybeLeftParen) &&\n isClosingParenToken(maybeRightParen) &&\n // Avoid false positive such as `if (a) {}`\n maybeLeftParen !== getParentSyntaxParen(node, sourceCode) &&\n --times > 0\n )\n\n return times === 0\n}\n","/**\n * @author Toru Nagashima \n * See LICENSE file in root directory for full license.\n */\n\nconst placeholder = /\\$(?:[$&`']|[1-9][0-9]?)/gu\n\n/** @type {WeakMap} */\nconst internal = new WeakMap()\n\n/**\n * Check whether a given character is escaped or not.\n * @param {string} str The string to check.\n * @param {number} index The location of the character to check.\n * @returns {boolean} `true` if the character is escaped.\n */\nfunction isEscaped(str, index) {\n let escaped = false\n for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) {\n escaped = !escaped\n }\n return escaped\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {string} replacement The new substring to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceS(matcher, str, replacement) {\n const chunks = []\n let index = 0\n\n /**\n * @param {string} key The placeholder.\n * @param {RegExpExecArray} match The matched information.\n * @returns {string} The replaced string.\n */\n function replacer(key, match) {\n switch (key) {\n case \"$$\":\n return \"$\"\n case \"$&\":\n return match[0]\n case \"$`\":\n return str.slice(0, match.index)\n case \"$'\":\n return str.slice(match.index + match[0].length)\n default: {\n const i = key.slice(1)\n if (i in match) {\n return match[/** @type {any} */ (i)]\n }\n return key\n }\n }\n }\n\n for (const match of matcher.execAll(str)) {\n chunks.push(str.slice(index, match.index))\n chunks.push(\n replacement.replace(placeholder, (key) => replacer(key, match)),\n )\n index = match.index + match[0].length\n }\n chunks.push(str.slice(index))\n\n return chunks.join(\"\")\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {(substring: string, ...args: any[]) => string} replace The function to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceF(matcher, str, replace) {\n const chunks = []\n let index = 0\n\n for (const match of matcher.execAll(str)) {\n chunks.push(str.slice(index, match.index))\n chunks.push(\n String(\n replace(\n .../** @type {[string, ...string[]]} */ (\n /** @type {string[]} */ (match)\n ),\n match.index,\n match.input,\n ),\n ),\n )\n index = match.index + match[0].length\n }\n chunks.push(str.slice(index))\n\n return chunks.join(\"\")\n}\n\n/**\n * The class to find patterns as considering escape sequences.\n */\nexport class PatternMatcher {\n /**\n * Initialize this matcher.\n * @param {RegExp} pattern The pattern to match.\n * @param {{escaped?:boolean}} [options] The options.\n */\n constructor(pattern, options = {}) {\n const { escaped = false } = options\n if (!(pattern instanceof RegExp)) {\n throw new TypeError(\"'pattern' should be a RegExp instance.\")\n }\n if (!pattern.flags.includes(\"g\")) {\n throw new Error(\"'pattern' should contains 'g' flag.\")\n }\n\n internal.set(this, {\n pattern: new RegExp(pattern.source, pattern.flags),\n escaped: Boolean(escaped),\n })\n }\n\n /**\n * Find the pattern in a given string.\n * @param {string} str The string to find.\n * @returns {IterableIterator} The iterator which iterate the matched information.\n */\n *execAll(str) {\n const { pattern, escaped } =\n /** @type {{pattern:RegExp,escaped:boolean}} */ (internal.get(this))\n let match = null\n let lastIndex = 0\n\n pattern.lastIndex = 0\n while ((match = pattern.exec(str)) != null) {\n if (escaped || !isEscaped(str, match.index)) {\n lastIndex = pattern.lastIndex\n yield match\n pattern.lastIndex = lastIndex\n }\n }\n }\n\n /**\n * Check whether the pattern is found in a given string.\n * @param {string} str The string to check.\n * @returns {boolean} `true` if the pattern was found in the string.\n */\n test(str) {\n const it = this.execAll(str)\n const ret = it.next()\n return !ret.done\n }\n\n /**\n * Replace a given string.\n * @param {string} str The string to be replaced.\n * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.\n * @returns {string} The replaced string.\n */\n [Symbol.replace](str, replacer) {\n return typeof replacer === \"function\"\n ? replaceF(this, String(str), replacer)\n : replaceS(this, String(str), String(replacer))\n }\n}\n","import { findVariable } from \"./find-variable.mjs\"\nimport { getPropertyName } from \"./get-property-name.mjs\"\nimport { getStringIfConstant } from \"./get-string-if-constant.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"eslint\").Rule.Node} RuleNode */\n/** @typedef {import(\"estree\").Node} Node */\n/** @typedef {import(\"estree\").Expression} Expression */\n/** @typedef {import(\"estree\").Pattern} Pattern */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n/** @typedef {import(\"estree\").SimpleCallExpression} CallExpression */\n/** @typedef {import(\"estree\").Program} Program */\n/** @typedef {import(\"estree\").ImportDeclaration} ImportDeclaration */\n/** @typedef {import(\"estree\").ExportAllDeclaration} ExportAllDeclaration */\n/** @typedef {import(\"estree\").ExportDefaultDeclaration} ExportDefaultDeclaration */\n/** @typedef {import(\"estree\").ExportNamedDeclaration} ExportNamedDeclaration */\n/** @typedef {import(\"estree\").ImportSpecifier} ImportSpecifier */\n/** @typedef {import(\"estree\").ImportDefaultSpecifier} ImportDefaultSpecifier */\n/** @typedef {import(\"estree\").ImportNamespaceSpecifier} ImportNamespaceSpecifier */\n/** @typedef {import(\"estree\").ExportSpecifier} ExportSpecifier */\n/** @typedef {import(\"estree\").Property} Property */\n/** @typedef {import(\"estree\").AssignmentProperty} AssignmentProperty */\n/** @typedef {import(\"estree\").Literal} Literal */\n/** @typedef {import(\"@typescript-eslint/types\").TSESTree.Node} TSESTreeNode */\n/** @typedef {import(\"./types.mjs\").ReferenceTrackerOptions} ReferenceTrackerOptions */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMap} TraceMap\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMapObject} TraceMapObject\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TrackedReferences} TrackedReferences\n */\n\nconst IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u\n\n/**\n * Check whether a given node is an import node or not.\n * @param {Node} node\n * @returns {node is ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration&{source: Literal}} `true` if the node is an import node.\n */\nfunction isHasSource(node) {\n return (\n IMPORT_TYPE.test(node.type) &&\n /** @type {ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration} */ (\n node\n ).source != null\n )\n}\nconst has =\n /** @type {(traceMap: TraceMap, v: T) => v is (string extends T ? string : T)} */ (\n Function.call.bind(Object.hasOwnProperty)\n )\n\nexport const READ = Symbol(\"read\")\nexport const CALL = Symbol(\"call\")\nexport const CONSTRUCT = Symbol(\"construct\")\nexport const ESM = Symbol(\"esm\")\n\nconst requireCall = { require: { [CALL]: true } }\n\n/**\n * Check whether a given variable is modified or not.\n * @param {Variable|undefined} variable The variable to check.\n * @returns {boolean} `true` if the variable is modified.\n */\nfunction isModifiedGlobal(variable) {\n return (\n variable == null ||\n variable.defs.length !== 0 ||\n variable.references.some((r) => r.isWrite())\n )\n}\n\n/**\n * Check if the value of a given node is passed through to the parent syntax as-is.\n * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.\n * @param {Node} node A node to check.\n * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through.\n */\nfunction isPassThrough(node) {\n const parent = /** @type {TSESTreeNode} */ (node).parent\n\n if (parent) {\n switch (parent.type) {\n case \"ConditionalExpression\":\n return parent.consequent === node || parent.alternate === node\n case \"LogicalExpression\":\n return true\n case \"SequenceExpression\":\n return (\n parent.expressions[parent.expressions.length - 1] === node\n )\n case \"ChainExpression\":\n return true\n case \"TSAsExpression\":\n case \"TSSatisfiesExpression\":\n case \"TSTypeAssertion\":\n case \"TSNonNullExpression\":\n case \"TSInstantiationExpression\":\n return true\n\n default:\n return false\n }\n }\n return false\n}\n\n/**\n * The reference tracker.\n */\nexport class ReferenceTracker {\n /**\n * Initialize this tracker.\n * @param {Scope} globalScope The global scope.\n * @param {object} [options] The options.\n * @param {\"legacy\"|\"strict\"} [options.mode=\"strict\"] The mode to determine the ImportDeclaration's behavior for CJS modules.\n * @param {string[]} [options.globalObjectNames=[\"global\",\"globalThis\",\"self\",\"window\"]] The variable names for Global Object.\n */\n constructor(globalScope, options = {}) {\n const {\n mode = \"strict\",\n globalObjectNames = [\"global\", \"globalThis\", \"self\", \"window\"],\n } = options\n /** @private @type {Variable[]} */\n this.variableStack = []\n /** @private */\n this.globalScope = globalScope\n /** @private */\n this.mode = mode\n /** @private */\n this.globalObjectNames = globalObjectNames.slice(0)\n }\n\n /**\n * Iterate the references of global variables.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateGlobalReferences(traceMap) {\n for (const key of Object.keys(traceMap)) {\n const nextTraceMap = traceMap[key]\n const path = [key]\n const variable = this.globalScope.set.get(key)\n\n if (isModifiedGlobal(variable)) {\n continue\n }\n\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (variable),\n path,\n nextTraceMap,\n true,\n )\n }\n\n for (const key of this.globalObjectNames) {\n /** @type {string[]} */\n const path = []\n const variable = this.globalScope.set.get(key)\n\n if (isModifiedGlobal(variable)) {\n continue\n }\n\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (variable),\n path,\n traceMap,\n false,\n )\n }\n }\n\n /**\n * Iterate the references of CommonJS modules.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateCjsReferences(traceMap) {\n for (const { node } of this.iterateGlobalReferences(requireCall)) {\n const key = getStringIfConstant(\n /** @type {CallExpression} */ (node).arguments[0],\n )\n if (key == null || !has(traceMap, key)) {\n continue\n }\n\n const nextTraceMap = traceMap[key]\n const path = [key]\n\n if (nextTraceMap[READ]) {\n yield {\n node,\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iteratePropertyReferences(\n /** @type {CallExpression} */ (node),\n path,\n nextTraceMap,\n )\n }\n }\n\n /**\n * Iterate the references of ES modules.\n * @template T\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *iterateEsmReferences(traceMap) {\n const programNode = /** @type {Program} */ (this.globalScope.block)\n\n for (const node of programNode.body) {\n if (!isHasSource(node)) {\n continue\n }\n const moduleId = /** @type {string} */ (node.source.value)\n\n if (!has(traceMap, moduleId)) {\n continue\n }\n const nextTraceMap = traceMap[moduleId]\n const path = [moduleId]\n\n if (nextTraceMap[READ]) {\n yield {\n // eslint-disable-next-line object-shorthand -- apply type\n node: /** @type {RuleNode} */ (node),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n\n if (node.type === \"ExportAllDeclaration\") {\n for (const key of Object.keys(nextTraceMap)) {\n const exportTraceMap = nextTraceMap[key]\n if (exportTraceMap[READ]) {\n yield {\n // eslint-disable-next-line object-shorthand -- apply type\n node: /** @type {RuleNode} */ (node),\n path: path.concat(key),\n type: READ,\n info: exportTraceMap[READ],\n }\n }\n }\n } else {\n for (const specifier of node.specifiers) {\n const esm = has(nextTraceMap, ESM)\n const it = this._iterateImportReferences(\n specifier,\n path,\n esm\n ? nextTraceMap\n : this.mode === \"legacy\"\n ? { default: nextTraceMap, ...nextTraceMap }\n : { default: nextTraceMap },\n )\n\n if (esm) {\n yield* it\n } else {\n for (const report of it) {\n report.path = report.path.filter(exceptDefault)\n if (\n report.path.length >= 2 ||\n report.type !== READ\n ) {\n yield report\n }\n }\n }\n }\n }\n }\n }\n\n /**\n * Iterate the property references for a given expression AST node.\n * @template T\n * @param {Expression} node The expression AST node to iterate property references.\n * @param {TraceMap} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate property references.\n */\n *iteratePropertyReferences(node, traceMap) {\n yield* this._iteratePropertyReferences(node, [], traceMap)\n }\n\n /**\n * Iterate the references for a given variable.\n * @private\n * @template T\n * @param {Variable} variable The variable to iterate that references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @param {boolean} shouldReport = The flag to report those references.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateVariableReferences(variable, path, traceMap, shouldReport) {\n if (this.variableStack.includes(variable)) {\n return\n }\n this.variableStack.push(variable)\n try {\n for (const reference of variable.references) {\n if (!reference.isRead()) {\n continue\n }\n const node = /** @type {RuleNode & Identifier} */ (\n reference.identifier\n )\n\n if (shouldReport && traceMap[READ]) {\n yield { node, path, type: READ, info: traceMap[READ] }\n }\n yield* this._iteratePropertyReferences(node, path, traceMap)\n }\n } finally {\n this.variableStack.pop()\n }\n }\n\n /**\n * Iterate the references for a given AST node.\n * @private\n * @template T\n * @param {Expression} rootNode The AST node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n //eslint-disable-next-line complexity\n *_iteratePropertyReferences(rootNode, path, traceMap) {\n let node = rootNode\n while (isPassThrough(node)) {\n node = node.parent\n }\n\n const parent = /** @type {RuleNode} */ (node).parent\n if (!parent) {\n return\n }\n if (parent.type === \"MemberExpression\") {\n if (parent.object === node) {\n const key = getPropertyName(parent)\n if (key == null || !has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: parent,\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iteratePropertyReferences(\n parent,\n path,\n nextTraceMap,\n )\n }\n return\n }\n if (parent.type === \"CallExpression\") {\n if (parent.callee === node && traceMap[CALL]) {\n yield { node: parent, path, type: CALL, info: traceMap[CALL] }\n }\n return\n }\n if (parent.type === \"NewExpression\") {\n if (parent.callee === node && traceMap[CONSTRUCT]) {\n yield {\n node: parent,\n path,\n type: CONSTRUCT,\n info: traceMap[CONSTRUCT],\n }\n }\n return\n }\n if (parent.type === \"AssignmentExpression\") {\n if (parent.right === node) {\n yield* this._iterateLhsReferences(parent.left, path, traceMap)\n yield* this._iteratePropertyReferences(parent, path, traceMap)\n }\n return\n }\n if (parent.type === \"AssignmentPattern\") {\n if (parent.right === node) {\n yield* this._iterateLhsReferences(parent.left, path, traceMap)\n }\n return\n }\n if (parent.type === \"VariableDeclarator\") {\n if (parent.init === node) {\n yield* this._iterateLhsReferences(parent.id, path, traceMap)\n }\n }\n }\n\n /**\n * Iterate the references for a given Pattern node.\n * @private\n * @template T\n * @param {Pattern} patternNode The Pattern node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateLhsReferences(patternNode, path, traceMap) {\n if (patternNode.type === \"Identifier\") {\n const variable = findVariable(this.globalScope, patternNode)\n if (variable != null) {\n yield* this._iterateVariableReferences(\n variable,\n path,\n traceMap,\n false,\n )\n }\n return\n }\n if (patternNode.type === \"ObjectPattern\") {\n for (const property of patternNode.properties) {\n const key = getPropertyName(\n /** @type {AssignmentProperty} */ (property),\n )\n\n if (key == null || !has(traceMap, key)) {\n continue\n }\n\n const nextPath = path.concat(key)\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (property),\n path: nextPath,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iterateLhsReferences(\n /** @type {AssignmentProperty} */ (property).value,\n nextPath,\n nextTraceMap,\n )\n }\n return\n }\n if (patternNode.type === \"AssignmentPattern\") {\n yield* this._iterateLhsReferences(patternNode.left, path, traceMap)\n }\n }\n\n /**\n * Iterate the references for a given ModuleSpecifier node.\n * @private\n * @template T\n * @param {ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier} specifierNode The ModuleSpecifier node to iterate references.\n * @param {string[]} path The current path.\n * @param {TraceMapObject} traceMap The trace map.\n * @returns {IterableIterator>} The iterator to iterate references.\n */\n *_iterateImportReferences(specifierNode, path, traceMap) {\n const type = specifierNode.type\n\n if (type === \"ImportSpecifier\" || type === \"ImportDefaultSpecifier\") {\n const key =\n type === \"ImportDefaultSpecifier\"\n ? \"default\"\n : specifierNode.imported.type === \"Identifier\"\n ? specifierNode.imported.name\n : specifierNode.imported.value\n if (!has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (specifierNode),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (\n findVariable(this.globalScope, specifierNode.local)\n ),\n path,\n nextTraceMap,\n false,\n )\n\n return\n }\n\n if (type === \"ImportNamespaceSpecifier\") {\n yield* this._iterateVariableReferences(\n /** @type {Variable} */ (\n findVariable(this.globalScope, specifierNode.local)\n ),\n path,\n traceMap,\n false,\n )\n return\n }\n\n if (type === \"ExportSpecifier\") {\n const key =\n specifierNode.local.type === \"Identifier\"\n ? specifierNode.local.name\n : specifierNode.local.value\n if (!has(traceMap, key)) {\n return\n }\n\n path = path.concat(key) //eslint-disable-line no-param-reassign\n const nextTraceMap = traceMap[key]\n if (nextTraceMap[READ]) {\n yield {\n node: /** @type {RuleNode} */ (specifierNode),\n path,\n type: READ,\n info: nextTraceMap[READ],\n }\n }\n }\n }\n}\n\nReferenceTracker.READ = READ\nReferenceTracker.CALL = CALL\nReferenceTracker.CONSTRUCT = CONSTRUCT\nReferenceTracker.ESM = ESM\n\n/**\n * This is a predicate function for Array#filter.\n * @param {string} name A name part.\n * @param {number} index The index of the name.\n * @returns {boolean} `false` if it's default.\n */\nfunction exceptDefault(name, index) {\n return !(index === 1 && name === \"default\")\n}\n","/** @typedef {import(\"./types.mjs\").StaticValue} StaticValue */\n/** @typedef {import(\"./types.mjs\").StaticValueOptional} StaticValueOptional */\n/** @typedef {import(\"./types.mjs\").StaticValueProvided} StaticValueProvided */\n/** @typedef {import(\"./types.mjs\").ReferenceTrackerOptions} ReferenceTrackerOptions */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TraceMap} TraceMap\n */\n/**\n * @template T\n * @typedef {import(\"./types.mjs\").TrackedReferences} TrackedReferences\n */\n/** @typedef {import(\"./types.mjs\").HasSideEffectOptions} HasSideEffectOptions */\n/** @typedef {import(\"./types.mjs\").ArrowToken} ArrowToken */\n/** @typedef {import(\"./types.mjs\").CommaToken} CommaToken */\n/** @typedef {import(\"./types.mjs\").SemicolonToken} SemicolonToken */\n/** @typedef {import(\"./types.mjs\").ColonToken} ColonToken */\n/** @typedef {import(\"./types.mjs\").OpeningParenToken} OpeningParenToken */\n/** @typedef {import(\"./types.mjs\").ClosingParenToken} ClosingParenToken */\n/** @typedef {import(\"./types.mjs\").OpeningBracketToken} OpeningBracketToken */\n/** @typedef {import(\"./types.mjs\").ClosingBracketToken} ClosingBracketToken */\n/** @typedef {import(\"./types.mjs\").OpeningBraceToken} OpeningBraceToken */\n/** @typedef {import(\"./types.mjs\").ClosingBraceToken} ClosingBraceToken */\n\nimport { findVariable } from \"./find-variable.mjs\"\nimport { getFunctionHeadLocation } from \"./get-function-head-location.mjs\"\nimport { getFunctionNameWithKind } from \"./get-function-name-with-kind.mjs\"\nimport { getInnermostScope } from \"./get-innermost-scope.mjs\"\nimport { getPropertyName } from \"./get-property-name.mjs\"\nimport { getStaticValue } from \"./get-static-value.mjs\"\nimport { getStringIfConstant } from \"./get-string-if-constant.mjs\"\nimport { hasSideEffect } from \"./has-side-effect.mjs\"\nimport { isParenthesized } from \"./is-parenthesized.mjs\"\nimport { PatternMatcher } from \"./pattern-matcher.mjs\"\nimport {\n CALL,\n CONSTRUCT,\n ESM,\n READ,\n ReferenceTracker,\n} from \"./reference-tracker.mjs\"\nimport {\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isSemicolonToken,\n} from \"./token-predicate.mjs\"\n\nexport default {\n CALL,\n CONSTRUCT,\n ESM,\n findVariable,\n getFunctionHeadLocation,\n getFunctionNameWithKind,\n getInnermostScope,\n getPropertyName,\n getStaticValue,\n getStringIfConstant,\n hasSideEffect,\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isParenthesized,\n isSemicolonToken,\n PatternMatcher,\n READ,\n ReferenceTracker,\n}\nexport {\n CALL,\n CONSTRUCT,\n ESM,\n findVariable,\n getFunctionHeadLocation,\n getFunctionNameWithKind,\n getInnermostScope,\n getPropertyName,\n getStaticValue,\n getStringIfConstant,\n hasSideEffect,\n isArrowToken,\n isClosingBraceToken,\n isClosingBracketToken,\n isClosingParenToken,\n isColonToken,\n isCommaToken,\n isCommentToken,\n isNotArrowToken,\n isNotClosingBraceToken,\n isNotClosingBracketToken,\n isNotClosingParenToken,\n isNotColonToken,\n isNotCommaToken,\n isNotCommentToken,\n isNotOpeningBraceToken,\n isNotOpeningBracketToken,\n isNotOpeningParenToken,\n isNotSemicolonToken,\n isOpeningBraceToken,\n isOpeningBracketToken,\n isOpeningParenToken,\n isParenthesized,\n isSemicolonToken,\n PatternMatcher,\n READ,\n ReferenceTracker,\n}\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,iBAAiB,CAAC,YAAY,EAAE,IAAI,EAAE;AACtD,IAAI,MAAM,QAAQ,mCAAmC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAC;AACpE;AACA,IAAI,IAAI,KAAK,GAAG,aAAY;AAC5B,IAAI,IAAI,KAAK,GAAG,MAAK;AACrB,IAAI,GAAG;AACP,QAAQ,KAAK,GAAG,MAAK;AACrB,QAAQ,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE;AACpD,YAAY,MAAM,KAAK;AACvB,gBAAgB,UAAU,CAAC,KAAK,CAAC,KAAK;AACtC,cAAa;AACb;AACA,YAAY,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,QAAQ,IAAI,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE;AAC7D,gBAAgB,KAAK,GAAG,WAAU;AAClC,gBAAgB,KAAK,GAAG,KAAI;AAC5B,gBAAgB,KAAK;AACrB,aAAa;AACb,SAAS;AACT,KAAK,QAAQ,KAAK,CAAC;AACnB;AACA,IAAI,OAAO,KAAK;AAChB;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,YAAY,EAAE,UAAU,EAAE;AACvD,IAAI,IAAI,IAAI,GAAG,GAAE;AACjB;AACA,IAAI,IAAI,KAAK,GAAG,aAAY;AAC5B;AACA,IAAI,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;AACxC,QAAQ,IAAI,GAAG,WAAU;AACzB,KAAK,MAAM;AACX,QAAQ,IAAI,GAAG,UAAU,CAAC,KAAI;AAC9B,QAAQ,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAC;AACpD,KAAK;AACL;AACA,IAAI,OAAO,KAAK,IAAI,IAAI,EAAE;AAC1B,QAAQ,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAC;AAC5C,QAAQ,IAAI,QAAQ,IAAI,IAAI,EAAE;AAC9B,YAAY,OAAO,QAAQ;AAC3B,SAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,MAAK;AAC3B,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,CAAC,EAAE;AACnB,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,0BAA0B,CAAC,KAAK,EAAE,KAAK,EAAE;AAClD,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK;AAC/D,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC;AAClD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gBAAgB,CAAC,KAAK,EAAE;AACxC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,KAAK,EAAE;AACpC,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,qBAAqB,CAAC,KAAK,EAAE;AAC7C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,qBAAqB,CAAC,KAAK,EAAE;AAC7C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,KAAK,EAAE;AAC3C,IAAI,OAAO,0BAA0B,CAAC,KAAK,EAAE,GAAG,CAAC;AACjD,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,KAAK,EAAE;AACtC,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC;AAC5D,CAAC;AACD;AACY,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAC;AAC/C,MAAC,eAAe,GAAG,MAAM,CAAC,YAAY,EAAC;AACvC,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,wBAAwB,GAAG,MAAM,CAAC,qBAAqB,EAAC;AACzD,MAAC,wBAAwB,GAAG,MAAM,CAAC,qBAAqB,EAAC;AACzD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,sBAAsB,GAAG,MAAM,CAAC,mBAAmB,EAAC;AACrD,MAAC,iBAAiB,GAAG,MAAM,CAAC,cAAc;;ACnJtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AACnD,IAAI,OAAO,IAAI,CAAC,EAAE;AAClB;AACA,cAAc,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,EAAE,mBAAmB,CAAC;AACpE;AACA;AACA,cAAc,UAAU,CAAC,aAAa,CAAC,IAAI,EAAE,mBAAmB,CAAC;AACjE,WAAW;AACX,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AAC1D,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA;AACA,IAAI,IAAI,KAAK,GAAG,KAAI;AACpB;AACA,IAAI,IAAI,GAAG,GAAG,KAAI;AAClB;AACA,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,yBAAyB,EAAE;AACjD,QAAQ,MAAM,UAAU;AACxB,YAAY,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;AAC9D,UAAS;AACT;AACA,QAAQ,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,MAAK;AACpC,QAAQ,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,IAAG;AAChC,KAAK,MAAM;AACX,QAAQ,MAAM;AACd,SAAS,MAAM,CAAC,IAAI,KAAK,UAAU;AACnC,YAAY,MAAM,CAAC,IAAI,KAAK,kBAAkB;AAC9C,YAAY,MAAM,CAAC,IAAI,KAAK,oBAAoB,CAAC;AACjD,MAAM;AACN,QAAQ,KAAK,iCAAiC,CAAC,MAAM,CAAC,GAAG,EAAE,MAAK;AAChE,QAAQ,GAAG,GAAG,uBAAuB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,MAAK;AACjE,KAAK,MAAM;AACX,QAAQ,KAAK,iCAAiC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAK;AAC9D,QAAQ,GAAG,GAAG,uBAAuB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,MAAK;AACjE,KAAK;AACL;AACA,IAAI,OAAO;AACX,QAAQ,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE;AAC3B,QAAQ,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE;AACvB,KAAK;AACL;;AChEA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,YAAY;AAClB,IAAI,OAAO,UAAU,KAAK,WAAW;AACrC,UAAU,UAAU;AACpB;AACA,QAAQ,OAAO,IAAI,KAAK,WAAW;AACnC;AACA,UAAU,IAAI;AACd;AACA,QAAQ,OAAO,MAAM,KAAK,WAAW;AACrC;AACA,UAAU,MAAM;AAChB,UAAU,OAAO,MAAM,KAAK,WAAW;AACvC,UAAU,MAAM;AAChB,UAAU,GAAE;AACZ;AACA,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM;AAClC,IAAI,IAAI,GAAG,CAAC;AACZ,QAAQ,OAAO;AACf,QAAQ,aAAa;AACrB,QAAQ,QAAQ;AAChB,QAAQ,eAAe;AACvB,QAAQ,gBAAgB;AACxB,QAAQ,SAAS;AACjB,QAAQ,UAAU;AAClB,QAAQ,MAAM;AACd,QAAQ,WAAW;AACnB,QAAQ,oBAAoB;AAC5B,QAAQ,WAAW;AACnB,QAAQ,oBAAoB;AAC5B,QAAQ,QAAQ;AAChB,QAAQ,cAAc;AACtB,QAAQ,cAAc;AACtB,QAAQ,UAAU;AAClB,QAAQ,UAAU;AAClB,QAAQ,YAAY;AACpB,QAAQ,YAAY;AACpB,QAAQ,WAAW;AACnB,QAAQ,UAAU;AAClB,QAAQ,OAAO;AACf,QAAQ,eAAe;AACvB,QAAQ,MAAM;AACd,QAAQ,KAAK;AACb,QAAQ,MAAM;AACd,QAAQ,KAAK;AACb,QAAQ,QAAQ;AAChB,QAAQ,QAAQ;AAChB,QAAQ,YAAY;AACpB,QAAQ,UAAU;AAClB,QAAQ,SAAS;AACjB,QAAQ,OAAO;AACf,QAAQ,SAAS;AACjB,QAAQ,QAAQ;AAChB,QAAQ,KAAK;AACb,QAAQ,QAAQ;AAChB,QAAQ,QAAQ;AAChB,QAAQ,aAAa;AACrB,QAAQ,aAAa;AACrB,QAAQ,YAAY;AACpB,QAAQ,mBAAmB;AAC3B,QAAQ,WAAW;AACnB,QAAQ,UAAU;AAClB,QAAQ,SAAS;AACjB,QAAQ,SAAS;AACjB,KAAK,CAAC;AACN,EAAC;AACD,MAAM,WAAW,GAAG,IAAI,GAAG;AAC3B,IAAI;AACJ,QAAQ,KAAK,CAAC,OAAO;AACrB,QAAQ,KAAK,CAAC,EAAE;AAChB,QAAQ,KAAK,CAAC,SAAS,CAAC,EAAE;AAC1B,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,KAAK,CAAC,SAAS,CAAC,OAAO;AAC/B,QAAQ,KAAK,CAAC,SAAS,CAAC,KAAK;AAC7B,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,SAAS;AACjC,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,QAAQ;AAChC,QAAQ,KAAK,CAAC,SAAS,CAAC,OAAO;AAC/B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,WAAW;AACnC,QAAQ,KAAK,CAAC,SAAS,CAAC,KAAK;AAC7B,QAAQ,KAAK,CAAC,SAAS,CAAC,IAAI;AAC5B,QAAQ,KAAK,CAAC,SAAS,CAAC,QAAQ;AAChC,QAAQ,KAAK,CAAC,SAAS,CAAC,MAAM;AAC9B,QAAQ,OAAO,MAAM,KAAK,UAAU,GAAG,MAAM,GAAG,SAAS;AACzD,QAAQ,OAAO;AACf,QAAQ,IAAI;AACZ,QAAQ,IAAI,CAAC,KAAK;AAClB,QAAQ,SAAS;AACjB,QAAQ,kBAAkB;AAC1B,QAAQ,SAAS;AACjB,QAAQ,kBAAkB;AAC1B,QAAQ,MAAM;AACd,QAAQ,QAAQ;AAChB,QAAQ,KAAK;AACb;AACA,QAAQ,aAAa;AACrB,QAAQ,GAAG;AACX,QAAQ,GAAG,CAAC,SAAS,CAAC,OAAO;AAC7B,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,IAAI;AAC1B,QAAQ,GAAG,CAAC,SAAS,CAAC,MAAM;AAC5B,QAAQ,wCAAwC;AAChD,YAAY,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC;AAC5C;AACA,aAAa,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC;AAC1C,aAAa,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;AAChC,aAAa,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,UAAU,CAAC;AACnD,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,KAAK;AACpB,QAAQ,MAAM,CAAC,UAAU;AACzB,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,SAAS,CAAC,aAAa;AACtC,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,OAAO;AACtB,QAAQ,MAAM,CAAC,EAAE;AACjB,QAAQ,MAAM,CAAC,YAAY;AAC3B,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,QAAQ;AACvB,QAAQ,MAAM,CAAC,IAAI;AACnB,QAAQ,MAAM,CAAC,MAAM;AACrB,QAAQ,UAAU;AAClB,QAAQ,QAAQ;AAChB,QAAQ,MAAM;AACd,QAAQ,GAAG;AACX,QAAQ,GAAG,CAAC,SAAS,CAAC,OAAO;AAC7B,QAAQ,GAAG,CAAC,SAAS,CAAC,GAAG;AACzB,QAAQ,GAAG,CAAC,SAAS,CAAC,IAAI;AAC1B,QAAQ,GAAG,CAAC,SAAS,CAAC,MAAM;AAC5B,QAAQ,MAAM;AACd,QAAQ,MAAM,CAAC,YAAY;AAC3B,QAAQ,MAAM,CAAC,aAAa;AAC5B,QAAQ,MAAM,CAAC,GAAG;AAClB,QAAQ,MAAM,CAAC,SAAS,CAAC,EAAE;AAC3B,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,UAAU;AACnC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,KAAK;AAC9B,QAAQ,MAAM,CAAC,SAAS,CAAC,UAAU;AACnC,QAAQ,MAAM,CAAC,SAAS,CAAC,MAAM;AAC/B,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,WAAW;AACpC,QAAQ,MAAM,CAAC,SAAS,CAAC,IAAI;AAC7B,QAAQ,MAAM,CAAC,SAAS,CAAC,OAAO;AAChC,QAAQ,MAAM,CAAC,SAAS,CAAC,QAAQ;AACjC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,SAAS,CAAC,SAAS;AAClC,QAAQ,MAAM,CAAC,GAAG;AAClB,QAAQ,MAAM,CAAC,MAAM;AACrB,QAAQ,QAAQ;AAChB,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,KAAK,UAAU,CAAC;AAC5C,EAAC;AACD,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;AAChC,IAAI,MAAM,CAAC,MAAM;AACjB,IAAI,MAAM,CAAC,iBAAiB;AAC5B,IAAI,MAAM,CAAC,IAAI;AACf,CAAC,EAAC;AACF;AACA;AACA,MAAM,aAAa,GAAG;AACtB,IAAI,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5B,IAAI;AACJ,QAAQ,MAAM;AACd,QAAQ,IAAI,GAAG,CAAC;AAChB,YAAY,QAAQ;AACpB,YAAY,OAAO;AACnB,YAAY,QAAQ;AACpB,YAAY,YAAY;AACxB,YAAY,YAAY;AACxB,YAAY,WAAW;AACvB,YAAY,QAAQ;AACpB,YAAY,QAAQ;AACpB,YAAY,SAAS;AACrB,SAAS,CAAC;AACV,KAAK;AACL,IAAI,CAAC,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5B,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAE;AAC7C,IAAI,IAAI,CAAC,GAAG,OAAM;AAClB,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,UAAU,KAAK,CAAC,KAAK,IAAI,EAAE;AAC7E,QAAQ,MAAM,CAAC,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAC;AAC1D,QAAQ,IAAI,CAAC,EAAE;AACf,YAAY,OAAO,CAAC;AACpB,SAAS;AACT,QAAQ,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,EAAC;AACpC,KAAK;AACL,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE;AAChC,IAAI,MAAM,CAAC,GAAG,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAC;AACjD,IAAI,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI;AACrC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE;AAClD,IAAI,MAAM,SAAS,GAAG,GAAE;AACxB;AACA,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;AAC9C,QAAQ,MAAM,WAAW,GAAG,QAAQ,CAAC,CAAC,EAAC;AACvC;AACA,QAAQ,IAAI,WAAW,IAAI,IAAI,EAAE;AACjC,YAAY,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,EAAC;AACpC,SAAS,MAAM,IAAI,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE;AACzD,YAAY,MAAM,QAAQ,GAAG,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAC;AAChF,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,SAAS,CAAC,IAAI,CAAC,iCAAiC,QAAQ,CAAC,KAAK,CAAC,EAAC;AAC5E,SAAS,MAAM;AACf,YAAY,MAAM,OAAO,GAAG,eAAe,CAAC,WAAW,EAAE,YAAY,EAAC;AACtE,YAAY,IAAI,OAAO,IAAI,IAAI,EAAE;AACjC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAC;AACzC,SAAS;AACT,KAAK;AACL;AACA,IAAI,OAAO,SAAS;AACpB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,QAAQ,EAAE;AACnC,IAAI;AACJ,QAAQ,QAAQ,IAAI,IAAI;AACxB,QAAQ,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;AAClC,QAAQ,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;AACvC,QAAQ,QAAQ,CAAC,IAAI,IAAI,YAAY;AACrC,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,oBAAoB,CAAC,QAAQ,EAAE;AACxC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;AACpC,QAAQ,OAAO,KAAK;AACpB,KAAK;AACL,IAAI,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC;AAChC,IAAI,OAAO,OAAO;AAClB,QAAQ,GAAG,CAAC,MAAM;AAClB,YAAY,GAAG,CAAC,IAAI,KAAK,UAAU;AACnC,aAAa,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,IAAI,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AACzE,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,kBAAkB,CAAC,QAAQ,EAAE;AACtC,IAAI,MAAM,IAAI,GAAG,QAAQ,CAAC,WAAU;AACpC;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,OAAM;AACnD,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,OAAM;AAC3D,IAAI,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,GAAG,KAAK,KAAK,IAAI,CAAC,MAAM,EAAE;AACtD;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL,IAAI,OAAO,KAAK;AAChB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,QAAQ,EAAE,YAAY,EAAE;AACvD,IAAI,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,UAAU,EAAE;AAC3C,QAAQ,IAAI,IAAI,gCAAgC,GAAG,CAAC,UAAU,EAAC;AAC/D,QAAQ,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE;AAC/E,YAAY,IAAI,GAAG,IAAI,CAAC,OAAM;AAC9B,SAAS;AACT,QAAQ,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AACnC,YAAY,QAAQ;AACpB,SAAS;AACT,QAAQ;AACR,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;AACxD,gBAAgB,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI;AACzC,aAAa,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;AACpD,gBAAgB,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,IAAI,CAAC;AAC9C,UAAU;AACV;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ;AACR,YAAY,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,gBAAgB;AACjD,YAAY,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI;AACvC,YAAY,IAAI,CAAC,IAAI,KAAK,kBAAkB;AAC5C,UAAU;AACV,YAAY,MAAM,UAAU,GAAG,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7E,YAAY,IAAI,2BAA2B,CAAC,UAAU,CAAC,EAAE;AACzD;AACA,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,SAAS;AACT,KAAK;AACL,IAAI,OAAO,KAAK;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,2BAA2B,CAAC,UAAU,EAAE;AACrD,QAAQ,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,KAAK,IAAI,IAAI,EAAE;AAC5D,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,MAAM,IAAI,GAAG,UAAU,CAAC,MAAK;AACrC,QAAQ;AACR,YAAY,IAAI,KAAK,YAAY;AACjC,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,KAAK;AAC1B,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,SAAS;AAC9B,YAAY,IAAI,KAAK,OAAO;AAC5B,YAAY,IAAI,KAAK,MAAM;AAC3B,YAAY,IAAI,KAAK,QAAQ;AAC7B,YAAY,IAAI,KAAK,SAAS;AAC9B,SAAS;AACT,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC;AACjC,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAC;AACtE,QAAQ,OAAO,QAAQ,IAAI,IAAI,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI;AAC5D,KAAK;AACL;AACA,IAAI,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC7C,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE;AACnC,YAAY,OAAO,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC;AAC5D,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY,EAAE;AACtE;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAC;AAC/D,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,EAAE;AAC3C,YAAY,QAAQ,IAAI,CAAC,QAAQ;AACjC,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;AAC/D,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;AAC/D,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE;AAChE,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE;AAChE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,KAAK;AAC1B,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,IAAI;AACzB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK;AAC7B,+CAA+C,CAAC,IAAI,CAAC,KAAK;AAC1D,gDAAgD,KAAK,CAAC,KAAK,CAAC;AAC5D,qBAAqB;AACrB;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE;AACvC,QAAQ,MAAM,UAAU,GAAG,IAAI,CAAC,OAAM;AACtC,QAAQ,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,EAAC;AACnE;AACA,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY,IAAI,UAAU,CAAC,IAAI,KAAK,kBAAkB,EAAE;AACxD,gBAAgB,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACtE,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,MAAM,GAAG,eAAe,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,EAAC;AAC/E,gBAAgB,IAAI,MAAM,IAAI,IAAI,EAAE;AACpC,oBAAoB;AACpB,wBAAwB,MAAM,CAAC,KAAK,IAAI,IAAI;AAC5C,yBAAyB,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;AAC1D,sBAAsB;AACtB,wBAAwB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AACnE,qBAAqB;AACrB,oBAAoB,MAAM,QAAQ,GAAG,0BAA0B;AAC/D,wBAAwB,UAAU;AAClC,wBAAwB,YAAY;AACpC,sBAAqB;AACrB;AACA,oBAAoB,IAAI,QAAQ,IAAI,IAAI,EAAE;AAC1C,wBAAwB,MAAM,QAAQ;AACtC;AACA,gCAAgC,MAAM,CAAC,KAAK;AAC5C,8BAA6B;AAC7B,wBAAwB,MAAM,UAAU;AACxC,4BAA4B,QAAQ,CAAC,KAAK;AAC1C,0BAAyB;AACzB,wBAAwB,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE;AACnE,4BAA4B,OAAO;AACnC,gCAAgC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC;AACpE,6BAA6B;AAC7B,yBAAyB;AACzB,wBAAwB,IAAI,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE;AACvE,4BAA4B,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE;AACrD,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa,MAAM;AACnB,gBAAgB,MAAM,MAAM,GAAG,eAAe,CAAC,UAAU,EAAE,YAAY,EAAC;AACxE,gBAAgB,IAAI,MAAM,IAAI,IAAI,EAAE;AACpC,oBAAoB,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/D,wBAAwB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AACnE,qBAAqB;AACrB,oBAAoB,MAAM,IAAI;AAC9B,wBAAwB,MAAM,CAAC,KAAK;AACpC,sBAAqB;AACrB,oBAAoB,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AAC/C,wBAAwB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE;AACvD,qBAAqB;AACrB,oBAAoB,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACnD,wBAAwB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE;AACjD,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC9C,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY,OAAO,IAAI,CAAC,KAAK;AAC7B,kBAAkB,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAChE,kBAAkB,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC;AAC/D,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC5C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL;AACA,IAAI,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE;AACnC,QAAQ,IAAI,YAAY,IAAI,IAAI,EAAE;AAClC,YAAY,MAAM,QAAQ,GAAG,YAAY,CAAC,YAAY,EAAE,IAAI,EAAC;AAC7D;AACA,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC;AACA,gBAAgB,IAAI,eAAe,CAAC,QAAQ,CAAC,EAAE;AAC/C,oBAAoB,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACjE,iBAAiB;AACjB;AACA;AACA,gBAAgB,IAAI,oBAAoB,CAAC,QAAQ,CAAC,EAAE;AACpD,oBAAoB,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC;AAChD,oBAAoB;AACpB;AACA,wBAAwB,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,YAAY;AACzD,sBAAsB;AACtB,wBAAwB,MAAM,IAAI,GAAG,eAAe;AACpD,4BAA4B,GAAG,CAAC,IAAI,CAAC,IAAI;AACzC,4BAA4B,YAAY;AACxC,0BAAyB;AACzB,wBAAwB;AACxB,4BAA4B,IAAI;AAChC,4BAA4B,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ;AAC1D,4BAA4B,IAAI,CAAC,KAAK,KAAK,IAAI;AAC/C,0BAA0B;AAC1B,4BAA4B,IAAI,qBAAqB,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE;AAC/E;AACA,gCAAgC,OAAO,IAAI;AAC3C,6BAA6B;AAC7B,yBAAyB;AACzB,wBAAwB,OAAO,IAAI;AACnC,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,OAAO,CAAC,IAAI,EAAE;AAClB,QAAQ,MAAM,OAAO;AACrB;AACA,gBAAgB,IAAI;AACpB,cAAa;AACb;AACA,QAAQ;AACR,YAAY,CAAC,OAAO,CAAC,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,MAAM,IAAI,IAAI;AAC5D,YAAY,OAAO,CAAC,KAAK,IAAI,IAAI;AACjC,UAAU;AACV;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;AACvC,KAAK;AACL;AACA,IAAI,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC1C,QAAQ,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAC;AAC7D,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1B,YAAY;AACZ,gBAAgB,CAAC,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI;AACvE,iBAAiB,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AACzE,iBAAiB,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;AAC9D,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb;AACA,YAAY,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAC;AACnE,YAAY,IAAI,KAAK,IAAI,IAAI,EAAE;AAC/B,gBAAgB,OAAO,KAAK;AAC5B,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACxD,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAC;AACjE,QAAQ,IAAI,MAAM,IAAI,IAAI,EAAE;AAC5B,YAAY,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,KAAK,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC5E,gBAAgB,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE;AAC3D,aAAa;AACb,YAAY,MAAM,QAAQ,GAAG,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAC;AAC3E;AACA,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB;AAChB,oBAAoB,CAAC,QAAQ;AAC7B,+CAA+C,MAAM,CAAC,KAAK;AAC3D,oDAAoD,QAAQ,CAAC,KAAK;AAClE,qBAAqB;AACrB,kBAAkB;AAClB,oBAAoB,OAAO;AAC3B,wBAAwB,KAAK,8CAA8C;AAC3E,4BAA4B,MAAM,CAAC,KAAK;AACxC,sDAAsD,QAAQ,CAAC,KAAK,EAAE;AACtE,qBAAqB;AACrB,iBAAiB;AACjB;AACA,gBAAgB,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,aAAa,EAAE;AAChE,oBAAoB;AACpB,wBAAwB,MAAM,CAAC,KAAK,YAAY,OAAO;AACvD,wBAAwB,OAAO,CAAC,GAAG,wBAAwB,QAAQ,CAAC,KAAK,EAAE;AAC3E,sBAAsB;AACtB,wBAAwB,OAAO;AAC/B,4BAA4B,KAAK,8CAA8C;AAC/E,gCAAgC,MAAM,CAAC,KAAK;AAC5C,0DAA0D,QAAQ,CAAC,KAAK,EAAE;AAC1E,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,EAAC;AACzE,QAAQ,IAAI,UAAU,IAAI,IAAI,EAAE;AAChC,YAAY,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE;AAC9C,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE;AACtC,QAAQ,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAC;AACjE,QAAQ,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,EAAC;AACnE;AACA,QAAQ,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE;AAC5C,YAAY,MAAM,IAAI;AACtB,gBAAgB,MAAM,CAAC,KAAK;AAC5B,cAAa;AACb,YAAY,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AACvC,gBAAgB,OAAO,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE;AACnD,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE;AACzC;AACA,QAAQ,MAAM,MAAM,GAAG,GAAE;AACzB;AACA,QAAQ,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,UAAU,EAAE;AACpD,YAAY,IAAI,YAAY,CAAC,IAAI,KAAK,UAAU,EAAE;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,KAAK,MAAM,EAAE;AAClD,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,GAAG,GAAG,0BAA0B;AACtD,oBAAoB,YAAY;AAChC,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,gBAAgB,MAAM,KAAK,GAAG,eAAe,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,EAAC;AAC/E,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,EAAE;AAClD,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,6BAA6B,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,MAAK;AAC5E,aAAa,MAAM;AACnB,gBAAgB,YAAY,CAAC,IAAI,KAAK,eAAe;AACrD;AACA,gBAAgB,YAAY,CAAC,IAAI,KAAK,4BAA4B;AAClE,cAAc;AACd,gBAAgB,MAAM,QAAQ,GAAG,eAAe;AAChD,oBAAoB,YAAY,CAAC,QAAQ;AACzC,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,gBAAgB,IAAI,QAAQ,IAAI,IAAI,EAAE;AACtC,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,gBAAgB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,EAAC;AACrD,aAAa,MAAM;AACnB,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE;AAChC,KAAK;AACL;AACA,IAAI,kBAAkB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC3C,QAAQ,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAC;AAClE,QAAQ,OAAO,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC;AAClD,KAAK;AACL;AACA,IAAI,wBAAwB,CAAC,IAAI,EAAE,YAAY,EAAE;AACjD,QAAQ,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,EAAC;AAC3D,QAAQ,MAAM,WAAW,GAAG,gBAAgB;AAC5C,YAAY,IAAI,CAAC,KAAK,CAAC,WAAW;AAClC,YAAY,YAAY;AACxB,UAAS;AACT;AACA,QAAQ,IAAI,GAAG,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,EAAE;AAChD,YAAY,MAAM,IAAI,2CAA2C,GAAG,CAAC,KAAK,EAAC;AAC3E;AACA,YAAY,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,EAAC;AACxE,YAAY,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,EAAC;AACnE;AACA,YAAY,IAAI,IAAI,KAAK,MAAM,CAAC,GAAG,EAAE;AACrC,gBAAgB,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,WAAW,CAAC,EAAE;AAC/D,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,EAAC;AAC5E,QAAQ,IAAI,WAAW,IAAI,IAAI,EAAE;AACjC,YAAY,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAM;AACnD,YAAY,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;AACzD,gBAAgB,KAAK,IAAI,WAAW,CAAC,CAAC,EAAC;AACvC,gBAAgB,KAAK,2BAA2B,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAC;AAChF,aAAa;AACb,YAAY,OAAO,EAAE,KAAK,EAAE;AAC5B,SAAS;AACT,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE;AACxC;AACA,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,MAAM,EAAE;AACtC,YAAY,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE;AACvC,SAAS;AACT;AACA,QAAQ,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAC;AAChE,QAAQ,IAAI,GAAG,IAAI,IAAI,EAAE;AACzB,YAAY,QAAQ,IAAI,CAAC,QAAQ;AACjC,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE;AAChD,gBAAgB,KAAK,GAAG;AACxB,oBAAoB,OAAO,EAAE,KAAK,EAAE,sBAAsB,GAAG,CAAC,KAAK,EAAE,EAAE;AACvE,gBAAgB,KAAK,QAAQ;AAC7B,oBAAoB,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,KAAK,EAAE;AACtD;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL,IAAI,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE;AACvC,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC9C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACxC,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE;AAC5C,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,IAAI,yBAAyB,CAAC,IAAI,EAAE,YAAY,EAAE;AAClD,QAAQ,OAAO,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC;AAC7D,KAAK;AACL,CAAC,EAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AAC7C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;AAC3E,QAAQ,2CAA2C,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;AACzE,yCAAyC,IAAI;AAC7C,YAAY,YAAY;AACxB,SAAS;AACT,KAAK;AACL,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,0BAA0B,CAAC,IAAI,EAAE,YAAY,EAAE;AACxD,IAAI,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,KAAK,UAAU,GAAG,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,SAAQ;AACxE;AACA,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;AACvB,QAAQ,OAAO,eAAe,CAAC,QAAQ,EAAE,YAAY,CAAC;AACtD,KAAK;AACL;AACA,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE;AACxC,QAAQ,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE;AACvC,KAAK;AACL;AACA,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,EAAE;AACrC,QAAQ,0CAA0C,CAAC,QAAQ,EAAE,MAAM,EAAE;AACrE,YAAY,OAAO,EAAE,KAAK,+BAA+B,CAAC,QAAQ,EAAE,MAAM,EAAE;AAC5E,SAAS;AACT,QAAQ,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;AAChD,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,EAAE;AAC1D,IAAI,IAAI;AACR,QAAQ,OAAO,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC;AAClD,KAAK,CAAC,OAAO,MAAM,EAAE;AACrB,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;;AC35BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,EAAE;AAC/D;AACA,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE;AAChE,QAAQ,MAAM,OAAO;AACrB;AACA,gBAAgB,IAAI;AACpB,cAAa;AACb,QAAQ,IAAI,OAAO,CAAC,KAAK,EAAE;AAC3B,YAAY,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACrE,SAAS;AACT,QAAQ,IAAI,OAAO,CAAC,MAAM,EAAE;AAC5B,YAAY,OAAO,OAAO,CAAC,MAAM;AACjC,SAAS;AACT,KAAK;AACL;AACA,IAAI,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,EAAC;AACxD;AACA,IAAI,IAAI,SAAS,EAAE;AACnB;AACA,QAAQ,IAAI;AACZ,YAAY,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC;AAC1C,SAAS,CAAC,MAAM;AAChB;AACA,SAAS;AACT,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE;AACpD,IAAI,QAAQ,IAAI,CAAC,IAAI;AACrB,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,OAAO,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC;AACvE,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,mBAAmB,EAAE;AAC5D,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,0CAA0C,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI;AAC1E;AACA,QAAQ,KAAK,UAAU,CAAC;AACxB,QAAQ,KAAK,kBAAkB,CAAC;AAChC,QAAQ,KAAK,oBAAoB;AACjC,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,OAAO,mBAAmB,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC;AAClE,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE;AAC7C,gBAAgB,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;AAC7C,aAAa;AACb,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACvD,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,0CAA0C,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI;AAIrE,KAAK;AACL;AACA,IAAI,OAAO,IAAI;AACf;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,IAAI,EAAE,UAAU,EAAE;AAC1D,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA,IAAI,IAAI,CAAC,MAAM,EAAE;AACjB,QAAQ,OAAO,EAAE;AACjB,KAAK;AACL;AACA,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AAC9E,IAAI,MAAM,aAAa;AACvB,QAAQ,MAAM,CAAC,IAAI,KAAK,kBAAkB,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AACnE,IAAI,MAAM,kBAAkB;AAC5B,QAAQ,MAAM,CAAC,IAAI,KAAK,oBAAoB,IAAI,MAAM,CAAC,KAAK,KAAK,KAAI;AACrE;AACA;AACA,IAAI,IAAI,aAAa,IAAI,kBAAkB,EAAE;AAC7C,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;AAC3B,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,SAAS,EAAC;AAClC,SAAS;AACT,KAAK;AACL,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;AACpB,QAAQ,MAAM,CAAC,IAAI,CAAC,OAAO,EAAC;AAC5B,KAAK;AACL,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE;AACxB,QAAQ,MAAM,CAAC,IAAI,CAAC,WAAW,EAAC;AAChC,KAAK;AACL;AACA;AACA,IAAI,IAAI,cAAc,IAAI,aAAa,EAAE;AACzC,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,EAAE;AAC3C,YAAY,OAAO,aAAa;AAChC,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,EAAE;AACnC,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,EAAE;AAC1C,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS,MAAM;AACf,YAAY,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AACjC,SAAS;AACT,KAAK,MAAM,IAAI,kBAAkB,EAAE;AACnC,QAAQ,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC;AAC7B,KAAK,MAAM;AACX,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,yBAAyB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,OAAO,EAAC;AAChC,SAAS;AACT,QAAQ,MAAM,CAAC,IAAI,CAAC,UAAU,EAAC;AAC/B,KAAK;AACL;AACA;AACA,IAAI,IAAI,cAAc,IAAI,aAAa,IAAI,kBAAkB,EAAE;AAC/D,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrD,YAAY,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAC;AAC9C,SAAS,MAAM;AACf,YAAY,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,EAAC;AAChD,YAAY,IAAI,IAAI,EAAE;AACtB,gBAAgB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAC;AACxC,aAAa,MAAM,IAAI,UAAU,EAAE;AACnC,gBAAgB,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAC;AAC9D,gBAAgB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AAC7C,oBAAoB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAC;AAC/C,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;AAC5B,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AACxC,KAAK,MAAM;AACX,QAAQ,MAAM,CAAC,IAAI,KAAK,oBAAoB;AAC5C,QAAQ,MAAM,CAAC,EAAE;AACjB,QAAQ,MAAM,CAAC,EAAE,CAAC,IAAI,KAAK,YAAY;AACvC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AAC1C,KAAK,MAAM;AACX,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;AAC/C,YAAY,MAAM,CAAC,IAAI,KAAK,mBAAmB;AAC/C,QAAQ,MAAM,CAAC,IAAI;AACnB,QAAQ,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY;AACzC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC;AAC5C,KAAK,MAAM;AACX,QAAQ,MAAM,CAAC,IAAI,KAAK,0BAA0B;AAClD,QAAQ,MAAM,CAAC,WAAW,KAAK,IAAI;AACnC,MAAM;AACN,QAAQ,MAAM,CAAC,IAAI,CAAC,WAAW,EAAC;AAChC,KAAK;AACL;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC;AAC3B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,IAAI,EAAE;AACrB,IAAI,OAAO,OAAO;AAClB,yEAAyE,CAAC,IAAI;AAC9E,aAAa,EAAE;AACf,KAAK;AACL;;AClHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM;AAC7C,IAAI,IAAI,GAAG,CAAC;AACZ,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,IAAI;AACZ,QAAQ,KAAK;AACb,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,IAAI;AACZ,KAAK,CAAC;AACN,EAAC;AACD,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAC;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,CAAC,EAAE;AACnB,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;AAC5E,CAAC;AACD;AACA,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM;AAC7B,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;AACvC;AACA;AACA;AACA;AACA;AACA,QAAQ,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AAC3C,YAAY,MAAM,EAAE,IAAI,EAAE,GAAG,KAAI;AACjC;AACA,YAAY,IAAI,2BAA2B,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,UAAU,EAAE;AACzE,gBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,CAAC;AACtD,oBAAoB,IAAI;AACxB,oBAAoB,OAAO;AAC3B,oBAAoB,WAAW;AAC/B,iBAAiB;AACjB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACnD,YAAY,MAAM,EAAE,IAAI,EAAE,GAAG,KAAI;AACjC;AACA,YAAY,KAAK,MAAM,GAAG;AAC1B,gBAAgB,WAAW,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;AAClD,eAAe;AACf,gBAAgB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAC;AACvC;AACA,gBAAgB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AAC1C,oBAAoB,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE;AACjD,wBAAwB;AACxB,4BAA4B,MAAM,CAAC,OAAO,CAAC;AAC3C,4BAA4B,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC;AACtE,0BAA0B;AAC1B,4BAA4B,OAAO,IAAI;AACvC,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB,MAAM;AACvB,oBAAoB,MAAM,CAAC,KAAK,CAAC;AACjC,oBAAoB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC;AAC5D,kBAAkB;AAClB,oBAAoB,OAAO,IAAI;AAC/B,iBAAiB;AACjB,aAAa;AACb;AACA,YAAY,OAAO,KAAK;AACxB,SAAS;AACT;AACA,QAAQ,uBAAuB,GAAG;AAClC,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,oBAAoB,GAAG;AAC/B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,eAAe,GAAG;AAC1B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;AAC1D,iBAAiB,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAC/E,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,cAAc,GAAG;AACzB,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,kBAAkB,GAAG;AAC7B,YAAY,OAAO,KAAK;AACxB,SAAS;AACT,QAAQ,gBAAgB,GAAG;AAC3B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE;AACzC,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;AAChD,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACrD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,aAAa,GAAG;AACxB,YAAY,OAAO,IAAI;AACvB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AAC7C,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACvD,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,IAAI,CAAC,QAAQ;AAC7B,gBAAgB,IAAI,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS;AAC3C,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,QAAQ,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;AACpD,YAAY,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE;AAC5C,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY;AACZ,gBAAgB,OAAO,CAAC,8BAA8B;AACtD,gBAAgB,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;AACzD,gBAAgB,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;AAChD,cAAc;AACd,gBAAgB,OAAO,IAAI;AAC3B,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC;AAClE,SAAS;AACT,QAAQ,gBAAgB,GAAG;AAC3B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,QAAQ,eAAe,GAAG;AAC1B,YAAY,OAAO,IAAI;AACvB,SAAS;AACT,KAAK,CAAC;AACN,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,GAAG,EAAE,EAAE;AAC9D,IAAI,MAAM,EAAE,eAAe,GAAG,KAAK,EAAE,8BAA8B,GAAG,KAAK,EAAE;AAC7E,QAAQ,QAAO;AACf,IAAI,OAAO,OAAO,CAAC,MAAM;AACzB,QAAQ,IAAI;AACZ,QAAQ,EAAE,eAAe,EAAE,8BAA8B,EAAE;AAC3D,QAAQ,UAAU,CAAC,WAAW,IAAI,IAAI;AACtC,KAAK;AACL;;AC9OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE;AAChD,IAAI,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AACxD;AACA,IAAI,IAAI,CAAC,MAAM,EAAE;AACjB,QAAQ,OAAO,IAAI;AACnB,KAAK;AACL;AACA,IAAI,QAAQ,MAAM,CAAC,IAAI;AACvB,QAAQ,KAAK,gBAAgB,CAAC;AAC9B,QAAQ,KAAK,eAAe;AAC5B,YAAY,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;AAC/E,gBAAgB,OAAO,UAAU,CAAC,aAAa;AAC/C;AACA,oBAAoB,MAAM,CAAC,aAAa;AACxC;AACA;AACA,kFAAkF;AAClF,oCAAoC,MAAM;AAC1C,kCAAkC,cAAc;AAChD;AACA,yBAAyB;AACzB,wBAAwB,MAAM,CAAC,MAAM;AACrC,oBAAoB,mBAAmB;AACvC,iBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,UAAU,CAAC,aAAa;AAC/C,oBAAoB,MAAM,CAAC,IAAI;AAC/B,oBAAoB,mBAAmB;AACvC,iBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,aAAa,CAAC;AAC3B,QAAQ,KAAK,gBAAgB;AAC7B,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,kBAAkB;AAC/B,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,iBAAiB;AAC9B,YAAY,IAAI,MAAM,CAAC,YAAY,KAAK,IAAI,EAAE;AAC9C,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ,KAAK,eAAe;AAC5B,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,OAAO,UAAU,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1D,aAAa;AACb,YAAY,OAAO,IAAI;AACvB;AACA,QAAQ;AACR,YAAY,OAAO,IAAI;AACvB,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe;AAC/B,IAAI,WAAW;AACf,IAAI,gBAAgB;AACpB,IAAI,kBAAkB;AACtB,EAAE;AACF;AACA,IAAI,IAAI,KAAK;AACb;AACA,QAAQ,IAAI;AACZ;AACA,QAAQ,UAAU;AAClB,QAAQ,cAAc;AACtB,QAAQ,gBAAe;AACvB,IAAI,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE;AACzC,QAAQ,KAAK,GAAG,WAAW,GAAG,EAAC;AAC/B,QAAQ,IAAI,4BAA4B,gBAAgB,EAAC;AACzD,QAAQ,UAAU,8BAA8B,kBAAkB,EAAC;AACnE,QAAQ,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE;AAC3B,YAAY,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC;AACxE,SAAS;AACT,KAAK,MAAM;AACX,QAAQ,KAAK,GAAG,EAAC;AACjB,QAAQ,IAAI,4BAA4B,WAAW,EAAC;AACpD,QAAQ,UAAU,8BAA8B,gBAAgB,EAAC;AACjE,KAAK;AACL;AACA,IAAI;AACJ,QAAQ,IAAI,IAAI,IAAI;AACpB;AACA,QAAQ,IAAI,CAAC,MAAM,IAAI,IAAI;AAC3B;AACA,SAAS,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI,CAAC;AAC1E,MAAM;AACN,QAAQ,OAAO,KAAK;AACpB,KAAK;AACL;AACA,IAAI,cAAc,GAAG,eAAe,GAAG,KAAI;AAC3C,IAAI,GAAG;AACP,QAAQ,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC,cAAc,EAAC;AAClE,QAAQ,eAAe,GAAG,UAAU,CAAC,aAAa,CAAC,eAAe,EAAC;AACnE,KAAK;AACL,QAAQ,cAAc,IAAI,IAAI;AAC9B,QAAQ,eAAe,IAAI,IAAI;AAC/B,QAAQ,mBAAmB,CAAC,cAAc,CAAC;AAC3C,QAAQ,mBAAmB,CAAC,eAAe,CAAC;AAC5C;AACA,QAAQ,cAAc,KAAK,oBAAoB,CAAC,IAAI,EAAE,UAAU,CAAC;AACjE,QAAQ,EAAE,KAAK,GAAG,CAAC;AACnB,KAAK;AACL;AACA,IAAI,OAAO,KAAK,KAAK,CAAC;AACtB;;ACzJA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,6BAA4B;AAChD;AACA;AACA,MAAM,QAAQ,GAAG,IAAI,OAAO,GAAE;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE;AAC/B,IAAI,IAAI,OAAO,GAAG,MAAK;AACvB,IAAI,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC,EAAE;AACvE,QAAQ,OAAO,GAAG,CAAC,QAAO;AAC1B,KAAK;AACL,IAAI,OAAO,OAAO;AAClB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE;AAC7C,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,IAAI,KAAK,GAAG,EAAC;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE;AAClC,QAAQ,QAAQ,GAAG;AACnB,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG;AAC1B,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,KAAK,CAAC,CAAC,CAAC;AAC/B,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;AAChD,YAAY,KAAK,IAAI;AACrB,gBAAgB,OAAO,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC/D,YAAY,SAAS;AACrB,gBAAgB,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAC;AACtC,gBAAgB,IAAI,CAAC,IAAI,KAAK,EAAE;AAChC,oBAAoB,OAAO,KAAK,qBAAqB,CAAC,EAAE;AACxD,iBAAiB;AACjB,gBAAgB,OAAO,GAAG;AAC1B,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA,IAAI,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;AAC9C,QAAQ,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAC;AAClD,QAAQ,MAAM,CAAC,IAAI;AACnB,YAAY,WAAW,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAC3E,UAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAM;AAC7C,KAAK;AACL,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC;AACjC;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE;AACzC,IAAI,MAAM,MAAM,GAAG,GAAE;AACrB,IAAI,IAAI,KAAK,GAAG,EAAC;AACjB;AACA,IAAI,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;AAC9C,QAAQ,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAC;AAClD,QAAQ,MAAM,CAAC,IAAI;AACnB,YAAY,MAAM;AAClB,gBAAgB,OAAO;AACvB,oBAAoB;AACpB,iDAAiD,KAAK;AACtD,qBAAqB;AACrB,oBAAoB,KAAK,CAAC,KAAK;AAC/B,oBAAoB,KAAK,CAAC,KAAK;AAC/B,iBAAiB;AACjB,aAAa;AACb,UAAS;AACT,QAAQ,KAAK,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAM;AAC7C,KAAK;AACL,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC;AACjC;AACA,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACO,MAAM,cAAc,CAAC;AAC5B;AACA;AACA;AACA;AACA;AACA,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,EAAE,EAAE;AACvC,QAAQ,MAAM,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,QAAO;AAC3C,QAAQ,IAAI,EAAE,OAAO,YAAY,MAAM,CAAC,EAAE;AAC1C,YAAY,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC;AACzE,SAAS;AACT,QAAQ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AAC1C,YAAY,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC;AAClE,SAAS;AACT;AACA,QAAQ,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE;AAC3B,YAAY,OAAO,EAAE,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC;AAC9D,YAAY,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;AACrC,SAAS,EAAC;AACV,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE;AAClB,QAAQ,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE;AAClC,6DAA6D,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAC;AAChF,QAAQ,IAAI,KAAK,GAAG,KAAI;AACxB,QAAQ,IAAI,SAAS,GAAG,EAAC;AACzB;AACA,QAAQ,OAAO,CAAC,SAAS,GAAG,EAAC;AAC7B,QAAQ,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;AACpD,YAAY,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE;AACzD,gBAAgB,SAAS,GAAG,OAAO,CAAC,UAAS;AAC7C,gBAAgB,MAAM,MAAK;AAC3B,gBAAgB,OAAO,CAAC,SAAS,GAAG,UAAS;AAC7C,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,IAAI,CAAC,GAAG,EAAE;AACd,QAAQ,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAC;AACpC,QAAQ,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,GAAE;AAC7B,QAAQ,OAAO,CAAC,GAAG,CAAC,IAAI;AACxB,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE;AACpC,QAAQ,OAAO,OAAO,QAAQ,KAAK,UAAU;AAC7C,cAAc,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;AACnD,cAAc,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC3D,KAAK;AACL;;ACvKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,WAAW,GAAG,uDAAsD;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,WAAW,CAAC,IAAI,EAAE;AAC3B,IAAI;AACJ,QAAQ,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACnC,qFAAqF;AACrF,YAAY,IAAI;AAChB,UAAU,MAAM,IAAI,IAAI;AACxB,KAAK;AACL,CAAC;AACD,MAAM,GAAG;AACT;AACA,QAAQ,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;AACjD,MAAK;AACL;AACY,MAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAC;AACtB,MAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAC;AACtB,MAAC,SAAS,GAAG,MAAM,CAAC,WAAW,EAAC;AAChC,MAAC,GAAG,GAAG,MAAM,CAAC,KAAK,EAAC;AAChC;AACA,MAAM,WAAW,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,GAAG,IAAI,EAAE,GAAE;AACjD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,gBAAgB,CAAC,QAAQ,EAAE;AACpC,IAAI;AACJ,QAAQ,QAAQ,IAAI,IAAI;AACxB,QAAQ,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;AAClC,QAAQ,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AACpD,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,aAAa,CAAC,IAAI,EAAE;AAC7B,IAAI,MAAM,MAAM,+BAA+B,CAAC,IAAI,EAAE,OAAM;AAC5D;AACA,IAAI,IAAI,MAAM,EAAE;AAChB,QAAQ,QAAQ,MAAM,CAAC,IAAI;AAC3B,YAAY,KAAK,uBAAuB;AACxC,gBAAgB,OAAO,MAAM,CAAC,UAAU,KAAK,IAAI,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI;AAC9E,YAAY,KAAK,mBAAmB;AACpC,gBAAgB,OAAO,IAAI;AAC3B,YAAY,KAAK,oBAAoB;AACrC,gBAAgB;AAChB,oBAAoB,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;AAC9E,iBAAiB;AACjB,YAAY,KAAK,iBAAiB;AAClC,gBAAgB,OAAO,IAAI;AAC3B,YAAY,KAAK,gBAAgB,CAAC;AAClC,YAAY,KAAK,uBAAuB,CAAC;AACzC,YAAY,KAAK,iBAAiB,CAAC;AACnC,YAAY,KAAK,qBAAqB,CAAC;AACvC,YAAY,KAAK,2BAA2B;AAC5C,gBAAgB,OAAO,IAAI;AAC3B;AACA,YAAY;AACZ,gBAAgB,OAAO,KAAK;AAC5B,SAAS;AACT,KAAK;AACL,IAAI,OAAO,KAAK;AAChB,CAAC;AACD;AACA;AACA;AACA;AACO,MAAM,gBAAgB,CAAC;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,WAAW,CAAC,WAAW,EAAE,OAAO,GAAG,EAAE,EAAE;AAC3C,QAAQ,MAAM;AACd,YAAY,IAAI,GAAG,QAAQ;AAC3B,YAAY,iBAAiB,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC;AAC1E,SAAS,GAAG,QAAO;AACnB;AACA,QAAQ,IAAI,CAAC,aAAa,GAAG,GAAE;AAC/B;AACA,QAAQ,IAAI,CAAC,WAAW,GAAG,YAAW;AACtC;AACA,QAAQ,IAAI,CAAC,IAAI,GAAG,KAAI;AACxB;AACA,QAAQ,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAAC;AAC3D,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE;AACvC,QAAQ,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;AACjD,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,MAAM,IAAI,GAAG,CAAC,GAAG,EAAC;AAC9B,YAAY,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAC;AAC1D;AACA,YAAY,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE;AAC5C,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,yCAAyC,QAAQ;AACjD,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,gBAAgB,IAAI;AACpB,cAAa;AACb,SAAS;AACT;AACA,QAAQ,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,iBAAiB,EAAE;AAClD;AACA,YAAY,MAAM,IAAI,GAAG,GAAE;AAC3B,YAAY,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAC;AAC1D;AACA,YAAY,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE;AAC5C,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,yCAAyC,QAAQ;AACjD,gBAAgB,IAAI;AACpB,gBAAgB,QAAQ;AACxB,gBAAgB,KAAK;AACrB,cAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;AACpC,QAAQ,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,EAAE;AAC1E,YAAY,MAAM,GAAG,GAAG,mBAAmB;AAC3C,8CAA8C,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;AACjE,cAAa;AACb,YAAY,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACpD,gBAAgB,QAAQ;AACxB,aAAa;AACb;AACA,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,MAAM,IAAI,GAAG,CAAC,GAAG,EAAC;AAC9B;AACA,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI;AACxB,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD,+CAA+C,IAAI;AACnD,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,cAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;AACpC,QAAQ,MAAM,WAAW,2BAA2B,IAAI,CAAC,WAAW,CAAC,KAAK,EAAC;AAC3E;AACA,QAAQ,KAAK,MAAM,IAAI,IAAI,WAAW,CAAC,IAAI,EAAE;AAC7C,YAAY,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,QAAQ;AACxB,aAAa;AACb,YAAY,MAAM,QAAQ,0BAA0B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAC;AACtE;AACA,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;AAC1C,gBAAgB,QAAQ;AACxB,aAAa;AACb,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,EAAC;AACnD,YAAY,MAAM,IAAI,GAAG,CAAC,QAAQ,EAAC;AACnC;AACA,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB;AACA,oBAAoB,IAAI,2BAA2B,IAAI,CAAC;AACxD,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb;AACA,YAAY,IAAI,IAAI,CAAC,IAAI,KAAK,sBAAsB,EAAE;AACtD,gBAAgB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;AAC7D,oBAAoB,MAAM,cAAc,GAAG,YAAY,CAAC,GAAG,EAAC;AAC5D,oBAAoB,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE;AAC9C,wBAAwB,MAAM;AAC9B;AACA,4BAA4B,IAAI,2BAA2B,IAAI,CAAC;AAChE,4BAA4B,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;AAClD,4BAA4B,IAAI,EAAE,IAAI;AACtC,4BAA4B,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AACtD,0BAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa,MAAM;AACnB,gBAAgB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;AACzD,oBAAoB,MAAM,GAAG,GAAG,GAAG,CAAC,YAAY,EAAE,GAAG,EAAC;AACtD,oBAAoB,MAAM,EAAE,GAAG,IAAI,CAAC,wBAAwB;AAC5D,wBAAwB,SAAS;AACjC,wBAAwB,IAAI;AAC5B,wBAAwB,GAAG;AAC3B,8BAA8B,YAAY;AAC1C,8BAA8B,IAAI,CAAC,IAAI,KAAK,QAAQ;AACpD,8BAA8B,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE;AACxE,8BAA8B,EAAE,OAAO,EAAE,YAAY,EAAE;AACvD,sBAAqB;AACrB;AACA,oBAAoB,IAAI,GAAG,EAAE;AAC7B,wBAAwB,OAAO,GAAE;AACjC,qBAAqB,MAAM;AAC3B,wBAAwB,KAAK,MAAM,MAAM,IAAI,EAAE,EAAE;AACjD,4BAA4B,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,EAAC;AAC3E,4BAA4B;AAC5B,gCAAgC,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC;AACvD,gCAAgC,MAAM,CAAC,IAAI,KAAK,IAAI;AACpD,8BAA8B;AAC9B,gCAAgC,MAAM,OAAM;AAC5C,6BAA6B;AAC7B,yBAAyB;AACzB,qBAAqB;AACrB,iBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE;AAC/C,QAAQ,OAAO,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAC;AAClE,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,0BAA0B,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE;AACxE,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;AACnD,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAC;AACzC,QAAQ,IAAI;AACZ,YAAY,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE;AACzD,gBAAgB,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE;AACzC,oBAAoB,QAAQ;AAC5B,iBAAiB;AACjB,gBAAgB,MAAM,IAAI;AAC1B,oBAAoB,SAAS,CAAC,UAAU;AACxC,kBAAiB;AACjB;AACA,gBAAgB,IAAI,YAAY,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE;AACpD,oBAAoB,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAE;AAC1E,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC5E,aAAa;AACb,SAAS,SAAS;AAClB,YAAY,IAAI,CAAC,aAAa,CAAC,GAAG,GAAE;AACpC,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,0BAA0B,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE;AAC1D,QAAQ,IAAI,IAAI,GAAG,SAAQ;AAC3B,QAAQ,OAAO,aAAa,CAAC,IAAI,CAAC,EAAE;AACpC,YAAY,IAAI,GAAG,IAAI,CAAC,OAAM;AAC9B,SAAS;AACT;AACA,QAAQ,MAAM,MAAM,2BAA2B,CAAC,IAAI,EAAE,OAAM;AAC5D,QAAQ,IAAI,CAAC,MAAM,EAAE;AACrB,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,kBAAkB,EAAE;AAChD,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;AACxC,gBAAgB,MAAM,GAAG,GAAG,eAAe,CAAC,MAAM,EAAC;AACnD,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACxD,oBAAoB,MAAM;AAC1B,iBAAiB;AACjB;AACA,gBAAgB,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACvC,gBAAgB,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACxC,oBAAoB,MAAM;AAC1B,wBAAwB,IAAI,EAAE,MAAM;AACpC,wBAAwB,IAAI;AAC5B,wBAAwB,IAAI,EAAE,IAAI;AAClC,wBAAwB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAChD,sBAAqB;AACrB,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,0BAA0B;AACtD,oBAAoB,MAAM;AAC1B,oBAAoB,IAAI;AACxB,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,EAAE;AAC9C,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE;AAC1D,gBAAgB,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAE;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,eAAe,EAAE;AAC7C,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE;AAC/D,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,EAAE,MAAM;AAChC,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,SAAS;AACnC,oBAAoB,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC;AAC7C,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,sBAAsB,EAAE;AACpD,YAAY,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;AACvC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,gBAAgB,OAAO,IAAI,CAAC,0BAA0B,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACjD,YAAY,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;AACvC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC9E,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB,EAAE;AAClD,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;AACtC,gBAAgB,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC5E,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE;AACxD,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,YAAY,EAAE;AAC/C,YAAY,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAC;AACxE,YAAY,IAAI,QAAQ,IAAI,IAAI,EAAE;AAClC,gBAAgB,OAAO,IAAI,CAAC,0BAA0B;AACtD,oBAAoB,QAAQ;AAC5B,oBAAoB,IAAI;AACxB,oBAAoB,QAAQ;AAC5B,oBAAoB,KAAK;AACzB,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE;AAClD,YAAY,KAAK,MAAM,QAAQ,IAAI,WAAW,CAAC,UAAU,EAAE;AAC3D,gBAAgB,MAAM,GAAG,GAAG,eAAe;AAC3C,uDAAuD,QAAQ;AAC/D,kBAAiB;AACjB;AACA,gBAAgB,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACxD,oBAAoB,QAAQ;AAC5B,iBAAiB;AACjB;AACA,gBAAgB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACjD,gBAAgB,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAClD,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACxC,oBAAoB,MAAM;AAC1B,wBAAwB,IAAI,2BAA2B,QAAQ,CAAC;AAChE,wBAAwB,IAAI,EAAE,QAAQ;AACtC,wBAAwB,IAAI,EAAE,IAAI;AAClC,wBAAwB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAChD,sBAAqB;AACrB,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,qBAAqB;AACjD,sDAAsD,CAAC,QAAQ,EAAE,KAAK;AACtE,oBAAoB,QAAQ;AAC5B,oBAAoB,YAAY;AAChC,kBAAiB;AACjB,aAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACtD,YAAY,OAAO,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAC;AAC/E,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,CAAC,wBAAwB,CAAC,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE;AAC7D,QAAQ,MAAM,IAAI,GAAG,aAAa,CAAC,KAAI;AACvC;AACA,QAAQ,IAAI,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,wBAAwB,EAAE;AAC7E,YAAY,MAAM,GAAG;AACrB,gBAAgB,IAAI,KAAK,wBAAwB;AACjD,sBAAsB,SAAS;AAC/B,sBAAsB,aAAa,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;AAClE,sBAAsB,aAAa,CAAC,QAAQ,CAAC,IAAI;AACjD,sBAAsB,aAAa,CAAC,QAAQ,CAAC,MAAK;AAClD,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACrC,gBAAgB,MAAM;AACtB,aAAa;AACb;AACA,YAAY,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACnC,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,2BAA2B,aAAa,CAAC;AACjE,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD;AACA,oBAAoB,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,KAAK,CAAC;AACvE;AACA,gBAAgB,IAAI;AACpB,gBAAgB,YAAY;AAC5B,gBAAgB,KAAK;AACrB,cAAa;AACb;AACA,YAAY,MAAM;AAClB,SAAS;AACT;AACA,QAAQ,IAAI,IAAI,KAAK,0BAA0B,EAAE;AACjD,YAAY,OAAO,IAAI,CAAC,0BAA0B;AAClD;AACA,oBAAoB,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,KAAK,CAAC;AACvE;AACA,gBAAgB,IAAI;AACpB,gBAAgB,QAAQ;AACxB,gBAAgB,KAAK;AACrB,cAAa;AACb,YAAY,MAAM;AAClB,SAAS;AACT;AACA,QAAQ,IAAI,IAAI,KAAK,iBAAiB,EAAE;AACxC,YAAY,MAAM,GAAG;AACrB,gBAAgB,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY;AACzD,sBAAsB,aAAa,CAAC,KAAK,CAAC,IAAI;AAC9C,sBAAsB,aAAa,CAAC,KAAK,CAAC,MAAK;AAC/C,YAAY,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE;AACrC,gBAAgB,MAAM;AACtB,aAAa;AACb;AACA,YAAY,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAC;AACnC,YAAY,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAC;AAC9C,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;AACpC,gBAAgB,MAAM;AACtB,oBAAoB,IAAI,2BAA2B,aAAa,CAAC;AACjE,oBAAoB,IAAI;AACxB,oBAAoB,IAAI,EAAE,IAAI;AAC9B,oBAAoB,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC;AAC5C,kBAAiB;AACjB,aAAa;AACb,SAAS;AACT,KAAK;AACL,CAAC;AACD;AACA,gBAAgB,CAAC,IAAI,GAAG,KAAI;AAC5B,gBAAgB,CAAC,IAAI,GAAG,KAAI;AAC5B,gBAAgB,CAAC,SAAS,GAAG,UAAS;AACtC,gBAAgB,CAAC,GAAG,GAAG,IAAG;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE;AACpC,IAAI,OAAO,EAAE,KAAK,KAAK,CAAC,IAAI,IAAI,KAAK,SAAS,CAAC;AAC/C;;ACrjBA;AAiEA;AACA,YAAe;AACf,IAAI,IAAI;AACR,IAAI,SAAS;AACb,IAAI,GAAG;AACP,IAAI,YAAY;AAChB,IAAI,uBAAuB;AAC3B,IAAI,uBAAuB;AAC3B,IAAI,iBAAiB;AACrB,IAAI,eAAe;AACnB,IAAI,cAAc;AAClB,IAAI,mBAAmB;AACvB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,mBAAmB;AACvB,IAAI,YAAY;AAChB,IAAI,YAAY;AAChB,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,sBAAsB;AAC1B,IAAI,wBAAwB;AAC5B,IAAI,sBAAsB;AAC1B,IAAI,eAAe;AACnB,IAAI,eAAe;AACnB,IAAI,iBAAiB;AACrB,IAAI,sBAAsB;AAC1B,IAAI,wBAAwB;AAC5B,IAAI,sBAAsB;AAC1B,IAAI,mBAAmB;AACvB,IAAI,mBAAmB;AACvB,IAAI,qBAAqB;AACzB,IAAI,mBAAmB;AACvB,IAAI,eAAe;AACnB,IAAI,gBAAgB;AACpB,IAAI,cAAc;AAClB,IAAI,IAAI;AACR,IAAI,gBAAgB;AACpB;;;;"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/package.json b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/package.json new file mode 100644 index 00000000..da6d5776 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils/package.json @@ -0,0 +1,94 @@ +{ + "name": "@eslint-community/eslint-utils", + "version": "4.10.1", + "description": "Utilities for ESLint plugins.", + "keywords": [ + "eslint" + ], + "homepage": "https://github.com/eslint-community/eslint-utils#readme", + "bugs": { + "url": "https://github.com/eslint-community/eslint-utils/issues" + }, + "repository": { + "type": "git", + "url": "https://github.com/eslint-community/eslint-utils" + }, + "license": "MIT", + "author": "Toru Nagashima", + "sideEffects": false, + "exports": { + ".": { + "import": "./index.mjs", + "require": "./index.js" + }, + "./package.json": "./package.json" + }, + "main": "index", + "module": "index.mjs", + "files": [ + "index.*" + ], + "scripts": { + "prebuild": "npm run -s clean", + "build": "npm run build:dts && npm run build:rollup", + "build:dts": "tsc -p tsconfig.build.json", + "build:rollup": "rollup -c", + "clean": "rimraf .nyc_output coverage index.* dist", + "coverage": "opener ./coverage/lcov-report/index.html", + "docs:build": "vitepress build docs", + "docs:watch": "vitepress dev docs", + "format": "npm run -s format:prettier -- --write", + "format:prettier": "prettier .", + "format:check": "npm run -s format:prettier -- --check", + "lint:eslint": "eslint .", + "lint:format": "npm run -s format:check", + "lint:installed-check": "installed-check -v -i installed-check -i npm-run-all2 -i knip -i rollup-plugin-dts", + "lint:knip": "knip", + "lint": "run-p lint:*", + "test-coverage": "c8 mocha --reporter dot \"test/*.mjs\"", + "test": "mocha --reporter dot \"test/*.mjs\"", + "preversion": "npm run test-coverage && npm run -s build", + "postversion": "git push && git push --tags", + "prewatch": "npm run -s clean", + "watch": "warun \"{src,test}/**/*.mjs\" -- npm run -s test:mocha" + }, + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "devDependencies": { + "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0", + "@types/eslint": "^9.6.1", + "@types/estree": "^1.0.8", + "@types/node": "^20.19.43", + "@typescript-eslint/parser": "^5.62.0", + "@typescript-eslint/types": "^5.62.0", + "c8": "^8.0.1", + "dot-prop": "^7.2.0", + "eslint": "^8.57.1", + "eslint-config-prettier": "^10.1.8", + "eslint-plugin-n": "^15.7.0", + "eslint-plugin-prettier": "^4.2.5", + "globals": "^13.24.0", + "installed-check": "^8.0.1", + "knip": "^5.80.2", + "mocha": "^9.2.2", + "npm-run-all2": "^6.2.6", + "opener": "^1.5.2", + "prettier": "2.8.8", + "rimraf": "^3.0.2", + "rollup": "^2.79.2", + "rollup-plugin-dts": "^4.2.3", + "rollup-plugin-sourcemaps": "^0.6.3", + "semver": "^7.7.3", + "typescript": "^4.9.5", + "vitepress": "^1.6.4", + "warun": "^1.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": "https://opencollective.com/eslint" +} diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint-visitor-keys b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint-visitor-keys new file mode 120000 index 00000000..ac5b2995 --- /dev/null +++ b/backend/node_modules/.pnpm/@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/eslint-visitor-keys @@ -0,0 +1 @@ +../../eslint-visitor-keys@3.4.3/node_modules/eslint-visitor-keys \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/LICENSE b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/LICENSE new file mode 100644 index 00000000..0a81b2ad --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/LICENSE @@ -0,0 +1,19 @@ +Copyright 2019 Justin Ridgewell + +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/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/README.md b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/README.md new file mode 100644 index 00000000..2fe70df7 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/README.md @@ -0,0 +1,40 @@ +# @jridgewell/resolve-uri + +> Resolve a URI relative to an optional base URI + +Resolve any combination of absolute URIs, protocol-realtive URIs, absolute paths, or relative paths. + +## Installation + +```sh +npm install @jridgewell/resolve-uri +``` + +## Usage + +```typescript +function resolve(input: string, base?: string): string; +``` + +```js +import resolve from '@jridgewell/resolve-uri'; + +resolve('foo', 'https://example.com'); // => 'https://example.com/foo' +``` + +| Input | Base | Resolution | Explanation | +|-----------------------|-------------------------|--------------------------------|--------------------------------------------------------------| +| `https://example.com` | _any_ | `https://example.com/` | Input is normalized only | +| `//example.com` | `https://base.com/` | `https://example.com/` | Input inherits the base's protocol | +| `//example.com` | _rest_ | `//example.com/` | Input is normalized only | +| `/example` | `https://base.com/` | `https://base.com/example` | Input inherits the base's origin | +| `/example` | `//base.com/` | `//base.com/example` | Input inherits the base's host and remains protocol relative | +| `/example` | _rest_ | `/example` | Input is normalized only | +| `example` | `https://base.com/dir/` | `https://base.com/dir/example` | Input is joined with the base | +| `example` | `https://base.com/file` | `https://base.com/example` | Input is joined with the base without its file | +| `example` | `//base.com/dir/` | `//base.com/dir/example` | Input is joined with the base's last directory | +| `example` | `//base.com/file` | `//base.com/example` | Input is joined with the base without its file | +| `example` | `/base/dir/` | `/base/dir/example` | Input is joined with the base's last directory | +| `example` | `/base/file` | `/base/example` | Input is joined with the base without its file | +| `example` | `base/dir/` | `base/dir/example` | Input is joined with the base's last directory | +| `example` | `base/file` | `base/example` | Input is joined with the base without its file | diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs new file mode 100644 index 00000000..e958e881 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs @@ -0,0 +1,232 @@ +// Matches the scheme of a URL, eg "http://" +const schemeRegex = /^[\w+.-]+:\/\//; +/** + * Matches the parts of a URL: + * 1. Scheme, including ":", guaranteed. + * 2. User/password, including "@", optional. + * 3. Host, guaranteed. + * 4. Port, including ":", optional. + * 5. Path, including "/", optional. + * 6. Query, including "?", optional. + * 7. Hash, including "#", optional. + */ +const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/; +/** + * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start + * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive). + * + * 1. Host, optional. + * 2. Path, which may include "/", guaranteed. + * 3. Query, including "?", optional. + * 4. Hash, including "#", optional. + */ +const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i; +function isAbsoluteUrl(input) { + return schemeRegex.test(input); +} +function isSchemeRelativeUrl(input) { + return input.startsWith('//'); +} +function isAbsolutePath(input) { + return input.startsWith('/'); +} +function isFileUrl(input) { + return input.startsWith('file:'); +} +function isRelative(input) { + return /^[.?#]/.test(input); +} +function parseAbsoluteUrl(input) { + const match = urlRegex.exec(input); + return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || ''); +} +function parseFileUrl(input) { + const match = fileRegex.exec(input); + const path = match[2]; + return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || ''); +} +function makeUrl(scheme, user, host, port, path, query, hash) { + return { + scheme, + user, + host, + port, + path, + query, + hash, + type: 7 /* Absolute */, + }; +} +function parseUrl(input) { + if (isSchemeRelativeUrl(input)) { + const url = parseAbsoluteUrl('http:' + input); + url.scheme = ''; + url.type = 6 /* SchemeRelative */; + return url; + } + if (isAbsolutePath(input)) { + const url = parseAbsoluteUrl('http://foo.com' + input); + url.scheme = ''; + url.host = ''; + url.type = 5 /* AbsolutePath */; + return url; + } + if (isFileUrl(input)) + return parseFileUrl(input); + if (isAbsoluteUrl(input)) + return parseAbsoluteUrl(input); + const url = parseAbsoluteUrl('http://foo.com/' + input); + url.scheme = ''; + url.host = ''; + url.type = input + ? input.startsWith('?') + ? 3 /* Query */ + : input.startsWith('#') + ? 2 /* Hash */ + : 4 /* RelativePath */ + : 1 /* Empty */; + return url; +} +function stripPathFilename(path) { + // If a path ends with a parent directory "..", then it's a relative path with excess parent + // paths. It's not a file, so we can't strip it. + if (path.endsWith('/..')) + return path; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); +} +function mergePaths(url, base) { + normalizePath(base, base.type); + // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative + // path). + if (url.path === '/') { + url.path = base.path; + } + else { + // Resolution happens relative to the base path's directory, not the file. + url.path = stripPathFilename(base.path) + url.path; + } +} +/** + * The path can have empty directories "//", unneeded parents "foo/..", or current directory + * "foo/.". We need to normalize to a standard representation. + */ +function normalizePath(url, type) { + const rel = type <= 4 /* RelativePath */; + const pieces = url.path.split('/'); + // We need to preserve the first piece always, so that we output a leading slash. The item at + // pieces[0] is an empty string. + let pointer = 1; + // Positive is the number of real directories we've output, used for popping a parent directory. + // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo". + let positive = 0; + // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will + // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a + // real directory, we won't need to append, unless the other conditions happen again. + let addTrailingSlash = false; + for (let i = 1; i < pieces.length; i++) { + const piece = pieces[i]; + // An empty directory, could be a trailing slash, or just a double "//" in the path. + if (!piece) { + addTrailingSlash = true; + continue; + } + // If we encounter a real directory, then we don't need to append anymore. + addTrailingSlash = false; + // A current directory, which we can always drop. + if (piece === '.') + continue; + // A parent directory, we need to see if there are any real directories we can pop. Else, we + // have an excess of parents, and we'll need to keep the "..". + if (piece === '..') { + if (positive) { + addTrailingSlash = true; + positive--; + pointer--; + } + else if (rel) { + // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute + // URL, protocol relative URL, or an absolute path, we don't need to keep excess. + pieces[pointer++] = piece; + } + continue; + } + // We've encountered a real directory. Move it to the next insertion pointer, which accounts for + // any popped or dropped directories. + pieces[pointer++] = piece; + positive++; + } + let path = ''; + for (let i = 1; i < pointer; i++) { + path += '/' + pieces[i]; + } + if (!path || (addTrailingSlash && !path.endsWith('/..'))) { + path += '/'; + } + url.path = path; +} +/** + * Attempts to resolve `input` URL/path relative to `base`. + */ +function resolve(input, base) { + if (!input && !base) + return ''; + const url = parseUrl(input); + let inputType = url.type; + if (base && inputType !== 7 /* Absolute */) { + const baseUrl = parseUrl(base); + const baseType = baseUrl.type; + switch (inputType) { + case 1 /* Empty */: + url.hash = baseUrl.hash; + // fall through + case 2 /* Hash */: + url.query = baseUrl.query; + // fall through + case 3 /* Query */: + case 4 /* RelativePath */: + mergePaths(url, baseUrl); + // fall through + case 5 /* AbsolutePath */: + // The host, user, and port are joined, you can't copy one without the others. + url.user = baseUrl.user; + url.host = baseUrl.host; + url.port = baseUrl.port; + // fall through + case 6 /* SchemeRelative */: + // The input doesn't have a schema at least, so we need to copy at least that over. + url.scheme = baseUrl.scheme; + } + if (baseType > inputType) + inputType = baseType; + } + normalizePath(url, inputType); + const queryHash = url.query + url.hash; + switch (inputType) { + // This is impossible, because of the empty checks at the start of the function. + // case UrlType.Empty: + case 2 /* Hash */: + case 3 /* Query */: + return queryHash; + case 4 /* RelativePath */: { + // The first char is always a "/", and we need it to be relative. + const path = url.path.slice(1); + if (!path) + return queryHash || '.'; + if (isRelative(base || input) && !isRelative(path)) { + // If base started with a leading ".", or there is no base and input started with a ".", + // then we need to ensure that the relative path starts with a ".". We don't know if + // relative starts with a "..", though, so check before prepending. + return './' + path + queryHash; + } + return path + queryHash; + } + case 5 /* AbsolutePath */: + return url.path + queryHash; + default: + return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash; + } +} + +export { resolve as default }; +//# sourceMappingURL=resolve-uri.mjs.map diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map new file mode 100644 index 00000000..1de97d01 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve-uri.mjs","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":"AAAA;AACA,MAAM,WAAW,GAAG,gBAAgB,CAAC;AAErC;;;;;;;;;;AAUA,MAAM,QAAQ,GAAG,0EAA0E,CAAC;AAE5F;;;;;;;;;AASA,MAAM,SAAS,GAAG,iEAAiE,CAAC;AAuBpF,SAAS,aAAa,CAAC,KAAa;IAClC,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjC,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAa;IACxC,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,SAAS,cAAc,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAa;IACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAE,CAAC;IACpC,OAAO,OAAO,CACZ,KAAK,CAAC,CAAC,CAAC,EACR,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,EACR,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,EACf,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CACf,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,KAAa;IACjC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAE,CAAC;IACrC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,OAAO,CACZ,OAAO,EACP,EAAE,EACF,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,EAAE,EACF,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,EACxC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CACf,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CACd,MAAc,EACd,IAAY,EACZ,IAAY,EACZ,IAAY,EACZ,IAAY,EACZ,KAAa,EACb,IAAY;IAEZ,OAAO;QACL,MAAM;QACN,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,IAAI;QACJ,KAAK;QACL,IAAI;QACJ,IAAI;KACL,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CAAC,KAAa;IAC7B,IAAI,mBAAmB,CAAC,KAAK,CAAC,EAAE;QAC9B,MAAM,GAAG,GAAG,gBAAgB,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;QAC9C,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;QAChB,GAAG,CAAC,IAAI,0BAA0B;QAClC,OAAO,GAAG,CAAC;KACZ;IAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE;QACzB,MAAM,GAAG,GAAG,gBAAgB,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC;QACvD,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;QAChB,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;QACd,GAAG,CAAC,IAAI,wBAAwB;QAChC,OAAO,GAAG,CAAC;KACZ;IAED,IAAI,SAAS,CAAC,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;IAEjD,IAAI,aAAa,CAAC,KAAK,CAAC;QAAE,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAEzD,MAAM,GAAG,GAAG,gBAAgB,CAAC,iBAAiB,GAAG,KAAK,CAAC,CAAC;IACxD,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;IAChB,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;IACd,GAAG,CAAC,IAAI,GAAG,KAAK;UACZ,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;;cAEnB,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;;;wBAGT;IAClB,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAY;;;IAGrC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACtC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACpC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;AAClC,CAAC;AAED,SAAS,UAAU,CAAC,GAAQ,EAAE,IAAS;IACrC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;;;IAI/B,IAAI,GAAG,CAAC,IAAI,KAAK,GAAG,EAAE;QACpB,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;KACtB;SAAM;;QAEL,GAAG,CAAC,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;KACpD;AACH,CAAC;AAED;;;;AAIA,SAAS,aAAa,CAAC,GAAQ,EAAE,IAAa;IAC5C,MAAM,GAAG,GAAG,IAAI,yBAAyB;IACzC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;;;IAInC,IAAI,OAAO,GAAG,CAAC,CAAC;;;IAIhB,IAAI,QAAQ,GAAG,CAAC,CAAC;;;;IAKjB,IAAI,gBAAgB,GAAG,KAAK,CAAC;IAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;;QAGxB,IAAI,CAAC,KAAK,EAAE;YACV,gBAAgB,GAAG,IAAI,CAAC;YACxB,SAAS;SACV;;QAGD,gBAAgB,GAAG,KAAK,CAAC;;QAGzB,IAAI,KAAK,KAAK,GAAG;YAAE,SAAS;;;QAI5B,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,IAAI,QAAQ,EAAE;gBACZ,gBAAgB,GAAG,IAAI,CAAC;gBACxB,QAAQ,EAAE,CAAC;gBACX,OAAO,EAAE,CAAC;aACX;iBAAM,IAAI,GAAG,EAAE;;;gBAGd,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;aAC3B;YACD,SAAS;SACV;;;QAID,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;QAC1B,QAAQ,EAAE,CAAC;KACZ;IAED,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE;QAChC,IAAI,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;KACzB;IACD,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;QACxD,IAAI,IAAI,GAAG,CAAC;KACb;IACD,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;AAClB,CAAC;AAED;;;SAGwB,OAAO,CAAC,KAAa,EAAE,IAAwB;IACrE,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IAE/B,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5B,IAAI,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC;IAEzB,IAAI,IAAI,IAAI,SAAS,uBAAuB;QAC1C,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;QAE9B,QAAQ,SAAS;YACf;gBACE,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;YAG1B;gBACE,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;;YAG5B,mBAAmB;YACnB;gBACE,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;;YAG3B;;gBAEE,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;gBACxB,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;gBACxB,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;YAG1B;;gBAEE,GAAG,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;SAC/B;QACD,IAAI,QAAQ,GAAG,SAAS;YAAE,SAAS,GAAG,QAAQ,CAAC;KAChD;IAED,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAE9B,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;IACvC,QAAQ,SAAS;;;QAIf,kBAAkB;QAClB;YACE,OAAO,SAAS,CAAC;QAEnB,2BAA2B;;YAEzB,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAE/B,IAAI,CAAC,IAAI;gBAAE,OAAO,SAAS,IAAI,GAAG,CAAC;YAEnC,IAAI,UAAU,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;;;;gBAIlD,OAAO,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;aAChC;YAED,OAAO,IAAI,GAAG,SAAS,CAAC;SACzB;QAED;YACE,OAAO,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;QAE9B;YACE,OAAO,GAAG,CAAC,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;KACpF;AACH;;;;"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js new file mode 100644 index 00000000..a783049b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js @@ -0,0 +1,240 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory()); +})(this, (function () { 'use strict'; + + // Matches the scheme of a URL, eg "http://" + const schemeRegex = /^[\w+.-]+:\/\//; + /** + * Matches the parts of a URL: + * 1. Scheme, including ":", guaranteed. + * 2. User/password, including "@", optional. + * 3. Host, guaranteed. + * 4. Port, including ":", optional. + * 5. Path, including "/", optional. + * 6. Query, including "?", optional. + * 7. Hash, including "#", optional. + */ + const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/; + /** + * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start + * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive). + * + * 1. Host, optional. + * 2. Path, which may include "/", guaranteed. + * 3. Query, including "?", optional. + * 4. Hash, including "#", optional. + */ + const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i; + function isAbsoluteUrl(input) { + return schemeRegex.test(input); + } + function isSchemeRelativeUrl(input) { + return input.startsWith('//'); + } + function isAbsolutePath(input) { + return input.startsWith('/'); + } + function isFileUrl(input) { + return input.startsWith('file:'); + } + function isRelative(input) { + return /^[.?#]/.test(input); + } + function parseAbsoluteUrl(input) { + const match = urlRegex.exec(input); + return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || ''); + } + function parseFileUrl(input) { + const match = fileRegex.exec(input); + const path = match[2]; + return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || ''); + } + function makeUrl(scheme, user, host, port, path, query, hash) { + return { + scheme, + user, + host, + port, + path, + query, + hash, + type: 7 /* Absolute */, + }; + } + function parseUrl(input) { + if (isSchemeRelativeUrl(input)) { + const url = parseAbsoluteUrl('http:' + input); + url.scheme = ''; + url.type = 6 /* SchemeRelative */; + return url; + } + if (isAbsolutePath(input)) { + const url = parseAbsoluteUrl('http://foo.com' + input); + url.scheme = ''; + url.host = ''; + url.type = 5 /* AbsolutePath */; + return url; + } + if (isFileUrl(input)) + return parseFileUrl(input); + if (isAbsoluteUrl(input)) + return parseAbsoluteUrl(input); + const url = parseAbsoluteUrl('http://foo.com/' + input); + url.scheme = ''; + url.host = ''; + url.type = input + ? input.startsWith('?') + ? 3 /* Query */ + : input.startsWith('#') + ? 2 /* Hash */ + : 4 /* RelativePath */ + : 1 /* Empty */; + return url; + } + function stripPathFilename(path) { + // If a path ends with a parent directory "..", then it's a relative path with excess parent + // paths. It's not a file, so we can't strip it. + if (path.endsWith('/..')) + return path; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); + } + function mergePaths(url, base) { + normalizePath(base, base.type); + // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative + // path). + if (url.path === '/') { + url.path = base.path; + } + else { + // Resolution happens relative to the base path's directory, not the file. + url.path = stripPathFilename(base.path) + url.path; + } + } + /** + * The path can have empty directories "//", unneeded parents "foo/..", or current directory + * "foo/.". We need to normalize to a standard representation. + */ + function normalizePath(url, type) { + const rel = type <= 4 /* RelativePath */; + const pieces = url.path.split('/'); + // We need to preserve the first piece always, so that we output a leading slash. The item at + // pieces[0] is an empty string. + let pointer = 1; + // Positive is the number of real directories we've output, used for popping a parent directory. + // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo". + let positive = 0; + // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will + // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a + // real directory, we won't need to append, unless the other conditions happen again. + let addTrailingSlash = false; + for (let i = 1; i < pieces.length; i++) { + const piece = pieces[i]; + // An empty directory, could be a trailing slash, or just a double "//" in the path. + if (!piece) { + addTrailingSlash = true; + continue; + } + // If we encounter a real directory, then we don't need to append anymore. + addTrailingSlash = false; + // A current directory, which we can always drop. + if (piece === '.') + continue; + // A parent directory, we need to see if there are any real directories we can pop. Else, we + // have an excess of parents, and we'll need to keep the "..". + if (piece === '..') { + if (positive) { + addTrailingSlash = true; + positive--; + pointer--; + } + else if (rel) { + // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute + // URL, protocol relative URL, or an absolute path, we don't need to keep excess. + pieces[pointer++] = piece; + } + continue; + } + // We've encountered a real directory. Move it to the next insertion pointer, which accounts for + // any popped or dropped directories. + pieces[pointer++] = piece; + positive++; + } + let path = ''; + for (let i = 1; i < pointer; i++) { + path += '/' + pieces[i]; + } + if (!path || (addTrailingSlash && !path.endsWith('/..'))) { + path += '/'; + } + url.path = path; + } + /** + * Attempts to resolve `input` URL/path relative to `base`. + */ + function resolve(input, base) { + if (!input && !base) + return ''; + const url = parseUrl(input); + let inputType = url.type; + if (base && inputType !== 7 /* Absolute */) { + const baseUrl = parseUrl(base); + const baseType = baseUrl.type; + switch (inputType) { + case 1 /* Empty */: + url.hash = baseUrl.hash; + // fall through + case 2 /* Hash */: + url.query = baseUrl.query; + // fall through + case 3 /* Query */: + case 4 /* RelativePath */: + mergePaths(url, baseUrl); + // fall through + case 5 /* AbsolutePath */: + // The host, user, and port are joined, you can't copy one without the others. + url.user = baseUrl.user; + url.host = baseUrl.host; + url.port = baseUrl.port; + // fall through + case 6 /* SchemeRelative */: + // The input doesn't have a schema at least, so we need to copy at least that over. + url.scheme = baseUrl.scheme; + } + if (baseType > inputType) + inputType = baseType; + } + normalizePath(url, inputType); + const queryHash = url.query + url.hash; + switch (inputType) { + // This is impossible, because of the empty checks at the start of the function. + // case UrlType.Empty: + case 2 /* Hash */: + case 3 /* Query */: + return queryHash; + case 4 /* RelativePath */: { + // The first char is always a "/", and we need it to be relative. + const path = url.path.slice(1); + if (!path) + return queryHash || '.'; + if (isRelative(base || input) && !isRelative(path)) { + // If base started with a leading ".", or there is no base and input started with a ".", + // then we need to ensure that the relative path starts with a ".". We don't know if + // relative starts with a "..", though, so check before prepending. + return './' + path + queryHash; + } + return path + queryHash; + } + case 5 /* AbsolutePath */: + return url.path + queryHash; + default: + return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash; + } + } + + return resolve; + +})); +//# sourceMappingURL=resolve-uri.umd.js.map diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map new file mode 100644 index 00000000..70a37f21 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve-uri.umd.js","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":";;;;;;IAAA;IACA,MAAM,WAAW,GAAG,gBAAgB,CAAC;IAErC;;;;;;;;;;IAUA,MAAM,QAAQ,GAAG,0EAA0E,CAAC;IAE5F;;;;;;;;;IASA,MAAM,SAAS,GAAG,iEAAiE,CAAC;IAuBpF,SAAS,aAAa,CAAC,KAAa;QAClC,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,SAAS,mBAAmB,CAAC,KAAa;QACxC,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,SAAS,cAAc,CAAC,KAAa;QACnC,OAAO,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;IAED,SAAS,SAAS,CAAC,KAAa;QAC9B,OAAO,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED,SAAS,UAAU,CAAC,KAAa;QAC/B,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,SAAS,gBAAgB,CAAC,KAAa;QACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAE,CAAC;QACpC,OAAO,OAAO,CACZ,KAAK,CAAC,CAAC,CAAC,EACR,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,EACR,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,EACf,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CACf,CAAC;IACJ,CAAC;IAED,SAAS,YAAY,CAAC,KAAa;QACjC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAE,CAAC;QACrC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,OAAO,OAAO,CACZ,OAAO,EACP,EAAE,EACF,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,EAAE,EACF,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,EACxC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,EACd,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CACf,CAAC;IACJ,CAAC;IAED,SAAS,OAAO,CACd,MAAc,EACd,IAAY,EACZ,IAAY,EACZ,IAAY,EACZ,IAAY,EACZ,KAAa,EACb,IAAY;QAEZ,OAAO;YACL,MAAM;YACN,IAAI;YACJ,IAAI;YACJ,IAAI;YACJ,IAAI;YACJ,KAAK;YACL,IAAI;YACJ,IAAI;SACL,CAAC;IACJ,CAAC;IAED,SAAS,QAAQ,CAAC,KAAa;QAC7B,IAAI,mBAAmB,CAAC,KAAK,CAAC,EAAE;YAC9B,MAAM,GAAG,GAAG,gBAAgB,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;YAC9C,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;YAChB,GAAG,CAAC,IAAI,0BAA0B;YAClC,OAAO,GAAG,CAAC;SACZ;QAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE;YACzB,MAAM,GAAG,GAAG,gBAAgB,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC;YACvD,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;YAChB,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;YACd,GAAG,CAAC,IAAI,wBAAwB;YAChC,OAAO,GAAG,CAAC;SACZ;QAED,IAAI,SAAS,CAAC,KAAK,CAAC;YAAE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;QAEjD,IAAI,aAAa,CAAC,KAAK,CAAC;YAAE,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEzD,MAAM,GAAG,GAAG,gBAAgB,CAAC,iBAAiB,GAAG,KAAK,CAAC,CAAC;QACxD,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC;QAChB,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;QACd,GAAG,CAAC,IAAI,GAAG,KAAK;cACZ,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;;kBAEnB,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;;;4BAGT;QAClB,OAAO,GAAG,CAAC;IACb,CAAC;IAED,SAAS,iBAAiB,CAAC,IAAY;;;QAGrC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACtC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;IAClC,CAAC;IAED,SAAS,UAAU,CAAC,GAAQ,EAAE,IAAS;QACrC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;;;QAI/B,IAAI,GAAG,CAAC,IAAI,KAAK,GAAG,EAAE;YACpB,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;SACtB;aAAM;;YAEL,GAAG,CAAC,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;SACpD;IACH,CAAC;IAED;;;;IAIA,SAAS,aAAa,CAAC,GAAQ,EAAE,IAAa;QAC5C,MAAM,GAAG,GAAG,IAAI,yBAAyB;QACzC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;;;QAInC,IAAI,OAAO,GAAG,CAAC,CAAC;;;QAIhB,IAAI,QAAQ,GAAG,CAAC,CAAC;;;;QAKjB,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;;YAGxB,IAAI,CAAC,KAAK,EAAE;gBACV,gBAAgB,GAAG,IAAI,CAAC;gBACxB,SAAS;aACV;;YAGD,gBAAgB,GAAG,KAAK,CAAC;;YAGzB,IAAI,KAAK,KAAK,GAAG;gBAAE,SAAS;;;YAI5B,IAAI,KAAK,KAAK,IAAI,EAAE;gBAClB,IAAI,QAAQ,EAAE;oBACZ,gBAAgB,GAAG,IAAI,CAAC;oBACxB,QAAQ,EAAE,CAAC;oBACX,OAAO,EAAE,CAAC;iBACX;qBAAM,IAAI,GAAG,EAAE;;;oBAGd,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;iBAC3B;gBACD,SAAS;aACV;;;YAID,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;YAC1B,QAAQ,EAAE,CAAC;SACZ;QAED,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE;YAChC,IAAI,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;YACxD,IAAI,IAAI,GAAG,CAAC;SACb;QACD,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;IAED;;;aAGwB,OAAO,CAAC,KAAa,EAAE,IAAwB;QACrE,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,CAAC;QAE/B,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC;QAEzB,IAAI,IAAI,IAAI,SAAS,uBAAuB;YAC1C,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC/B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;YAE9B,QAAQ,SAAS;gBACf;oBACE,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;gBAG1B;oBACE,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;;gBAG5B,mBAAmB;gBACnB;oBACE,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;;gBAG3B;;oBAEE,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;oBACxB,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;oBACxB,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;gBAG1B;;oBAEE,GAAG,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAC/B;YACD,IAAI,QAAQ,GAAG,SAAS;gBAAE,SAAS,GAAG,QAAQ,CAAC;SAChD;QAED,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QAE9B,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;QACvC,QAAQ,SAAS;;;YAIf,kBAAkB;YAClB;gBACE,OAAO,SAAS,CAAC;YAEnB,2BAA2B;;gBAEzB,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAE/B,IAAI,CAAC,IAAI;oBAAE,OAAO,SAAS,IAAI,GAAG,CAAC;gBAEnC,IAAI,UAAU,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;;;;oBAIlD,OAAO,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;iBAChC;gBAED,OAAO,IAAI,GAAG,SAAS,CAAC;aACzB;YAED;gBACE,OAAO,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;YAE9B;gBACE,OAAO,GAAG,CAAC,MAAM,GAAG,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;SACpF;IACH;;;;;;;;"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts new file mode 100644 index 00000000..b7f0b3b2 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts @@ -0,0 +1,4 @@ +/** + * Attempts to resolve `input` URL/path relative to `base`. + */ +export default function resolve(input: string, base: string | undefined): string; diff --git a/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/package.json b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/package.json new file mode 100644 index 00000000..02a4c518 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/package.json @@ -0,0 +1,69 @@ +{ + "name": "@jridgewell/resolve-uri", + "version": "3.1.2", + "description": "Resolve a URI relative to an optional base URI", + "keywords": [ + "resolve", + "uri", + "url", + "path" + ], + "author": "Justin Ridgewell ", + "license": "MIT", + "repository": "https://github.com/jridgewell/resolve-uri", + "main": "dist/resolve-uri.umd.js", + "module": "dist/resolve-uri.mjs", + "types": "dist/types/resolve-uri.d.ts", + "exports": { + ".": [ + { + "types": "./dist/types/resolve-uri.d.ts", + "browser": "./dist/resolve-uri.umd.js", + "require": "./dist/resolve-uri.umd.js", + "import": "./dist/resolve-uri.mjs" + }, + "./dist/resolve-uri.umd.js" + ], + "./package.json": "./package.json" + }, + "files": [ + "dist" + ], + "engines": { + "node": ">=6.0.0" + }, + "scripts": { + "prebuild": "rm -rf dist", + "build": "run-s -n build:*", + "build:rollup": "rollup -c rollup.config.js", + "build:ts": "tsc --project tsconfig.build.json", + "lint": "run-s -n lint:*", + "lint:prettier": "npm run test:lint:prettier -- --write", + "lint:ts": "npm run test:lint:ts -- --fix", + "pretest": "run-s build:rollup", + "test": "run-s -n test:lint test:only", + "test:debug": "mocha --inspect-brk", + "test:lint": "run-s -n test:lint:*", + "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'", + "test:lint:ts": "eslint '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:coverage": "c8 mocha", + "test:watch": "mocha --watch", + "prepublishOnly": "npm run preversion", + "preversion": "run-s test build" + }, + "devDependencies": { + "@jridgewell/resolve-uri-latest": "npm:@jridgewell/resolve-uri@*", + "@rollup/plugin-typescript": "8.3.0", + "@typescript-eslint/eslint-plugin": "5.10.0", + "@typescript-eslint/parser": "5.10.0", + "c8": "7.11.0", + "eslint": "8.7.0", + "eslint-config-prettier": "8.3.0", + "mocha": "9.2.0", + "npm-run-all": "4.1.5", + "prettier": "2.5.1", + "rollup": "2.66.0", + "typescript": "4.5.5" + } +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/LICENSE b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/LICENSE new file mode 100644 index 00000000..1f6ce94c --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/README.md b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/README.md new file mode 100644 index 00000000..b3e0708b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/README.md @@ -0,0 +1,264 @@ +# @jridgewell/sourcemap-codec + +Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit). + + +## Why? + +Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap. + +This package makes the process slightly easier. + + +## Installation + +```bash +npm install @jridgewell/sourcemap-codec +``` + + +## Usage + +```js +import { encode, decode } from '@jridgewell/sourcemap-codec'; + +var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' ); + +assert.deepEqual( decoded, [ + // the first line (of the generated code) has no mappings, + // as shown by the starting semi-colon (which separates lines) + [], + + // the second line contains four (comma-separated) segments + [ + // segments are encoded as you'd expect: + // [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ] + + // i.e. the first segment begins at column 2, and maps back to the second column + // of the second line (both zero-based) of the 0th source, and uses the 0th + // name in the `map.names` array + [ 2, 0, 2, 2, 0 ], + + // the remaining segments are 4-length rather than 5-length, + // because they don't map a name + [ 4, 0, 2, 4 ], + [ 6, 0, 2, 5 ], + [ 7, 0, 2, 7 ] + ], + + // the final line contains two segments + [ + [ 2, 1, 10, 19 ], + [ 12, 1, 11, 20 ] + ] +]); + +var encoded = encode( decoded ); +assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' ); +``` + +## Benchmarks + +``` +node v20.10.0 + +amp.js.map - 45120 segments + +Decode Memory Usage: +local code 5815135 bytes +@jridgewell/sourcemap-codec 1.4.15 5868160 bytes +sourcemap-codec 5492584 bytes +source-map-0.6.1 13569984 bytes +source-map-0.8.0 6390584 bytes +chrome dev tools 8011136 bytes +Smallest memory usage is sourcemap-codec + +Decode speed: +decode: local code x 492 ops/sec ±1.22% (90 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 499 ops/sec ±1.16% (89 runs sampled) +decode: sourcemap-codec x 376 ops/sec ±1.66% (89 runs sampled) +decode: source-map-0.6.1 x 34.99 ops/sec ±0.94% (48 runs sampled) +decode: source-map-0.8.0 x 351 ops/sec ±0.07% (95 runs sampled) +chrome dev tools x 165 ops/sec ±0.91% (86 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 444248 bytes +@jridgewell/sourcemap-codec 1.4.15 623024 bytes +sourcemap-codec 8696280 bytes +source-map-0.6.1 8745176 bytes +source-map-0.8.0 8736624 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 796 ops/sec ±0.11% (97 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 795 ops/sec ±0.25% (98 runs sampled) +encode: sourcemap-codec x 231 ops/sec ±0.83% (86 runs sampled) +encode: source-map-0.6.1 x 166 ops/sec ±0.57% (86 runs sampled) +encode: source-map-0.8.0 x 203 ops/sec ±0.45% (88 runs sampled) +Fastest is encode: local code,encode: @jridgewell/sourcemap-codec 1.4.15 + + +*** + + +babel.min.js.map - 347793 segments + +Decode Memory Usage: +local code 35424960 bytes +@jridgewell/sourcemap-codec 1.4.15 35424696 bytes +sourcemap-codec 36033464 bytes +source-map-0.6.1 62253704 bytes +source-map-0.8.0 43843920 bytes +chrome dev tools 45111400 bytes +Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15 + +Decode speed: +decode: local code x 38.18 ops/sec ±5.44% (52 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 38.36 ops/sec ±5.02% (52 runs sampled) +decode: sourcemap-codec x 34.05 ops/sec ±4.45% (47 runs sampled) +decode: source-map-0.6.1 x 4.31 ops/sec ±2.76% (15 runs sampled) +decode: source-map-0.8.0 x 55.60 ops/sec ±0.13% (73 runs sampled) +chrome dev tools x 16.94 ops/sec ±3.78% (46 runs sampled) +Fastest is decode: source-map-0.8.0 + +Encode Memory Usage: +local code 2606016 bytes +@jridgewell/sourcemap-codec 1.4.15 2626440 bytes +sourcemap-codec 21152576 bytes +source-map-0.6.1 25023928 bytes +source-map-0.8.0 25256448 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 127 ops/sec ±0.18% (83 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 128 ops/sec ±0.26% (83 runs sampled) +encode: sourcemap-codec x 29.31 ops/sec ±2.55% (53 runs sampled) +encode: source-map-0.6.1 x 18.85 ops/sec ±3.19% (36 runs sampled) +encode: source-map-0.8.0 x 19.34 ops/sec ±1.97% (36 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15 + + +*** + + +preact.js.map - 1992 segments + +Decode Memory Usage: +local code 261696 bytes +@jridgewell/sourcemap-codec 1.4.15 244296 bytes +sourcemap-codec 302816 bytes +source-map-0.6.1 939176 bytes +source-map-0.8.0 336 bytes +chrome dev tools 587368 bytes +Smallest memory usage is source-map-0.8.0 + +Decode speed: +decode: local code x 17,782 ops/sec ±0.32% (97 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 17,863 ops/sec ±0.40% (100 runs sampled) +decode: sourcemap-codec x 12,453 ops/sec ±0.27% (101 runs sampled) +decode: source-map-0.6.1 x 1,288 ops/sec ±1.05% (96 runs sampled) +decode: source-map-0.8.0 x 9,289 ops/sec ±0.27% (101 runs sampled) +chrome dev tools x 4,769 ops/sec ±0.18% (100 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 262944 bytes +@jridgewell/sourcemap-codec 1.4.15 25544 bytes +sourcemap-codec 323048 bytes +source-map-0.6.1 507808 bytes +source-map-0.8.0 507480 bytes +Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15 + +Encode speed: +encode: local code x 24,207 ops/sec ±0.79% (95 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 24,288 ops/sec ±0.48% (96 runs sampled) +encode: sourcemap-codec x 6,761 ops/sec ±0.21% (100 runs sampled) +encode: source-map-0.6.1 x 5,374 ops/sec ±0.17% (99 runs sampled) +encode: source-map-0.8.0 x 5,633 ops/sec ±0.32% (99 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15,encode: local code + + +*** + + +react.js.map - 5726 segments + +Decode Memory Usage: +local code 678816 bytes +@jridgewell/sourcemap-codec 1.4.15 678816 bytes +sourcemap-codec 816400 bytes +source-map-0.6.1 2288864 bytes +source-map-0.8.0 721360 bytes +chrome dev tools 1012512 bytes +Smallest memory usage is local code + +Decode speed: +decode: local code x 6,178 ops/sec ±0.19% (98 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 6,261 ops/sec ±0.22% (100 runs sampled) +decode: sourcemap-codec x 4,472 ops/sec ±0.90% (99 runs sampled) +decode: source-map-0.6.1 x 449 ops/sec ±0.31% (95 runs sampled) +decode: source-map-0.8.0 x 3,219 ops/sec ±0.13% (100 runs sampled) +chrome dev tools x 1,743 ops/sec ±0.20% (99 runs sampled) +Fastest is decode: @jridgewell/sourcemap-codec 1.4.15 + +Encode Memory Usage: +local code 140960 bytes +@jridgewell/sourcemap-codec 1.4.15 159808 bytes +sourcemap-codec 969304 bytes +source-map-0.6.1 930520 bytes +source-map-0.8.0 930248 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 8,013 ops/sec ±0.19% (100 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 7,989 ops/sec ±0.20% (101 runs sampled) +encode: sourcemap-codec x 2,472 ops/sec ±0.21% (99 runs sampled) +encode: source-map-0.6.1 x 2,200 ops/sec ±0.17% (99 runs sampled) +encode: source-map-0.8.0 x 2,220 ops/sec ±0.37% (99 runs sampled) +Fastest is encode: local code + + +*** + + +vscode.map - 2141001 segments + +Decode Memory Usage: +local code 198955264 bytes +@jridgewell/sourcemap-codec 1.4.15 199175352 bytes +sourcemap-codec 199102688 bytes +source-map-0.6.1 386323432 bytes +source-map-0.8.0 244116432 bytes +chrome dev tools 293734280 bytes +Smallest memory usage is local code + +Decode speed: +decode: local code x 3.90 ops/sec ±22.21% (15 runs sampled) +decode: @jridgewell/sourcemap-codec 1.4.15 x 3.95 ops/sec ±23.53% (15 runs sampled) +decode: sourcemap-codec x 3.82 ops/sec ±17.94% (14 runs sampled) +decode: source-map-0.6.1 x 0.61 ops/sec ±7.81% (6 runs sampled) +decode: source-map-0.8.0 x 9.54 ops/sec ±0.28% (28 runs sampled) +chrome dev tools x 2.18 ops/sec ±10.58% (10 runs sampled) +Fastest is decode: source-map-0.8.0 + +Encode Memory Usage: +local code 13509880 bytes +@jridgewell/sourcemap-codec 1.4.15 13537648 bytes +sourcemap-codec 32540104 bytes +source-map-0.6.1 127531040 bytes +source-map-0.8.0 127535312 bytes +Smallest memory usage is local code + +Encode speed: +encode: local code x 20.10 ops/sec ±0.19% (38 runs sampled) +encode: @jridgewell/sourcemap-codec 1.4.15 x 20.26 ops/sec ±0.32% (38 runs sampled) +encode: sourcemap-codec x 5.44 ops/sec ±1.64% (18 runs sampled) +encode: source-map-0.6.1 x 2.30 ops/sec ±4.79% (10 runs sampled) +encode: source-map-0.8.0 x 2.46 ops/sec ±6.53% (10 runs sampled) +Fastest is encode: @jridgewell/sourcemap-codec 1.4.15 +``` + +# License + +MIT diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs new file mode 100644 index 00000000..4e10070c --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs @@ -0,0 +1,467 @@ +// src/vlq.ts +var comma = ",".charCodeAt(0); +var semicolon = ";".charCodeAt(0); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +function decodeInteger(reader) { + let value = 0; + let shift = 0; + let integer = 0; + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + return value; +} +function decodeSign(num) { + return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1; +} +function encodeInteger(builder, num) { + do { + let clamped = num & 31; + num >>>= 5; + if (num > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (num > 0); +} +function encodeSign(num) { + return num < 0 ? -num << 1 | 1 : num << 1; +} +function hasMoreVlq(reader, max) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} + +// src/strings.ts +var bufLength = 1024 * 16; +var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } +} : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } +}; +var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +}; +var StringReader = class { + constructor(buffer) { + this.pos = 0; + this.buffer = buffer; + } + next() { + return this.buffer.charCodeAt(this.pos++); + } + peek() { + return this.buffer.charCodeAt(this.pos); + } + indexOf(char) { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +}; + +// src/scopes.ts +var EMPTY = []; +function decodeOriginalScopes(input) { + const { length } = input; + const reader = new StringReader(input); + const scopes = []; + const stack = []; + let line = 0; + for (; reader.pos < length; reader.pos++) { + line += decodeSign(decodeInteger(reader)); + const column = decodeSign(decodeInteger(reader)); + if (!hasMoreVlq(reader, length)) { + const last = stack.pop(); + last[2] = line; + last[3] = column; + continue; + } + const kind = decodeSign(decodeInteger(reader)); + const fields = decodeSign(decodeInteger(reader)); + const hasName = fields & 1; + const scope = hasName ? [line, column, 0, 0, kind, decodeSign(decodeInteger(reader))] : [line, column, 0, 0, kind]; + let vars = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeSign(decodeInteger(reader)); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + scopes.push(scope); + stack.push(scope); + } + return scopes; +} +function encodeOriginalScopes(scopes) { + const writer = new StringWriter(); + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + return writer.flush(); +} +function _encodeOriginalScopes(scopes, index, writer, state) { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + if (index > 0) writer.write(comma); + encodeInteger(writer, encodeSign(startLine - state[0])); + state[0] = startLine; + encodeInteger(writer, encodeSign(startColumn)); + encodeInteger(writer, encodeSign(kind)); + const fields = scope.length === 6 ? 1 : 0; + encodeInteger(writer, encodeSign(fields)); + if (scope.length === 6) encodeInteger(writer, encodeSign(scope[5])); + for (const v of vars) { + encodeInteger(writer, encodeSign(v)); + } + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + writer.write(comma); + encodeInteger(writer, encodeSign(endLine - state[0])); + state[0] = endLine; + encodeInteger(writer, encodeSign(endColumn)); + return index; +} +function decodeGeneratedRanges(input) { + const { length } = input; + const reader = new StringReader(input); + const ranges = []; + const stack = []; + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + do { + const semi = reader.indexOf(";"); + let genColumn = 0; + for (; reader.pos < semi; reader.pos++) { + genColumn += decodeSign(decodeInteger(reader)); + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop(); + last[2] = genLine; + last[3] = genColumn; + continue; + } + const fields = decodeSign(decodeInteger(reader)); + const hasDefinition = fields & 1; + const hasCallsite = fields & 2; + const hasScope = fields & 4; + let callsite = null; + let bindings = EMPTY; + let range; + if (hasDefinition) { + const defSourcesIndex = definitionSourcesIndex + decodeSign(decodeInteger(reader)); + definitionScopeIndex = decodeSign(decodeInteger(reader)) + (definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0); + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex]; + } else { + range = [genLine, genColumn, 0, 0]; + } + range.isScope = !!hasScope; + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex += decodeSign(decodeInteger(reader)); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = (sameSource ? callsiteLine : 0) + decodeSign(decodeInteger(reader)); + callsiteColumn = (sameSource && prevLine === callsiteLine ? callsiteColumn : 0) + decodeSign(decodeInteger(reader)); + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeSign(decodeInteger(reader)); + let expressionRanges; + if (expressionsCount < -1) { + expressionRanges = [[decodeSign(decodeInteger(reader))]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine += decodeSign(decodeInteger(reader)); + bindingColumn = (bindingLine === prevBl ? bindingColumn : 0) + decodeSign(decodeInteger(reader)); + const expression = decodeSign(decodeInteger(reader)); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + ranges.push(range); + stack.push(range); + } + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + return ranges; +} +function encodeGeneratedRanges(ranges) { + if (ranges.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + return writer.flush(); +} +function _encodeGeneratedRanges(ranges, index, writer, state) { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings + } = range; + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + encodeInteger(writer, encodeSign(range[1] - state[1])); + state[1] = range[1]; + const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0); + encodeInteger(writer, encodeSign(fields)); + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[2])); + state[2] = sourcesIndex; + encodeInteger(writer, encodeSign(scopesIndex - state[3])); + state[3] = scopesIndex; + } + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[4])); + state[4] = sourcesIndex; + encodeInteger(writer, encodeSign(callLine - state[5])); + state[5] = callLine; + encodeInteger(writer, encodeSign(callColumn - state[6])); + state[6] = callColumn; + } + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, encodeSign(-binding.length)); + const expression = binding[0][0]; + encodeInteger(writer, encodeSign(expression)); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + encodeInteger(writer, encodeSign(expRange[1] - bindingStartLine)); + bindingStartLine = expRange[1]; + encodeInteger(writer, encodeSign(expRange[2] - bindingStartColumn)); + bindingStartColumn = expRange[2]; + encodeInteger(writer, encodeSign(expRange[0])); + } + } + } + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + encodeInteger(writer, encodeSign(endColumn - state[1])); + state[1] = endColumn; + return index; +} +function catchupLine(writer, lastLine, line) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} + +// src/range-mappings.ts +function decodeRangeMappings(input) { + const { length } = input; + const reader = new StringReader(input); + const rangeMappings = []; + do { + const semi = reader.indexOf(";"); + const indices = []; + let index = 0; + while (reader.pos < semi) { + index += decodeInteger(reader); + indices.push(index); + } + rangeMappings.push(indices); + reader.pos = semi + 1; + } while (reader.pos <= length); + return rangeMappings; +} +function encodeRangeMappings(decoded) { + if (decoded.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < decoded.length; i++) { + const indices = decoded[i]; + if (i > 0) writer.write(semicolon); + let index = 0; + for (let j = 0; j < indices.length; j++) { + const offset = indices[j]; + encodeInteger(writer, offset - index); + index = offset; + } + } + return writer.flush(); +} + +// src/sourcemap-codec.ts +function decode(mappings) { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + do { + const semi = reader.indexOf(";"); + const line = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + while (reader.pos < semi) { + let seg; + genColumn += decodeSign(decodeInteger(reader)); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + if (hasMoreVlq(reader, semi)) { + sourcesIndex += decodeSign(decodeInteger(reader)); + sourceLine += decodeSign(decodeInteger(reader)); + sourceColumn += decodeSign(decodeInteger(reader)); + if (hasMoreVlq(reader, semi)) { + namesIndex += decodeSign(decodeInteger(reader)); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + line.push(seg); + reader.pos++; + } + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + return decoded; +} +function sort(line) { + line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[0] - b[0]; +} +function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + encodeInteger(writer, encodeSign(segment[0] - genColumn)); + genColumn = segment[0]; + if (segment.length === 1) continue; + encodeInteger(writer, encodeSign(segment[1] - sourcesIndex)); + encodeInteger(writer, encodeSign(segment[2] - sourceLine)); + encodeInteger(writer, encodeSign(segment[3] - sourceColumn)); + sourcesIndex = segment[1]; + sourceLine = segment[2]; + sourceColumn = segment[3]; + if (segment.length === 4) continue; + encodeInteger(writer, encodeSign(segment[4] - namesIndex)); + namesIndex = segment[4]; + } + } + return writer.flush(); +} +export { + decode, + decodeGeneratedRanges, + decodeOriginalScopes, + decodeRangeMappings, + encode, + encodeGeneratedRanges, + encodeOriginalScopes, + encodeRangeMappings +}; +//# sourceMappingURL=sourcemap-codec.mjs.map diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map new file mode 100644 index 00000000..ed642a69 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts", "../src/range-mappings.ts", "../src/sourcemap-codec.ts"], + "mappings": ";AAEO,IAAM,QAAQ,IAAI,WAAW,CAAC;AAC9B,IAAM,YAAY,IAAI,WAAW,CAAC;AAEzC,IAAM,QAAQ;AACd,IAAM,YAAY,IAAI,WAAW,EAAE;AACnC,IAAM,YAAY,IAAI,WAAW,GAAG;AAEpC,SAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAM,IAAI,MAAM,WAAW,CAAC;AAC5B,YAAU,CAAC,IAAI;AACf,YAAU,CAAC,IAAI;AACjB;AAEO,SAAS,cAAc,QAA8B;AAC1D,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,MAAI,UAAU;AAEd,KAAG;AACD,UAAM,IAAI,OAAO,KAAK;AACtB,cAAU,UAAU,CAAC;AACrB,cAAU,UAAU,OAAO;AAC3B,aAAS;AAAA,EACX,SAAS,UAAU;AAEnB,SAAO;AACT;AAEO,SAAS,WAAW,KAAqB;AAC9C,SAAO,MAAM,IAAI,cAAc,EAAE,QAAQ,KAAK,QAAQ;AACxD;AAEO,SAAS,cAAc,SAAuB,KAAa;AAChE,KAAG;AACD,QAAI,UAAU,MAAM;AACpB,aAAS;AACT,QAAI,MAAM,EAAG,YAAW;AACxB,YAAQ,MAAM,UAAU,OAAO,CAAC;AAAA,EAClC,SAAS,MAAM;AACjB;AAEO,SAAS,WAAW,KAAqB;AAC9C,SAAO,MAAM,IAAK,CAAC,OAAO,IAAK,IAAI,OAAO;AAC5C;AAEO,SAAS,WAAW,QAAsB,KAAa;AAC5D,MAAI,OAAO,OAAO,IAAK,QAAO;AAC9B,SAAO,OAAO,KAAK,MAAM;AAC3B;;;AClDA,IAAM,YAAY,OAAO;AAGzB,IAAM,KACJ,OAAO,gBAAgB,cACH,oBAAI,YAAY,IAChC,OAAO,WAAW,cAChB;AAAA,EACE,OAAO,KAAyB;AAC9B,UAAM,MAAM,OAAO,KAAK,IAAI,QAAQ,IAAI,YAAY,IAAI,UAAU;AAClE,WAAO,IAAI,SAAS;AAAA,EACtB;AACF,IACA;AAAA,EACE,OAAO,KAAyB;AAC9B,QAAI,MAAM;AACV,aAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,aAAO,OAAO,aAAa,IAAI,CAAC,CAAC;AAAA,IACnC;AACA,WAAO;AAAA,EACT;AACF;AAED,IAAM,eAAN,MAAmB;AAAA,EAAnB;AACL,eAAM;AACN,SAAQ,MAAM;AACd,SAAQ,SAAS,IAAI,WAAW,SAAS;AAAA;AAAA,EAEzC,MAAM,GAAiB;AACrB,UAAM,EAAE,OAAO,IAAI;AACnB,WAAO,KAAK,KAAK,IAAI;AACrB,QAAI,KAAK,QAAQ,WAAW;AAC1B,WAAK,OAAO,GAAG,OAAO,MAAM;AAC5B,WAAK,MAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,QAAgB;AACd,UAAM,EAAE,QAAQ,KAAK,IAAI,IAAI;AAC7B,WAAO,MAAM,IAAI,MAAM,GAAG,OAAO,OAAO,SAAS,GAAG,GAAG,CAAC,IAAI;AAAA,EAC9D;AACF;AAEO,IAAM,eAAN,MAAmB;AAAA,EAIxB,YAAY,QAAgB;AAH5B,eAAM;AAIJ,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,OAAO,WAAW,KAAK,KAAK;AAAA,EAC1C;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,OAAO,WAAW,KAAK,GAAG;AAAA,EACxC;AAAA,EAEA,QAAQ,MAAsB;AAC5B,UAAM,EAAE,QAAQ,IAAI,IAAI;AACxB,UAAM,MAAM,OAAO,QAAQ,MAAM,GAAG;AACpC,WAAO,QAAQ,KAAK,OAAO,SAAS;AAAA,EACtC;AACF;;;ACrDA,IAAM,QAAe,CAAC;AA+Bf,SAAS,qBAAqB,OAAgC;AACnE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,SAA0B,CAAC;AACjC,QAAM,QAAyB,CAAC;AAChC,MAAI,OAAO;AAEX,SAAO,OAAO,MAAM,QAAQ,OAAO,OAAO;AACxC,YAAQ,WAAW,cAAc,MAAM,CAAC;AACxC,UAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAE/C,QAAI,CAAC,WAAW,QAAQ,MAAM,GAAG;AAC/B,YAAM,OAAO,MAAM,IAAI;AACvB,WAAK,CAAC,IAAI;AACV,WAAK,CAAC,IAAI;AACV;AAAA,IACF;AAEA,UAAM,OAAO,WAAW,cAAc,MAAM,CAAC;AAC7C,UAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAC/C,UAAM,UAAU,SAAS;AAEzB,UAAM,QACJ,UACI,CAAC,MAAM,QAAQ,GAAG,GAAG,MAAM,WAAW,cAAc,MAAM,CAAC,CAAC,IAC5D,CAAC,MAAM,QAAQ,GAAG,GAAG,IAAI;AAG/B,QAAI,OAAc;AAClB,QAAI,WAAW,QAAQ,MAAM,GAAG;AAC9B,aAAO,CAAC;AACR,SAAG;AACD,cAAM,YAAY,WAAW,cAAc,MAAM,CAAC;AAClD,aAAK,KAAK,SAAS;AAAA,MACrB,SAAS,WAAW,QAAQ,MAAM;AAAA,IACpC;AACA,UAAM,OAAO;AAEb,WAAO,KAAK,KAAK;AACjB,UAAM,KAAK,KAAK;AAAA,EAClB;AAEA,SAAO;AACT;AAEO,SAAS,qBAAqB,QAAiC;AACpE,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,OAAO,UAAU;AACnC,QAAI,sBAAsB,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;AAAA,EAClD;AAEA,SAAO,OAAO,MAAM;AACtB;AAEA,SAAS,sBACP,QACA,OACA,QACA,OAGQ;AACR,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM,EAAE,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,KAAK,IAAI;AAElF,MAAI,QAAQ,EAAG,QAAO,MAAM,KAAK;AAEjC,gBAAc,QAAQ,WAAW,YAAY,MAAM,CAAC,CAAC,CAAC;AACtD,QAAM,CAAC,IAAI;AACX,gBAAc,QAAQ,WAAW,WAAW,CAAC;AAC7C,gBAAc,QAAQ,WAAW,IAAI,CAAC;AAEtC,QAAM,SAAS,MAAM,WAAW,IAAI,IAAS;AAC7C,gBAAc,QAAQ,WAAW,MAAM,CAAC;AACxC,MAAI,MAAM,WAAW,EAAG,eAAc,QAAQ,WAAW,MAAM,CAAC,CAAC,CAAC;AAElE,aAAW,KAAK,MAAM;AACpB,kBAAc,QAAQ,WAAW,CAAC,CAAC;AAAA,EACrC;AAEA,OAAK,SAAS,QAAQ,OAAO,UAAU;AACrC,UAAM,OAAO,OAAO,KAAK;AACzB,UAAM,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI;AACvB,QAAI,IAAI,WAAY,MAAM,WAAW,KAAK,WAAY;AACpD;AAAA,IACF;AACA,YAAQ,sBAAsB,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC5D;AAEA,SAAO,MAAM,KAAK;AAClB,gBAAc,QAAQ,WAAW,UAAU,MAAM,CAAC,CAAC,CAAC;AACpD,QAAM,CAAC,IAAI;AACX,gBAAc,QAAQ,WAAW,SAAS,CAAC;AAE3C,SAAO;AACT;AAEO,SAAS,sBAAsB,OAAiC;AACrE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,SAA2B,CAAC;AAClC,QAAM,QAA0B,CAAC;AAEjC,MAAI,UAAU;AACd,MAAI,yBAAyB;AAC7B,MAAI,uBAAuB;AAC3B,MAAI,uBAAuB;AAC3B,MAAI,eAAe;AACnB,MAAI,iBAAiB;AACrB,MAAI,cAAc;AAClB,MAAI,gBAAgB;AAEpB,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,QAAI,YAAY;AAEhB,WAAO,OAAO,MAAM,MAAM,OAAO,OAAO;AACtC,mBAAa,WAAW,cAAc,MAAM,CAAC;AAE7C,UAAI,CAAC,WAAW,QAAQ,IAAI,GAAG;AAC7B,cAAM,OAAO,MAAM,IAAI;AACvB,aAAK,CAAC,IAAI;AACV,aAAK,CAAC,IAAI;AACV;AAAA,MACF;AAEA,YAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAC/C,YAAM,gBAAgB,SAAS;AAC/B,YAAM,cAAc,SAAS;AAC7B,YAAM,WAAW,SAAS;AAE1B,UAAI,WAA4B;AAChC,UAAI,WAAsB;AAC1B,UAAI;AACJ,UAAI,eAAe;AACjB,cAAM,kBAAkB,yBAAyB,WAAW,cAAc,MAAM,CAAC;AACjF,+BACE,WAAW,cAAc,MAAM,CAAC,KAC/B,2BAA2B,kBAAkB,uBAAuB;AAEvE,iCAAyB;AACzB,gBAAQ,CAAC,SAAS,WAAW,GAAG,GAAG,iBAAiB,oBAAoB;AAAA,MAC1E,OAAO;AACL,gBAAQ,CAAC,SAAS,WAAW,GAAG,CAAC;AAAA,MACnC;AAEA,YAAM,UAAU,CAAC,CAAC;AAElB,UAAI,aAAa;AACf,cAAM,UAAU;AAChB,cAAM,WAAW;AACjB,gCAAwB,WAAW,cAAc,MAAM,CAAC;AACxD,cAAM,aAAa,YAAY;AAC/B,wBAAgB,aAAa,eAAe,KAAK,WAAW,cAAc,MAAM,CAAC;AACjF,0BACG,cAAc,aAAa,eAAe,iBAAiB,KAC5D,WAAW,cAAc,MAAM,CAAC;AAElC,mBAAW,CAAC,sBAAsB,cAAc,cAAc;AAAA,MAChE;AACA,YAAM,WAAW;AAEjB,UAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,mBAAW,CAAC;AACZ,WAAG;AACD,wBAAc;AACd,0BAAgB;AAChB,gBAAM,mBAAmB,WAAW,cAAc,MAAM,CAAC;AACzD,cAAI;AACJ,cAAI,mBAAmB,IAAI;AACzB,+BAAmB,CAAC,CAAC,WAAW,cAAc,MAAM,CAAC,CAAC,CAAC;AACvD,qBAAS,IAAI,IAAI,IAAI,kBAAkB,KAAK;AAC1C,oBAAM,SAAS;AACf,6BAAe,WAAW,cAAc,MAAM,CAAC;AAC/C,+BACG,gBAAgB,SAAS,gBAAgB,KAAK,WAAW,cAAc,MAAM,CAAC;AACjF,oBAAM,aAAa,WAAW,cAAc,MAAM,CAAC;AACnD,+BAAiB,KAAK,CAAC,YAAY,aAAa,aAAa,CAAC;AAAA,YAChE;AAAA,UACF,OAAO;AACL,+BAAmB,CAAC,CAAC,gBAAgB,CAAC;AAAA,UACxC;AACA,mBAAS,KAAK,gBAAgB;AAAA,QAChC,SAAS,WAAW,QAAQ,IAAI;AAAA,MAClC;AACA,YAAM,WAAW;AAEjB,aAAO,KAAK,KAAK;AACjB,YAAM,KAAK,KAAK;AAAA,IAClB;AAEA;AACA,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,MAAM;AAEtB,SAAO;AACT;AAEO,SAAS,sBAAsB,QAAkC;AACtE,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,OAAO,UAAU;AACnC,QAAI,uBAAuB,QAAQ,GAAG,QAAQ,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,EACrE;AAEA,SAAO,OAAO,MAAM;AACtB;AAEA,SAAS,uBACP,QACA,OACA,QACA,OASQ;AACR,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM;AAAA,IACJ,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,MAAI,MAAM,CAAC,IAAI,WAAW;AACxB,gBAAY,QAAQ,MAAM,CAAC,GAAG,SAAS;AACvC,UAAM,CAAC,IAAI;AACX,UAAM,CAAC,IAAI;AAAA,EACb,WAAW,QAAQ,GAAG;AACpB,WAAO,MAAM,KAAK;AAAA,EACpB;AAEA,gBAAc,QAAQ,WAAW,MAAM,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC;AACrD,QAAM,CAAC,IAAI,MAAM,CAAC;AAElB,QAAM,UACH,MAAM,WAAW,IAAI,IAAS,MAAM,WAAW,IAAS,MAAM,UAAU,IAAS;AACpF,gBAAc,QAAQ,WAAW,MAAM,CAAC;AAExC,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,EAAE,GAAG,cAAc,GAAG,YAAY,IAAI;AAC5C,QAAI,iBAAiB,MAAM,CAAC,GAAG;AAC7B,YAAM,CAAC,IAAI;AAAA,IACb;AACA,kBAAc,QAAQ,WAAW,eAAe,MAAM,CAAC,CAAC,CAAC;AACzD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,cAAc,MAAM,CAAC,CAAC,CAAC;AACxD,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,MAAI,UAAU;AACZ,UAAM,EAAE,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,IAAI,MAAM;AAC9D,QAAI,iBAAiB,MAAM,CAAC,GAAG;AAC7B,YAAM,CAAC,IAAI;AACX,YAAM,CAAC,IAAI;AAAA,IACb,WAAW,aAAa,MAAM,CAAC,GAAG;AAChC,YAAM,CAAC,IAAI;AAAA,IACb;AACA,kBAAc,QAAQ,WAAW,eAAe,MAAM,CAAC,CAAC,CAAC;AACzD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,WAAW,MAAM,CAAC,CAAC,CAAC;AACrD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,aAAa,MAAM,CAAC,CAAC,CAAC;AACvD,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,MAAI,UAAU;AACZ,eAAW,WAAW,UAAU;AAC9B,UAAI,QAAQ,SAAS,EAAG,eAAc,QAAQ,WAAW,CAAC,QAAQ,MAAM,CAAC;AACzE,YAAM,aAAa,QAAQ,CAAC,EAAE,CAAC;AAC/B,oBAAc,QAAQ,WAAW,UAAU,CAAC;AAC5C,UAAI,mBAAmB;AACvB,UAAI,qBAAqB;AACzB,eAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,cAAM,WAAW,QAAQ,CAAC;AAC1B,sBAAc,QAAQ,WAAW,SAAS,CAAC,IAAK,gBAAgB,CAAC;AACjE,2BAAmB,SAAS,CAAC;AAC7B,sBAAc,QAAQ,WAAW,SAAS,CAAC,IAAK,kBAAkB,CAAC;AACnE,6BAAqB,SAAS,CAAC;AAC/B,sBAAc,QAAQ,WAAW,SAAS,CAAC,CAAE,CAAC;AAAA,MAChD;AAAA,IACF;AAAA,EACF;AAEA,OAAK,SAAS,QAAQ,OAAO,UAAU;AACrC,UAAM,OAAO,OAAO,KAAK;AACzB,UAAM,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI;AACvB,QAAI,IAAI,WAAY,MAAM,WAAW,KAAK,WAAY;AACpD;AAAA,IACF;AACA,YAAQ,uBAAuB,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC7D;AAEA,MAAI,MAAM,CAAC,IAAI,SAAS;AACtB,gBAAY,QAAQ,MAAM,CAAC,GAAG,OAAO;AACrC,UAAM,CAAC,IAAI;AACX,UAAM,CAAC,IAAI;AAAA,EACb,OAAO;AACL,WAAO,MAAM,KAAK;AAAA,EACpB;AACA,gBAAc,QAAQ,WAAW,YAAY,MAAM,CAAC,CAAC,CAAC;AACtD,QAAM,CAAC,IAAI;AAEX,SAAO;AACT;AAEA,SAAS,YAAY,QAAsB,UAAkB,MAAc;AACzE,KAAG;AACD,WAAO,MAAM,SAAS;AAAA,EACxB,SAAS,EAAE,WAAW;AACxB;;;ACtWO,SAAS,oBAAoB,OAA8B;AAChE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,gBAA+B,CAAC;AAEtC,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,UAAM,UAA0B,CAAC;AACjC,QAAI,QAAQ;AAEZ,WAAO,OAAO,MAAM,MAAM;AACxB,eAAS,cAAc,MAAM;AAC7B,cAAQ,KAAK,KAAK;AAAA,IACpB;AAEA,kBAAc,KAAK,OAAO;AAC1B,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,OAAO;AAEvB,SAAO;AACT;AAEO,SAAS,oBAAoB,SAAgC;AAClE,MAAI,QAAQ,WAAW,EAAG,QAAO;AAEjC,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,UAAU,QAAQ,CAAC;AACzB,QAAI,IAAI,EAAG,QAAO,MAAM,SAAS;AAEjC,QAAI,QAAQ;AACZ,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,YAAM,SAAS,QAAQ,CAAC;AACxB,oBAAc,QAAQ,SAAS,KAAK;AACpC,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,SAAO,OAAO,MAAM;AACtB;;;ACjBO,SAAS,OAAO,UAAqC;AAC1D,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,QAAQ;AACxC,QAAM,UAA6B,CAAC;AACpC,MAAI,YAAY;AAChB,MAAI,eAAe;AACnB,MAAI,aAAa;AACjB,MAAI,eAAe;AACnB,MAAI,aAAa;AAEjB,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,UAAM,OAAsB,CAAC;AAC7B,QAAI,SAAS;AACb,QAAI,UAAU;AACd,gBAAY;AAEZ,WAAO,OAAO,MAAM,MAAM;AACxB,UAAI;AAEJ,mBAAa,WAAW,cAAc,MAAM,CAAC;AAC7C,UAAI,YAAY,QAAS,UAAS;AAClC,gBAAU;AAEV,UAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,wBAAgB,WAAW,cAAc,MAAM,CAAC;AAChD,sBAAc,WAAW,cAAc,MAAM,CAAC;AAC9C,wBAAgB,WAAW,cAAc,MAAM,CAAC;AAEhD,YAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,wBAAc,WAAW,cAAc,MAAM,CAAC;AAC9C,gBAAM,CAAC,WAAW,cAAc,YAAY,cAAc,UAAU;AAAA,QACtE,OAAO;AACL,gBAAM,CAAC,WAAW,cAAc,YAAY,YAAY;AAAA,QAC1D;AAAA,MACF,OAAO;AACL,cAAM,CAAC,SAAS;AAAA,MAClB;AAEA,WAAK,KAAK,GAAG;AACb,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,OAAQ,MAAK,IAAI;AACtB,YAAQ,KAAK,IAAI;AACjB,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,OAAO;AAEvB,SAAO;AACT;AAEA,SAAS,KAAK,MAA0B;AACtC,OAAK,KAAK,cAAc;AAC1B;AAEA,SAAS,eAAe,GAAqB,GAA6B;AACxE,SAAO,EAAE,CAAC,IAAI,EAAE,CAAC;AACnB;AAIO,SAAS,OAAO,SAA8C;AACnE,QAAM,SAAS,IAAI,aAAa;AAChC,MAAI,eAAe;AACnB,MAAI,aAAa;AACjB,MAAI,eAAe;AACnB,MAAI,aAAa;AAEjB,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,QAAI,IAAI,EAAG,QAAO,MAAM,SAAS;AACjC,QAAI,KAAK,WAAW,EAAG;AAEvB,QAAI,YAAY;AAEhB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,UAAU,KAAK,CAAC;AACtB,UAAI,IAAI,EAAG,QAAO,MAAM,KAAK;AAE7B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,SAAS,CAAC;AACxD,kBAAY,QAAQ,CAAC;AAErB,UAAI,QAAQ,WAAW,EAAG;AAC1B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;AAC3D,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,UAAU,CAAC;AACzD,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;AAC3D,qBAAe,QAAQ,CAAC;AACxB,mBAAa,QAAQ,CAAC;AACtB,qBAAe,QAAQ,CAAC;AAExB,UAAI,QAAQ,WAAW,EAAG;AAC1B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,UAAU,CAAC;AACzD,mBAAa,QAAQ,CAAC;AAAA,IACxB;AAAA,EACF;AAEA,SAAO,OAAO,MAAM;AACtB;", + "names": [] +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js new file mode 100644 index 00000000..a4f5e302 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js @@ -0,0 +1,508 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.sourcemapCodec = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module) { +"use strict"; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/sourcemap-codec.ts +var sourcemap_codec_exports = {}; +__export(sourcemap_codec_exports, { + decode: () => decode, + decodeGeneratedRanges: () => decodeGeneratedRanges, + decodeOriginalScopes: () => decodeOriginalScopes, + decodeRangeMappings: () => decodeRangeMappings, + encode: () => encode, + encodeGeneratedRanges: () => encodeGeneratedRanges, + encodeOriginalScopes: () => encodeOriginalScopes, + encodeRangeMappings: () => encodeRangeMappings +}); +module.exports = __toCommonJS(sourcemap_codec_exports); + +// src/vlq.ts +var comma = ",".charCodeAt(0); +var semicolon = ";".charCodeAt(0); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +function decodeInteger(reader) { + let value = 0; + let shift = 0; + let integer = 0; + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + return value; +} +function decodeSign(num) { + return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1; +} +function encodeInteger(builder, num) { + do { + let clamped = num & 31; + num >>>= 5; + if (num > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (num > 0); +} +function encodeSign(num) { + return num < 0 ? -num << 1 | 1 : num << 1; +} +function hasMoreVlq(reader, max) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} + +// src/strings.ts +var bufLength = 1024 * 16; +var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } +} : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } +}; +var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +}; +var StringReader = class { + constructor(buffer) { + this.pos = 0; + this.buffer = buffer; + } + next() { + return this.buffer.charCodeAt(this.pos++); + } + peek() { + return this.buffer.charCodeAt(this.pos); + } + indexOf(char) { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +}; + +// src/scopes.ts +var EMPTY = []; +function decodeOriginalScopes(input) { + const { length } = input; + const reader = new StringReader(input); + const scopes = []; + const stack = []; + let line = 0; + for (; reader.pos < length; reader.pos++) { + line += decodeSign(decodeInteger(reader)); + const column = decodeSign(decodeInteger(reader)); + if (!hasMoreVlq(reader, length)) { + const last = stack.pop(); + last[2] = line; + last[3] = column; + continue; + } + const kind = decodeSign(decodeInteger(reader)); + const fields = decodeSign(decodeInteger(reader)); + const hasName = fields & 1; + const scope = hasName ? [line, column, 0, 0, kind, decodeSign(decodeInteger(reader))] : [line, column, 0, 0, kind]; + let vars = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeSign(decodeInteger(reader)); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + scopes.push(scope); + stack.push(scope); + } + return scopes; +} +function encodeOriginalScopes(scopes) { + const writer = new StringWriter(); + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + return writer.flush(); +} +function _encodeOriginalScopes(scopes, index, writer, state) { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + if (index > 0) writer.write(comma); + encodeInteger(writer, encodeSign(startLine - state[0])); + state[0] = startLine; + encodeInteger(writer, encodeSign(startColumn)); + encodeInteger(writer, encodeSign(kind)); + const fields = scope.length === 6 ? 1 : 0; + encodeInteger(writer, encodeSign(fields)); + if (scope.length === 6) encodeInteger(writer, encodeSign(scope[5])); + for (const v of vars) { + encodeInteger(writer, encodeSign(v)); + } + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + writer.write(comma); + encodeInteger(writer, encodeSign(endLine - state[0])); + state[0] = endLine; + encodeInteger(writer, encodeSign(endColumn)); + return index; +} +function decodeGeneratedRanges(input) { + const { length } = input; + const reader = new StringReader(input); + const ranges = []; + const stack = []; + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + do { + const semi = reader.indexOf(";"); + let genColumn = 0; + for (; reader.pos < semi; reader.pos++) { + genColumn += decodeSign(decodeInteger(reader)); + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop(); + last[2] = genLine; + last[3] = genColumn; + continue; + } + const fields = decodeSign(decodeInteger(reader)); + const hasDefinition = fields & 1; + const hasCallsite = fields & 2; + const hasScope = fields & 4; + let callsite = null; + let bindings = EMPTY; + let range; + if (hasDefinition) { + const defSourcesIndex = definitionSourcesIndex + decodeSign(decodeInteger(reader)); + definitionScopeIndex = decodeSign(decodeInteger(reader)) + (definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0); + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex]; + } else { + range = [genLine, genColumn, 0, 0]; + } + range.isScope = !!hasScope; + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex += decodeSign(decodeInteger(reader)); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = (sameSource ? callsiteLine : 0) + decodeSign(decodeInteger(reader)); + callsiteColumn = (sameSource && prevLine === callsiteLine ? callsiteColumn : 0) + decodeSign(decodeInteger(reader)); + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeSign(decodeInteger(reader)); + let expressionRanges; + if (expressionsCount < -1) { + expressionRanges = [[decodeSign(decodeInteger(reader))]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine += decodeSign(decodeInteger(reader)); + bindingColumn = (bindingLine === prevBl ? bindingColumn : 0) + decodeSign(decodeInteger(reader)); + const expression = decodeSign(decodeInteger(reader)); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + ranges.push(range); + stack.push(range); + } + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + return ranges; +} +function encodeGeneratedRanges(ranges) { + if (ranges.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + return writer.flush(); +} +function _encodeGeneratedRanges(ranges, index, writer, state) { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings + } = range; + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + encodeInteger(writer, encodeSign(range[1] - state[1])); + state[1] = range[1]; + const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0); + encodeInteger(writer, encodeSign(fields)); + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[2])); + state[2] = sourcesIndex; + encodeInteger(writer, encodeSign(scopesIndex - state[3])); + state[3] = scopesIndex; + } + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[4])); + state[4] = sourcesIndex; + encodeInteger(writer, encodeSign(callLine - state[5])); + state[5] = callLine; + encodeInteger(writer, encodeSign(callColumn - state[6])); + state[6] = callColumn; + } + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, encodeSign(-binding.length)); + const expression = binding[0][0]; + encodeInteger(writer, encodeSign(expression)); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + encodeInteger(writer, encodeSign(expRange[1] - bindingStartLine)); + bindingStartLine = expRange[1]; + encodeInteger(writer, encodeSign(expRange[2] - bindingStartColumn)); + bindingStartColumn = expRange[2]; + encodeInteger(writer, encodeSign(expRange[0])); + } + } + } + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || l === endLine && c >= endColumn) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + encodeInteger(writer, encodeSign(endColumn - state[1])); + state[1] = endColumn; + return index; +} +function catchupLine(writer, lastLine, line) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} + +// src/range-mappings.ts +function decodeRangeMappings(input) { + const { length } = input; + const reader = new StringReader(input); + const rangeMappings = []; + do { + const semi = reader.indexOf(";"); + const indices = []; + let index = 0; + while (reader.pos < semi) { + index += decodeInteger(reader); + indices.push(index); + } + rangeMappings.push(indices); + reader.pos = semi + 1; + } while (reader.pos <= length); + return rangeMappings; +} +function encodeRangeMappings(decoded) { + if (decoded.length === 0) return ""; + const writer = new StringWriter(); + for (let i = 0; i < decoded.length; i++) { + const indices = decoded[i]; + if (i > 0) writer.write(semicolon); + let index = 0; + for (let j = 0; j < indices.length; j++) { + const offset = indices[j]; + encodeInteger(writer, offset - index); + index = offset; + } + } + return writer.flush(); +} + +// src/sourcemap-codec.ts +function decode(mappings) { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + do { + const semi = reader.indexOf(";"); + const line = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + while (reader.pos < semi) { + let seg; + genColumn += decodeSign(decodeInteger(reader)); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + if (hasMoreVlq(reader, semi)) { + sourcesIndex += decodeSign(decodeInteger(reader)); + sourceLine += decodeSign(decodeInteger(reader)); + sourceColumn += decodeSign(decodeInteger(reader)); + if (hasMoreVlq(reader, semi)) { + namesIndex += decodeSign(decodeInteger(reader)); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + line.push(seg); + reader.pos++; + } + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + return decoded; +} +function sort(line) { + line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[0] - b[0]; +} +function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + encodeInteger(writer, encodeSign(segment[0] - genColumn)); + genColumn = segment[0]; + if (segment.length === 1) continue; + encodeInteger(writer, encodeSign(segment[1] - sourcesIndex)); + encodeInteger(writer, encodeSign(segment[2] - sourceLine)); + encodeInteger(writer, encodeSign(segment[3] - sourceColumn)); + sourcesIndex = segment[1]; + sourceLine = segment[2]; + sourceColumn = segment[3]; + if (segment.length === 4) continue; + encodeInteger(writer, encodeSign(segment[4] - namesIndex)); + namesIndex = segment[4]; + } + } + return writer.flush(); +} +})); +//# sourceMappingURL=sourcemap-codec.umd.js.map diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map new file mode 100644 index 00000000..c65e6f01 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/sourcemap-codec.ts", "../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts", "../src/range-mappings.ts"], + "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACEO,IAAM,QAAQ,IAAI,WAAW,CAAC;AAC9B,IAAM,YAAY,IAAI,WAAW,CAAC;AAEzC,IAAM,QAAQ;AACd,IAAM,YAAY,IAAI,WAAW,EAAE;AACnC,IAAM,YAAY,IAAI,WAAW,GAAG;AAEpC,SAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAM,IAAI,MAAM,WAAW,CAAC;AAC5B,YAAU,CAAC,IAAI;AACf,YAAU,CAAC,IAAI;AACjB;AAEO,SAAS,cAAc,QAA8B;AAC1D,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,MAAI,UAAU;AAEd,KAAG;AACD,UAAM,IAAI,OAAO,KAAK;AACtB,cAAU,UAAU,CAAC;AACrB,cAAU,UAAU,OAAO;AAC3B,aAAS;AAAA,EACX,SAAS,UAAU;AAEnB,SAAO;AACT;AAEO,SAAS,WAAW,KAAqB;AAC9C,SAAO,MAAM,IAAI,cAAc,EAAE,QAAQ,KAAK,QAAQ;AACxD;AAEO,SAAS,cAAc,SAAuB,KAAa;AAChE,KAAG;AACD,QAAI,UAAU,MAAM;AACpB,aAAS;AACT,QAAI,MAAM,EAAG,YAAW;AACxB,YAAQ,MAAM,UAAU,OAAO,CAAC;AAAA,EAClC,SAAS,MAAM;AACjB;AAEO,SAAS,WAAW,KAAqB;AAC9C,SAAO,MAAM,IAAK,CAAC,OAAO,IAAK,IAAI,OAAO;AAC5C;AAEO,SAAS,WAAW,QAAsB,KAAa;AAC5D,MAAI,OAAO,OAAO,IAAK,QAAO;AAC9B,SAAO,OAAO,KAAK,MAAM;AAC3B;;;AClDA,IAAM,YAAY,OAAO;AAGzB,IAAM,KACJ,OAAO,gBAAgB,cACH,oBAAI,YAAY,IAChC,OAAO,WAAW,cAChB;AAAA,EACE,OAAO,KAAyB;AAC9B,UAAM,MAAM,OAAO,KAAK,IAAI,QAAQ,IAAI,YAAY,IAAI,UAAU;AAClE,WAAO,IAAI,SAAS;AAAA,EACtB;AACF,IACA;AAAA,EACE,OAAO,KAAyB;AAC9B,QAAI,MAAM;AACV,aAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,aAAO,OAAO,aAAa,IAAI,CAAC,CAAC;AAAA,IACnC;AACA,WAAO;AAAA,EACT;AACF;AAED,IAAM,eAAN,MAAmB;AAAA,EAAnB;AACL,eAAM;AACN,SAAQ,MAAM;AACd,SAAQ,SAAS,IAAI,WAAW,SAAS;AAAA;AAAA,EAEzC,MAAM,GAAiB;AACrB,UAAM,EAAE,OAAO,IAAI;AACnB,WAAO,KAAK,KAAK,IAAI;AACrB,QAAI,KAAK,QAAQ,WAAW;AAC1B,WAAK,OAAO,GAAG,OAAO,MAAM;AAC5B,WAAK,MAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,QAAgB;AACd,UAAM,EAAE,QAAQ,KAAK,IAAI,IAAI;AAC7B,WAAO,MAAM,IAAI,MAAM,GAAG,OAAO,OAAO,SAAS,GAAG,GAAG,CAAC,IAAI;AAAA,EAC9D;AACF;AAEO,IAAM,eAAN,MAAmB;AAAA,EAIxB,YAAY,QAAgB;AAH5B,eAAM;AAIJ,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,OAAO,WAAW,KAAK,KAAK;AAAA,EAC1C;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,OAAO,WAAW,KAAK,GAAG;AAAA,EACxC;AAAA,EAEA,QAAQ,MAAsB;AAC5B,UAAM,EAAE,QAAQ,IAAI,IAAI;AACxB,UAAM,MAAM,OAAO,QAAQ,MAAM,GAAG;AACpC,WAAO,QAAQ,KAAK,OAAO,SAAS;AAAA,EACtC;AACF;;;ACrDA,IAAM,QAAe,CAAC;AA+Bf,SAAS,qBAAqB,OAAgC;AACnE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,SAA0B,CAAC;AACjC,QAAM,QAAyB,CAAC;AAChC,MAAI,OAAO;AAEX,SAAO,OAAO,MAAM,QAAQ,OAAO,OAAO;AACxC,YAAQ,WAAW,cAAc,MAAM,CAAC;AACxC,UAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAE/C,QAAI,CAAC,WAAW,QAAQ,MAAM,GAAG;AAC/B,YAAM,OAAO,MAAM,IAAI;AACvB,WAAK,CAAC,IAAI;AACV,WAAK,CAAC,IAAI;AACV;AAAA,IACF;AAEA,UAAM,OAAO,WAAW,cAAc,MAAM,CAAC;AAC7C,UAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAC/C,UAAM,UAAU,SAAS;AAEzB,UAAM,QACJ,UACI,CAAC,MAAM,QAAQ,GAAG,GAAG,MAAM,WAAW,cAAc,MAAM,CAAC,CAAC,IAC5D,CAAC,MAAM,QAAQ,GAAG,GAAG,IAAI;AAG/B,QAAI,OAAc;AAClB,QAAI,WAAW,QAAQ,MAAM,GAAG;AAC9B,aAAO,CAAC;AACR,SAAG;AACD,cAAM,YAAY,WAAW,cAAc,MAAM,CAAC;AAClD,aAAK,KAAK,SAAS;AAAA,MACrB,SAAS,WAAW,QAAQ,MAAM;AAAA,IACpC;AACA,UAAM,OAAO;AAEb,WAAO,KAAK,KAAK;AACjB,UAAM,KAAK,KAAK;AAAA,EAClB;AAEA,SAAO;AACT;AAEO,SAAS,qBAAqB,QAAiC;AACpE,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,OAAO,UAAU;AACnC,QAAI,sBAAsB,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;AAAA,EAClD;AAEA,SAAO,OAAO,MAAM;AACtB;AAEA,SAAS,sBACP,QACA,OACA,QACA,OAGQ;AACR,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM,EAAE,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,KAAK,IAAI;AAElF,MAAI,QAAQ,EAAG,QAAO,MAAM,KAAK;AAEjC,gBAAc,QAAQ,WAAW,YAAY,MAAM,CAAC,CAAC,CAAC;AACtD,QAAM,CAAC,IAAI;AACX,gBAAc,QAAQ,WAAW,WAAW,CAAC;AAC7C,gBAAc,QAAQ,WAAW,IAAI,CAAC;AAEtC,QAAM,SAAS,MAAM,WAAW,IAAI,IAAS;AAC7C,gBAAc,QAAQ,WAAW,MAAM,CAAC;AACxC,MAAI,MAAM,WAAW,EAAG,eAAc,QAAQ,WAAW,MAAM,CAAC,CAAC,CAAC;AAElE,aAAW,KAAK,MAAM;AACpB,kBAAc,QAAQ,WAAW,CAAC,CAAC;AAAA,EACrC;AAEA,OAAK,SAAS,QAAQ,OAAO,UAAU;AACrC,UAAM,OAAO,OAAO,KAAK;AACzB,UAAM,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI;AACvB,QAAI,IAAI,WAAY,MAAM,WAAW,KAAK,WAAY;AACpD;AAAA,IACF;AACA,YAAQ,sBAAsB,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC5D;AAEA,SAAO,MAAM,KAAK;AAClB,gBAAc,QAAQ,WAAW,UAAU,MAAM,CAAC,CAAC,CAAC;AACpD,QAAM,CAAC,IAAI;AACX,gBAAc,QAAQ,WAAW,SAAS,CAAC;AAE3C,SAAO;AACT;AAEO,SAAS,sBAAsB,OAAiC;AACrE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,SAA2B,CAAC;AAClC,QAAM,QAA0B,CAAC;AAEjC,MAAI,UAAU;AACd,MAAI,yBAAyB;AAC7B,MAAI,uBAAuB;AAC3B,MAAI,uBAAuB;AAC3B,MAAI,eAAe;AACnB,MAAI,iBAAiB;AACrB,MAAI,cAAc;AAClB,MAAI,gBAAgB;AAEpB,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,QAAI,YAAY;AAEhB,WAAO,OAAO,MAAM,MAAM,OAAO,OAAO;AACtC,mBAAa,WAAW,cAAc,MAAM,CAAC;AAE7C,UAAI,CAAC,WAAW,QAAQ,IAAI,GAAG;AAC7B,cAAM,OAAO,MAAM,IAAI;AACvB,aAAK,CAAC,IAAI;AACV,aAAK,CAAC,IAAI;AACV;AAAA,MACF;AAEA,YAAM,SAAS,WAAW,cAAc,MAAM,CAAC;AAC/C,YAAM,gBAAgB,SAAS;AAC/B,YAAM,cAAc,SAAS;AAC7B,YAAM,WAAW,SAAS;AAE1B,UAAI,WAA4B;AAChC,UAAI,WAAsB;AAC1B,UAAI;AACJ,UAAI,eAAe;AACjB,cAAM,kBAAkB,yBAAyB,WAAW,cAAc,MAAM,CAAC;AACjF,+BACE,WAAW,cAAc,MAAM,CAAC,KAC/B,2BAA2B,kBAAkB,uBAAuB;AAEvE,iCAAyB;AACzB,gBAAQ,CAAC,SAAS,WAAW,GAAG,GAAG,iBAAiB,oBAAoB;AAAA,MAC1E,OAAO;AACL,gBAAQ,CAAC,SAAS,WAAW,GAAG,CAAC;AAAA,MACnC;AAEA,YAAM,UAAU,CAAC,CAAC;AAElB,UAAI,aAAa;AACf,cAAM,UAAU;AAChB,cAAM,WAAW;AACjB,gCAAwB,WAAW,cAAc,MAAM,CAAC;AACxD,cAAM,aAAa,YAAY;AAC/B,wBAAgB,aAAa,eAAe,KAAK,WAAW,cAAc,MAAM,CAAC;AACjF,0BACG,cAAc,aAAa,eAAe,iBAAiB,KAC5D,WAAW,cAAc,MAAM,CAAC;AAElC,mBAAW,CAAC,sBAAsB,cAAc,cAAc;AAAA,MAChE;AACA,YAAM,WAAW;AAEjB,UAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,mBAAW,CAAC;AACZ,WAAG;AACD,wBAAc;AACd,0BAAgB;AAChB,gBAAM,mBAAmB,WAAW,cAAc,MAAM,CAAC;AACzD,cAAI;AACJ,cAAI,mBAAmB,IAAI;AACzB,+BAAmB,CAAC,CAAC,WAAW,cAAc,MAAM,CAAC,CAAC,CAAC;AACvD,qBAAS,IAAI,IAAI,IAAI,kBAAkB,KAAK;AAC1C,oBAAM,SAAS;AACf,6BAAe,WAAW,cAAc,MAAM,CAAC;AAC/C,+BACG,gBAAgB,SAAS,gBAAgB,KAAK,WAAW,cAAc,MAAM,CAAC;AACjF,oBAAM,aAAa,WAAW,cAAc,MAAM,CAAC;AACnD,+BAAiB,KAAK,CAAC,YAAY,aAAa,aAAa,CAAC;AAAA,YAChE;AAAA,UACF,OAAO;AACL,+BAAmB,CAAC,CAAC,gBAAgB,CAAC;AAAA,UACxC;AACA,mBAAS,KAAK,gBAAgB;AAAA,QAChC,SAAS,WAAW,QAAQ,IAAI;AAAA,MAClC;AACA,YAAM,WAAW;AAEjB,aAAO,KAAK,KAAK;AACjB,YAAM,KAAK,KAAK;AAAA,IAClB;AAEA;AACA,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,MAAM;AAEtB,SAAO;AACT;AAEO,SAAS,sBAAsB,QAAkC;AACtE,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,OAAO,UAAU;AACnC,QAAI,uBAAuB,QAAQ,GAAG,QAAQ,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,EACrE;AAEA,SAAO,OAAO,MAAM;AACtB;AAEA,SAAS,uBACP,QACA,OACA,QACA,OASQ;AACR,QAAM,QAAQ,OAAO,KAAK;AAC1B,QAAM;AAAA,IACJ,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,MAAI,MAAM,CAAC,IAAI,WAAW;AACxB,gBAAY,QAAQ,MAAM,CAAC,GAAG,SAAS;AACvC,UAAM,CAAC,IAAI;AACX,UAAM,CAAC,IAAI;AAAA,EACb,WAAW,QAAQ,GAAG;AACpB,WAAO,MAAM,KAAK;AAAA,EACpB;AAEA,gBAAc,QAAQ,WAAW,MAAM,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC;AACrD,QAAM,CAAC,IAAI,MAAM,CAAC;AAElB,QAAM,UACH,MAAM,WAAW,IAAI,IAAS,MAAM,WAAW,IAAS,MAAM,UAAU,IAAS;AACpF,gBAAc,QAAQ,WAAW,MAAM,CAAC;AAExC,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,EAAE,GAAG,cAAc,GAAG,YAAY,IAAI;AAC5C,QAAI,iBAAiB,MAAM,CAAC,GAAG;AAC7B,YAAM,CAAC,IAAI;AAAA,IACb;AACA,kBAAc,QAAQ,WAAW,eAAe,MAAM,CAAC,CAAC,CAAC;AACzD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,cAAc,MAAM,CAAC,CAAC,CAAC;AACxD,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,MAAI,UAAU;AACZ,UAAM,EAAE,GAAG,cAAc,GAAG,UAAU,GAAG,WAAW,IAAI,MAAM;AAC9D,QAAI,iBAAiB,MAAM,CAAC,GAAG;AAC7B,YAAM,CAAC,IAAI;AACX,YAAM,CAAC,IAAI;AAAA,IACb,WAAW,aAAa,MAAM,CAAC,GAAG;AAChC,YAAM,CAAC,IAAI;AAAA,IACb;AACA,kBAAc,QAAQ,WAAW,eAAe,MAAM,CAAC,CAAC,CAAC;AACzD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,WAAW,MAAM,CAAC,CAAC,CAAC;AACrD,UAAM,CAAC,IAAI;AACX,kBAAc,QAAQ,WAAW,aAAa,MAAM,CAAC,CAAC,CAAC;AACvD,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,MAAI,UAAU;AACZ,eAAW,WAAW,UAAU;AAC9B,UAAI,QAAQ,SAAS,EAAG,eAAc,QAAQ,WAAW,CAAC,QAAQ,MAAM,CAAC;AACzE,YAAM,aAAa,QAAQ,CAAC,EAAE,CAAC;AAC/B,oBAAc,QAAQ,WAAW,UAAU,CAAC;AAC5C,UAAI,mBAAmB;AACvB,UAAI,qBAAqB;AACzB,eAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,cAAM,WAAW,QAAQ,CAAC;AAC1B,sBAAc,QAAQ,WAAW,SAAS,CAAC,IAAK,gBAAgB,CAAC;AACjE,2BAAmB,SAAS,CAAC;AAC7B,sBAAc,QAAQ,WAAW,SAAS,CAAC,IAAK,kBAAkB,CAAC;AACnE,6BAAqB,SAAS,CAAC;AAC/B,sBAAc,QAAQ,WAAW,SAAS,CAAC,CAAE,CAAC;AAAA,MAChD;AAAA,IACF;AAAA,EACF;AAEA,OAAK,SAAS,QAAQ,OAAO,UAAU;AACrC,UAAM,OAAO,OAAO,KAAK;AACzB,UAAM,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI;AACvB,QAAI,IAAI,WAAY,MAAM,WAAW,KAAK,WAAY;AACpD;AAAA,IACF;AACA,YAAQ,uBAAuB,QAAQ,OAAO,QAAQ,KAAK;AAAA,EAC7D;AAEA,MAAI,MAAM,CAAC,IAAI,SAAS;AACtB,gBAAY,QAAQ,MAAM,CAAC,GAAG,OAAO;AACrC,UAAM,CAAC,IAAI;AACX,UAAM,CAAC,IAAI;AAAA,EACb,OAAO;AACL,WAAO,MAAM,KAAK;AAAA,EACpB;AACA,gBAAc,QAAQ,WAAW,YAAY,MAAM,CAAC,CAAC,CAAC;AACtD,QAAM,CAAC,IAAI;AAEX,SAAO;AACT;AAEA,SAAS,YAAY,QAAsB,UAAkB,MAAc;AACzE,KAAG;AACD,WAAO,MAAM,SAAS;AAAA,EACxB,SAAS,EAAE,WAAW;AACxB;;;ACtWO,SAAS,oBAAoB,OAA8B;AAChE,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,KAAK;AACrC,QAAM,gBAA+B,CAAC;AAEtC,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,UAAM,UAA0B,CAAC;AACjC,QAAI,QAAQ;AAEZ,WAAO,OAAO,MAAM,MAAM;AACxB,eAAS,cAAc,MAAM;AAC7B,cAAQ,KAAK,KAAK;AAAA,IACpB;AAEA,kBAAc,KAAK,OAAO;AAC1B,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,OAAO;AAEvB,SAAO;AACT;AAEO,SAAS,oBAAoB,SAAgC;AAClE,MAAI,QAAQ,WAAW,EAAG,QAAO;AAEjC,QAAM,SAAS,IAAI,aAAa;AAEhC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,UAAU,QAAQ,CAAC;AACzB,QAAI,IAAI,EAAG,QAAO,MAAM,SAAS;AAEjC,QAAI,QAAQ;AACZ,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,YAAM,SAAS,QAAQ,CAAC;AACxB,oBAAc,QAAQ,SAAS,KAAK;AACpC,cAAQ;AAAA,IACV;AAAA,EACF;AAEA,SAAO,OAAO,MAAM;AACtB;;;AJjBO,SAAS,OAAO,UAAqC;AAC1D,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,SAAS,IAAI,aAAa,QAAQ;AACxC,QAAM,UAA6B,CAAC;AACpC,MAAI,YAAY;AAChB,MAAI,eAAe;AACnB,MAAI,aAAa;AACjB,MAAI,eAAe;AACnB,MAAI,aAAa;AAEjB,KAAG;AACD,UAAM,OAAO,OAAO,QAAQ,GAAG;AAC/B,UAAM,OAAsB,CAAC;AAC7B,QAAI,SAAS;AACb,QAAI,UAAU;AACd,gBAAY;AAEZ,WAAO,OAAO,MAAM,MAAM;AACxB,UAAI;AAEJ,mBAAa,WAAW,cAAc,MAAM,CAAC;AAC7C,UAAI,YAAY,QAAS,UAAS;AAClC,gBAAU;AAEV,UAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,wBAAgB,WAAW,cAAc,MAAM,CAAC;AAChD,sBAAc,WAAW,cAAc,MAAM,CAAC;AAC9C,wBAAgB,WAAW,cAAc,MAAM,CAAC;AAEhD,YAAI,WAAW,QAAQ,IAAI,GAAG;AAC5B,wBAAc,WAAW,cAAc,MAAM,CAAC;AAC9C,gBAAM,CAAC,WAAW,cAAc,YAAY,cAAc,UAAU;AAAA,QACtE,OAAO;AACL,gBAAM,CAAC,WAAW,cAAc,YAAY,YAAY;AAAA,QAC1D;AAAA,MACF,OAAO;AACL,cAAM,CAAC,SAAS;AAAA,MAClB;AAEA,WAAK,KAAK,GAAG;AACb,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,OAAQ,MAAK,IAAI;AACtB,YAAQ,KAAK,IAAI;AACjB,WAAO,MAAM,OAAO;AAAA,EACtB,SAAS,OAAO,OAAO;AAEvB,SAAO;AACT;AAEA,SAAS,KAAK,MAA0B;AACtC,OAAK,KAAK,cAAc;AAC1B;AAEA,SAAS,eAAe,GAAqB,GAA6B;AACxE,SAAO,EAAE,CAAC,IAAI,EAAE,CAAC;AACnB;AAIO,SAAS,OAAO,SAA8C;AACnE,QAAM,SAAS,IAAI,aAAa;AAChC,MAAI,eAAe;AACnB,MAAI,aAAa;AACjB,MAAI,eAAe;AACnB,MAAI,aAAa;AAEjB,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,QAAI,IAAI,EAAG,QAAO,MAAM,SAAS;AACjC,QAAI,KAAK,WAAW,EAAG;AAEvB,QAAI,YAAY;AAEhB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,UAAU,KAAK,CAAC;AACtB,UAAI,IAAI,EAAG,QAAO,MAAM,KAAK;AAE7B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,SAAS,CAAC;AACxD,kBAAY,QAAQ,CAAC;AAErB,UAAI,QAAQ,WAAW,EAAG;AAC1B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;AAC3D,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,UAAU,CAAC;AACzD,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;AAC3D,qBAAe,QAAQ,CAAC;AACxB,mBAAa,QAAQ,CAAC;AACtB,qBAAe,QAAQ,CAAC;AAExB,UAAI,QAAQ,WAAW,EAAG;AAC1B,oBAAc,QAAQ,WAAW,QAAQ,CAAC,IAAI,UAAU,CAAC;AACzD,mBAAa,QAAQ,CAAC;AAAA,IACxB;AAAA,EACF;AAEA,SAAO,OAAO,MAAM;AACtB;", + "names": [] +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/package.json b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/package.json new file mode 100644 index 00000000..a84412bc --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/package.json @@ -0,0 +1,64 @@ +{ + "name": "@jridgewell/sourcemap-codec", + "version": "1.6.0", + "description": "Encode/decode sourcemap mappings", + "keywords": [ + "sourcemap", + "vlq" + ], + "main": "dist/sourcemap-codec.umd.js", + "module": "dist/sourcemap-codec.mjs", + "types": "types/sourcemap-codec.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/sourcemap-codec.d.mts", + "default": "./dist/sourcemap-codec.mjs" + }, + "default": { + "types": "./types/sourcemap-codec.d.cts", + "default": "./dist/sourcemap-codec.umd.js" + } + }, + "./dist/sourcemap-codec.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.js", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs sourcemap-codec.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "test:watch": "mocha --watch", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/sourcemap-codec", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/sourcemap-codec" + }, + "author": "Justin Ridgewell ", + "license": "MIT" +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/range-mappings.ts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/range-mappings.ts new file mode 100644 index 00000000..710d1248 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/range-mappings.ts @@ -0,0 +1,47 @@ +import { StringReader, StringWriter } from './strings'; +import { decodeInteger, encodeInteger, semicolon } from './vlq'; + +export type MappingIndex = number; +export type RangeMappings = MappingIndex[][]; + +export function decodeRangeMappings(input: string): RangeMappings { + const { length } = input; + const reader = new StringReader(input); + const rangeMappings: RangeMappings = []; + + do { + const semi = reader.indexOf(';'); + const indices: MappingIndex[] = []; + let index = 0; + + while (reader.pos < semi) { + index += decodeInteger(reader); + indices.push(index); + } + + rangeMappings.push(indices); + reader.pos = semi + 1; + } while (reader.pos <= length); + + return rangeMappings; +} + +export function encodeRangeMappings(decoded: RangeMappings): string { + if (decoded.length === 0) return ''; + + const writer = new StringWriter(); + + for (let i = 0; i < decoded.length; i++) { + const indices = decoded[i]; + if (i > 0) writer.write(semicolon); + + let index = 0; + for (let j = 0; j < indices.length; j++) { + const offset = indices[j]; + encodeInteger(writer, offset - index); + index = offset; + } + } + + return writer.flush(); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts new file mode 100644 index 00000000..9e8d4d58 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts @@ -0,0 +1,365 @@ +import { StringReader, StringWriter } from './strings'; +import { + comma, + decodeInteger, + decodeSign, + encodeInteger, + encodeSign, + hasMoreVlq, + semicolon, +} from './vlq'; + +const EMPTY: any[] = []; + +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; + +type Mix = (A & O) | (B & O); + +export type OriginalScope = Mix< + [Line, Column, Line, Column, Kind], + [Line, Column, Line, Column, Kind, Name], + { vars: Var[] } +>; + +export type GeneratedRange = Mix< + [Line, Column, Line, Column], + [Line, Column, Line, Column, SourcesIndex, ScopesIndex], + { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; + } +>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; + +export function decodeOriginalScopes(input: string): OriginalScope[] { + const { length } = input; + const reader = new StringReader(input); + const scopes: OriginalScope[] = []; + const stack: OriginalScope[] = []; + let line = 0; + + for (; reader.pos < length; reader.pos++) { + line += decodeSign(decodeInteger(reader)); + const column = decodeSign(decodeInteger(reader)); + + if (!hasMoreVlq(reader, length)) { + const last = stack.pop()!; + last[2] = line; + last[3] = column; + continue; + } + + const kind = decodeSign(decodeInteger(reader)); + const fields = decodeSign(decodeInteger(reader)); + const hasName = fields & 0b0001; + + const scope: OriginalScope = ( + hasName + ? [line, column, 0, 0, kind, decodeSign(decodeInteger(reader))] + : [line, column, 0, 0, kind] + ) as OriginalScope; + + let vars: Var[] = EMPTY; + if (hasMoreVlq(reader, length)) { + vars = []; + do { + const varsIndex = decodeSign(decodeInteger(reader)); + vars.push(varsIndex); + } while (hasMoreVlq(reader, length)); + } + scope.vars = vars; + + scopes.push(scope); + stack.push(scope); + } + + return scopes; +} + +export function encodeOriginalScopes(scopes: OriginalScope[]): string { + const writer = new StringWriter(); + + for (let i = 0; i < scopes.length; ) { + i = _encodeOriginalScopes(scopes, i, writer, [0]); + } + + return writer.flush(); +} + +function _encodeOriginalScopes( + scopes: OriginalScope[], + index: number, + writer: StringWriter, + state: [ + number, // GenColumn + ], +): number { + const scope = scopes[index]; + const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope; + + if (index > 0) writer.write(comma); + + encodeInteger(writer, encodeSign(startLine - state[0])); + state[0] = startLine; + encodeInteger(writer, encodeSign(startColumn)); + encodeInteger(writer, encodeSign(kind)); + + const fields = scope.length === 6 ? 0b0001 : 0; + encodeInteger(writer, encodeSign(fields)); + if (scope.length === 6) encodeInteger(writer, encodeSign(scope[5])); + + for (const v of vars) { + encodeInteger(writer, encodeSign(v)); + } + + for (index++; index < scopes.length; ) { + const next = scopes[index]; + const { 0: l, 1: c } = next; + if (l > endLine || (l === endLine && c >= endColumn)) { + break; + } + index = _encodeOriginalScopes(scopes, index, writer, state); + } + + writer.write(comma); + encodeInteger(writer, encodeSign(endLine - state[0])); + state[0] = endLine; + encodeInteger(writer, encodeSign(endColumn)); + + return index; +} + +export function decodeGeneratedRanges(input: string): GeneratedRange[] { + const { length } = input; + const reader = new StringReader(input); + const ranges: GeneratedRange[] = []; + const stack: GeneratedRange[] = []; + + let genLine = 0; + let definitionSourcesIndex = 0; + let definitionScopeIndex = 0; + let callsiteSourcesIndex = 0; + let callsiteLine = 0; + let callsiteColumn = 0; + let bindingLine = 0; + let bindingColumn = 0; + + do { + const semi = reader.indexOf(';'); + let genColumn = 0; + + for (; reader.pos < semi; reader.pos++) { + genColumn += decodeSign(decodeInteger(reader)); + + if (!hasMoreVlq(reader, semi)) { + const last = stack.pop()!; + last[2] = genLine; + last[3] = genColumn; + continue; + } + + const fields = decodeSign(decodeInteger(reader)); + const hasDefinition = fields & 0b0001; + const hasCallsite = fields & 0b0010; + const hasScope = fields & 0b0100; + + let callsite: CallSite | null = null; + let bindings: Binding[] = EMPTY; + let range: GeneratedRange; + if (hasDefinition) { + const defSourcesIndex = definitionSourcesIndex + decodeSign(decodeInteger(reader)); + definitionScopeIndex = + decodeSign(decodeInteger(reader)) + + (definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0); + + definitionSourcesIndex = defSourcesIndex; + range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex] as GeneratedRange; + } else { + range = [genLine, genColumn, 0, 0] as GeneratedRange; + } + + range.isScope = !!hasScope; + + if (hasCallsite) { + const prevCsi = callsiteSourcesIndex; + const prevLine = callsiteLine; + callsiteSourcesIndex += decodeSign(decodeInteger(reader)); + const sameSource = prevCsi === callsiteSourcesIndex; + callsiteLine = (sameSource ? callsiteLine : 0) + decodeSign(decodeInteger(reader)); + callsiteColumn = + (sameSource && prevLine === callsiteLine ? callsiteColumn : 0) + + decodeSign(decodeInteger(reader)); + + callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn]; + } + range.callsite = callsite; + + if (hasMoreVlq(reader, semi)) { + bindings = []; + do { + bindingLine = genLine; + bindingColumn = genColumn; + const expressionsCount = decodeSign(decodeInteger(reader)); + let expressionRanges: BindingExpressionRange[]; + if (expressionsCount < -1) { + expressionRanges = [[decodeSign(decodeInteger(reader))]]; + for (let i = -1; i > expressionsCount; i--) { + const prevBl = bindingLine; + bindingLine += decodeSign(decodeInteger(reader)); + bindingColumn = + (bindingLine === prevBl ? bindingColumn : 0) + decodeSign(decodeInteger(reader)); + const expression = decodeSign(decodeInteger(reader)); + expressionRanges.push([expression, bindingLine, bindingColumn]); + } + } else { + expressionRanges = [[expressionsCount]]; + } + bindings.push(expressionRanges); + } while (hasMoreVlq(reader, semi)); + } + range.bindings = bindings; + + ranges.push(range); + stack.push(range); + } + + genLine++; + reader.pos = semi + 1; + } while (reader.pos < length); + + return ranges; +} + +export function encodeGeneratedRanges(ranges: GeneratedRange[]): string { + if (ranges.length === 0) return ''; + + const writer = new StringWriter(); + + for (let i = 0; i < ranges.length; ) { + i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]); + } + + return writer.flush(); +} + +function _encodeGeneratedRanges( + ranges: GeneratedRange[], + index: number, + writer: StringWriter, + state: [ + number, // GenLine + number, // GenColumn + number, // DefSourcesIndex + number, // DefScopesIndex + number, // CallSourcesIndex + number, // CallLine + number, // CallColumn + ], +): number { + const range = ranges[index]; + const { + 0: startLine, + 1: startColumn, + 2: endLine, + 3: endColumn, + isScope, + callsite, + bindings, + } = range; + + if (state[0] < startLine) { + catchupLine(writer, state[0], startLine); + state[0] = startLine; + state[1] = 0; + } else if (index > 0) { + writer.write(comma); + } + + encodeInteger(writer, encodeSign(range[1] - state[1])); + state[1] = range[1]; + + const fields = + (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0); + encodeInteger(writer, encodeSign(fields)); + + if (range.length === 6) { + const { 4: sourcesIndex, 5: scopesIndex } = range; + if (sourcesIndex !== state[2]) { + state[3] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[2])); + state[2] = sourcesIndex; + encodeInteger(writer, encodeSign(scopesIndex - state[3])); + state[3] = scopesIndex; + } + + if (callsite) { + const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite!; + if (sourcesIndex !== state[4]) { + state[5] = 0; + state[6] = 0; + } else if (callLine !== state[5]) { + state[6] = 0; + } + encodeInteger(writer, encodeSign(sourcesIndex - state[4])); + state[4] = sourcesIndex; + encodeInteger(writer, encodeSign(callLine - state[5])); + state[5] = callLine; + encodeInteger(writer, encodeSign(callColumn - state[6])); + state[6] = callColumn; + } + + if (bindings) { + for (const binding of bindings) { + if (binding.length > 1) encodeInteger(writer, encodeSign(-binding.length)); + const expression = binding[0][0]; + encodeInteger(writer, encodeSign(expression)); + let bindingStartLine = startLine; + let bindingStartColumn = startColumn; + for (let i = 1; i < binding.length; i++) { + const expRange = binding[i]; + encodeInteger(writer, encodeSign(expRange[1]! - bindingStartLine)); + bindingStartLine = expRange[1]!; + encodeInteger(writer, encodeSign(expRange[2]! - bindingStartColumn)); + bindingStartColumn = expRange[2]!; + encodeInteger(writer, encodeSign(expRange[0]!)); + } + } + } + + for (index++; index < ranges.length; ) { + const next = ranges[index]; + const { 0: l, 1: c } = next; + if (l > endLine || (l === endLine && c >= endColumn)) { + break; + } + index = _encodeGeneratedRanges(ranges, index, writer, state); + } + + if (state[0] < endLine) { + catchupLine(writer, state[0], endLine); + state[0] = endLine; + state[1] = 0; + } else { + writer.write(comma); + } + encodeInteger(writer, encodeSign(endColumn - state[1])); + state[1] = endColumn; + + return index; +} + +function catchupLine(writer: StringWriter, lastLine: number, line: number) { + do { + writer.write(semicolon); + } while (++lastLine < line); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts new file mode 100644 index 00000000..dd02c6f5 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts @@ -0,0 +1,127 @@ +import { + comma, + decodeInteger, + decodeSign, + encodeInteger, + encodeSign, + hasMoreVlq, + semicolon, +} from './vlq'; +import { StringWriter, StringReader } from './strings'; + +export { + decodeOriginalScopes, + encodeOriginalScopes, + decodeGeneratedRanges, + encodeGeneratedRanges, +} from './scopes'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes'; + +export { decodeRangeMappings, encodeRangeMappings } from './range-mappings'; +export type { MappingIndex, RangeMappings } from './range-mappings'; + +export type SourceMapSegment = + | [number] + | [number, number, number, number] + | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; + +export function decode(mappings: string): SourceMapMappings { + const { length } = mappings; + const reader = new StringReader(mappings); + const decoded: SourceMapMappings = []; + let genColumn = 0; + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + + do { + const semi = reader.indexOf(';'); + const line: SourceMapLine = []; + let sorted = true; + let lastCol = 0; + genColumn = 0; + + while (reader.pos < semi) { + let seg: SourceMapSegment; + + genColumn += decodeSign(decodeInteger(reader)); + if (genColumn < lastCol) sorted = false; + lastCol = genColumn; + + if (hasMoreVlq(reader, semi)) { + sourcesIndex += decodeSign(decodeInteger(reader)); + sourceLine += decodeSign(decodeInteger(reader)); + sourceColumn += decodeSign(decodeInteger(reader)); + + if (hasMoreVlq(reader, semi)) { + namesIndex += decodeSign(decodeInteger(reader)); + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]; + } else { + seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]; + } + } else { + seg = [genColumn]; + } + + line.push(seg); + reader.pos++; + } + + if (!sorted) sort(line); + decoded.push(line); + reader.pos = semi + 1; + } while (reader.pos <= length); + + return decoded; +} + +function sort(line: SourceMapSegment[]) { + line.sort(sortComparator); +} + +function sortComparator(a: SourceMapSegment, b: SourceMapSegment): number { + return a[0] - b[0]; +} + +export function encode(decoded: SourceMapMappings): string; +export function encode(decoded: Readonly): string; +export function encode(decoded: Readonly): string { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + + let genColumn = 0; + + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + + encodeInteger(writer, encodeSign(segment[0] - genColumn)); + genColumn = segment[0]; + + if (segment.length === 1) continue; + encodeInteger(writer, encodeSign(segment[1] - sourcesIndex)); + encodeInteger(writer, encodeSign(segment[2] - sourceLine)); + encodeInteger(writer, encodeSign(segment[3] - sourceColumn)); + sourcesIndex = segment[1]; + sourceLine = segment[2]; + sourceColumn = segment[3]; + + if (segment.length === 4) continue; + encodeInteger(writer, encodeSign(segment[4] - namesIndex)); + namesIndex = segment[4]; + } + } + + return writer.flush(); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/strings.ts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/strings.ts new file mode 100644 index 00000000..d1619650 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/strings.ts @@ -0,0 +1,65 @@ +const bufLength = 1024 * 16; + +// Provide a fallback for older environments. +const td = + typeof TextDecoder !== 'undefined' + ? /* #__PURE__ */ new TextDecoder() + : typeof Buffer !== 'undefined' + ? { + decode(buf: Uint8Array): string { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + }, + } + : { + decode(buf: Uint8Array): string { + let out = ''; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + }, + }; + +export class StringWriter { + pos = 0; + private out = ''; + private buffer = new Uint8Array(bufLength); + + write(v: number): void { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + + flush(): string { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } +} + +export class StringReader { + pos = 0; + declare private buffer: string; + + constructor(buffer: string) { + this.buffer = buffer; + } + + next(): number { + return this.buffer.charCodeAt(this.pos++); + } + + peek(): number { + return this.buffer.charCodeAt(this.pos); + } + + indexOf(char: string): number { + const { buffer, pos } = this; + const idx = buffer.indexOf(char, pos); + return idx === -1 ? buffer.length : idx; + } +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts new file mode 100644 index 00000000..e2f047ec --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts @@ -0,0 +1,51 @@ +import type { StringReader, StringWriter } from './strings'; + +export const comma = ','.charCodeAt(0); +export const semicolon = ';'.charCodeAt(0); + +const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; +const intToChar = new Uint8Array(64); // 64 possible chars. +const charToInt = new Uint8Array(128); // z is 122 in ASCII + +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} + +export function decodeInteger(reader: StringReader): number { + let value = 0; + let shift = 0; + let integer = 0; + + do { + const c = reader.next(); + integer = charToInt[c]; + value |= (integer & 31) << shift; + shift += 5; + } while (integer & 32); + + return value; +} + +export function decodeSign(num: number): number { + return num & 1 ? -0x80000000 | -(num >>> 1) : num >>> 1; +} + +export function encodeInteger(builder: StringWriter, num: number) { + do { + let clamped = num & 0b011111; + num >>>= 5; + if (num > 0) clamped |= 0b100000; + builder.write(intToChar[clamped]); + } while (num > 0); +} + +export function encodeSign(num: number): number { + return num < 0 ? (-num << 1) | 1 : num << 1; +} + +export function hasMoreVlq(reader: StringReader, max: number) { + if (reader.pos >= max) return false; + return reader.peek() !== comma; +} diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts new file mode 100644 index 00000000..8826f645 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts @@ -0,0 +1,5 @@ +export type MappingIndex = number; +export type RangeMappings = MappingIndex[][]; +export declare function decodeRangeMappings(input: string): RangeMappings; +export declare function encodeRangeMappings(decoded: RangeMappings): string; +//# sourceMappingURL=range-mappings.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts.map new file mode 100644 index 00000000..1418bb69 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"range-mappings.d.ts","sourceRoot":"","sources":["../src/range-mappings.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAClC,MAAM,MAAM,aAAa,GAAG,YAAY,EAAE,EAAE,CAAC;AAE7C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAoBhE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAkBlE"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts new file mode 100644 index 00000000..8826f645 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts @@ -0,0 +1,5 @@ +export type MappingIndex = number; +export type RangeMappings = MappingIndex[][]; +export declare function decodeRangeMappings(input: string): RangeMappings; +export declare function encodeRangeMappings(decoded: RangeMappings): string; +//# sourceMappingURL=range-mappings.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts.map new file mode 100644 index 00000000..1418bb69 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/range-mappings.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"range-mappings.d.ts","sourceRoot":"","sources":["../src/range-mappings.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAClC,MAAM,MAAM,aAAa,GAAG,YAAY,EAAE,EAAE,CAAC;AAE7C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAoBhE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAkBlE"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts new file mode 100644 index 00000000..c583c756 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts @@ -0,0 +1,50 @@ +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; +type Mix = (A & O) | (B & O); +export type OriginalScope = Mix<[ + Line, + Column, + Line, + Column, + Kind +], [ + Line, + Column, + Line, + Column, + Kind, + Name +], { + vars: Var[]; +}>; +export type GeneratedRange = Mix<[ + Line, + Column, + Line, + Column +], [ + Line, + Column, + Line, + Column, + SourcesIndex, + ScopesIndex +], { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; +}>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; +export declare function decodeOriginalScopes(input: string): OriginalScope[]; +export declare function encodeOriginalScopes(scopes: OriginalScope[]): string; +export declare function decodeGeneratedRanges(input: string): GeneratedRange[]; +export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string; +export {}; +//# sourceMappingURL=scopes.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map new file mode 100644 index 00000000..96f3603c --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAaA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CA2CnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA6CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAmGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts new file mode 100644 index 00000000..c583c756 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts @@ -0,0 +1,50 @@ +type Line = number; +type Column = number; +type Kind = number; +type Name = number; +type Var = number; +type SourcesIndex = number; +type ScopesIndex = number; +type Mix = (A & O) | (B & O); +export type OriginalScope = Mix<[ + Line, + Column, + Line, + Column, + Kind +], [ + Line, + Column, + Line, + Column, + Kind, + Name +], { + vars: Var[]; +}>; +export type GeneratedRange = Mix<[ + Line, + Column, + Line, + Column +], [ + Line, + Column, + Line, + Column, + SourcesIndex, + ScopesIndex +], { + callsite: CallSite | null; + bindings: Binding[]; + isScope: boolean; +}>; +export type CallSite = [SourcesIndex, Line, Column]; +type Binding = BindingExpressionRange[]; +export type BindingExpressionRange = [Name] | [Name, Line, Column]; +export declare function decodeOriginalScopes(input: string): OriginalScope[]; +export declare function encodeOriginalScopes(scopes: OriginalScope[]): string; +export declare function decodeGeneratedRanges(input: string): GeneratedRange[]; +export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string; +export {}; +//# sourceMappingURL=scopes.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map new file mode 100644 index 00000000..96f3603c --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAaA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CA2CnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA6CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAmGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts new file mode 100644 index 00000000..2fdeab88 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts @@ -0,0 +1,11 @@ +export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.cts'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.cts'; +export { decodeRangeMappings, encodeRangeMappings } from './range-mappings.cts'; +export type { MappingIndex, RangeMappings } from './range-mappings.cts'; +export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; +export declare function decode(mappings: string): SourceMapMappings; +export declare function encode(decoded: SourceMapMappings): string; +export declare function encode(decoded: Readonly): string; +//# sourceMappingURL=sourcemap-codec.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map new file mode 100644 index 00000000..e0d67e3b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts new file mode 100644 index 00000000..2f0e5194 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts @@ -0,0 +1,11 @@ +export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.mts'; +export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.mts'; +export { decodeRangeMappings, encodeRangeMappings } from './range-mappings.mts'; +export type { MappingIndex, RangeMappings } from './range-mappings.mts'; +export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number]; +export type SourceMapLine = SourceMapSegment[]; +export type SourceMapMappings = SourceMapLine[]; +export declare function decode(mappings: string): SourceMapMappings; +export declare function encode(decoded: SourceMapMappings): string; +export declare function encode(decoded: Readonly): string; +//# sourceMappingURL=sourcemap-codec.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map new file mode 100644 index 00000000..e0d67e3b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts new file mode 100644 index 00000000..62faceb3 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts @@ -0,0 +1,16 @@ +export declare class StringWriter { + pos: number; + private out; + private buffer; + write(v: number): void; + flush(): string; +} +export declare class StringReader { + pos: number; + private buffer; + constructor(buffer: string); + next(): number; + peek(): number; + indexOf(char: string): number; +} +//# sourceMappingURL=strings.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map new file mode 100644 index 00000000..d3602da4 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts new file mode 100644 index 00000000..62faceb3 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts @@ -0,0 +1,16 @@ +export declare class StringWriter { + pos: number; + private out; + private buffer; + write(v: number): void; + flush(): string; +} +export declare class StringReader { + pos: number; + private buffer; + constructor(buffer: string); + next(): number; + peek(): number; + indexOf(char: string): number; +} +//# sourceMappingURL=strings.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map new file mode 100644 index 00000000..d3602da4 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts new file mode 100644 index 00000000..b2ba4330 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts @@ -0,0 +1,9 @@ +import type { StringReader, StringWriter } from './strings.cts'; +export declare const comma: number; +export declare const semicolon: number; +export declare function decodeInteger(reader: StringReader): number; +export declare function decodeSign(num: number): number; +export declare function encodeInteger(builder: StringWriter, num: number): void; +export declare function encodeSign(num: number): number; +export declare function hasMoreVlq(reader: StringReader, max: number): boolean; +//# sourceMappingURL=vlq.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map new file mode 100644 index 00000000..b9dd843b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAa1D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,QAO/D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts new file mode 100644 index 00000000..30bdc61f --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts @@ -0,0 +1,9 @@ +import type { StringReader, StringWriter } from './strings.mts'; +export declare const comma: number; +export declare const semicolon: number; +export declare function decodeInteger(reader: StringReader): number; +export declare function decodeSign(num: number): number; +export declare function encodeInteger(builder: StringWriter, num: number): void; +export declare function encodeSign(num: number): number; +export declare function hasMoreVlq(reader: StringReader, max: number): boolean; +//# sourceMappingURL=vlq.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map new file mode 100644 index 00000000..b9dd843b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAa1D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,QAO/D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/resolve-uri b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/resolve-uri new file mode 120000 index 00000000..24143832 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/resolve-uri @@ -0,0 +1 @@ +../../../@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/sourcemap-codec b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/sourcemap-codec new file mode 120000 index 00000000..77b0ee42 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/sourcemap-codec @@ -0,0 +1 @@ +../../../@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/LICENSE b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/LICENSE new file mode 100644 index 00000000..1f6ce94c --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/LICENSE @@ -0,0 +1,19 @@ +Copyright 2024 Justin Ridgewell + +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/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/README.md b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/README.md new file mode 100644 index 00000000..9fc0ed09 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/README.md @@ -0,0 +1,348 @@ +# @jridgewell/trace-mapping + +> Trace the original position through a source map + +`trace-mapping` allows you to take the line and column of an output file and trace it to the +original location in the source file through a source map. + +You may already be familiar with the [`source-map`][source-map] package's `SourceMapConsumer`. This +provides the same `originalPositionFor` and `generatedPositionFor` API, without requiring WASM. + +## Installation + +```sh +npm install @jridgewell/trace-mapping +``` + +## Usage + +```typescript +import { + TraceMap, + originalPositionFor, + generatedPositionFor, + sourceContentFor, + isIgnored, +} from '@jridgewell/trace-mapping'; + +const tracer = new TraceMap({ + version: 3, + sources: ['input.js'], + sourcesContent: ['content of input.js'], + names: ['foo'], + mappings: 'KAyCIA', + ignoreList: [], +}); + +// Lines start at line 1, columns at column 0. +const traced = originalPositionFor(tracer, { line: 1, column: 5 }); +assert.deepEqual(traced, { + source: 'input.js', + line: 42, + column: 4, + name: 'foo', +}); + +const content = sourceContentFor(tracer, traced.source); +assert.strictEqual(content, 'content for input.js'); + +const generated = generatedPositionFor(tracer, { + source: 'input.js', + line: 42, + column: 4, +}); +assert.deepEqual(generated, { + line: 1, + column: 5, +}); + +const ignored = isIgnored(tracer, 'input.js'); +assert.equal(ignored, false); +``` + +We also provide a lower level API to get the actual segment that matches our line and column. Unlike +`originalPositionFor`, `traceSegment` uses a 0-base for `line`: + +```typescript +import { traceSegment } from '@jridgewell/trace-mapping'; + +// line is 0-base. +const traced = traceSegment(tracer, /* line */ 0, /* column */ 5); + +// Segments are [outputColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] +// Again, line is 0-base and so is sourceLine +assert.deepEqual(traced, [5, 0, 41, 4, 0]); +``` + +### SectionedSourceMaps + +The sourcemap spec defines a special `sections` field that's designed to handle concatenation of +output code with associated sourcemaps. This type of sourcemap is rarely used (no major build tool +produces it), but if you are hand coding a concatenation you may need it. We provide an `AnyMap` +helper that can receive either a regular sourcemap or a `SectionedSourceMap` and returns a +`TraceMap` instance: + +```typescript +import { AnyMap } from '@jridgewell/trace-mapping'; +const fooOutput = 'foo'; +const barOutput = 'bar'; +const output = [fooOutput, barOutput].join('\n'); + +const sectioned = new AnyMap({ + version: 3, + sections: [ + { + // 0-base line and column + offset: { line: 0, column: 0 }, + // fooOutput's sourcemap + map: { + version: 3, + sources: ['foo.js'], + names: ['foo'], + mappings: 'AAAAA', + }, + }, + { + // barOutput's sourcemap will not affect the first line, only the second + offset: { line: 1, column: 0 }, + map: { + version: 3, + sources: ['bar.js'], + names: ['bar'], + mappings: 'AAAAA', + }, + }, + ], +}); + +const traced = originalPositionFor(sectioned, { + line: 2, + column: 0, +}); + +assert.deepEqual(traced, { + source: 'bar.js', + line: 1, + column: 0, + name: 'bar', +}); +``` + +## Benchmarks + +``` +node v20.10.0 + +amp.js.map - 45120 segments + +Memory Usage: +trace-mapping decoded 414164 bytes +trace-mapping encoded 6274352 bytes +source-map-js 10968904 bytes +source-map-0.6.1 17587160 bytes +source-map-0.8.0 8812155 bytes +Chrome dev tools 8672912 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 205 ops/sec ±0.19% (88 runs sampled) +trace-mapping: encoded JSON input x 405 ops/sec ±1.47% (88 runs sampled) +trace-mapping: decoded Object input x 4,645 ops/sec ±0.15% (98 runs sampled) +trace-mapping: encoded Object input x 458 ops/sec ±1.63% (91 runs sampled) +source-map-js: encoded Object input x 75.48 ops/sec ±1.64% (67 runs sampled) +source-map-0.6.1: encoded Object input x 39.37 ops/sec ±1.44% (53 runs sampled) +Chrome dev tools: encoded Object input x 150 ops/sec ±1.76% (79 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 44,946 ops/sec ±0.16% (99 runs sampled) +trace-mapping: encoded originalPositionFor x 37,995 ops/sec ±1.81% (89 runs sampled) +source-map-js: encoded originalPositionFor x 9,230 ops/sec ±1.36% (93 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 8,057 ops/sec ±0.84% (96 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 28,198 ops/sec ±1.12% (91 runs sampled) +Chrome dev tools: encoded originalPositionFor x 46,276 ops/sec ±1.35% (95 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 204,406 ops/sec ±0.19% (97 runs sampled) +trace-mapping: encoded originalPositionFor x 196,695 ops/sec ±0.24% (99 runs sampled) +source-map-js: encoded originalPositionFor x 11,948 ops/sec ±0.94% (99 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 10,730 ops/sec ±0.36% (100 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 51,427 ops/sec ±0.21% (98 runs sampled) +Chrome dev tools: encoded originalPositionFor x 162,615 ops/sec ±0.18% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +babel.min.js.map - 347793 segments + +Memory Usage: +trace-mapping decoded 18504 bytes +trace-mapping encoded 35428008 bytes +source-map-js 51676808 bytes +source-map-0.6.1 63367136 bytes +source-map-0.8.0 43158400 bytes +Chrome dev tools 50721552 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 17.82 ops/sec ±6.35% (35 runs sampled) +trace-mapping: encoded JSON input x 31.57 ops/sec ±7.50% (43 runs sampled) +trace-mapping: decoded Object input x 867 ops/sec ±0.74% (94 runs sampled) +trace-mapping: encoded Object input x 33.83 ops/sec ±7.66% (46 runs sampled) +source-map-js: encoded Object input x 6.58 ops/sec ±3.31% (20 runs sampled) +source-map-0.6.1: encoded Object input x 4.23 ops/sec ±3.43% (15 runs sampled) +Chrome dev tools: encoded Object input x 22.14 ops/sec ±3.79% (41 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 78,234 ops/sec ±1.48% (29 runs sampled) +trace-mapping: encoded originalPositionFor x 60,761 ops/sec ±1.35% (21 runs sampled) +source-map-js: encoded originalPositionFor x 51,448 ops/sec ±2.17% (89 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 47,221 ops/sec ±1.99% (15 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 84,002 ops/sec ±1.45% (27 runs sampled) +Chrome dev tools: encoded originalPositionFor x 106,457 ops/sec ±1.38% (37 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 930,943 ops/sec ±0.25% (99 runs sampled) +trace-mapping: encoded originalPositionFor x 843,545 ops/sec ±0.34% (97 runs sampled) +source-map-js: encoded originalPositionFor x 114,510 ops/sec ±1.37% (36 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 87,412 ops/sec ±0.72% (92 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 197,709 ops/sec ±0.89% (59 runs sampled) +Chrome dev tools: encoded originalPositionFor x 688,983 ops/sec ±0.33% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +preact.js.map - 1992 segments + +Memory Usage: +trace-mapping decoded 33136 bytes +trace-mapping encoded 254240 bytes +source-map-js 837488 bytes +source-map-0.6.1 961928 bytes +source-map-0.8.0 54384 bytes +Chrome dev tools 709680 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 3,709 ops/sec ±0.13% (99 runs sampled) +trace-mapping: encoded JSON input x 6,447 ops/sec ±0.22% (101 runs sampled) +trace-mapping: decoded Object input x 83,062 ops/sec ±0.23% (100 runs sampled) +trace-mapping: encoded Object input x 14,980 ops/sec ±0.28% (100 runs sampled) +source-map-js: encoded Object input x 2,544 ops/sec ±0.16% (99 runs sampled) +source-map-0.6.1: encoded Object input x 1,221 ops/sec ±0.37% (97 runs sampled) +Chrome dev tools: encoded Object input x 4,241 ops/sec ±0.39% (93 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 91,028 ops/sec ±0.14% (94 runs sampled) +trace-mapping: encoded originalPositionFor x 84,348 ops/sec ±0.26% (98 runs sampled) +source-map-js: encoded originalPositionFor x 26,998 ops/sec ±0.23% (98 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 18,049 ops/sec ±0.26% (100 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 41,916 ops/sec ±0.28% (98 runs sampled) +Chrome dev tools: encoded originalPositionFor x 88,616 ops/sec ±0.14% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 319,960 ops/sec ±0.16% (100 runs sampled) +trace-mapping: encoded originalPositionFor x 302,153 ops/sec ±0.18% (100 runs sampled) +source-map-js: encoded originalPositionFor x 35,574 ops/sec ±0.19% (100 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 19,943 ops/sec ±0.12% (101 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 54,648 ops/sec ±0.20% (99 runs sampled) +Chrome dev tools: encoded originalPositionFor x 278,319 ops/sec ±0.17% (102 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +react.js.map - 5726 segments + +Memory Usage: +trace-mapping decoded 10872 bytes +trace-mapping encoded 681512 bytes +source-map-js 2563944 bytes +source-map-0.6.1 2150864 bytes +source-map-0.8.0 88680 bytes +Chrome dev tools 1149576 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 1,887 ops/sec ±0.28% (99 runs sampled) +trace-mapping: encoded JSON input x 4,749 ops/sec ±0.48% (97 runs sampled) +trace-mapping: decoded Object input x 74,236 ops/sec ±0.11% (99 runs sampled) +trace-mapping: encoded Object input x 5,752 ops/sec ±0.38% (100 runs sampled) +source-map-js: encoded Object input x 806 ops/sec ±0.19% (97 runs sampled) +source-map-0.6.1: encoded Object input x 418 ops/sec ±0.33% (94 runs sampled) +Chrome dev tools: encoded Object input x 1,524 ops/sec ±0.57% (92 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 620,201 ops/sec ±0.33% (96 runs sampled) +trace-mapping: encoded originalPositionFor x 579,548 ops/sec ±0.35% (97 runs sampled) +source-map-js: encoded originalPositionFor x 230,983 ops/sec ±0.62% (54 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 158,145 ops/sec ±0.80% (46 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 343,801 ops/sec ±0.55% (96 runs sampled) +Chrome dev tools: encoded originalPositionFor x 659,649 ops/sec ±0.49% (98 runs sampled) +Fastest is Chrome dev tools: encoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 2,368,079 ops/sec ±0.32% (98 runs sampled) +trace-mapping: encoded originalPositionFor x 2,134,039 ops/sec ±2.72% (87 runs sampled) +source-map-js: encoded originalPositionFor x 290,120 ops/sec ±2.49% (82 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 187,613 ops/sec ±0.86% (49 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 479,569 ops/sec ±0.65% (96 runs sampled) +Chrome dev tools: encoded originalPositionFor x 2,048,414 ops/sec ±0.24% (98 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + + +*** + + +vscode.map - 2141001 segments + +Memory Usage: +trace-mapping decoded 5206584 bytes +trace-mapping encoded 208370336 bytes +source-map-js 278493008 bytes +source-map-0.6.1 391564048 bytes +source-map-0.8.0 257508787 bytes +Chrome dev tools 291053000 bytes +Smallest memory usage is trace-mapping decoded + +Init speed: +trace-mapping: decoded JSON input x 1.63 ops/sec ±33.88% (9 runs sampled) +trace-mapping: encoded JSON input x 3.29 ops/sec ±36.13% (13 runs sampled) +trace-mapping: decoded Object input x 103 ops/sec ±0.93% (77 runs sampled) +trace-mapping: encoded Object input x 5.42 ops/sec ±28.54% (19 runs sampled) +source-map-js: encoded Object input x 1.07 ops/sec ±13.84% (7 runs sampled) +source-map-0.6.1: encoded Object input x 0.60 ops/sec ±2.43% (6 runs sampled) +Chrome dev tools: encoded Object input x 2.61 ops/sec ±22.00% (11 runs sampled) +Fastest is trace-mapping: decoded Object input + +Trace speed (random): +trace-mapping: decoded originalPositionFor x 257,019 ops/sec ±0.97% (93 runs sampled) +trace-mapping: encoded originalPositionFor x 179,163 ops/sec ±0.83% (92 runs sampled) +source-map-js: encoded originalPositionFor x 73,337 ops/sec ±1.35% (87 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 38,797 ops/sec ±1.66% (88 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 107,758 ops/sec ±1.94% (45 runs sampled) +Chrome dev tools: encoded originalPositionFor x 188,550 ops/sec ±1.85% (79 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor + +Trace speed (ascending): +trace-mapping: decoded originalPositionFor x 447,621 ops/sec ±3.64% (94 runs sampled) +trace-mapping: encoded originalPositionFor x 323,698 ops/sec ±5.20% (88 runs sampled) +source-map-js: encoded originalPositionFor x 78,387 ops/sec ±1.69% (89 runs sampled) +source-map-0.6.1: encoded originalPositionFor x 41,016 ops/sec ±3.01% (25 runs sampled) +source-map-0.8.0: encoded originalPositionFor x 124,204 ops/sec ±0.90% (92 runs sampled) +Chrome dev tools: encoded originalPositionFor x 230,087 ops/sec ±2.61% (93 runs sampled) +Fastest is trace-mapping: decoded originalPositionFor +``` + +[source-map]: https://www.npmjs.com/package/source-map diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs new file mode 100644 index 00000000..73a95c77 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs @@ -0,0 +1,493 @@ +// src/trace-mapping.ts +import { encode, decode } from "@jridgewell/sourcemap-codec"; + +// src/resolve.ts +import resolveUri from "@jridgewell/resolve-uri"; + +// src/strip-filename.ts +function stripFilename(path) { + if (!path) return ""; + const index = path.lastIndexOf("/"); + return path.slice(0, index + 1); +} + +// src/resolve.ts +function resolver(mapUrl, sourceRoot) { + const from = stripFilename(mapUrl); + const prefix = sourceRoot ? sourceRoot + "/" : ""; + return (source) => resolveUri(prefix + (source || ""), from); +} + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; +var REV_GENERATED_LINE = 1; +var REV_GENERATED_COLUMN = 2; + +// src/sort.ts +function maybeSort(mappings, owned) { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + if (!owned) mappings = mappings.slice(); + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} +function nextUnsortedSegmentLine(mappings, start) { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} +function isSorted(line) { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} +function sortSegments(line, owned) { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[COLUMN] - b[COLUMN]; +} + +// src/by-source.ts +function buildBySources(decoded, memos) { + const sources = memos.map(() => []); + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + const sourceIndex2 = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + const source = sources[sourceIndex2]; + const segs = source[sourceLine] || (source[sourceLine] = []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + return sources; +} + +// src/binary-search.ts +var found = false; +function binarySearch(haystack, needle, low, high) { + while (low <= high) { + const mid = low + (high - low >> 1); + const cmp = haystack[mid][COLUMN] - needle; + if (cmp === 0) { + found = true; + return mid; + } + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + found = false; + return low - 1; +} +function upperBound(haystack, needle, index) { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function lowerBound(haystack, needle, index) { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function memoizedState() { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1 + }; +} +function memoizedBinarySearch(haystack, needle, state, key) { + const { lastKey, lastNeedle, lastIndex } = state; + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + if (needle >= lastNeedle) { + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + return state.lastIndex = binarySearch(haystack, needle, low, high); +} + +// src/types.ts +function parse(map) { + return typeof map === "string" ? JSON.parse(map) : map; +} + +// src/flatten-map.ts +var FlattenMap = function(map, mapUrl) { + const parsed = parse(map); + if (!("sections" in parsed)) { + return new TraceMap(parsed, mapUrl); + } + const mappings = []; + const sources = []; + const sourcesContent = []; + const names = []; + const ignoreList = []; + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity + ); + const joined = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList + }; + return presortedDecodedMap(joined); +}; +function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc + ); + } +} +function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const parsed = parse(input); + if ("sections" in parsed) return recurse(...arguments); + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + append(sources, resolvedSources); + append(names, map.names); + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + if (lineI > stopLine) return; + const out = getLine(mappings, lineI); + const cOffset = i === 0 ? columnOffset : 0; + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + if (lineI === stopLine && column >= stopColumn) return; + if (seg.length === 1) { + out.push([column]); + continue; + } + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]] + ); + } + } +} +function append(arr, other) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} +function getLine(arr, index) { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} + +// src/trace-mapping.ts +var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)"; +var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)"; +var LEAST_UPPER_BOUND = -1; +var GREATEST_LOWER_BOUND = 1; +var TraceMap = class { + constructor(map, mapUrl) { + const isString = typeof map === "string"; + if (!isString && map._decodedMemo) return map; + const parsed = parse(map); + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0; + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + const { mappings } = parsed; + if (typeof mappings === "string") { + this._encoded = mappings; + this._decoded = void 0; + } else if (Array.isArray(mappings)) { + this._encoded = void 0; + this._decoded = maybeSort(mappings, isString); + } else if (parsed.sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + this._decodedMemo = memoizedState(); + this._bySources = void 0; + this._bySourceMemos = void 0; + } +}; +function cast(map) { + return map; +} +function encodedMappings(map) { + var _a, _b; + return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = encode(cast(map)._decoded); +} +function decodedMappings(map) { + var _a; + return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)); +} +function traceSegment(map, line, column) { + const decoded = decodedMappings(map); + if (line >= decoded.length) return null; + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND + ); + return index === -1 ? null : segments[index]; +} +function originalPositionFor(map, needle) { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const decoded = decodedMappings(map); + if (line >= decoded.length) return OMapping(null, null, null, null); + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND + ); + if (index === -1) return OMapping(null, null, null, null); + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null + ); +} +function generatedPositionFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} +function allGeneratedPositionsFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} +function eachMapping(map, cb) { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name + }); + } + } +} +function sourceIndex(map, source) { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} +function sourceContentFor(map, source) { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} +function isIgnored(map, source) { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} +function presortedDecodedMap(map, mapUrl) { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} +function decodedMap(map) { + return clone(map, decodedMappings(map)); +} +function encodedMap(map) { + return clone(map, encodedMappings(map)); +} +function clone(map, mappings) { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || map.x_google_ignoreList + }; +} +function OMapping(source, line, column, name) { + return { source, line, column, name }; +} +function GMapping(line, column) { + return { line, column }; +} +function traceSegmentInternal(segments, memo, line, column, bias) { + let index = memoizedBinarySearch(segments, column, memo, line); + if (found) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + if (index === -1 || index === segments.length) return -1; + return index; +} +function sliceGeneratedPositions(segments, memo, line, column, bias) { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + if (!found && bias === LEAST_UPPER_BOUND) min++; + if (min === -1 || min === segments.length) return []; + const matchedColumn = found ? column : segments[min][COLUMN]; + if (!found) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} +function generatedPosition(map, source, line, column, bias, all) { + var _a, _b; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const { sources, resolvedSources } = map; + let sourceIndex2 = sources.indexOf(source); + if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source); + if (sourceIndex2 === -1) return all ? [] : GMapping(null, null); + const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState)); + const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos)); + const segments = generated[sourceIndex2][line]; + if (segments == null) return all ? [] : GMapping(null, null); + const memo = bySourceMemos[sourceIndex2]; + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} +export { + FlattenMap as AnyMap, + FlattenMap, + GREATEST_LOWER_BOUND, + LEAST_UPPER_BOUND, + TraceMap, + allGeneratedPositionsFor, + decodedMap, + decodedMappings, + eachMapping, + encodedMap, + encodedMappings, + generatedPositionFor, + isIgnored, + originalPositionFor, + presortedDecodedMap, + sourceContentFor, + traceSegment +}; +//# sourceMappingURL=trace-mapping.mjs.map diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map new file mode 100644 index 00000000..a7895814 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"], + "mappings": ";AAAA,SAAS,QAAQ,cAAc;;;ACA/B,OAAO,gBAAgB;;;ACGR,SAAR,cAA+B,MAAyC;AAC7E,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,KAAK,YAAY,GAAG;AAClC,SAAO,KAAK,MAAM,GAAG,QAAQ,CAAC;AAChC;;;ADHe,SAAR,SACL,QACA,YACS;AACT,QAAM,OAAO,cAAc,MAAM;AAIjC,QAAM,SAAS,aAAa,aAAa,MAAM;AAE/C,SAAO,CAAC,WAAW,WAAW,UAAU,UAAU,KAAK,IAAI;AAC7D;;;AEAO,IAAM,SAAS;AACf,IAAM,gBAAgB;AACtB,IAAM,cAAc;AACpB,IAAM,gBAAgB;AACtB,IAAM,cAAc;AAEpB,IAAM,qBAAqB;AAC3B,IAAM,uBAAuB;;;AClBrB,SAAR,UACL,UACA,OACsB;AACtB,QAAM,gBAAgB,wBAAwB,UAAU,CAAC;AACzD,MAAI,kBAAkB,SAAS,OAAQ,QAAO;AAI9C,MAAI,CAAC,MAAO,YAAW,SAAS,MAAM;AAEtC,WAAS,IAAI,eAAe,IAAI,SAAS,QAAQ,IAAI,wBAAwB,UAAU,IAAI,CAAC,GAAG;AAC7F,aAAS,CAAC,IAAI,aAAa,SAAS,CAAC,GAAG,KAAK;AAAA,EAC/C;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,UAAgC,OAAuB;AACtF,WAAS,IAAI,OAAO,IAAI,SAAS,QAAQ,KAAK;AAC5C,QAAI,CAAC,SAAS,SAAS,CAAC,CAAC,EAAG,QAAO;AAAA,EACrC;AACA,SAAO,SAAS;AAClB;AAEA,SAAS,SAAS,MAAmC;AACnD,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,KAAK,CAAC,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,EAAE,MAAM,GAAG;AACzC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,aAAa,MAA0B,OAAoC;AAClF,MAAI,CAAC,MAAO,QAAO,KAAK,MAAM;AAC9B,SAAO,KAAK,KAAK,cAAc;AACjC;AAEO,SAAS,eAA4D,GAAM,GAAc;AAC9F,SAAO,EAAE,MAAM,IAAI,EAAE,MAAM;AAC7B;;;ACnCe,SAAR,eACL,SACA,OACU;AACV,QAAM,UAAoB,MAAM,IAAI,MAAM,CAAC,CAAC;AAE5C,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,IAAI,WAAW,EAAG;AAEtB,YAAMA,eAAc,IAAI,aAAa;AACrC,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AAEtC,YAAM,SAAS,QAAQA,YAAW;AAClC,YAAM,OAAQ,4CAAuB,CAAC;AACtC,WAAK,KAAK,CAAC,cAAc,GAAG,IAAI,MAAM,CAAC,CAAC;AAAA,IAC1C;AAAA,EACF;AAEA,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,SAAS,QAAQ,CAAC;AACxB,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,OAAO,OAAO,CAAC;AACrB,UAAI,KAAM,MAAK,KAAK,cAAc;AAAA,IACpC;AAAA,EACF;AAEA,SAAO;AACT;;;AC/BO,IAAI,QAAQ;AAkBZ,SAAS,aACd,UACA,QACA,KACA,MACQ;AACR,SAAO,OAAO,MAAM;AAClB,UAAM,MAAM,OAAQ,OAAO,OAAQ;AACnC,UAAM,MAAM,SAAS,GAAG,EAAE,MAAM,IAAI;AAEpC,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,aAAO;AAAA,IACT;AAEA,QAAI,MAAM,GAAG;AACX,YAAM,MAAM;AAAA,IACd,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,UAAQ;AACR,SAAO,MAAM;AACf;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,IAAI,SAAS,QAAQ,QAAQ,KAAK;AACxD,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,KAAK,GAAG,QAAQ,KAAK;AAC3C,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,gBAA2B;AACzC,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,WAAW;AAAA,EACb;AACF;AAMO,SAAS,qBACd,UACA,QACA,OACA,KACQ;AACR,QAAM,EAAE,SAAS,YAAY,UAAU,IAAI;AAE3C,MAAI,MAAM;AACV,MAAI,OAAO,SAAS,SAAS;AAC7B,MAAI,QAAQ,SAAS;AACnB,QAAI,WAAW,YAAY;AACzB,cAAQ,cAAc,MAAM,SAAS,SAAS,EAAE,MAAM,MAAM;AAC5D,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,YAAY;AAExB,YAAM,cAAc,KAAK,IAAI;AAAA,IAC/B,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AACA,QAAM,UAAU;AAChB,QAAM,aAAa;AAEnB,SAAQ,MAAM,YAAY,aAAa,UAAU,QAAQ,KAAK,IAAI;AACpE;;;ACHO,SAAS,MAAS,KAA4B;AACnD,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAK;AACtD;;;ACvFO,IAAM,aAAyB,SAAU,KAAK,QAAQ;AAC3D,QAAM,SAAS,MAAM,GAA8B;AAEnD,MAAI,EAAE,cAAc,SAAS;AAC3B,WAAO,IAAI,SAAS,QAA2D,MAAM;AAAA,EACvF;AAEA,QAAM,WAAiC,CAAC;AACxC,QAAM,UAAoB,CAAC;AAC3B,QAAM,iBAAoC,CAAC;AAC3C,QAAM,QAAkB,CAAC;AACzB,QAAM,aAAuB,CAAC;AAE9B;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,SAA2B;AAAA,IAC/B,SAAS;AAAA,IACT,MAAM,OAAO;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,oBAAoB,MAAM;AACnC;AAEA,SAAS,QACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,EAAE,SAAS,IAAI;AACrB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,UAAM,EAAE,KAAK,OAAO,IAAI,SAAS,CAAC;AAElC,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,IAAI,IAAI,SAAS,QAAQ;AAC3B,YAAM,aAAa,SAAS,IAAI,CAAC,EAAE;AACnC,WAAK,KAAK,IAAI,UAAU,aAAa,WAAW,IAAI;AAEpD,UAAI,OAAO,UAAU;AACnB,aAAK,KAAK,IAAI,YAAY,eAAe,WAAW,MAAM;AAAA,MAC5D,WAAW,KAAK,UAAU;AACxB,aAAK,eAAe,WAAW;AAAA,MACjC;AAAA,IACF;AAEA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,aAAa,OAAO;AAAA,MACpB,eAAe,OAAO;AAAA,MACtB;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,WACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,SAAS,MAAM,KAAK;AAC1B,MAAI,cAAc,OAAQ,QAAO,QAAQ,GAAI,SAAmD;AAEhG,QAAM,MAAM,IAAI,SAAS,QAAQ,MAAM;AACvC,QAAM,gBAAgB,QAAQ;AAC9B,QAAM,cAAc,MAAM;AAC1B,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,iBAAiB,gBAAgB,UAAU,YAAY,QAAQ,IAAI;AAE3E,SAAO,SAAS,eAAe;AAC/B,SAAO,OAAO,IAAI,KAAK;AAEvB,MAAI,SAAU,QAAO,gBAAgB,QAAQ;AAAA,MACxC,UAAS,IAAI,GAAG,IAAI,gBAAgB,QAAQ,IAAK,gBAAe,KAAK,IAAI;AAE9E,MAAI,QAAS,UAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAAK,YAAW,KAAK,QAAQ,CAAC,IAAI,aAAa;AAEhG,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,QAAQ,aAAa;AAM3B,QAAI,QAAQ,SAAU;AAItB,UAAM,MAAM,QAAQ,UAAU,KAAK;AAGnC,UAAM,UAAU,MAAM,IAAI,eAAe;AAEzC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,SAAS,UAAU,IAAI,MAAM;AAInC,UAAI,UAAU,YAAY,UAAU,WAAY;AAEhD,UAAI,IAAI,WAAW,GAAG;AACpB,YAAI,KAAK,CAAC,MAAM,CAAC;AACjB;AAAA,MACF;AAEA,YAAM,eAAe,gBAAgB,IAAI,aAAa;AACtD,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AACtC,UAAI;AAAA,QACF,IAAI,WAAW,IACX,CAAC,QAAQ,cAAc,YAAY,YAAY,IAC/C,CAAC,QAAQ,cAAc,YAAY,cAAc,cAAc,IAAI,WAAW,CAAC;AAAA,MACrF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,OAAU,KAAU,OAAY;AACvC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAK,KAAI,KAAK,MAAM,CAAC,CAAC;AAC1D;AAEA,SAAS,QAAW,KAAY,OAAoB;AAClD,WAAS,IAAI,IAAI,QAAQ,KAAK,OAAO,IAAK,KAAI,CAAC,IAAI,CAAC;AACpD,SAAO,IAAI,KAAK;AAClB;;;ARhHA,IAAM,gBAAgB;AACtB,IAAM,kBAAkB;AAEjB,IAAM,oBAAoB;AAC1B,IAAM,uBAAuB;AAI7B,IAAM,WAAN,MAAoC;AAAA,EAkBzC,YAAY,KAAyB,QAAwB;AAC3D,UAAM,WAAW,OAAO,QAAQ;AAChC,QAAI,CAAC,YAAa,IAAyC,aAAc,QAAO;AAEhF,UAAM,SAAS,MAAM,GAAwC;AAE7D,UAAM,EAAE,SAAS,MAAM,OAAO,YAAY,SAAS,eAAe,IAAI;AACtE,SAAK,UAAU;AACf,SAAK,OAAO;AACZ,SAAK,QAAQ,SAAS,CAAC;AACvB,SAAK,aAAa;AAClB,SAAK,UAAU;AACf,SAAK,iBAAiB;AACtB,SAAK,aAAa,OAAO,cAAe,OAAkB,uBAAuB;AAEjF,UAAM,UAAU,SAAS,QAAQ,UAAU;AAC3C,SAAK,kBAAkB,QAAQ,IAAI,OAAO;AAE1C,UAAM,EAAE,SAAS,IAAI;AACrB,QAAI,OAAO,aAAa,UAAU;AAChC,WAAK,WAAW;AAChB,WAAK,WAAW;AAAA,IAClB,WAAW,MAAM,QAAQ,QAAQ,GAAG;AAClC,WAAK,WAAW;AAChB,WAAK,WAAW,UAAU,UAAU,QAAQ;AAAA,IAC9C,WAAY,OAAyC,UAAU;AAC7D,YAAM,IAAI,MAAM,4EAA4E;AAAA,IAC9F,OAAO;AACL,YAAM,IAAI,MAAM,uBAAuB,KAAK,UAAU,MAAM,CAAC,EAAE;AAAA,IACjE;AAEA,SAAK,eAAe,cAAc;AAClC,SAAK,aAAa;AAClB,SAAK,iBAAiB;AAAA,EACxB;AACF;AAMA,SAAS,KAAK,KAAyB;AACrC,SAAO;AACT;AAKO,SAAS,gBAAgB,KAA6C;AAzJ7E;AA0JE,UAAQ,gBAAK,GAAG,GAAE,aAAV,eAAU,WAAa,OAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAKO,SAAS,gBAAgB,KAAuD;AAhKvF;AAiKE,UAAQ,UAAK,GAAG,GAAE,aAAV,GAAU,WAAa,OAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAMO,SAAS,aACd,KACA,MACA,QACmC;AACnC,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO;AAEnC,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,UAAU,KAAK,OAAO,SAAS,KAAK;AAC7C;AAOO,SAAS,oBACd,KACA,QAC0C;AAC1C,MAAI,EAAE,MAAM,QAAQ,KAAK,IAAI;AAC7B;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAElE,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAExD,QAAM,UAAU,SAAS,KAAK;AAC9B,MAAI,QAAQ,WAAW,EAAG,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAEhE,QAAM,EAAE,OAAO,gBAAgB,IAAI;AACnC,SAAO;AAAA,IACL,gBAAgB,QAAQ,aAAa,CAAC;AAAA,IACtC,QAAQ,WAAW,IAAI;AAAA,IACvB,QAAQ,aAAa;AAAA,IACrB,QAAQ,WAAW,IAAI,MAAM,QAAQ,WAAW,CAAC,IAAI;AAAA,EACvD;AACF;AAKO,SAAS,qBACd,KACA,QAC4C;AAC5C,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AACvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,sBAAsB,KAAK;AACzF;AAKO,SAAS,yBAAyB,KAAe,QAA0C;AAChG,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AAEvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,mBAAmB,IAAI;AACrF;AAKO,SAAS,YAAY,KAAe,IAA0C;AACnF,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,OAAO,gBAAgB,IAAI;AAEnC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAElB,YAAM,gBAAgB,IAAI;AAC1B,YAAM,kBAAkB,IAAI,CAAC;AAC7B,UAAI,SAAS;AACb,UAAI,eAAe;AACnB,UAAI,iBAAiB;AACrB,UAAI,OAAO;AACX,UAAI,IAAI,WAAW,GAAG;AACpB,iBAAS,gBAAgB,IAAI,CAAC,CAAC;AAC/B,uBAAe,IAAI,CAAC,IAAI;AACxB,yBAAiB,IAAI,CAAC;AAAA,MACxB;AACA,UAAI,IAAI,WAAW,EAAG,QAAO,MAAM,IAAI,CAAC,CAAC;AAEzC,SAAG;AAAA,QACD;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAgB;AAAA,IAClB;AAAA,EACF;AACF;AAEA,SAAS,YAAY,KAAe,QAAwB;AAC1D,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAI,QAAQ,QAAQ,QAAQ,MAAM;AAClC,MAAI,UAAU,GAAI,SAAQ,gBAAgB,QAAQ,MAAM;AACxD,SAAO;AACT;AAKO,SAAS,iBAAiB,KAAe,QAA+B;AAC7E,QAAM,EAAE,eAAe,IAAI;AAC3B,MAAI,kBAAkB,KAAM,QAAO;AACnC,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,OAAO,eAAe,KAAK;AACnD;AAKO,SAAS,UAAU,KAAe,QAAyB;AAChE,QAAM,EAAE,WAAW,IAAI;AACvB,MAAI,cAAc,KAAM,QAAO;AAC/B,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,QAAQ,WAAW,SAAS,KAAK;AACzD;AAMO,SAAS,oBAAoB,KAAuB,QAA2B;AACpF,QAAM,SAAS,IAAI,SAAS,MAAM,KAAK,CAAC,CAAC,GAAG,MAAM;AAClD,OAAK,MAAM,EAAE,WAAW,IAAI;AAC5B,SAAO;AACT;AAMO,SAAS,WACd,KACkF;AAClF,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAMO,SAAS,WAAW,KAAiC;AAC1D,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAEA,SAAS,MACP,KACA,UACwD;AACxD,SAAO;AAAA,IACL,SAAS,IAAI;AAAA,IACb,MAAM,IAAI;AAAA,IACV,OAAO,IAAI;AAAA,IACX,YAAY,IAAI;AAAA,IAChB,SAAS,IAAI;AAAA,IACb,gBAAgB,IAAI;AAAA,IACpB;AAAA,IACA,YAAY,IAAI,cAAe,IAAe;AAAA,EAChD;AACF;AASA,SAAS,SACP,QACA,MACA,QACA,MAC0C;AAC1C,SAAO,EAAE,QAAQ,MAAM,QAAQ,KAAK;AACtC;AAIA,SAAS,SACP,MACA,QAC4C;AAC5C,SAAO,EAAE,MAAM,OAAO;AACxB;AAgBA,SAAS,qBACP,UACA,MACA,MACA,QACA,MACQ;AACR,MAAI,QAAQ,qBAAqB,UAAU,QAAQ,MAAM,IAAI;AAC7D,MAAI,OAAS;AACX,aAAS,SAAS,oBAAoB,aAAa,YAAY,UAAU,QAAQ,KAAK;AAAA,EACxF,WAAW,SAAS,kBAAmB;AAEvC,MAAI,UAAU,MAAM,UAAU,SAAS,OAAQ,QAAO;AACtD,SAAO;AACT;AAEA,SAAS,wBACP,UACA,MACA,MACA,QACA,MACoB;AACpB,MAAI,MAAM,qBAAqB,UAAU,MAAM,MAAM,QAAQ,oBAAoB;AAQjF,MAAI,CAAC,SAAW,SAAS,kBAAmB;AAE5C,MAAI,QAAQ,MAAM,QAAQ,SAAS,OAAQ,QAAO,CAAC;AAKnD,QAAM,gBAAgB,QAAU,SAAS,SAAS,GAAG,EAAE,MAAM;AAG7D,MAAI,CAAC,MAAS,OAAM,WAAW,UAAU,eAAe,GAAG;AAC3D,QAAM,MAAM,WAAW,UAAU,eAAe,GAAG;AAEnD,QAAM,SAAS,CAAC;AAChB,SAAO,OAAO,KAAK,OAAO;AACxB,UAAM,UAAU,SAAS,GAAG;AAC5B,WAAO,KAAK,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC,CAAC;AAAA,EACtF;AACA,SAAO;AACT;AAkBA,SAAS,kBACP,KACA,QACA,MACA,QACA,MACA,KACiE;AA5dnE;AA6dE;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAIC,eAAc,QAAQ,QAAQ,MAAM;AACxC,MAAIA,iBAAgB,GAAI,CAAAA,eAAc,gBAAgB,QAAQ,MAAM;AACpE,MAAIA,iBAAgB,GAAI,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE7D,QAAM,iBAAiB,UAAK,GAAG,GAAE,mBAAV,GAAU,iBAAmB,QAAQ,IAAI,aAAa;AAC7E,QAAM,aAAa,UAAK,GAAG,GAAE,eAAV,GAAU,aAAe,eAAe,gBAAgB,GAAG,GAAG,aAAa;AAE9F,QAAM,WAAW,UAAUA,YAAW,EAAE,IAAI;AAC5C,MAAI,YAAY,KAAM,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE3D,QAAM,OAAO,cAAcA,YAAW;AAEtC,MAAI,IAAK,QAAO,wBAAwB,UAAU,MAAM,MAAM,QAAQ,IAAI;AAE1E,QAAM,QAAQ,qBAAqB,UAAU,MAAM,MAAM,QAAQ,IAAI;AACrE,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,IAAI;AAE5C,QAAM,UAAU,SAAS,KAAK;AAC9B,SAAO,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC;AAChF;", + "names": ["sourceIndex", "sourceIndex"] +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js new file mode 100644 index 00000000..0387ae38 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js @@ -0,0 +1,559 @@ +(function (global, factory) { + if (typeof exports === 'object' && typeof module !== 'undefined') { + factory(module, require('@jridgewell/resolve-uri'), require('@jridgewell/sourcemap-codec')); + module.exports = def(module); + } else if (typeof define === 'function' && define.amd) { + define(['module', '@jridgewell/resolve-uri', '@jridgewell/sourcemap-codec'], function(mod) { + factory.apply(this, arguments); + mod.exports = def(mod); + }); + } else { + const mod = { exports: {} }; + factory(mod, global.resolveURI, global.sourcemapCodec); + global = typeof globalThis !== 'undefined' ? globalThis : global || self; + global.traceMapping = def(mod); + } + function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; } +})(this, (function (module, require_resolveURI, require_sourcemapCodec) { +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// umd:@jridgewell/sourcemap-codec +var require_sourcemap_codec = __commonJS({ + "umd:@jridgewell/sourcemap-codec"(exports, module2) { + module2.exports = require_sourcemapCodec; + } +}); + +// umd:@jridgewell/resolve-uri +var require_resolve_uri = __commonJS({ + "umd:@jridgewell/resolve-uri"(exports, module2) { + module2.exports = require_resolveURI; + } +}); + +// src/trace-mapping.ts +var trace_mapping_exports = {}; +__export(trace_mapping_exports, { + AnyMap: () => FlattenMap, + FlattenMap: () => FlattenMap, + GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND, + LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND, + TraceMap: () => TraceMap, + allGeneratedPositionsFor: () => allGeneratedPositionsFor, + decodedMap: () => decodedMap, + decodedMappings: () => decodedMappings, + eachMapping: () => eachMapping, + encodedMap: () => encodedMap, + encodedMappings: () => encodedMappings, + generatedPositionFor: () => generatedPositionFor, + isIgnored: () => isIgnored, + originalPositionFor: () => originalPositionFor, + presortedDecodedMap: () => presortedDecodedMap, + sourceContentFor: () => sourceContentFor, + traceSegment: () => traceSegment +}); +module.exports = __toCommonJS(trace_mapping_exports); +var import_sourcemap_codec = __toESM(require_sourcemap_codec()); + +// src/resolve.ts +var import_resolve_uri = __toESM(require_resolve_uri()); + +// src/strip-filename.ts +function stripFilename(path) { + if (!path) return ""; + const index = path.lastIndexOf("/"); + return path.slice(0, index + 1); +} + +// src/resolve.ts +function resolver(mapUrl, sourceRoot) { + const from = stripFilename(mapUrl); + const prefix = sourceRoot ? sourceRoot + "/" : ""; + return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from); +} + +// src/sourcemap-segment.ts +var COLUMN = 0; +var SOURCES_INDEX = 1; +var SOURCE_LINE = 2; +var SOURCE_COLUMN = 3; +var NAMES_INDEX = 4; +var REV_GENERATED_LINE = 1; +var REV_GENERATED_COLUMN = 2; + +// src/sort.ts +function maybeSort(mappings, owned) { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + if (!owned) mappings = mappings.slice(); + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} +function nextUnsortedSegmentLine(mappings, start) { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} +function isSorted(line) { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} +function sortSegments(line, owned) { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} +function sortComparator(a, b) { + return a[COLUMN] - b[COLUMN]; +} + +// src/by-source.ts +function buildBySources(decoded, memos) { + const sources = memos.map(() => []); + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + const sourceIndex2 = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + const source = sources[sourceIndex2]; + const segs = source[sourceLine] || (source[sourceLine] = []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + return sources; +} + +// src/binary-search.ts +var found = false; +function binarySearch(haystack, needle, low, high) { + while (low <= high) { + const mid = low + (high - low >> 1); + const cmp = haystack[mid][COLUMN] - needle; + if (cmp === 0) { + found = true; + return mid; + } + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + found = false; + return low - 1; +} +function upperBound(haystack, needle, index) { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function lowerBound(haystack, needle, index) { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} +function memoizedState() { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1 + }; +} +function memoizedBinarySearch(haystack, needle, state, key) { + const { lastKey, lastNeedle, lastIndex } = state; + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + if (needle >= lastNeedle) { + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + return state.lastIndex = binarySearch(haystack, needle, low, high); +} + +// src/types.ts +function parse(map) { + return typeof map === "string" ? JSON.parse(map) : map; +} + +// src/flatten-map.ts +var FlattenMap = function(map, mapUrl) { + const parsed = parse(map); + if (!("sections" in parsed)) { + return new TraceMap(parsed, mapUrl); + } + const mappings = []; + const sources = []; + const sourcesContent = []; + const names = []; + const ignoreList = []; + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity + ); + const joined = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList + }; + return presortedDecodedMap(joined); +}; +function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc + ); + } +} +function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) { + const parsed = parse(input); + if ("sections" in parsed) return recurse(...arguments); + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + append(sources, resolvedSources); + append(names, map.names); + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + if (lineI > stopLine) return; + const out = getLine(mappings, lineI); + const cOffset = i === 0 ? columnOffset : 0; + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + if (lineI === stopLine && column >= stopColumn) return; + if (seg.length === 1) { + out.push([column]); + continue; + } + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]] + ); + } + } +} +function append(arr, other) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} +function getLine(arr, index) { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} + +// src/trace-mapping.ts +var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)"; +var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)"; +var LEAST_UPPER_BOUND = -1; +var GREATEST_LOWER_BOUND = 1; +var TraceMap = class { + constructor(map, mapUrl) { + const isString = typeof map === "string"; + if (!isString && map._decodedMemo) return map; + const parsed = parse(map); + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0; + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + const { mappings } = parsed; + if (typeof mappings === "string") { + this._encoded = mappings; + this._decoded = void 0; + } else if (Array.isArray(mappings)) { + this._encoded = void 0; + this._decoded = maybeSort(mappings, isString); + } else if (parsed.sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + this._decodedMemo = memoizedState(); + this._bySources = void 0; + this._bySourceMemos = void 0; + } +}; +function cast(map) { + return map; +} +function encodedMappings(map) { + var _a, _b; + return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = (0, import_sourcemap_codec.encode)(cast(map)._decoded); +} +function decodedMappings(map) { + var _a; + return (_a = cast(map))._decoded || (_a._decoded = (0, import_sourcemap_codec.decode)(cast(map)._encoded)); +} +function traceSegment(map, line, column) { + const decoded = decodedMappings(map); + if (line >= decoded.length) return null; + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND + ); + return index === -1 ? null : segments[index]; +} +function originalPositionFor(map, needle) { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const decoded = decodedMappings(map); + if (line >= decoded.length) return OMapping(null, null, null, null); + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND + ); + if (index === -1) return OMapping(null, null, null, null); + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null + ); +} +function generatedPositionFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} +function allGeneratedPositionsFor(map, needle) { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} +function eachMapping(map, cb) { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name + }); + } + } +} +function sourceIndex(map, source) { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} +function sourceContentFor(map, source) { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} +function isIgnored(map, source) { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} +function presortedDecodedMap(map, mapUrl) { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} +function decodedMap(map) { + return clone(map, decodedMappings(map)); +} +function encodedMap(map) { + return clone(map, encodedMappings(map)); +} +function clone(map, mappings) { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || map.x_google_ignoreList + }; +} +function OMapping(source, line, column, name) { + return { source, line, column, name }; +} +function GMapping(line, column) { + return { line, column }; +} +function traceSegmentInternal(segments, memo, line, column, bias) { + let index = memoizedBinarySearch(segments, column, memo, line); + if (found) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + if (index === -1 || index === segments.length) return -1; + return index; +} +function sliceGeneratedPositions(segments, memo, line, column, bias) { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + if (!found && bias === LEAST_UPPER_BOUND) min++; + if (min === -1 || min === segments.length) return []; + const matchedColumn = found ? column : segments[min][COLUMN]; + if (!found) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} +function generatedPosition(map, source, line, column, bias, all) { + var _a, _b; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + const { sources, resolvedSources } = map; + let sourceIndex2 = sources.indexOf(source); + if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source); + if (sourceIndex2 === -1) return all ? [] : GMapping(null, null); + const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState)); + const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos)); + const segments = generated[sourceIndex2][line]; + if (segments == null) return all ? [] : GMapping(null, null); + const memo = bySourceMemos[sourceIndex2]; + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} +})); +//# sourceMappingURL=trace-mapping.umd.js.map diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map new file mode 100644 index 00000000..68b0c775 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map @@ -0,0 +1,6 @@ +{ + "version": 3, + "sources": ["umd:@jridgewell/sourcemap-codec", "umd:@jridgewell/resolve-uri", "../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"], + "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA,6CAAAA,SAAA;AAAA,IAAAA,QAAO,UAAU;AAAA;AAAA;;;ACAjB;AAAA,yCAAAC,SAAA;AAAA,IAAAA,QAAO,UAAU;AAAA;AAAA;;;ACAjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAA+B;;;ACA/B,yBAAuB;;;ACGR,SAAR,cAA+B,MAAyC;AAC7E,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,KAAK,YAAY,GAAG;AAClC,SAAO,KAAK,MAAM,GAAG,QAAQ,CAAC;AAChC;;;ADHe,SAAR,SACL,QACA,YACS;AACT,QAAM,OAAO,cAAc,MAAM;AAIjC,QAAM,SAAS,aAAa,aAAa,MAAM;AAE/C,SAAO,CAAC,eAAW,mBAAAC,SAAW,UAAU,UAAU,KAAK,IAAI;AAC7D;;;AEAO,IAAM,SAAS;AACf,IAAM,gBAAgB;AACtB,IAAM,cAAc;AACpB,IAAM,gBAAgB;AACtB,IAAM,cAAc;AAEpB,IAAM,qBAAqB;AAC3B,IAAM,uBAAuB;;;AClBrB,SAAR,UACL,UACA,OACsB;AACtB,QAAM,gBAAgB,wBAAwB,UAAU,CAAC;AACzD,MAAI,kBAAkB,SAAS,OAAQ,QAAO;AAI9C,MAAI,CAAC,MAAO,YAAW,SAAS,MAAM;AAEtC,WAAS,IAAI,eAAe,IAAI,SAAS,QAAQ,IAAI,wBAAwB,UAAU,IAAI,CAAC,GAAG;AAC7F,aAAS,CAAC,IAAI,aAAa,SAAS,CAAC,GAAG,KAAK;AAAA,EAC/C;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,UAAgC,OAAuB;AACtF,WAAS,IAAI,OAAO,IAAI,SAAS,QAAQ,KAAK;AAC5C,QAAI,CAAC,SAAS,SAAS,CAAC,CAAC,EAAG,QAAO;AAAA,EACrC;AACA,SAAO,SAAS;AAClB;AAEA,SAAS,SAAS,MAAmC;AACnD,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,QAAI,KAAK,CAAC,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,EAAE,MAAM,GAAG;AACzC,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,aAAa,MAA0B,OAAoC;AAClF,MAAI,CAAC,MAAO,QAAO,KAAK,MAAM;AAC9B,SAAO,KAAK,KAAK,cAAc;AACjC;AAEO,SAAS,eAA4D,GAAM,GAAc;AAC9F,SAAO,EAAE,MAAM,IAAI,EAAE,MAAM;AAC7B;;;ACnCe,SAAR,eACL,SACA,OACU;AACV,QAAM,UAAoB,MAAM,IAAI,MAAM,CAAC,CAAC;AAE5C,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,IAAI,WAAW,EAAG;AAEtB,YAAMC,eAAc,IAAI,aAAa;AACrC,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AAEtC,YAAM,SAAS,QAAQA,YAAW;AAClC,YAAM,OAAQ,4CAAuB,CAAC;AACtC,WAAK,KAAK,CAAC,cAAc,GAAG,IAAI,MAAM,CAAC,CAAC;AAAA,IAC1C;AAAA,EACF;AAEA,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,SAAS,QAAQ,CAAC;AACxB,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,OAAO,OAAO,CAAC;AACrB,UAAI,KAAM,MAAK,KAAK,cAAc;AAAA,IACpC;AAAA,EACF;AAEA,SAAO;AACT;;;AC/BO,IAAI,QAAQ;AAkBZ,SAAS,aACd,UACA,QACA,KACA,MACQ;AACR,SAAO,OAAO,MAAM;AAClB,UAAM,MAAM,OAAQ,OAAO,OAAQ;AACnC,UAAM,MAAM,SAAS,GAAG,EAAE,MAAM,IAAI;AAEpC,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,aAAO;AAAA,IACT;AAEA,QAAI,MAAM,GAAG;AACX,YAAM,MAAM;AAAA,IACd,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,UAAQ;AACR,SAAO,MAAM;AACf;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,IAAI,SAAS,QAAQ,QAAQ,KAAK;AACxD,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,WACd,UACA,QACA,OACQ;AACR,WAAS,IAAI,QAAQ,GAAG,KAAK,GAAG,QAAQ,KAAK;AAC3C,QAAI,SAAS,CAAC,EAAE,MAAM,MAAM,OAAQ;AAAA,EACtC;AACA,SAAO;AACT;AAEO,SAAS,gBAA2B;AACzC,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY;AAAA,IACZ,WAAW;AAAA,EACb;AACF;AAMO,SAAS,qBACd,UACA,QACA,OACA,KACQ;AACR,QAAM,EAAE,SAAS,YAAY,UAAU,IAAI;AAE3C,MAAI,MAAM;AACV,MAAI,OAAO,SAAS,SAAS;AAC7B,MAAI,QAAQ,SAAS;AACnB,QAAI,WAAW,YAAY;AACzB,cAAQ,cAAc,MAAM,SAAS,SAAS,EAAE,MAAM,MAAM;AAC5D,aAAO;AAAA,IACT;AAEA,QAAI,UAAU,YAAY;AAExB,YAAM,cAAc,KAAK,IAAI;AAAA,IAC/B,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AACA,QAAM,UAAU;AAChB,QAAM,aAAa;AAEnB,SAAQ,MAAM,YAAY,aAAa,UAAU,QAAQ,KAAK,IAAI;AACpE;;;ACHO,SAAS,MAAS,KAA4B;AACnD,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAK;AACtD;;;ACvFO,IAAM,aAAyB,SAAU,KAAK,QAAQ;AAC3D,QAAM,SAAS,MAAM,GAA8B;AAEnD,MAAI,EAAE,cAAc,SAAS;AAC3B,WAAO,IAAI,SAAS,QAA2D,MAAM;AAAA,EACvF;AAEA,QAAM,WAAiC,CAAC;AACxC,QAAM,UAAoB,CAAC;AAC3B,QAAM,iBAAoC,CAAC;AAC3C,QAAM,QAAkB,CAAC;AACzB,QAAM,aAAuB,CAAC;AAE9B;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,QAAM,SAA2B;AAAA,IAC/B,SAAS;AAAA,IACT,MAAM,OAAO;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,oBAAoB,MAAM;AACnC;AAEA,SAAS,QACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,EAAE,SAAS,IAAI;AACrB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,UAAM,EAAE,KAAK,OAAO,IAAI,SAAS,CAAC;AAElC,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,IAAI,IAAI,SAAS,QAAQ;AAC3B,YAAM,aAAa,SAAS,IAAI,CAAC,EAAE;AACnC,WAAK,KAAK,IAAI,UAAU,aAAa,WAAW,IAAI;AAEpD,UAAI,OAAO,UAAU;AACnB,aAAK,KAAK,IAAI,YAAY,eAAe,WAAW,MAAM;AAAA,MAC5D,WAAW,KAAK,UAAU;AACxB,aAAK,eAAe,WAAW;AAAA,MACjC;AAAA,IACF;AAEA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,aAAa,OAAO;AAAA,MACpB,eAAe,OAAO;AAAA,MACtB;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,WACP,OACA,QACA,UACA,SACA,gBACA,OACA,YACA,YACA,cACA,UACA,YACA;AACA,QAAM,SAAS,MAAM,KAAK;AAC1B,MAAI,cAAc,OAAQ,QAAO,QAAQ,GAAI,SAAmD;AAEhG,QAAM,MAAM,IAAI,SAAS,QAAQ,MAAM;AACvC,QAAM,gBAAgB,QAAQ;AAC9B,QAAM,cAAc,MAAM;AAC1B,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,iBAAiB,gBAAgB,UAAU,YAAY,QAAQ,IAAI;AAE3E,SAAO,SAAS,eAAe;AAC/B,SAAO,OAAO,IAAI,KAAK;AAEvB,MAAI,SAAU,QAAO,gBAAgB,QAAQ;AAAA,MACxC,UAAS,IAAI,GAAG,IAAI,gBAAgB,QAAQ,IAAK,gBAAe,KAAK,IAAI;AAE9E,MAAI,QAAS,UAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAAK,YAAW,KAAK,QAAQ,CAAC,IAAI,aAAa;AAEhG,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,QAAQ,aAAa;AAM3B,QAAI,QAAQ,SAAU;AAItB,UAAM,MAAM,QAAQ,UAAU,KAAK;AAGnC,UAAM,UAAU,MAAM,IAAI,eAAe;AAEzC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAClB,YAAM,SAAS,UAAU,IAAI,MAAM;AAInC,UAAI,UAAU,YAAY,UAAU,WAAY;AAEhD,UAAI,IAAI,WAAW,GAAG;AACpB,YAAI,KAAK,CAAC,MAAM,CAAC;AACjB;AAAA,MACF;AAEA,YAAM,eAAe,gBAAgB,IAAI,aAAa;AACtD,YAAM,aAAa,IAAI,WAAW;AAClC,YAAM,eAAe,IAAI,aAAa;AACtC,UAAI;AAAA,QACF,IAAI,WAAW,IACX,CAAC,QAAQ,cAAc,YAAY,YAAY,IAC/C,CAAC,QAAQ,cAAc,YAAY,cAAc,cAAc,IAAI,WAAW,CAAC;AAAA,MACrF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,OAAU,KAAU,OAAY;AACvC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAK,KAAI,KAAK,MAAM,CAAC,CAAC;AAC1D;AAEA,SAAS,QAAW,KAAY,OAAoB;AAClD,WAAS,IAAI,IAAI,QAAQ,KAAK,OAAO,IAAK,KAAI,CAAC,IAAI,CAAC;AACpD,SAAO,IAAI,KAAK;AAClB;;;ARhHA,IAAM,gBAAgB;AACtB,IAAM,kBAAkB;AAEjB,IAAM,oBAAoB;AAC1B,IAAM,uBAAuB;AAI7B,IAAM,WAAN,MAAoC;AAAA,EAkBzC,YAAY,KAAyB,QAAwB;AAC3D,UAAM,WAAW,OAAO,QAAQ;AAChC,QAAI,CAAC,YAAa,IAAyC,aAAc,QAAO;AAEhF,UAAM,SAAS,MAAM,GAAwC;AAE7D,UAAM,EAAE,SAAS,MAAM,OAAO,YAAY,SAAS,eAAe,IAAI;AACtE,SAAK,UAAU;AACf,SAAK,OAAO;AACZ,SAAK,QAAQ,SAAS,CAAC;AACvB,SAAK,aAAa;AAClB,SAAK,UAAU;AACf,SAAK,iBAAiB;AACtB,SAAK,aAAa,OAAO,cAAe,OAAkB,uBAAuB;AAEjF,UAAM,UAAU,SAAS,QAAQ,UAAU;AAC3C,SAAK,kBAAkB,QAAQ,IAAI,OAAO;AAE1C,UAAM,EAAE,SAAS,IAAI;AACrB,QAAI,OAAO,aAAa,UAAU;AAChC,WAAK,WAAW;AAChB,WAAK,WAAW;AAAA,IAClB,WAAW,MAAM,QAAQ,QAAQ,GAAG;AAClC,WAAK,WAAW;AAChB,WAAK,WAAW,UAAU,UAAU,QAAQ;AAAA,IAC9C,WAAY,OAAyC,UAAU;AAC7D,YAAM,IAAI,MAAM,4EAA4E;AAAA,IAC9F,OAAO;AACL,YAAM,IAAI,MAAM,uBAAuB,KAAK,UAAU,MAAM,CAAC,EAAE;AAAA,IACjE;AAEA,SAAK,eAAe,cAAc;AAClC,SAAK,aAAa;AAClB,SAAK,iBAAiB;AAAA,EACxB;AACF;AAMA,SAAS,KAAK,KAAyB;AACrC,SAAO;AACT;AAKO,SAAS,gBAAgB,KAA6C;AAzJ7E;AA0JE,UAAQ,gBAAK,GAAG,GAAE,aAAV,eAAU,eAAa,+BAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAKO,SAAS,gBAAgB,KAAuD;AAhKvF;AAiKE,UAAQ,UAAK,GAAG,GAAE,aAAV,GAAU,eAAa,+BAAO,KAAK,GAAG,EAAE,QAAS;AAC3D;AAMO,SAAS,aACd,KACA,MACA,QACmC;AACnC,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO;AAEnC,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAEA,SAAO,UAAU,KAAK,OAAO,SAAS,KAAK;AAC7C;AAOO,SAAS,oBACd,KACA,QAC0C;AAC1C,MAAI,EAAE,MAAM,QAAQ,KAAK,IAAI;AAC7B;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,UAAU,gBAAgB,GAAG;AAInC,MAAI,QAAQ,QAAQ,OAAQ,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAElE,QAAM,WAAW,QAAQ,IAAI;AAC7B,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA,KAAK,GAAG,EAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAExD,QAAM,UAAU,SAAS,KAAK;AAC9B,MAAI,QAAQ,WAAW,EAAG,QAAO,SAAS,MAAM,MAAM,MAAM,IAAI;AAEhE,QAAM,EAAE,OAAO,gBAAgB,IAAI;AACnC,SAAO;AAAA,IACL,gBAAgB,QAAQ,aAAa,CAAC;AAAA,IACtC,QAAQ,WAAW,IAAI;AAAA,IACvB,QAAQ,aAAa;AAAA,IACrB,QAAQ,WAAW,IAAI,MAAM,QAAQ,WAAW,CAAC,IAAI;AAAA,EACvD;AACF;AAKO,SAAS,qBACd,KACA,QAC4C;AAC5C,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AACvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,sBAAsB,KAAK;AACzF;AAKO,SAAS,yBAAyB,KAAe,QAA0C;AAChG,QAAM,EAAE,QAAQ,MAAM,QAAQ,KAAK,IAAI;AAEvC,SAAO,kBAAkB,KAAK,QAAQ,MAAM,QAAQ,QAAQ,mBAAmB,IAAI;AACrF;AAKO,SAAS,YAAY,KAAe,IAA0C;AACnF,QAAM,UAAU,gBAAgB,GAAG;AACnC,QAAM,EAAE,OAAO,gBAAgB,IAAI;AAEnC,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,OAAO,QAAQ,CAAC;AACtB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,YAAM,MAAM,KAAK,CAAC;AAElB,YAAM,gBAAgB,IAAI;AAC1B,YAAM,kBAAkB,IAAI,CAAC;AAC7B,UAAI,SAAS;AACb,UAAI,eAAe;AACnB,UAAI,iBAAiB;AACrB,UAAI,OAAO;AACX,UAAI,IAAI,WAAW,GAAG;AACpB,iBAAS,gBAAgB,IAAI,CAAC,CAAC;AAC/B,uBAAe,IAAI,CAAC,IAAI;AACxB,yBAAiB,IAAI,CAAC;AAAA,MACxB;AACA,UAAI,IAAI,WAAW,EAAG,QAAO,MAAM,IAAI,CAAC,CAAC;AAEzC,SAAG;AAAA,QACD;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAgB;AAAA,IAClB;AAAA,EACF;AACF;AAEA,SAAS,YAAY,KAAe,QAAwB;AAC1D,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAI,QAAQ,QAAQ,QAAQ,MAAM;AAClC,MAAI,UAAU,GAAI,SAAQ,gBAAgB,QAAQ,MAAM;AACxD,SAAO;AACT;AAKO,SAAS,iBAAiB,KAAe,QAA+B;AAC7E,QAAM,EAAE,eAAe,IAAI;AAC3B,MAAI,kBAAkB,KAAM,QAAO;AACnC,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,OAAO,eAAe,KAAK;AACnD;AAKO,SAAS,UAAU,KAAe,QAAyB;AAChE,QAAM,EAAE,WAAW,IAAI;AACvB,MAAI,cAAc,KAAM,QAAO;AAC/B,QAAM,QAAQ,YAAY,KAAK,MAAM;AACrC,SAAO,UAAU,KAAK,QAAQ,WAAW,SAAS,KAAK;AACzD;AAMO,SAAS,oBAAoB,KAAuB,QAA2B;AACpF,QAAM,SAAS,IAAI,SAAS,MAAM,KAAK,CAAC,CAAC,GAAG,MAAM;AAClD,OAAK,MAAM,EAAE,WAAW,IAAI;AAC5B,SAAO;AACT;AAMO,SAAS,WACd,KACkF;AAClF,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAMO,SAAS,WAAW,KAAiC;AAC1D,SAAO,MAAM,KAAK,gBAAgB,GAAG,CAAC;AACxC;AAEA,SAAS,MACP,KACA,UACwD;AACxD,SAAO;AAAA,IACL,SAAS,IAAI;AAAA,IACb,MAAM,IAAI;AAAA,IACV,OAAO,IAAI;AAAA,IACX,YAAY,IAAI;AAAA,IAChB,SAAS,IAAI;AAAA,IACb,gBAAgB,IAAI;AAAA,IACpB;AAAA,IACA,YAAY,IAAI,cAAe,IAAe;AAAA,EAChD;AACF;AASA,SAAS,SACP,QACA,MACA,QACA,MAC0C;AAC1C,SAAO,EAAE,QAAQ,MAAM,QAAQ,KAAK;AACtC;AAIA,SAAS,SACP,MACA,QAC4C;AAC5C,SAAO,EAAE,MAAM,OAAO;AACxB;AAgBA,SAAS,qBACP,UACA,MACA,MACA,QACA,MACQ;AACR,MAAI,QAAQ,qBAAqB,UAAU,QAAQ,MAAM,IAAI;AAC7D,MAAI,OAAS;AACX,aAAS,SAAS,oBAAoB,aAAa,YAAY,UAAU,QAAQ,KAAK;AAAA,EACxF,WAAW,SAAS,kBAAmB;AAEvC,MAAI,UAAU,MAAM,UAAU,SAAS,OAAQ,QAAO;AACtD,SAAO;AACT;AAEA,SAAS,wBACP,UACA,MACA,MACA,QACA,MACoB;AACpB,MAAI,MAAM,qBAAqB,UAAU,MAAM,MAAM,QAAQ,oBAAoB;AAQjF,MAAI,CAAC,SAAW,SAAS,kBAAmB;AAE5C,MAAI,QAAQ,MAAM,QAAQ,SAAS,OAAQ,QAAO,CAAC;AAKnD,QAAM,gBAAgB,QAAU,SAAS,SAAS,GAAG,EAAE,MAAM;AAG7D,MAAI,CAAC,MAAS,OAAM,WAAW,UAAU,eAAe,GAAG;AAC3D,QAAM,MAAM,WAAW,UAAU,eAAe,GAAG;AAEnD,QAAM,SAAS,CAAC;AAChB,SAAO,OAAO,KAAK,OAAO;AACxB,UAAM,UAAU,SAAS,GAAG;AAC5B,WAAO,KAAK,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC,CAAC;AAAA,EACtF;AACA,SAAO;AACT;AAkBA,SAAS,kBACP,KACA,QACA,MACA,QACA,MACA,KACiE;AA5dnE;AA6dE;AACA,MAAI,OAAO,EAAG,OAAM,IAAI,MAAM,aAAa;AAC3C,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM,eAAe;AAE/C,QAAM,EAAE,SAAS,gBAAgB,IAAI;AACrC,MAAIC,eAAc,QAAQ,QAAQ,MAAM;AACxC,MAAIA,iBAAgB,GAAI,CAAAA,eAAc,gBAAgB,QAAQ,MAAM;AACpE,MAAIA,iBAAgB,GAAI,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE7D,QAAM,iBAAiB,UAAK,GAAG,GAAE,mBAAV,GAAU,iBAAmB,QAAQ,IAAI,aAAa;AAC7E,QAAM,aAAa,UAAK,GAAG,GAAE,eAAV,GAAU,aAAe,eAAe,gBAAgB,GAAG,GAAG,aAAa;AAE9F,QAAM,WAAW,UAAUA,YAAW,EAAE,IAAI;AAC5C,MAAI,YAAY,KAAM,QAAO,MAAM,CAAC,IAAI,SAAS,MAAM,IAAI;AAE3D,QAAM,OAAO,cAAcA,YAAW;AAEtC,MAAI,IAAK,QAAO,wBAAwB,UAAU,MAAM,MAAM,QAAQ,IAAI;AAE1E,QAAM,QAAQ,qBAAqB,UAAU,MAAM,MAAM,QAAQ,IAAI;AACrE,MAAI,UAAU,GAAI,QAAO,SAAS,MAAM,IAAI;AAE5C,QAAM,UAAU,SAAS,KAAK;AAC9B,SAAO,SAAS,QAAQ,kBAAkB,IAAI,GAAG,QAAQ,oBAAoB,CAAC;AAChF;", + "names": ["module", "module", "resolveUri", "sourceIndex", "sourceIndex"] +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/package.json b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/package.json new file mode 100644 index 00000000..9d3a1c08 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/package.json @@ -0,0 +1,67 @@ +{ + "name": "@jridgewell/trace-mapping", + "version": "0.3.31", + "description": "Trace the original position through a source map", + "keywords": [ + "source", + "map" + ], + "main": "dist/trace-mapping.umd.js", + "module": "dist/trace-mapping.mjs", + "types": "types/trace-mapping.d.cts", + "files": [ + "dist", + "src", + "types" + ], + "exports": { + ".": [ + { + "import": { + "types": "./types/trace-mapping.d.mts", + "default": "./dist/trace-mapping.mjs" + }, + "default": { + "types": "./types/trace-mapping.d.cts", + "default": "./dist/trace-mapping.umd.js" + } + }, + "./dist/trace-mapping.umd.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "benchmark": "run-s build:code benchmark:*", + "benchmark:install": "cd benchmark && npm install", + "benchmark:only": "node --expose-gc benchmark/index.mjs", + "build": "run-s -n build:code build:types", + "build:code": "node ../../esbuild.mjs trace-mapping.ts", + "build:types": "run-s build:types:force build:types:emit build:types:mts", + "build:types:force": "rimraf tsconfig.build.tsbuildinfo", + "build:types:emit": "tsc --project tsconfig.build.json", + "build:types:mts": "node ../../mts-types.mjs", + "clean": "run-s -n clean:code clean:types", + "clean:code": "tsc --build --clean tsconfig.build.json", + "clean:types": "rimraf dist types", + "test": "run-s -n test:types test:only test:format", + "test:format": "prettier --check '{src,test}/**/*.ts'", + "test:only": "mocha", + "test:types": "eslint '{src,test}/**/*.ts'", + "lint": "run-s -n lint:types lint:format", + "lint:format": "npm run test:format -- --write", + "lint:types": "npm run test:types -- --fix", + "prepublishOnly": "npm run-s -n build test" + }, + "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping", + "repository": { + "type": "git", + "url": "git+https://github.com/jridgewell/sourcemaps.git", + "directory": "packages/trace-mapping" + }, + "author": "Justin Ridgewell ", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/binary-search.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/binary-search.ts new file mode 100644 index 00000000..c1144ad1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/binary-search.ts @@ -0,0 +1,115 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment'; +import { COLUMN } from './sourcemap-segment'; + +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; + +export let found = false; + +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export function binarySearch( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + low: number, + high: number, +): number { + while (low <= high) { + const mid = low + ((high - low) >> 1); + const cmp = haystack[mid][COLUMN] - needle; + + if (cmp === 0) { + found = true; + return mid; + } + + if (cmp < 0) { + low = mid + 1; + } else { + high = mid - 1; + } + } + + found = false; + return low - 1; +} + +export function upperBound( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + index: number, +): number { + for (let i = index + 1; i < haystack.length; index = i++) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} + +export function lowerBound( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + index: number, +): number { + for (let i = index - 1; i >= 0; index = i--) { + if (haystack[i][COLUMN] !== needle) break; + } + return index; +} + +export function memoizedState(): MemoState { + return { + lastKey: -1, + lastNeedle: -1, + lastIndex: -1, + }; +} + +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export function memoizedBinarySearch( + haystack: SourceMapSegment[] | ReverseSegment[], + needle: number, + state: MemoState, + key: number, +): number { + const { lastKey, lastNeedle, lastIndex } = state; + + let low = 0; + let high = haystack.length - 1; + if (key === lastKey) { + if (needle === lastNeedle) { + found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle; + return lastIndex; + } + + if (needle >= lastNeedle) { + // lastIndex may be -1 if the previous needle was not found. + low = lastIndex === -1 ? 0 : lastIndex; + } else { + high = lastIndex; + } + } + state.lastKey = key; + state.lastNeedle = needle; + + return (state.lastIndex = binarySearch(haystack, needle, low, high)); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/by-source.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/by-source.ts new file mode 100644 index 00000000..1da6af05 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/by-source.ts @@ -0,0 +1,41 @@ +import { COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN } from './sourcemap-segment'; +import { sortComparator } from './sort'; + +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment'; + +export type Source = ReverseSegment[][]; + +// Rebuilds the original source files, with mappings that are ordered by source line/column instead +// of generated line/column. +export default function buildBySources( + decoded: readonly SourceMapSegment[][], + memos: unknown[], +): Source[] { + const sources: Source[] = memos.map(() => []); + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + if (seg.length === 1) continue; + + const sourceIndex = seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + + const source = sources[sourceIndex]; + const segs = (source[sourceLine] ||= []); + segs.push([sourceColumn, i, seg[COLUMN]]); + } + } + + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + for (let j = 0; j < source.length; j++) { + const line = source[j]; + if (line) line.sort(sortComparator); + } + } + + return sources; +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts new file mode 100644 index 00000000..61ac40ca --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts @@ -0,0 +1,192 @@ +import { TraceMap, presortedDecodedMap, decodedMappings } from './trace-mapping'; +import { + COLUMN, + SOURCES_INDEX, + SOURCE_LINE, + SOURCE_COLUMN, + NAMES_INDEX, +} from './sourcemap-segment'; +import { parse } from './types'; + +import type { + DecodedSourceMap, + DecodedSourceMapXInput, + EncodedSourceMapXInput, + SectionedSourceMapXInput, + SectionedSourceMapInput, + SectionXInput, + Ro, +} from './types'; +import type { SourceMapSegment } from './sourcemap-segment'; + +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; + +export const FlattenMap: FlattenMap = function (map, mapUrl) { + const parsed = parse(map as SectionedSourceMapInput); + + if (!('sections' in parsed)) { + return new TraceMap(parsed as DecodedSourceMapXInput | EncodedSourceMapXInput, mapUrl); + } + + const mappings: SourceMapSegment[][] = []; + const sources: string[] = []; + const sourcesContent: (string | null)[] = []; + const names: string[] = []; + const ignoreList: number[] = []; + + recurse( + parsed, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + 0, + 0, + Infinity, + Infinity, + ); + + const joined: DecodedSourceMap = { + version: 3, + file: parsed.file, + names, + sources, + sourcesContent, + mappings, + ignoreList, + }; + + return presortedDecodedMap(joined); +} as FlattenMap; + +function recurse( + input: SectionedSourceMapXInput, + mapUrl: string | null | undefined, + mappings: SourceMapSegment[][], + sources: string[], + sourcesContent: (string | null)[], + names: string[], + ignoreList: number[], + lineOffset: number, + columnOffset: number, + stopLine: number, + stopColumn: number, +) { + const { sections } = input; + for (let i = 0; i < sections.length; i++) { + const { map, offset } = sections[i]; + + let sl = stopLine; + let sc = stopColumn; + if (i + 1 < sections.length) { + const nextOffset = sections[i + 1].offset; + sl = Math.min(stopLine, lineOffset + nextOffset.line); + + if (sl === stopLine) { + sc = Math.min(stopColumn, columnOffset + nextOffset.column); + } else if (sl < stopLine) { + sc = columnOffset + nextOffset.column; + } + } + + addSection( + map, + mapUrl, + mappings, + sources, + sourcesContent, + names, + ignoreList, + lineOffset + offset.line, + columnOffset + offset.column, + sl, + sc, + ); + } +} + +function addSection( + input: SectionXInput['map'], + mapUrl: string | null | undefined, + mappings: SourceMapSegment[][], + sources: string[], + sourcesContent: (string | null)[], + names: string[], + ignoreList: number[], + lineOffset: number, + columnOffset: number, + stopLine: number, + stopColumn: number, +) { + const parsed = parse(input); + if ('sections' in parsed) return recurse(...(arguments as unknown as Parameters)); + + const map = new TraceMap(parsed, mapUrl); + const sourcesOffset = sources.length; + const namesOffset = names.length; + const decoded = decodedMappings(map); + const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map; + + append(sources, resolvedSources); + append(names, map.names); + + if (contents) append(sourcesContent, contents); + else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null); + + if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset); + + for (let i = 0; i < decoded.length; i++) { + const lineI = lineOffset + i; + + // We can only add so many lines before we step into the range that the next section's map + // controls. When we get to the last line, then we'll start checking the segments to see if + // they've crossed into the column range. But it may not have any columns that overstep, so we + // still need to check that we don't overstep lines, too. + if (lineI > stopLine) return; + + // The out line may already exist in mappings (if we're continuing the line started by a + // previous section). Or, we may have jumped ahead several lines to start this section. + const out = getLine(mappings, lineI); + // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the + // map can be multiple lines), it doesn't. + const cOffset = i === 0 ? columnOffset : 0; + + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + const column = cOffset + seg[COLUMN]; + + // If this segment steps into the column range that the next section's map controls, we need + // to stop early. + if (lineI === stopLine && column >= stopColumn) return; + + if (seg.length === 1) { + out.push([column]); + continue; + } + + const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX]; + const sourceLine = seg[SOURCE_LINE]; + const sourceColumn = seg[SOURCE_COLUMN]; + out.push( + seg.length === 4 + ? [column, sourcesIndex, sourceLine, sourceColumn] + : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]], + ); + } + } +} + +function append(arr: T[], other: T[]) { + for (let i = 0; i < other.length; i++) arr.push(other[i]); +} + +function getLine(arr: T[][], index: number): T[] { + for (let i = arr.length; i <= index; i++) arr[i] = []; + return arr[index]; +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/resolve.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/resolve.ts new file mode 100644 index 00000000..30bfa3b2 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/resolve.ts @@ -0,0 +1,16 @@ +import resolveUri from '@jridgewell/resolve-uri'; +import stripFilename from './strip-filename'; + +type Resolve = (source: string | null) => string; +export default function resolver( + mapUrl: string | null | undefined, + sourceRoot: string | undefined, +): Resolve { + const from = stripFilename(mapUrl); + // The sourceRoot is always treated as a directory, if it's not empty. + // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327 + // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401 + const prefix = sourceRoot ? sourceRoot + '/' : ''; + + return (source) => resolveUri(prefix + (source || ''), from); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sort.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sort.ts new file mode 100644 index 00000000..5d016cb7 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sort.ts @@ -0,0 +1,45 @@ +import { COLUMN } from './sourcemap-segment'; + +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment'; + +export default function maybeSort( + mappings: SourceMapSegment[][], + owned: boolean, +): SourceMapSegment[][] { + const unsortedIndex = nextUnsortedSegmentLine(mappings, 0); + if (unsortedIndex === mappings.length) return mappings; + + // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If + // not, we do not want to modify the consumer's input array. + if (!owned) mappings = mappings.slice(); + + for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) { + mappings[i] = sortSegments(mappings[i], owned); + } + return mappings; +} + +function nextUnsortedSegmentLine(mappings: SourceMapSegment[][], start: number): number { + for (let i = start; i < mappings.length; i++) { + if (!isSorted(mappings[i])) return i; + } + return mappings.length; +} + +function isSorted(line: SourceMapSegment[]): boolean { + for (let j = 1; j < line.length; j++) { + if (line[j][COLUMN] < line[j - 1][COLUMN]) { + return false; + } + } + return true; +} + +function sortSegments(line: SourceMapSegment[], owned: boolean): SourceMapSegment[] { + if (!owned) line = line.slice(); + return line.sort(sortComparator); +} + +export function sortComparator(a: T, b: T): number { + return a[COLUMN] - b[COLUMN]; +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts new file mode 100644 index 00000000..94f1b6ab --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts @@ -0,0 +1,23 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; + +type GeneratedLine = number; + +export type SourceMapSegment = + | [GeneratedColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] + | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; + +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; + +export const COLUMN = 0; +export const SOURCES_INDEX = 1; +export const SOURCE_LINE = 2; +export const SOURCE_COLUMN = 3; +export const NAMES_INDEX = 4; + +export const REV_GENERATED_LINE = 1; +export const REV_GENERATED_COLUMN = 2; diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts new file mode 100644 index 00000000..2c889800 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts @@ -0,0 +1,8 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export default function stripFilename(path: string | undefined | null): string { + if (!path) return ''; + const index = path.lastIndexOf('/'); + return path.slice(0, index + 1); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts new file mode 100644 index 00000000..0b793d5b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts @@ -0,0 +1,502 @@ +import { encode, decode } from '@jridgewell/sourcemap-codec'; + +import resolver from './resolve'; +import maybeSort from './sort'; +import buildBySources from './by-source'; +import { + memoizedState, + memoizedBinarySearch, + upperBound, + lowerBound, + found as bsFound, +} from './binary-search'; +import { + COLUMN, + SOURCES_INDEX, + SOURCE_LINE, + SOURCE_COLUMN, + NAMES_INDEX, + REV_GENERATED_LINE, + REV_GENERATED_COLUMN, +} from './sourcemap-segment'; +import { parse } from './types'; + +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment'; +import type { + SourceMapV3, + DecodedSourceMap, + EncodedSourceMap, + InvalidOriginalMapping, + OriginalMapping, + InvalidGeneratedMapping, + GeneratedMapping, + SourceMapInput, + Needle, + SourceNeedle, + SourceMap, + EachMapping, + Bias, + XInput, + SectionedSourceMap, + Ro, +} from './types'; +import type { Source } from './by-source'; +import type { MemoState } from './binary-search'; + +export type { SourceMapSegment } from './sourcemap-segment'; +export type { + SourceMap, + DecodedSourceMap, + EncodedSourceMap, + Section, + SectionedSourceMap, + SourceMapV3, + Bias, + EachMapping, + GeneratedMapping, + InvalidGeneratedMapping, + InvalidOriginalMapping, + Needle, + OriginalMapping, + OriginalMapping as Mapping, + SectionedSourceMapInput, + SourceMapInput, + SourceNeedle, + XInput, + EncodedSourceMapXInput, + DecodedSourceMapXInput, + SectionedSourceMapXInput, + SectionXInput, +} from './types'; + +interface PublicMap { + _encoded: TraceMap['_encoded']; + _decoded: TraceMap['_decoded']; + _decodedMemo: TraceMap['_decodedMemo']; + _bySources: TraceMap['_bySources']; + _bySourceMemos: TraceMap['_bySourceMemos']; +} + +const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)'; +const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)'; + +export const LEAST_UPPER_BOUND = -1; +export const GREATEST_LOWER_BOUND = 1; + +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map'; + +export class TraceMap implements SourceMap { + declare version: SourceMapV3['version']; + declare file: SourceMapV3['file']; + declare names: SourceMapV3['names']; + declare sourceRoot: SourceMapV3['sourceRoot']; + declare sources: SourceMapV3['sources']; + declare sourcesContent: SourceMapV3['sourcesContent']; + declare ignoreList: SourceMapV3['ignoreList']; + + declare resolvedSources: string[]; + declare private _encoded: string | undefined; + + declare private _decoded: SourceMapSegment[][] | undefined; + declare private _decodedMemo: MemoState; + + declare private _bySources: Source[] | undefined; + declare private _bySourceMemos: MemoState[] | undefined; + + constructor(map: Ro, mapUrl?: string | null) { + const isString = typeof map === 'string'; + if (!isString && (map as unknown as { _decodedMemo: any })._decodedMemo) return map as TraceMap; + + const parsed = parse(map as Exclude); + + const { version, file, names, sourceRoot, sources, sourcesContent } = parsed; + this.version = version; + this.file = file; + this.names = names || []; + this.sourceRoot = sourceRoot; + this.sources = sources; + this.sourcesContent = sourcesContent; + this.ignoreList = parsed.ignoreList || (parsed as XInput).x_google_ignoreList || undefined; + + const resolve = resolver(mapUrl, sourceRoot); + this.resolvedSources = sources.map(resolve); + + const { mappings } = parsed; + if (typeof mappings === 'string') { + this._encoded = mappings; + this._decoded = undefined; + } else if (Array.isArray(mappings)) { + this._encoded = undefined; + this._decoded = maybeSort(mappings, isString); + } else if ((parsed as unknown as SectionedSourceMap).sections) { + throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`); + } else { + throw new Error(`invalid source map: ${JSON.stringify(parsed)}`); + } + + this._decodedMemo = memoizedState(); + this._bySources = undefined; + this._bySourceMemos = undefined; + } +} + +/** + * Typescript doesn't allow friend access to private fields, so this just casts the map into a type + * with public access modifiers. + */ +function cast(map: unknown): PublicMap { + return map as any; +} + +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'] { + return (cast(map)._encoded ??= encode(cast(map)._decoded!)); +} + +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export function decodedMappings(map: TraceMap): Readonly { + return (cast(map)._decoded ||= decode(cast(map)._encoded!)); +} + +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export function traceSegment( + map: TraceMap, + line: number, + column: number, +): Readonly | null { + const decoded = decodedMappings(map); + + // It's common for parent source maps to have pointers to lines that have no + // mapping (like a "//# sourceMappingURL=") at the end of the child file. + if (line >= decoded.length) return null; + + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + GREATEST_LOWER_BOUND, + ); + + return index === -1 ? null : segments[index]; +} + +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export function originalPositionFor( + map: TraceMap, + needle: Needle, +): OriginalMapping | InvalidOriginalMapping { + let { line, column, bias } = needle; + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + + const decoded = decodedMappings(map); + + // It's common for parent source maps to have pointers to lines that have no + // mapping (like a "//# sourceMappingURL=") at the end of the child file. + if (line >= decoded.length) return OMapping(null, null, null, null); + + const segments = decoded[line]; + const index = traceSegmentInternal( + segments, + cast(map)._decodedMemo, + line, + column, + bias || GREATEST_LOWER_BOUND, + ); + + if (index === -1) return OMapping(null, null, null, null); + + const segment = segments[index]; + if (segment.length === 1) return OMapping(null, null, null, null); + + const { names, resolvedSources } = map; + return OMapping( + resolvedSources[segment[SOURCES_INDEX]], + segment[SOURCE_LINE] + 1, + segment[SOURCE_COLUMN], + segment.length === 5 ? names[segment[NAMES_INDEX]] : null, + ); +} + +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export function generatedPositionFor( + map: TraceMap, + needle: SourceNeedle, +): GeneratedMapping | InvalidGeneratedMapping { + const { source, line, column, bias } = needle; + return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false); +} + +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[] { + const { source, line, column, bias } = needle; + // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit. + return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true); +} + +/** + * Iterates each mapping in generated position order. + */ +export function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void { + const decoded = decodedMappings(map); + const { names, resolvedSources } = map; + + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + for (let j = 0; j < line.length; j++) { + const seg = line[j]; + + const generatedLine = i + 1; + const generatedColumn = seg[0]; + let source = null; + let originalLine = null; + let originalColumn = null; + let name = null; + if (seg.length !== 1) { + source = resolvedSources[seg[1]]; + originalLine = seg[2] + 1; + originalColumn = seg[3]; + } + if (seg.length === 5) name = names[seg[4]]; + + cb({ + generatedLine, + generatedColumn, + source, + originalLine, + originalColumn, + name, + } as EachMapping); + } + } +} + +function sourceIndex(map: TraceMap, source: string): number { + const { sources, resolvedSources } = map; + let index = sources.indexOf(source); + if (index === -1) index = resolvedSources.indexOf(source); + return index; +} + +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export function sourceContentFor(map: TraceMap, source: string): string | null { + const { sourcesContent } = map; + if (sourcesContent == null) return null; + const index = sourceIndex(map, source); + return index === -1 ? null : sourcesContent[index]; +} + +/** + * Determines if the source is marked to ignore by the source map. + */ +export function isIgnored(map: TraceMap, source: string): boolean { + const { ignoreList } = map; + if (ignoreList == null) return false; + const index = sourceIndex(map, source); + return index === -1 ? false : ignoreList.includes(index); +} + +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap { + const tracer = new TraceMap(clone(map, []), mapUrl); + cast(tracer)._decoded = map.mappings; + return tracer; +} + +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function decodedMap( + map: TraceMap, +): Omit & { mappings: readonly SourceMapSegment[][] } { + return clone(map, decodedMappings(map)); +} + +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export function encodedMap(map: TraceMap): EncodedSourceMap { + return clone(map, encodedMappings(map)); +} + +function clone( + map: TraceMap | DecodedSourceMap, + mappings: T, +): T extends string ? EncodedSourceMap : DecodedSourceMap { + return { + version: map.version, + file: map.file, + names: map.names, + sourceRoot: map.sourceRoot, + sources: map.sources, + sourcesContent: map.sourcesContent, + mappings, + ignoreList: map.ignoreList || (map as XInput).x_google_ignoreList, + } as any; +} + +function OMapping(source: null, line: null, column: null, name: null): InvalidOriginalMapping; +function OMapping( + source: string, + line: number, + column: number, + name: string | null, +): OriginalMapping; +function OMapping( + source: string | null, + line: number | null, + column: number | null, + name: string | null, +): OriginalMapping | InvalidOriginalMapping { + return { source, line, column, name } as any; +} + +function GMapping(line: null, column: null): InvalidGeneratedMapping; +function GMapping(line: number, column: number): GeneratedMapping; +function GMapping( + line: number | null, + column: number | null, +): GeneratedMapping | InvalidGeneratedMapping { + return { line, column } as any; +} + +function traceSegmentInternal( + segments: SourceMapSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number; +function traceSegmentInternal( + segments: ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number; +function traceSegmentInternal( + segments: SourceMapSegment[] | ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): number { + let index = memoizedBinarySearch(segments, column, memo, line); + if (bsFound) { + index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index); + } else if (bias === LEAST_UPPER_BOUND) index++; + + if (index === -1 || index === segments.length) return -1; + return index; +} + +function sliceGeneratedPositions( + segments: ReverseSegment[], + memo: MemoState, + line: number, + column: number, + bias: Bias, +): GeneratedMapping[] { + let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND); + + // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in + // insertion order) segment that matched. Even if we did respect the bias when tracing, we would + // still need to call `lowerBound()` to find the first segment, which is slower than just looking + // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the + // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to + // match LEAST_UPPER_BOUND. + if (!bsFound && bias === LEAST_UPPER_BOUND) min++; + + if (min === -1 || min === segments.length) return []; + + // We may have found the segment that started at an earlier column. If this is the case, then we + // need to slice all generated segments that match _that_ column, because all such segments span + // to our desired column. + const matchedColumn = bsFound ? column : segments[min][COLUMN]; + + // The binary search is not guaranteed to find the lower bound when a match wasn't found. + if (!bsFound) min = lowerBound(segments, matchedColumn, min); + const max = upperBound(segments, matchedColumn, min); + + const result = []; + for (; min <= max; min++) { + const segment = segments[min]; + result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN])); + } + return result; +} + +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: false, +): GeneratedMapping | InvalidGeneratedMapping; +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: true, +): GeneratedMapping[]; +function generatedPosition( + map: TraceMap, + source: string, + line: number, + column: number, + bias: Bias, + all: boolean, +): GeneratedMapping | InvalidGeneratedMapping | GeneratedMapping[] { + line--; + if (line < 0) throw new Error(LINE_GTR_ZERO); + if (column < 0) throw new Error(COL_GTR_EQ_ZERO); + + const { sources, resolvedSources } = map; + let sourceIndex = sources.indexOf(source); + if (sourceIndex === -1) sourceIndex = resolvedSources.indexOf(source); + if (sourceIndex === -1) return all ? [] : GMapping(null, null); + + const bySourceMemos = (cast(map)._bySourceMemos ||= sources.map(memoizedState)); + const generated = (cast(map)._bySources ||= buildBySources(decodedMappings(map), bySourceMemos)); + + const segments = generated[sourceIndex][line]; + if (segments == null) return all ? [] : GMapping(null, null); + + const memo = bySourceMemos[sourceIndex]; + + if (all) return sliceGeneratedPositions(segments, memo, line, column, bias); + + const index = traceSegmentInternal(segments, memo, line, column, bias); + if (index === -1) return GMapping(null, null); + + const segment = segments[index]; + return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/types.ts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/types.ts new file mode 100644 index 00000000..730a61fb --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/src/types.ts @@ -0,0 +1,114 @@ +import type { SourceMapSegment } from './sourcemap-segment'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping'; + +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} + +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} + +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} + +export interface Section { + offset: { line: number; column: number }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} + +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} + +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; + +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; + +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; + +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; + +export type XInput = { x_google_ignoreList?: SourceMapV3['ignoreList'] }; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; + +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; + +export type Needle = { line: number; column: number; bias?: Bias }; +export type SourceNeedle = { source: string; line: number; column: number; bias?: Bias }; + +export type EachMapping = + | { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; + } + | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; + }; + +export abstract class SourceMap { + declare version: SourceMapV3['version']; + declare file: SourceMapV3['file']; + declare names: SourceMapV3['names']; + declare sourceRoot: SourceMapV3['sourceRoot']; + declare sources: SourceMapV3['sources']; + declare sourcesContent: SourceMapV3['sourcesContent']; + declare resolvedSources: SourceMapV3['sources']; + declare ignoreList: SourceMapV3['ignoreList']; +} + +export type Ro = + T extends Array + ? V[] | Readonly | RoArray | Readonly> + : T extends object + ? T | Readonly | RoObject | Readonly> + : T; +type RoArray = Ro[]; +type RoObject = { [K in keyof T]: T[K] | Ro }; + +export function parse(map: T): Exclude { + return typeof map === 'string' ? JSON.parse(map) : (map as Exclude); +} diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts new file mode 100644 index 00000000..b7bb85c9 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts @@ -0,0 +1,33 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.cts'; +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; +export declare let found: boolean; +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number; +export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function memoizedState(): MemoState; +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number; +//# sourceMappingURL=binary-search.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map new file mode 100644 index 00000000..648e84c1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts new file mode 100644 index 00000000..19e1e6b9 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts @@ -0,0 +1,33 @@ +import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.mts'; +export type MemoState = { + lastKey: number; + lastNeedle: number; + lastIndex: number; +}; +export declare let found: boolean; +/** + * A binary search implementation that returns the index if a match is found. + * If no match is found, then the left-index (the index associated with the item that comes just + * before the desired index) is returned. To maintain proper sort order, a splice would happen at + * the next index: + * + * ```js + * const array = [1, 3]; + * const needle = 2; + * const index = binarySearch(array, needle, (item, needle) => item - needle); + * + * assert.equal(index, 0); + * array.splice(index + 1, 0, needle); + * assert.deepEqual(array, [1, 2, 3]); + * ``` + */ +export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number; +export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number; +export declare function memoizedState(): MemoState; +/** + * This overly complicated beast is just to record the last tested line/column and the resulting + * index, allowing us to skip a few tests if mappings are monotonically increasing. + */ +export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number; +//# sourceMappingURL=binary-search.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map new file mode 100644 index 00000000..648e84c1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts new file mode 100644 index 00000000..da496939 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts'; +export type Source = ReverseSegment[][]; +export = function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[]; +//# sourceMappingURL=by-source.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map new file mode 100644 index 00000000..32d2a7a1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts new file mode 100644 index 00000000..f3610495 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts'; +export type Source = ReverseSegment[][]; +export default function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[]; +//# sourceMappingURL=by-source.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map new file mode 100644 index 00000000..32d2a7a1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts new file mode 100644 index 00000000..433d849b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts @@ -0,0 +1,9 @@ +import { TraceMap } from './trace-mapping.cts'; +import type { SectionedSourceMapInput, Ro } from './types.cts'; +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; +export declare const FlattenMap: FlattenMap; +export {}; +//# sourceMappingURL=flatten-map.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map new file mode 100644 index 00000000..994b208a --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts new file mode 100644 index 00000000..444a1bed --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts @@ -0,0 +1,9 @@ +import { TraceMap } from './trace-mapping.mts'; +import type { SectionedSourceMapInput, Ro } from './types.mts'; +type FlattenMap = { + new (map: Ro, mapUrl?: string | null): TraceMap; + (map: Ro, mapUrl?: string | null): TraceMap; +}; +export declare const FlattenMap: FlattenMap; +export {}; +//# sourceMappingURL=flatten-map.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map new file mode 100644 index 00000000..994b208a --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts new file mode 100644 index 00000000..62aeedb5 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts @@ -0,0 +1,4 @@ +type Resolve = (source: string | null) => string; +export = function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve; +export {}; +//# sourceMappingURL=resolve.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map new file mode 100644 index 00000000..9f155ace --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts new file mode 100644 index 00000000..e2798a19 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts @@ -0,0 +1,4 @@ +type Resolve = (source: string | null) => string; +export default function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve; +export {}; +//# sourceMappingURL=resolve.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map new file mode 100644 index 00000000..9f155ace --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts new file mode 100644 index 00000000..aa14c129 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts'; +export = function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][]; +export declare function sortComparator(a: T, b: T): number; +//# sourceMappingURL=sort.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map new file mode 100644 index 00000000..48b8e674 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts new file mode 100644 index 00000000..c5b94e64 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts @@ -0,0 +1,4 @@ +import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts'; +export default function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][]; +export declare function sortComparator(a: T, b: T): number; +//# sourceMappingURL=sort.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map new file mode 100644 index 00000000..48b8e674 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts new file mode 100644 index 00000000..8d3cabc1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts @@ -0,0 +1,17 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +type GeneratedLine = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export declare const REV_GENERATED_LINE = 1; +export declare const REV_GENERATED_COLUMN = 2; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map new file mode 100644 index 00000000..0c94a461 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts new file mode 100644 index 00000000..8d3cabc1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts @@ -0,0 +1,17 @@ +type GeneratedColumn = number; +type SourcesIndex = number; +type SourceLine = number; +type SourceColumn = number; +type NamesIndex = number; +type GeneratedLine = number; +export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex]; +export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn]; +export declare const COLUMN = 0; +export declare const SOURCES_INDEX = 1; +export declare const SOURCE_LINE = 2; +export declare const SOURCE_COLUMN = 3; +export declare const NAMES_INDEX = 4; +export declare const REV_GENERATED_LINE = 1; +export declare const REV_GENERATED_COLUMN = 2; +export {}; +//# sourceMappingURL=sourcemap-segment.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map new file mode 100644 index 00000000..0c94a461 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts new file mode 100644 index 00000000..8b3c0e9b --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts @@ -0,0 +1,5 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export = function stripFilename(path: string | undefined | null): string; +//# sourceMappingURL=strip-filename.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map new file mode 100644 index 00000000..17a25da0 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts new file mode 100644 index 00000000..cbbaee0d --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts @@ -0,0 +1,5 @@ +/** + * Removes everything after the last "/", but leaves the slash. + */ +export default function stripFilename(path: string | undefined | null): string; +//# sourceMappingURL=strip-filename.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map new file mode 100644 index 00000000..17a25da0 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts new file mode 100644 index 00000000..a40f3054 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts @@ -0,0 +1,80 @@ +import type { SourceMapSegment } from './sourcemap-segment.cts'; +import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.cts'; +export type { SourceMapSegment } from './sourcemap-segment.cts'; +export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.cts'; +export declare const LEAST_UPPER_BOUND = -1; +export declare const GREATEST_LOWER_BOUND = 1; +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.cts'; +export declare class TraceMap implements SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + ignoreList: SourceMapV3['ignoreList']; + resolvedSources: string[]; + private _encoded; + private _decoded; + private _decodedMemo; + private _bySources; + private _bySourceMemos; + constructor(map: Ro, mapUrl?: string | null); +} +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings']; +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export declare function decodedMappings(map: TraceMap): Readonly; +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null; +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping; +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping; +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[]; +/** + * Iterates each mapping in generated position order. + */ +export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void; +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export declare function sourceContentFor(map: TraceMap, source: string): string | null; +/** + * Determines if the source is marked to ignore by the source map. + */ +export declare function isIgnored(map: TraceMap, source: string): boolean; +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function decodedMap(map: TraceMap): Omit & { + mappings: readonly SourceMapSegment[][]; +}; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function encodedMap(map: TraceMap): EncodedSourceMap; +//# sourceMappingURL=trace-mapping.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map new file mode 100644 index 00000000..b5a874c0 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,cAAc,EACd,MAAM,EACN,YAAY,EACZ,SAAS,EACT,WAAW,EAIX,EAAE,EACH,MAAM,SAAS,CAAC;AAIjB,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,kBAAkB,EAClB,WAAW,EACX,IAAI,EACJ,WAAW,EACX,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,MAAM,EACN,eAAe,EACf,eAAe,IAAI,OAAO,EAC1B,uBAAuB,EACvB,cAAc,EACd,YAAY,EACZ,MAAM,EACN,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,GACd,MAAM,SAAS,CAAC;AAajB,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,eAAe,CAAC;AAEjE,qBAAa,QAAS,YAAW,SAAS;IAChC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC5B,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IACtC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,cAAc,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAC9C,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IAEtC,eAAe,EAAE,MAAM,EAAE,CAAC;IAClC,QAAgB,QAAQ,CAAqB;IAE7C,QAAgB,QAAQ,CAAmC;IAC3D,QAAgB,YAAY,CAAY;IAExC,QAAgB,UAAU,CAAuB;IACjD,QAAgB,cAAc,CAA0B;gBAE5C,GAAG,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;CAmC5D;AAUD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAE3E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAErF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAiBnC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,GACb,eAAe,GAAG,sBAAsB,CAiC1C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,YAAY,GACnB,gBAAgB,GAAG,uBAAuB,CAG5C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAIhG;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAgCnF;AASD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK7E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKhE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAIpF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,QAAQ,GACZ,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,GAAG;IAAE,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAA;CAAE,CAElF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAE1D"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts new file mode 100644 index 00000000..bc2ff0f1 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts @@ -0,0 +1,80 @@ +import type { SourceMapSegment } from './sourcemap-segment.mts'; +import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.mts'; +export type { SourceMapSegment } from './sourcemap-segment.mts'; +export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.mts'; +export declare const LEAST_UPPER_BOUND = -1; +export declare const GREATEST_LOWER_BOUND = 1; +export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.mts'; +export declare class TraceMap implements SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + ignoreList: SourceMapV3['ignoreList']; + resolvedSources: string[]; + private _encoded; + private _decoded; + private _decodedMemo; + private _bySources; + private _bySourceMemos; + constructor(map: Ro, mapUrl?: string | null); +} +/** + * Returns the encoded (VLQ string) form of the SourceMap's mappings field. + */ +export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings']; +/** + * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field. + */ +export declare function decodedMappings(map: TraceMap): Readonly; +/** + * A low-level API to find the segment associated with a generated line/column (think, from a + * stack trace). Line and column here are 0-based, unlike `originalPositionFor`. + */ +export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null; +/** + * A higher-level API to find the source/line/column associated with a generated line/column + * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in + * `source-map` library. + */ +export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping; +/** + * Finds the generated line/column position of the provided source/line/column source position. + */ +export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping; +/** + * Finds all generated line/column positions of the provided source/line/column source position. + */ +export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[]; +/** + * Iterates each mapping in generated position order. + */ +export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void; +/** + * Retrieves the source content for a particular source, if its found. Returns null if not. + */ +export declare function sourceContentFor(map: TraceMap, source: string): string | null; +/** + * Determines if the source is marked to ignore by the source map. + */ +export declare function isIgnored(map: TraceMap, source: string): boolean; +/** + * A helper that skips sorting of the input map's mappings array, which can be expensive for larger + * maps. + */ +export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap; +/** + * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function decodedMap(map: TraceMap): Omit & { + mappings: readonly SourceMapSegment[][]; +}; +/** + * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects + * a sourcemap, or to JSON.stringify. + */ +export declare function encodedMap(map: TraceMap): EncodedSourceMap; +//# sourceMappingURL=trace-mapping.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map new file mode 100644 index 00000000..b5a874c0 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,cAAc,EACd,MAAM,EACN,YAAY,EACZ,SAAS,EACT,WAAW,EAIX,EAAE,EACH,MAAM,SAAS,CAAC;AAIjB,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,kBAAkB,EAClB,WAAW,EACX,IAAI,EACJ,WAAW,EACX,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,MAAM,EACN,eAAe,EACf,eAAe,IAAI,OAAO,EAC1B,uBAAuB,EACvB,cAAc,EACd,YAAY,EACZ,MAAM,EACN,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,GACd,MAAM,SAAS,CAAC;AAajB,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,eAAe,CAAC;AAEjE,qBAAa,QAAS,YAAW,SAAS;IAChC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC5B,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IACtC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,cAAc,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAC9C,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IAEtC,eAAe,EAAE,MAAM,EAAE,CAAC;IAClC,QAAgB,QAAQ,CAAqB;IAE7C,QAAgB,QAAQ,CAAmC;IAC3D,QAAgB,YAAY,CAAY;IAExC,QAAgB,UAAU,CAAuB;IACjD,QAAgB,cAAc,CAA0B;gBAE5C,GAAG,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;CAmC5D;AAUD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAE3E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAErF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAiBnC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,GACb,eAAe,GAAG,sBAAsB,CAiC1C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,YAAY,GACnB,gBAAgB,GAAG,uBAAuB,CAG5C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAIhG;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAgCnF;AASD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK7E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKhE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAIpF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,QAAQ,GACZ,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,GAAG;IAAE,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAA;CAAE,CAElF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAE1D"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts new file mode 100644 index 00000000..729c2c32 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts @@ -0,0 +1,107 @@ +import type { SourceMapSegment } from './sourcemap-segment.cts'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping.cts'; +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} +export interface Section { + offset: { + line: number; + column: number; + }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; +export type XInput = { + x_google_ignoreList?: SourceMapV3['ignoreList']; +}; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; +export type Needle = { + line: number; + column: number; + bias?: Bias; +}; +export type SourceNeedle = { + source: string; + line: number; + column: number; + bias?: Bias; +}; +export type EachMapping = { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; +} | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; +}; +export declare abstract class SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + resolvedSources: SourceMapV3['sources']; + ignoreList: SourceMapV3['ignoreList']; +} +export type Ro = T extends Array ? V[] | Readonly | RoArray | Readonly> : T extends object ? T | Readonly | RoObject | Readonly> : T; +type RoArray = Ro[]; +type RoObject = { + [K in keyof T]: T[K] | Ro; +}; +export declare function parse(map: T): Exclude; +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map new file mode 100644 index 00000000..92247839 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzF,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,gBAAgB,EAAE,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,GAAG,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;CAC/D;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC;CACZ;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG,OAAO,oBAAoB,GAAG,OAAO,iBAAiB,CAAC;AAE1E,MAAM,MAAM,MAAM,GAAG;IAAE,mBAAmB,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,GAAG;IAC5E,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG;IACjD,GAAG,EAAE,uBAAuB,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,sBAAsB,GAAG,sBAAsB,GAAG,QAAQ,CAAC;AACjG,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,wBAAwB,CAAC;AAEhF,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AACnE,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEzF,MAAM,MAAM,WAAW,GACnB;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,IAAI,CAAC;IACb,YAAY,EAAE,IAAI,CAAC;IACnB,cAAc,EAAE,IAAI,CAAC;IACrB,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEN,8BAAsB,SAAS;IACrB,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC5B,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IACtC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,cAAc,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAC9C,eAAe,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACxC,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;CAC/C;AAED,MAAM,MAAM,EAAE,CAAC,CAAC,IACd,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACpB,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACvD,CAAC,SAAS,MAAM,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GACrD,CAAC,CAAC;AACV,KAAK,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC1B,KAAK,QAAQ,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEvD,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAEnD"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts new file mode 100644 index 00000000..a26d1866 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts @@ -0,0 +1,107 @@ +import type { SourceMapSegment } from './sourcemap-segment.mts'; +import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping.mts'; +export interface SourceMapV3 { + file?: string | null; + names: string[]; + sourceRoot?: string; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList?: number[]; +} +export interface EncodedSourceMap extends SourceMapV3 { + mappings: string; +} +export interface DecodedSourceMap extends SourceMapV3 { + mappings: SourceMapSegment[][]; +} +export interface Section { + offset: { + line: number; + column: number; + }; + map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap; +} +export interface SectionedSourceMap { + file?: string | null; + sections: Section[]; + version: 3; +} +export type OriginalMapping = { + source: string | null; + line: number; + column: number; + name: string | null; +}; +export type InvalidOriginalMapping = { + source: null; + line: null; + column: null; + name: null; +}; +export type GeneratedMapping = { + line: number; + column: number; +}; +export type InvalidGeneratedMapping = { + line: null; + column: null; +}; +export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND; +export type XInput = { + x_google_ignoreList?: SourceMapV3['ignoreList']; +}; +export type EncodedSourceMapXInput = EncodedSourceMap & XInput; +export type DecodedSourceMapXInput = DecodedSourceMap & XInput; +export type SectionedSourceMapXInput = Omit & { + sections: SectionXInput[]; +}; +export type SectionXInput = Omit & { + map: SectionedSourceMapInput; +}; +export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap; +export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput; +export type Needle = { + line: number; + column: number; + bias?: Bias; +}; +export type SourceNeedle = { + source: string; + line: number; + column: number; + bias?: Bias; +}; +export type EachMapping = { + generatedLine: number; + generatedColumn: number; + source: null; + originalLine: null; + originalColumn: null; + name: null; +} | { + generatedLine: number; + generatedColumn: number; + source: string | null; + originalLine: number; + originalColumn: number; + name: string | null; +}; +export declare abstract class SourceMap { + version: SourceMapV3['version']; + file: SourceMapV3['file']; + names: SourceMapV3['names']; + sourceRoot: SourceMapV3['sourceRoot']; + sources: SourceMapV3['sources']; + sourcesContent: SourceMapV3['sourcesContent']; + resolvedSources: SourceMapV3['sources']; + ignoreList: SourceMapV3['ignoreList']; +} +export type Ro = T extends Array ? V[] | Readonly | RoArray | Readonly> : T extends object ? T | Readonly | RoObject | Readonly> : T; +type RoArray = Ro[]; +type RoObject = { + [K in keyof T]: T[K] | Ro; +}; +export declare function parse(map: T): Exclude; +export {}; +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map new file mode 100644 index 00000000..92247839 --- /dev/null +++ b/backend/node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/types/types.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzF,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC3B,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,gBAAgB,EAAE,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,GAAG,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;CAC/D;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC;CACZ;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG,OAAO,oBAAoB,GAAG,OAAO,iBAAiB,CAAC;AAE1E,MAAM,MAAM,MAAM,GAAG;IAAE,mBAAmB,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,GAAG;IAC5E,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG;IACjD,GAAG,EAAE,uBAAuB,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,sBAAsB,GAAG,sBAAsB,GAAG,QAAQ,CAAC;AACjG,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,wBAAwB,CAAC;AAEhF,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AACnE,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEzF,MAAM,MAAM,WAAW,GACnB;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,IAAI,CAAC;IACb,YAAY,EAAE,IAAI,CAAC;IACnB,cAAc,EAAE,IAAI,CAAC;IACrB,IAAI,EAAE,IAAI,CAAC;CACZ,GACD;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEN,8BAAsB,SAAS;IACrB,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC5B,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IACtC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,cAAc,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAC9C,eAAe,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACxC,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;CAC/C;AAED,MAAM,MAAM,EAAE,CAAC,CAAC,IACd,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACpB,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACvD,CAAC,SAAS,MAAM,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GACrD,CAAC,CAAC;AACV,KAAK,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC1B,KAAK,QAAQ,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEvD,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAEnD"} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/LICENSE b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/LICENSE new file mode 100644 index 00000000..444bffc0 --- /dev/null +++ b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2024-present VoidZero Inc. & Contributors +Copyright (c) 2023 Boshen + +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/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/README.md b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/README.md new file mode 100644 index 00000000..d5b248ac --- /dev/null +++ b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/README.md @@ -0,0 +1,3 @@ +# Oxc Types + +Typescript definitions for Oxc AST nodes. diff --git a/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/package.json b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/package.json new file mode 100644 index 00000000..7b7d3a71 --- /dev/null +++ b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/package.json @@ -0,0 +1,26 @@ +{ + "name": "@oxc-project/types", + "version": "0.151.0", + "description": "Types for Oxc AST nodes", + "keywords": [ + "AST", + "Parser" + ], + "homepage": "https://oxc.rs", + "bugs": "https://github.com/oxc-project/oxc/issues", + "license": "MIT", + "author": "Boshen and oxc contributors", + "repository": { + "type": "git", + "url": "git+https://github.com/oxc-project/oxc.git", + "directory": "npm/oxc-types" + }, + "funding": { + "url": "https://github.com/sponsors/oxc-project" + }, + "files": [ + "types.d.ts" + ], + "type": "module", + "types": "types.d.ts" +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/types.d.ts b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/types.d.ts new file mode 100644 index 00000000..895f2cfd --- /dev/null +++ b/backend/node_modules/.pnpm/@oxc-project+types@0.151.0/node_modules/@oxc-project/types/types.d.ts @@ -0,0 +1,1912 @@ +// Auto-generated code, DO NOT EDIT DIRECTLY! +// To edit this generated file you have to edit `tasks/ast_tools/src/generators/typescript.rs`. + +export interface Program extends Span { + type: "Program"; + body: Array; + sourceType: ModuleKind; + hashbang: Hashbang | null; + parent?: null; +} + +export type Expression = + | BooleanLiteral + | NullLiteral + | NumericLiteral + | BigIntLiteral + | RegExpLiteral + | StringLiteral + | TemplateLiteral + | IdentifierReference + | Super + | ArrayExpression + | ArrowFunctionExpression + | AssignmentExpression + | AwaitExpression + | BinaryExpression + | CallExpression + | ChainExpression + | Class + | ConditionalExpression + | Function + | ImportExpression + | LogicalExpression + | NewExpression + | ObjectExpression + | ParenthesizedExpression + | SequenceExpression + | TaggedTemplateExpression + | ThisExpression + | UnaryExpression + | UpdateExpression + | YieldExpression + | PrivateInExpression + | MetaProperty + | JSXElement + | JSXFragment + | TSAsExpression + | TSSatisfiesExpression + | TSTypeAssertion + | TSNonNullExpression + | TSInstantiationExpression + | V8IntrinsicExpression + | MemberExpression; + +export interface IdentifierName extends Span { + type: "Identifier"; + decorators?: []; + name: string; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface IdentifierReference extends Span { + type: "Identifier"; + decorators?: []; + name: string; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface BindingIdentifier extends Span { + type: "Identifier"; + decorators?: []; + name: string; + optional?: false; + typeAnnotation?: TSTypeAnnotation | null; + parent?: Node; +} + +export interface LabelIdentifier extends Span { + type: "Identifier"; + decorators?: []; + name: string; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface ThisExpression extends Span { + type: "ThisExpression"; + parent?: Node; +} + +export interface ArrayExpression extends Span { + type: "ArrayExpression"; + elements: Array; + parent?: Node; +} + +export type ArrayExpressionElement = SpreadElement | null | Expression; + +export interface ObjectExpression extends Span { + type: "ObjectExpression"; + properties: Array; + parent?: Node; +} + +export type ObjectPropertyKind = ObjectProperty | SpreadElement; + +export interface ObjectProperty extends Span { + type: "Property"; + kind: PropertyKind; + key: PropertyKey; + value: Expression; + method: boolean; + shorthand: boolean; + computed: boolean; + optional?: false; + parent?: Node; +} + +export type PropertyKey = IdentifierName | PrivateIdentifier | Expression; + +export type PropertyKind = "init" | "get" | "set"; + +export interface TemplateLiteral extends Span { + type: "TemplateLiteral"; + quasis: Array; + expressions: Array; + parent?: Node; +} + +export interface TaggedTemplateExpression extends Span { + type: "TaggedTemplateExpression"; + tag: Expression; + typeArguments?: TSTypeParameterInstantiation | null; + quasi: TemplateLiteral; + parent?: Node; +} + +export interface TemplateElement extends Span { + type: "TemplateElement"; + value: TemplateElementValue; + tail: boolean; + parent?: Node; +} + +export interface TemplateElementValue { + raw: string; + cooked: string | null; +} + +export type MemberExpression = + | ComputedMemberExpression + | StaticMemberExpression + | PrivateFieldExpression; + +export interface ComputedMemberExpression extends Span { + type: "MemberExpression"; + object: Expression; + property: Expression; + optional: boolean; + computed: true; + parent?: Node; +} + +export interface StaticMemberExpression extends Span { + type: "MemberExpression"; + object: Expression; + property: IdentifierName; + optional: boolean; + computed: false; + parent?: Node; +} + +export interface PrivateFieldExpression extends Span { + type: "MemberExpression"; + object: Expression; + property: PrivateIdentifier; + optional: boolean; + computed: false; + parent?: Node; +} + +export interface CallExpression extends Span { + type: "CallExpression"; + callee: Expression; + typeArguments?: TSTypeParameterInstantiation | null; + arguments: Array; + optional: boolean; + parent?: Node; +} + +export interface NewExpression extends Span { + type: "NewExpression"; + callee: Expression; + typeArguments?: TSTypeParameterInstantiation | null; + arguments: Array; + parent?: Node; +} + +export interface MetaProperty extends Span { + type: "MetaProperty"; + meta: IdentifierName; + property: IdentifierName; + parent?: Node; +} + +export interface SpreadElement extends Span { + type: "SpreadElement"; + argument: Expression; + parent?: Node; +} + +export type Argument = SpreadElement | Expression; + +export interface UpdateExpression extends Span { + type: "UpdateExpression"; + operator: UpdateOperator; + prefix: boolean; + argument: SimpleAssignmentTarget; + parent?: Node; +} + +export interface UnaryExpression extends Span { + type: "UnaryExpression"; + operator: UnaryOperator; + argument: Expression; + prefix: true; + parent?: Node; +} + +export interface BinaryExpression extends Span { + type: "BinaryExpression"; + left: Expression; + operator: BinaryOperator; + right: Expression; + parent?: Node; +} + +export interface PrivateInExpression extends Span { + type: "BinaryExpression"; + left: PrivateIdentifier; + operator: "in"; + right: Expression; + parent?: Node; +} + +export interface LogicalExpression extends Span { + type: "LogicalExpression"; + left: Expression; + operator: LogicalOperator; + right: Expression; + parent?: Node; +} + +export interface ConditionalExpression extends Span { + type: "ConditionalExpression"; + test: Expression; + consequent: Expression; + alternate: Expression; + parent?: Node; +} + +export interface AssignmentExpression extends Span { + type: "AssignmentExpression"; + operator: AssignmentOperator; + left: AssignmentTarget; + right: Expression; + parent?: Node; +} + +export type AssignmentTarget = SimpleAssignmentTarget | AssignmentTargetPattern; + +export type SimpleAssignmentTarget = + | IdentifierReference + | TSAsExpression + | TSSatisfiesExpression + | TSNonNullExpression + | TSTypeAssertion + | MemberExpression; + +export type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget; + +export interface ArrayAssignmentTarget extends Span { + type: "ArrayPattern"; + decorators?: []; + elements: Array; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface ObjectAssignmentTarget extends Span { + type: "ObjectPattern"; + decorators?: []; + properties: Array; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface AssignmentTargetRest extends Span { + type: "RestElement"; + decorators?: []; + argument: AssignmentTarget; + optional?: false; + typeAnnotation?: null; + value?: null; + parent?: Node; +} + +export type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget; + +export interface AssignmentTargetWithDefault extends Span { + type: "AssignmentPattern"; + decorators?: []; + left: AssignmentTarget; + right: Expression; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export type AssignmentTargetProperty = + | AssignmentTargetPropertyIdentifier + | AssignmentTargetPropertyProperty; + +export interface AssignmentTargetPropertyIdentifier extends Span { + type: "Property"; + kind: "init"; + key: IdentifierReference; + value: IdentifierReference | AssignmentTargetWithDefault; + method: false; + shorthand: true; + computed: false; + optional?: false; + parent?: Node; +} + +export interface AssignmentTargetPropertyProperty extends Span { + type: "Property"; + kind: "init"; + key: PropertyKey; + value: AssignmentTargetMaybeDefault; + method: false; + shorthand: false; + computed: boolean; + optional?: false; + parent?: Node; +} + +export interface SequenceExpression extends Span { + type: "SequenceExpression"; + expressions: Array; + parent?: Node; +} + +export interface Super extends Span { + type: "Super"; + parent?: Node; +} + +export interface AwaitExpression extends Span { + type: "AwaitExpression"; + argument: Expression; + parent?: Node; +} + +export interface ChainExpression extends Span { + type: "ChainExpression"; + expression: ChainElement; + parent?: Node; +} + +export type ChainElement = CallExpression | TSNonNullExpression | MemberExpression; + +export interface ParenthesizedExpression extends Span { + type: "ParenthesizedExpression"; + expression: Expression; + parent?: Node; +} + +export type Statement = + | BlockStatement + | BreakStatement + | ContinueStatement + | DebuggerStatement + | DoWhileStatement + | EmptyStatement + | ExpressionStatement + | ForInStatement + | ForOfStatement + | ForStatement + | IfStatement + | LabeledStatement + | ReturnStatement + | SwitchStatement + | ThrowStatement + | TryStatement + | WhileStatement + | WithStatement + | Declaration + | ModuleDeclaration; + +export interface Directive extends Span { + type: "ExpressionStatement"; + expression: StringLiteral; + directive: string; + parent?: Node; +} + +export interface Hashbang extends Span { + type: "Hashbang"; + value: string; + parent?: Node; +} + +export interface BlockStatement extends Span { + type: "BlockStatement"; + body: Array; + parent?: Node; +} + +export type Declaration = + | VariableDeclaration + | Function + | Class + | TSTypeAliasDeclaration + | TSInterfaceDeclaration + | TSEnumDeclaration + | TSModuleDeclaration + | TSGlobalDeclaration + | TSImportEqualsDeclaration; + +export interface VariableDeclaration extends Span { + type: "VariableDeclaration"; + kind: VariableDeclarationKind; + declarations: Array; + declare?: boolean; + parent?: Node; +} + +export type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using"; + +export interface VariableDeclarator extends Span { + type: "VariableDeclarator"; + id: BindingPattern; + init: Expression | null; + definite?: boolean; + parent?: Node; +} + +export interface EmptyStatement extends Span { + type: "EmptyStatement"; + parent?: Node; +} + +export interface ExpressionStatement extends Span { + type: "ExpressionStatement"; + expression: Expression; + directive?: string | null; + parent?: Node; +} + +export interface IfStatement extends Span { + type: "IfStatement"; + test: Expression; + consequent: Statement; + alternate: Statement | null; + parent?: Node; +} + +export interface DoWhileStatement extends Span { + type: "DoWhileStatement"; + body: Statement; + test: Expression; + parent?: Node; +} + +export interface WhileStatement extends Span { + type: "WhileStatement"; + test: Expression; + body: Statement; + parent?: Node; +} + +export interface ForStatement extends Span { + type: "ForStatement"; + init: ForStatementInit | null; + test: Expression | null; + update: Expression | null; + body: Statement; + parent?: Node; +} + +export type ForStatementInit = VariableDeclaration | Expression; + +export interface ForInStatement extends Span { + type: "ForInStatement"; + left: ForStatementLeft; + right: Expression; + body: Statement; + parent?: Node; +} + +export type ForStatementLeft = VariableDeclaration | AssignmentTarget; + +export interface ForOfStatement extends Span { + type: "ForOfStatement"; + await: boolean; + left: ForStatementLeft; + right: Expression; + body: Statement; + parent?: Node; +} + +export interface ContinueStatement extends Span { + type: "ContinueStatement"; + label: LabelIdentifier | null; + parent?: Node; +} + +export interface BreakStatement extends Span { + type: "BreakStatement"; + label: LabelIdentifier | null; + parent?: Node; +} + +export interface ReturnStatement extends Span { + type: "ReturnStatement"; + argument: Expression | null; + parent?: Node; +} + +export interface WithStatement extends Span { + type: "WithStatement"; + object: Expression; + body: Statement; + parent?: Node; +} + +export interface SwitchStatement extends Span { + type: "SwitchStatement"; + discriminant: Expression; + cases: Array; + parent?: Node; +} + +export interface SwitchCase extends Span { + type: "SwitchCase"; + test: Expression | null; + consequent: Array; + parent?: Node; +} + +export interface LabeledStatement extends Span { + type: "LabeledStatement"; + label: LabelIdentifier; + body: Statement; + parent?: Node; +} + +export interface ThrowStatement extends Span { + type: "ThrowStatement"; + argument: Expression; + parent?: Node; +} + +export interface TryStatement extends Span { + type: "TryStatement"; + block: BlockStatement; + handler: CatchClause | null; + finalizer: BlockStatement | null; + parent?: Node; +} + +export interface CatchClause extends Span { + type: "CatchClause"; + param: BindingPattern | null; + body: BlockStatement; + parent?: Node; +} + +export interface DebuggerStatement extends Span { + type: "DebuggerStatement"; + parent?: Node; +} + +export type BindingPattern = BindingIdentifier | ObjectPattern | ArrayPattern | AssignmentPattern; + +export interface AssignmentPattern extends Span { + type: "AssignmentPattern"; + decorators?: []; + left: BindingPattern; + right: Expression; + optional?: false; + typeAnnotation?: null; + parent?: Node; +} + +export interface ObjectPattern extends Span { + type: "ObjectPattern"; + decorators?: []; + properties: Array; + optional?: false; + typeAnnotation?: TSTypeAnnotation | null; + parent?: Node; +} + +export interface BindingProperty extends Span { + type: "Property"; + kind: "init"; + key: PropertyKey; + value: BindingPattern; + method: false; + shorthand: boolean; + computed: boolean; + optional?: false; + parent?: Node; +} + +export interface ArrayPattern extends Span { + type: "ArrayPattern"; + decorators?: []; + elements: Array; + optional?: false; + typeAnnotation?: TSTypeAnnotation | null; + parent?: Node; +} + +export interface BindingRestElement extends Span { + type: "RestElement"; + decorators?: []; + argument: BindingPattern; + optional?: false; + typeAnnotation?: TSTypeAnnotation | null; + value?: null; + parent?: Node; +} + +export interface Function extends Span { + type: FunctionType; + id: BindingIdentifier | null; + generator: boolean; + async: boolean; + declare?: boolean; + typeParameters?: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType?: TSTypeAnnotation | null; + body: FunctionBody | null; + expression: false; + parent?: Node; +} + +export type ParamPattern = FormalParameter | TSParameterProperty | FormalParameterRest; + +export type FunctionType = + | "FunctionDeclaration" + | "FunctionExpression" + | "TSDeclareFunction" + | "TSEmptyBodyFunctionExpression"; + +export interface FormalParameterRest extends Span { + type: "RestElement"; + argument: BindingPattern; + decorators?: Array; + optional?: boolean; + typeAnnotation?: TSTypeAnnotation | null; + value?: null; + parent?: Node; +} + +export type FormalParameter = { + decorators?: Array; +} & BindingPattern; + +export interface TSParameterProperty extends Span { + type: "TSParameterProperty"; + accessibility: TSAccessibility | null; + decorators: Array; + override: boolean; + parameter: FormalParameter; + readonly: boolean; + static: boolean; + parent?: Node; +} + +export interface FunctionBody extends Span { + type: "BlockStatement"; + body: Array; + parent?: Node; +} + +export interface ArrowFunctionExpression extends Span { + type: "ArrowFunctionExpression"; + expression: boolean; + async: boolean; + typeParameters?: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType?: TSTypeAnnotation | null; + body: FunctionBody | Expression; + id: null; + generator: false; + parent?: Node; +} + +export interface YieldExpression extends Span { + type: "YieldExpression"; + delegate: boolean; + argument: Expression | null; + parent?: Node; +} + +export interface Class extends Span { + type: ClassType; + decorators: Array; + id: BindingIdentifier | null; + typeParameters?: TSTypeParameterDeclaration | null; + superClass: Expression | null; + superTypeArguments?: TSTypeParameterInstantiation | null; + implements?: Array; + body: ClassBody; + abstract?: boolean; + declare?: boolean; + parent?: Node; +} + +export type ClassType = "ClassDeclaration" | "ClassExpression"; + +export interface ClassBody extends Span { + type: "ClassBody"; + body: Array; + parent?: Node; +} + +export type ClassElement = + | StaticBlock + | MethodDefinition + | PropertyDefinition + | AccessorProperty + | TSIndexSignature; + +export interface MethodDefinition extends Span { + type: MethodDefinitionType; + decorators: Array; + key: PropertyKey; + value: Function; + kind: MethodDefinitionKind; + computed: boolean; + static: boolean; + override?: boolean; + optional?: boolean; + accessibility?: TSAccessibility | null; + parent?: Node; +} + +export type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition"; + +export interface PropertyDefinition extends Span { + type: PropertyDefinitionType; + decorators: Array; + key: PropertyKey; + typeAnnotation?: TSTypeAnnotation | null; + value: Expression | null; + computed: boolean; + static: boolean; + declare?: boolean; + override?: boolean; + optional?: boolean; + definite?: boolean; + readonly?: boolean; + accessibility?: TSAccessibility | null; + parent?: Node; +} + +export type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition"; + +export type MethodDefinitionKind = "constructor" | "method" | "get" | "set"; + +export interface PrivateIdentifier extends Span { + type: "PrivateIdentifier"; + name: string; + parent?: Node; +} + +export interface StaticBlock extends Span { + type: "StaticBlock"; + body: Array; + parent?: Node; +} + +export type ModuleDeclaration = + | ImportDeclaration + | ExportAllDeclaration + | ExportDefaultDeclaration + | ExportNamedDeclaration + | TSExportAssignment + | TSNamespaceExportDeclaration; + +export type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty"; + +export interface AccessorProperty extends Span { + type: AccessorPropertyType; + decorators: Array; + key: PropertyKey; + typeAnnotation?: TSTypeAnnotation | null; + value: Expression | null; + computed: boolean; + static: boolean; + override?: boolean; + definite?: boolean; + accessibility?: TSAccessibility | null; + declare?: false; + optional?: false; + readonly?: false; + parent?: Node; +} + +export interface ImportExpression extends Span { + type: "ImportExpression"; + source: Expression; + options: Expression | null; + phase: ImportPhase | null; + parent?: Node; +} + +export interface ImportDeclaration extends Span { + type: "ImportDeclaration"; + specifiers: Array; + source: StringLiteral; + phase: ImportPhase | null; + attributes: Array; + importKind?: ImportOrExportKind; + parent?: Node; +} + +export type ImportPhase = "source" | "defer"; + +export type ImportDeclarationSpecifier = + | ImportSpecifier + | ImportDefaultSpecifier + | ImportNamespaceSpecifier; + +export interface ImportSpecifier extends Span { + type: "ImportSpecifier"; + imported: ModuleExportName; + local: BindingIdentifier; + importKind?: ImportOrExportKind; + parent?: Node; +} + +export interface ImportDefaultSpecifier extends Span { + type: "ImportDefaultSpecifier"; + local: BindingIdentifier; + parent?: Node; +} + +export interface ImportNamespaceSpecifier extends Span { + type: "ImportNamespaceSpecifier"; + local: BindingIdentifier; + parent?: Node; +} + +export interface ImportAttribute extends Span { + type: "ImportAttribute"; + key: ImportAttributeKey; + value: StringLiteral; + parent?: Node; +} + +export type ImportAttributeKey = IdentifierName | StringLiteral; + +export interface ExportNamedDeclaration extends Span { + type: "ExportNamedDeclaration"; + declaration: Declaration | null; + specifiers: Array; + source: StringLiteral | null; + exportKind?: ImportOrExportKind; + attributes: Array; + parent?: Node; +} + +export interface ExportDefaultDeclaration extends Span { + type: "ExportDefaultDeclaration"; + declaration: ExportDefaultDeclarationKind; + exportKind?: "value"; + parent?: Node; +} + +export interface ExportAllDeclaration extends Span { + type: "ExportAllDeclaration"; + exported: ModuleExportName | null; + source: StringLiteral; + attributes: Array; + exportKind?: ImportOrExportKind; + parent?: Node; +} + +export interface ExportSpecifier extends Span { + type: "ExportSpecifier"; + local: ModuleExportName; + exported: ModuleExportName; + exportKind?: ImportOrExportKind; + parent?: Node; +} + +export type ExportDefaultDeclarationKind = Function | Class | TSInterfaceDeclaration | Expression; + +export type ModuleExportName = IdentifierName | IdentifierReference | StringLiteral; + +export interface V8IntrinsicExpression extends Span { + type: "V8IntrinsicExpression"; + name: IdentifierName; + arguments: Array; + parent?: Node; +} + +export interface BooleanLiteral extends Span { + type: "Literal"; + value: boolean; + raw: string | null; + parent?: Node; +} + +export interface NullLiteral extends Span { + type: "Literal"; + value: null; + raw: "null" | null; + parent?: Node; +} + +export interface NumericLiteral extends Span { + type: "Literal"; + value: number; + raw: string | null; + parent?: Node; +} + +export interface StringLiteral extends Span { + type: "Literal"; + value: string; + raw: string | null; + parent?: Node; +} + +export interface BigIntLiteral extends Span { + type: "Literal"; + value: bigint; + raw: string | null; + bigint: string; + parent?: Node; +} + +export interface RegExpLiteral extends Span { + type: "Literal"; + value: RegExp | null; + raw: string | null; + regex: { pattern: string; flags: string }; + parent?: Node; +} + +export interface JSXElement extends Span { + type: "JSXElement"; + openingElement: JSXOpeningElement; + children: Array; + closingElement: JSXClosingElement | null; + parent?: Node; +} + +export interface JSXOpeningElement extends Span { + type: "JSXOpeningElement"; + name: JSXElementName; + typeArguments?: TSTypeParameterInstantiation | null; + attributes: Array; + selfClosing: boolean; + parent?: Node; +} + +export interface JSXClosingElement extends Span { + type: "JSXClosingElement"; + name: JSXElementName; + parent?: Node; +} + +export interface JSXFragment extends Span { + type: "JSXFragment"; + openingFragment: JSXOpeningFragment; + children: Array; + closingFragment: JSXClosingFragment; + parent?: Node; +} + +export interface JSXOpeningFragment extends Span { + type: "JSXOpeningFragment"; + attributes?: []; + selfClosing?: false; + parent?: Node; +} + +export interface JSXClosingFragment extends Span { + type: "JSXClosingFragment"; + parent?: Node; +} + +export type JSXElementName = JSXIdentifier | JSXNamespacedName | JSXMemberExpression; + +export interface JSXNamespacedName extends Span { + type: "JSXNamespacedName"; + namespace: JSXIdentifier; + name: JSXIdentifier; + parent?: Node; +} + +export interface JSXMemberExpression extends Span { + type: "JSXMemberExpression"; + object: JSXMemberExpressionObject; + property: JSXIdentifier; + parent?: Node; +} + +export type JSXMemberExpressionObject = JSXIdentifier | JSXMemberExpression; + +export interface JSXExpressionContainer extends Span { + type: "JSXExpressionContainer"; + expression: JSXExpression; + parent?: Node; +} + +export type JSXExpression = JSXEmptyExpression | Expression; + +export interface JSXEmptyExpression extends Span { + type: "JSXEmptyExpression"; + parent?: Node; +} + +export type JSXAttributeItem = JSXAttribute | JSXSpreadAttribute; + +export interface JSXAttribute extends Span { + type: "JSXAttribute"; + name: JSXAttributeName; + value: JSXAttributeValue | null; + parent?: Node; +} + +export interface JSXSpreadAttribute extends Span { + type: "JSXSpreadAttribute"; + argument: Expression; + parent?: Node; +} + +export type JSXAttributeName = JSXIdentifier | JSXNamespacedName; + +export type JSXAttributeValue = StringLiteral | JSXExpressionContainer | JSXElement | JSXFragment; + +export interface JSXIdentifier extends Span { + type: "JSXIdentifier"; + name: string; + parent?: Node; +} + +export type JSXChild = JSXText | JSXElement | JSXFragment | JSXExpressionContainer | JSXSpreadChild; + +export interface JSXSpreadChild extends Span { + type: "JSXSpreadChild"; + expression: Expression; + parent?: Node; +} + +export interface JSXText extends Span { + type: "JSXText"; + value: string; + raw: string | null; + parent?: Node; +} + +export interface TSThisParameter extends Span { + type: "Identifier"; + decorators: []; + name: "this"; + optional: false; + typeAnnotation: TSTypeAnnotation | null; + parent?: Node; +} + +export interface TSEnumDeclaration extends Span { + type: "TSEnumDeclaration"; + id: BindingIdentifier; + body: TSEnumBody; + const: boolean; + declare: boolean; + parent?: Node; +} + +export interface TSEnumBody extends Span { + type: "TSEnumBody"; + members: Array; + parent?: Node; +} + +export interface TSEnumMember extends Span { + type: "TSEnumMember"; + id: TSEnumMemberName; + initializer: Expression | null; + computed: boolean; + parent?: Node; +} + +export type TSEnumMemberName = IdentifierName | StringLiteral | TemplateLiteral; + +export interface TSTypeAnnotation extends Span { + type: "TSTypeAnnotation"; + typeAnnotation: TSType; + parent?: Node; +} + +export interface TSLiteralType extends Span { + type: "TSLiteralType"; + literal: TSLiteral; + parent?: Node; +} + +export type TSLiteral = + | BooleanLiteral + | NumericLiteral + | BigIntLiteral + | StringLiteral + | TemplateLiteral + | UnaryExpression; + +export type TSType = + | TSAnyKeyword + | TSBigIntKeyword + | TSBooleanKeyword + | TSIntrinsicKeyword + | TSNeverKeyword + | TSNullKeyword + | TSNumberKeyword + | TSObjectKeyword + | TSStringKeyword + | TSSymbolKeyword + | TSUndefinedKeyword + | TSUnknownKeyword + | TSVoidKeyword + | TSArrayType + | TSConditionalType + | TSConstructorType + | TSFunctionType + | TSImportType + | TSIndexedAccessType + | TSInferType + | TSIntersectionType + | TSLiteralType + | TSMappedType + | TSNamedTupleMember + | TSTemplateLiteralType + | TSThisType + | TSTupleType + | TSTypeLiteral + | TSTypeOperator + | TSTypePredicate + | TSTypeQuery + | TSTypeReference + | TSUnionType + | TSParenthesizedType + | JSDocNullableType + | JSDocNonNullableType + | JSDocUnknownType; + +export interface TSConditionalType extends Span { + type: "TSConditionalType"; + checkType: TSType; + extendsType: TSType; + trueType: TSType; + falseType: TSType; + parent?: Node; +} + +export interface TSUnionType extends Span { + type: "TSUnionType"; + types: Array; + parent?: Node; +} + +export interface TSIntersectionType extends Span { + type: "TSIntersectionType"; + types: Array; + parent?: Node; +} + +export interface TSParenthesizedType extends Span { + type: "TSParenthesizedType"; + typeAnnotation: TSType; + parent?: Node; +} + +export interface TSTypeOperator extends Span { + type: "TSTypeOperator"; + operator: TSTypeOperatorOperator; + typeAnnotation: TSType; + parent?: Node; +} + +export type TSTypeOperatorOperator = "keyof" | "unique" | "readonly"; + +export interface TSArrayType extends Span { + type: "TSArrayType"; + elementType: TSType; + parent?: Node; +} + +export interface TSIndexedAccessType extends Span { + type: "TSIndexedAccessType"; + objectType: TSType; + indexType: TSType; + parent?: Node; +} + +export interface TSTupleType extends Span { + type: "TSTupleType"; + elementTypes: Array; + parent?: Node; +} + +export interface TSNamedTupleMember extends Span { + type: "TSNamedTupleMember"; + label: IdentifierName; + elementType: TSTupleElement; + optional: boolean; + parent?: Node; +} + +export interface TSOptionalType extends Span { + type: "TSOptionalType"; + typeAnnotation: TSType; + parent?: Node; +} + +export interface TSRestType extends Span { + type: "TSRestType"; + typeAnnotation: TSType; + parent?: Node; +} + +export type TSTupleElement = TSOptionalType | TSRestType | TSType; + +export interface TSAnyKeyword extends Span { + type: "TSAnyKeyword"; + parent?: Node; +} + +export interface TSStringKeyword extends Span { + type: "TSStringKeyword"; + parent?: Node; +} + +export interface TSBooleanKeyword extends Span { + type: "TSBooleanKeyword"; + parent?: Node; +} + +export interface TSNumberKeyword extends Span { + type: "TSNumberKeyword"; + parent?: Node; +} + +export interface TSNeverKeyword extends Span { + type: "TSNeverKeyword"; + parent?: Node; +} + +export interface TSIntrinsicKeyword extends Span { + type: "TSIntrinsicKeyword"; + parent?: Node; +} + +export interface TSUnknownKeyword extends Span { + type: "TSUnknownKeyword"; + parent?: Node; +} + +export interface TSNullKeyword extends Span { + type: "TSNullKeyword"; + parent?: Node; +} + +export interface TSUndefinedKeyword extends Span { + type: "TSUndefinedKeyword"; + parent?: Node; +} + +export interface TSVoidKeyword extends Span { + type: "TSVoidKeyword"; + parent?: Node; +} + +export interface TSSymbolKeyword extends Span { + type: "TSSymbolKeyword"; + parent?: Node; +} + +export interface TSThisType extends Span { + type: "TSThisType"; + parent?: Node; +} + +export interface TSObjectKeyword extends Span { + type: "TSObjectKeyword"; + parent?: Node; +} + +export interface TSBigIntKeyword extends Span { + type: "TSBigIntKeyword"; + parent?: Node; +} + +export interface TSTypeReference extends Span { + type: "TSTypeReference"; + typeName: TSTypeName; + typeArguments: TSTypeParameterInstantiation | null; + parent?: Node; +} + +export type TSTypeName = IdentifierReference | TSQualifiedName | ThisExpression; + +export interface TSQualifiedName extends Span { + type: "TSQualifiedName"; + left: TSTypeName; + right: IdentifierName; + parent?: Node; +} + +export interface TSTypeParameterInstantiation extends Span { + type: "TSTypeParameterInstantiation"; + params: Array; + parent?: Node; +} + +export interface TSTypeParameter extends Span { + type: "TSTypeParameter"; + name: BindingIdentifier; + constraint: TSType | null; + default: TSType | null; + in: boolean; + out: boolean; + const: boolean; + parent?: Node; +} + +export interface TSTypeParameterDeclaration extends Span { + type: "TSTypeParameterDeclaration"; + params: Array; + parent?: Node; +} + +export interface TSTypeAliasDeclaration extends Span { + type: "TSTypeAliasDeclaration"; + id: BindingIdentifier; + typeParameters: TSTypeParameterDeclaration | null; + typeAnnotation: TSType; + declare: boolean; + parent?: Node; +} + +export type TSAccessibility = "private" | "protected" | "public"; + +export interface TSClassImplements extends Span { + type: "TSClassImplements"; + expression: IdentifierReference | ThisExpression | MemberExpression; + typeArguments: TSTypeParameterInstantiation | null; + parent?: Node; +} + +export interface TSInterfaceDeclaration extends Span { + type: "TSInterfaceDeclaration"; + id: BindingIdentifier; + typeParameters: TSTypeParameterDeclaration | null; + extends: Array; + body: TSInterfaceBody; + declare: boolean; + parent?: Node; +} + +export interface TSInterfaceBody extends Span { + type: "TSInterfaceBody"; + body: Array; + parent?: Node; +} + +export interface TSPropertySignature extends Span { + type: "TSPropertySignature"; + computed: boolean; + optional: boolean; + readonly: boolean; + key: PropertyKey; + typeAnnotation: TSTypeAnnotation | null; + accessibility: null; + static: false; + parent?: Node; +} + +export type TSSignature = + | TSIndexSignature + | TSPropertySignature + | TSCallSignatureDeclaration + | TSConstructSignatureDeclaration + | TSMethodSignature; + +export interface TSIndexSignature extends Span { + type: "TSIndexSignature"; + parameters: Array; + typeAnnotation: TSTypeAnnotation; + readonly: boolean; + static: boolean; + accessibility: null; + parent?: Node; +} + +export interface TSCallSignatureDeclaration extends Span { + type: "TSCallSignatureDeclaration"; + typeParameters: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType: TSTypeAnnotation | null; + parent?: Node; +} + +export type TSMethodSignatureKind = "method" | "get" | "set"; + +export interface TSMethodSignature extends Span { + type: "TSMethodSignature"; + key: PropertyKey; + computed: boolean; + optional: boolean; + kind: TSMethodSignatureKind; + typeParameters: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType: TSTypeAnnotation | null; + accessibility: null; + readonly: false; + static: false; + parent?: Node; +} + +export interface TSConstructSignatureDeclaration extends Span { + type: "TSConstructSignatureDeclaration"; + typeParameters: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType: TSTypeAnnotation | null; + parent?: Node; +} + +export interface TSIndexSignatureName extends Span { + type: "Identifier"; + decorators: []; + name: string; + optional: false; + typeAnnotation: TSTypeAnnotation; + parent?: Node; +} + +export interface TSInterfaceHeritage extends Span { + type: "TSInterfaceHeritage"; + expression: Expression; + typeArguments: TSTypeParameterInstantiation | null; + parent?: Node; +} + +export interface TSTypePredicate extends Span { + type: "TSTypePredicate"; + parameterName: TSTypePredicateName; + asserts: boolean; + typeAnnotation: TSTypeAnnotation | null; + parent?: Node; +} + +export type TSTypePredicateName = IdentifierName | TSThisType; + +export type TSModuleDeclarationKind = "module" | "namespace"; + +export interface TSModuleDeclaration extends Span { + type: "TSModuleDeclaration"; + id: BindingIdentifier | StringLiteral | TSQualifiedName; + body: TSModuleBlock | null; + kind: TSModuleDeclarationKind; + declare: boolean; + global: false; + parent?: Node; +} + +export interface TSGlobalDeclaration extends Span { + type: "TSModuleDeclaration"; + id: IdentifierName; + body: TSModuleBlock; + kind: "global"; + declare: boolean; + global: true; + parent?: Node; +} + +export interface TSModuleBlock extends Span { + type: "TSModuleBlock"; + body: Array; + parent?: Node; +} + +export interface TSTypeLiteral extends Span { + type: "TSTypeLiteral"; + members: Array; + parent?: Node; +} + +export interface TSInferType extends Span { + type: "TSInferType"; + typeParameter: TSTypeParameter; + parent?: Node; +} + +export interface TSTypeQuery extends Span { + type: "TSTypeQuery"; + exprName: TSTypeQueryExprName; + typeArguments: TSTypeParameterInstantiation | null; + parent?: Node; +} + +export type TSTypeQueryExprName = TSImportType | TSTypeName; + +export interface TSImportType extends Span { + type: "TSImportType"; + source: StringLiteral; + options: ObjectExpression | null; + qualifier: TSImportTypeQualifier | null; + typeArguments: TSTypeParameterInstantiation | null; + parent?: Node; +} + +export type TSImportTypeQualifier = IdentifierName | TSImportTypeQualifiedName; + +export interface TSImportTypeQualifiedName extends Span { + type: "TSQualifiedName"; + left: TSImportTypeQualifier; + right: IdentifierName; + parent?: Node; +} + +export interface TSFunctionType extends Span { + type: "TSFunctionType"; + typeParameters: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType: TSTypeAnnotation; + parent?: Node; +} + +export interface TSConstructorType extends Span { + type: "TSConstructorType"; + abstract: boolean; + typeParameters: TSTypeParameterDeclaration | null; + params: ParamPattern[]; + returnType: TSTypeAnnotation; + parent?: Node; +} + +export interface TSMappedType extends Span { + type: "TSMappedType"; + key: BindingIdentifier; + constraint: TSType; + nameType: TSType | null; + typeAnnotation: TSType | null; + optional: TSMappedTypeModifierOperator | false; + readonly: TSMappedTypeModifierOperator | null; + parent?: Node; +} + +export type TSMappedTypeModifierOperator = true | "+" | "-"; + +export interface TSTemplateLiteralType extends Span { + type: "TSTemplateLiteralType"; + quasis: Array; + types: Array; + parent?: Node; +} + +export interface TSAsExpression extends Span { + type: "TSAsExpression"; + expression: Expression; + typeAnnotation: TSType; + parent?: Node; +} + +export interface TSSatisfiesExpression extends Span { + type: "TSSatisfiesExpression"; + expression: Expression; + typeAnnotation: TSType; + parent?: Node; +} + +export interface TSTypeAssertion extends Span { + type: "TSTypeAssertion"; + typeAnnotation: TSType; + expression: Expression; + parent?: Node; +} + +export interface TSImportEqualsDeclaration extends Span { + type: "TSImportEqualsDeclaration"; + id: BindingIdentifier; + moduleReference: TSModuleReference; + importKind: ImportOrExportKind; + parent?: Node; +} + +export type TSModuleReference = TSExternalModuleReference | IdentifierReference | TSQualifiedName; + +export interface TSExternalModuleReference extends Span { + type: "TSExternalModuleReference"; + expression: StringLiteral; + parent?: Node; +} + +export interface TSNonNullExpression extends Span { + type: "TSNonNullExpression"; + expression: Expression; + parent?: Node; +} + +export interface Decorator extends Span { + type: "Decorator"; + expression: Expression; + parent?: Node; +} + +export interface TSExportAssignment extends Span { + type: "TSExportAssignment"; + expression: Expression; + parent?: Node; +} + +export interface TSNamespaceExportDeclaration extends Span { + type: "TSNamespaceExportDeclaration"; + id: IdentifierName; + parent?: Node; +} + +export interface TSInstantiationExpression extends Span { + type: "TSInstantiationExpression"; + expression: Expression; + typeArguments: TSTypeParameterInstantiation; + parent?: Node; +} + +export type ImportOrExportKind = "value" | "type"; + +export interface JSDocNullableType extends Span { + type: "TSJSDocNullableType"; + typeAnnotation: TSType; + postfix: boolean; + parent?: Node; +} + +export interface JSDocNonNullableType extends Span { + type: "TSJSDocNonNullableType"; + typeAnnotation: TSType; + postfix: boolean; + parent?: Node; +} + +export interface JSDocUnknownType extends Span { + type: "TSJSDocUnknownType"; + parent?: Node; +} + +export type ModuleKind = "script" | "module" | "commonjs"; + +export interface Span { + start: number; + end: number; + range?: [number, number]; +} + +export type AssignmentOperator = + | "=" + | "+=" + | "-=" + | "*=" + | "/=" + | "%=" + | "**=" + | "<<=" + | ">>=" + | ">>>=" + | "|=" + | "^=" + | "&=" + | "||=" + | "&&=" + | "??="; + +export type BinaryOperator = + | "==" + | "!=" + | "===" + | "!==" + | "<" + | "<=" + | ">" + | ">=" + | "+" + | "-" + | "*" + | "/" + | "%" + | "**" + | "<<" + | ">>" + | ">>>" + | "|" + | "^" + | "&" + | "in" + | "instanceof"; + +export type LogicalOperator = "||" | "&&" | "??"; + +export type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete"; + +export type UpdateOperator = "++" | "--"; + +export type Node = + | Program + | IdentifierName + | IdentifierReference + | BindingIdentifier + | LabelIdentifier + | ThisExpression + | ArrayExpression + | ObjectExpression + | ObjectProperty + | TemplateLiteral + | TaggedTemplateExpression + | TemplateElement + | ComputedMemberExpression + | StaticMemberExpression + | PrivateFieldExpression + | CallExpression + | NewExpression + | MetaProperty + | SpreadElement + | UpdateExpression + | UnaryExpression + | BinaryExpression + | PrivateInExpression + | LogicalExpression + | ConditionalExpression + | AssignmentExpression + | ArrayAssignmentTarget + | ObjectAssignmentTarget + | AssignmentTargetRest + | AssignmentTargetWithDefault + | AssignmentTargetPropertyIdentifier + | AssignmentTargetPropertyProperty + | SequenceExpression + | Super + | AwaitExpression + | ChainExpression + | ParenthesizedExpression + | Directive + | Hashbang + | BlockStatement + | VariableDeclaration + | VariableDeclarator + | EmptyStatement + | ExpressionStatement + | IfStatement + | DoWhileStatement + | WhileStatement + | ForStatement + | ForInStatement + | ForOfStatement + | ContinueStatement + | BreakStatement + | ReturnStatement + | WithStatement + | SwitchStatement + | SwitchCase + | LabeledStatement + | ThrowStatement + | TryStatement + | CatchClause + | DebuggerStatement + | AssignmentPattern + | ObjectPattern + | BindingProperty + | ArrayPattern + | BindingRestElement + | Function + | FunctionBody + | ArrowFunctionExpression + | YieldExpression + | Class + | ClassBody + | MethodDefinition + | PropertyDefinition + | PrivateIdentifier + | StaticBlock + | AccessorProperty + | ImportExpression + | ImportDeclaration + | ImportSpecifier + | ImportDefaultSpecifier + | ImportNamespaceSpecifier + | ImportAttribute + | ExportNamedDeclaration + | ExportDefaultDeclaration + | ExportAllDeclaration + | ExportSpecifier + | V8IntrinsicExpression + | BooleanLiteral + | NullLiteral + | NumericLiteral + | StringLiteral + | BigIntLiteral + | RegExpLiteral + | JSXElement + | JSXOpeningElement + | JSXClosingElement + | JSXFragment + | JSXOpeningFragment + | JSXClosingFragment + | JSXNamespacedName + | JSXMemberExpression + | JSXExpressionContainer + | JSXEmptyExpression + | JSXAttribute + | JSXSpreadAttribute + | JSXIdentifier + | JSXSpreadChild + | JSXText + | TSThisParameter + | TSEnumDeclaration + | TSEnumBody + | TSEnumMember + | TSTypeAnnotation + | TSLiteralType + | TSConditionalType + | TSUnionType + | TSIntersectionType + | TSParenthesizedType + | TSTypeOperator + | TSArrayType + | TSIndexedAccessType + | TSTupleType + | TSNamedTupleMember + | TSOptionalType + | TSRestType + | TSAnyKeyword + | TSStringKeyword + | TSBooleanKeyword + | TSNumberKeyword + | TSNeverKeyword + | TSIntrinsicKeyword + | TSUnknownKeyword + | TSNullKeyword + | TSUndefinedKeyword + | TSVoidKeyword + | TSSymbolKeyword + | TSThisType + | TSObjectKeyword + | TSBigIntKeyword + | TSTypeReference + | TSQualifiedName + | TSTypeParameterInstantiation + | TSTypeParameter + | TSTypeParameterDeclaration + | TSTypeAliasDeclaration + | TSClassImplements + | TSInterfaceDeclaration + | TSInterfaceBody + | TSPropertySignature + | TSIndexSignature + | TSCallSignatureDeclaration + | TSMethodSignature + | TSConstructSignatureDeclaration + | TSIndexSignatureName + | TSInterfaceHeritage + | TSTypePredicate + | TSModuleDeclaration + | TSGlobalDeclaration + | TSModuleBlock + | TSTypeLiteral + | TSInferType + | TSTypeQuery + | TSImportType + | TSImportTypeQualifiedName + | TSFunctionType + | TSConstructorType + | TSMappedType + | TSTemplateLiteralType + | TSAsExpression + | TSSatisfiesExpression + | TSTypeAssertion + | TSImportEqualsDeclaration + | TSExternalModuleReference + | TSNonNullExpression + | Decorator + | TSExportAssignment + | TSNamespaceExportDeclaration + | TSInstantiationExpression + | JSDocNullableType + | JSDocNonNullableType + | JSDocUnknownType + | ParamPattern; diff --git a/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/README.md b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/README.md new file mode 100644 index 00000000..deea4245 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/README.md @@ -0,0 +1,3 @@ +# `@rolldown/binding-linux-x64-gnu` + +This is the **x86_64-unknown-linux-gnu** binary for `@rolldown/binding` diff --git a/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/package.json b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/package.json new file mode 100644 index 00000000..d68a72e2 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/package.json @@ -0,0 +1,43 @@ +{ + "name": "@rolldown/binding-linux-x64-gnu", + "version": "1.2.11", + "cpu": [ + "x64" + ], + "main": "rolldown-binding.linux-x64-gnu.node", + "files": [ + "rolldown-binding.linux-x64-gnu.node" + ], + "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.", + "keywords": [ + "bundler", + "esbuild", + "parcel", + "rolldown", + "rollup", + "webpack" + ], + "homepage": "https://rolldown.rs/", + "license": "MIT", + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/rolldown/rolldown.git", + "directory": "packages/rolldown" + }, + "bugs": { + "url": "https://github.com/rolldown/rolldown/issues" + }, + "publishConfig": { + "registry": "https://registry.npmjs.org/", + "access": "public" + }, + "os": [ + "linux" + ], + "libc": [ + "glibc" + ] +} diff --git a/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/rolldown-binding.linux-x64-gnu.node b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/rolldown-binding.linux-x64-gnu.node new file mode 100644 index 00000000..752ad22a Binary files /dev/null and b/backend/node_modules/.pnpm/@rolldown+binding-linux-x64-gnu@1.2.11/node_modules/@rolldown/binding-linux-x64-gnu/rolldown-binding.linux-x64-gnu.node differ diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/LICENSE b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/LICENSE new file mode 100644 index 00000000..708388ce --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026-present, rolldown/plugins repository contributors + +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/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/README.md b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/README.md new file mode 100644 index 00000000..7d4d5a58 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/README.md @@ -0,0 +1,145 @@ +# @rolldown/pluginutils [![npm](https://img.shields.io/npm/v/@rolldown/pluginutils.svg)](https://npmx.dev/package/@rolldown/pluginutils) + +Plugin utilities for [Rolldown](https://rolldown.rs). + +Includes regex helpers for plugin hook filters, composable filter expressions, and a helper for filtering out Vite-serve-only plugins. + +## Install + +```bash +pnpm add -D @rolldown/pluginutils +``` + +## Usage + +```ts +import { exactRegex, prefixRegex, makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils' +``` + +All filter helpers are also exposed via the `/filter` subpath: + +```ts +import { and, or, id, include } from '@rolldown/pluginutils/filter' +``` + +## Regex helpers + +### `exactRegex` + +- **Type:** `(str: string, flags?: string) => RegExp` + +Constructs a `RegExp` that matches the exact string specified. Useful as a plugin hook filter. + +```ts +import { exactRegex } from '@rolldown/pluginutils' + +const plugin = { + name: 'plugin', + resolveId: { + filter: { id: exactRegex('foo') }, + handler(id) {}, // only called for `foo` + }, +} +``` + +### `prefixRegex` + +- **Type:** `(str: string, flags?: string) => RegExp` + +Constructs a `RegExp` that matches values starting with the specified prefix. + +```ts +import { prefixRegex } from '@rolldown/pluginutils' + +const plugin = { + name: 'plugin', + resolveId: { + filter: { id: prefixRegex('foo') }, + handler(id) {}, // called for IDs starting with `foo` + }, +} +``` + +### `makeIdFiltersToMatchWithQuery` + +- **Type:** `(input: string | RegExp | (string | RegExp)[]) => string | RegExp | (string | RegExp)[]` + +Converts an id filter so that it also matches ids that include a query string. + +```ts +import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils' + +const plugin = { + name: 'plugin', + transform: { + filter: { id: makeIdFiltersToMatchWithQuery(['**/*.js', /\.ts$/]) }, + // Matches: + // foo.js, foo.js?foo, foo.txt?foo.js, + // foo.ts, foo.ts?foo, foo.txt?foo.ts + handler(code, id) {}, + }, +} +``` + +## Composable filters + +[Composable filter expressions](https://rolldown.rs/apis/plugin-api/hook-filters#composable-filters) for use cases where a simple `id`/`include`/`exclude` is not enough. For example, when a plugin needs to combine `id`, `moduleType`, `code`, and `query` conditions. + +```ts +import { and, code, id, include, interpreter, moduleType, or } from '@rolldown/pluginutils' + +const expr = include(and(or(id(/\.tsx?$/), id(/\.jsx?$/)), moduleType('tsx'), code(/import React/))) + +interpreter(expr, sourceCode, sourceId, 'tsx') // boolean +``` + +### Builders + +| Builder | Description | +| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `and(...exprs)` | All operands must match. | +| `or(...exprs)` | At least one operand must match. | +| `not(expr)` | Negates the operand. | +| `id(pattern, params?)` | Match the module id. `pattern` is `string` or `RegExp`. `params.cleanUrl` strips the query/hash before matching. | +| `importerId(pattern, params?)` | Match the importer's id. Same shape as `id`. | +| `moduleType(type)` | Match Rolldown's module type (`'js'`, `'jsx'`, `'ts'`, `'tsx'`, `'json'`, `'text'`, `'base64'`, `'dataurl'`, `'binary'`, `'empty'`, or a custom string). | +| `code(pattern)` | Match the module source. `string` matches with `includes`; `RegExp` with `test`. | +| `query(key, pattern)` | Match a single query parameter. `pattern` is `boolean` (key presence/truthiness), `string` (exact value), or `RegExp` (value pattern). | +| `queries(obj)` | Shorthand for `and(...)` over multiple `query` entries. | +| `include(expr)` | Top-level wrapper marking `expr` as an inclusion rule. | +| `exclude(expr)` | Top-level wrapper marking `expr` as an exclusion rule. | + +### `interpreter` + +- **Type:** `(exprs, code?, id?, moduleType?, importerId?) => boolean` + +Evaluates one or more top-level expressions against the given inputs. Returns `true` when at least one `include` matches and no `exclude` matches; when no `include` is present, defaults to `true` unless an `exclude` matches. + +The argument required by each expression must be provided. For example, evaluating an `id(...)` expression without passing `id` will throw. + +## `filterVitePlugins` + +- **Type:** `(plugins: T | T[] | null | undefined | false) => T[]` + +Removes Vite plugins that target the dev server (`apply: 'serve'`) from a (possibly nested) plugin array. Plugins whose `apply` is a function are invoked with a `command: 'build'` context to decide. Useful when reusing a Vite plugin array inside a Rolldown config. + +```ts +import { defineConfig } from 'rolldown' +import { filterVitePlugins } from '@rolldown/pluginutils' +import viteReact from '@vitejs/plugin-react' + +export default defineConfig({ + plugins: filterVitePlugins([ + viteReact(), + { + name: 'dev-only', + apply: 'serve', // filtered out + // ... + }, + ]), +}) +``` + +## License + +MIT diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs new file mode 100644 index 00000000..e3bba279 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter-B_mD-HGz.mjs @@ -0,0 +1,323 @@ +//#region src/utils.ts +const postfixRE = /[?#].*$/; +function cleanUrl(url) { + return url.replace(postfixRE, ""); +} +function extractQueryWithoutFragment(url) { + const questionMarkIndex = url.indexOf("?"); + if (questionMarkIndex === -1) return ""; + const fragmentIndex = url.indexOf("#", questionMarkIndex); + if (fragmentIndex === -1) return url.substring(questionMarkIndex); + else return url.substring(questionMarkIndex, fragmentIndex); +} +//#endregion +//#region src/filter/composable-filters.ts +var And = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`And` expects at least one operand"); + this.args = args; + this.kind = "and"; + } +}; +var Or = class { + kind; + args; + constructor(...args) { + if (args.length === 0) throw new Error("`Or` expects at least one operand"); + this.args = args; + this.kind = "or"; + } +}; +var Not = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "not"; + } +}; +var Id = class { + kind; + pattern; + params; + constructor(pattern, params) { + this.pattern = pattern; + this.kind = "id"; + this.params = params ?? { cleanUrl: false }; + } +}; +var ImporterId = class { + kind; + pattern; + params; + constructor(pattern, params) { + this.pattern = pattern; + this.kind = "importerId"; + this.params = params ?? { cleanUrl: false }; + } +}; +var ModuleType = class { + kind; + pattern; + constructor(pattern) { + this.pattern = pattern; + this.kind = "moduleType"; + } +}; +var Code = class { + kind; + pattern; + constructor(expr) { + this.pattern = expr; + this.kind = "code"; + } +}; +var Query = class { + kind; + key; + pattern; + constructor(key, pattern) { + this.pattern = pattern; + this.key = key; + this.kind = "query"; + } +}; +var Include = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "include"; + } +}; +var Exclude = class { + kind; + expr; + constructor(expr) { + this.expr = expr; + this.kind = "exclude"; + } +}; +function and(...args) { + return new And(...args); +} +function or(...args) { + return new Or(...args); +} +function not(expr) { + return new Not(expr); +} +function id(pattern, params) { + return new Id(pattern, params); +} +function importerId(pattern, params) { + return new ImporterId(pattern, params); +} +function moduleType(pattern) { + return new ModuleType(pattern); +} +function code(pattern) { + return new Code(pattern); +} +function query(key, pattern) { + return new Query(key, pattern); +} +function include(expr) { + return new Include(expr); +} +function exclude(expr) { + return new Exclude(expr); +} +/** +* convert a queryObject to FilterExpression like +* ```js +* and(query(k1, v1), query(k2, v2)) +* ``` +* @param queryFilterObject The query filter object needs to be matched. +* @returns a `And` FilterExpression +*/ +function queries(queryFilter) { + return and(...Object.entries(queryFilter).map(([key, value]) => { + return new Query(key, value); + })); +} +function interpreter(exprs, code, id, moduleType, importerId) { + let arr = []; + if (Array.isArray(exprs)) arr = exprs; + else arr = [exprs]; + return interpreterImpl(arr, code, id, moduleType, importerId); +} +function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) { + let hasInclude = false; + for (const e of expr) switch (e.kind) { + case "include": + hasInclude = true; + if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return true; + break; + case "exclude": + if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) return false; + break; + } + return !hasInclude; +} +function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) { + switch (expr.kind) { + case "and": return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx)); + case "or": return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx)); + case "not": return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx); + case "id": { + if (id === void 0) throw new Error("`id` is required for `id` expression"); + let idToMatch = id; + if (expr.params.cleanUrl) idToMatch = cleanUrl(idToMatch); + return typeof expr.pattern === "string" ? idToMatch === expr.pattern : expr.pattern.test(idToMatch); + } + case "importerId": { + if (importerId === void 0) return false; + let importerIdToMatch = importerId; + if (expr.params.cleanUrl) importerIdToMatch = cleanUrl(importerIdToMatch); + return typeof expr.pattern === "string" ? importerIdToMatch === expr.pattern : expr.pattern.test(importerIdToMatch); + } + case "moduleType": + if (moduleType === void 0) throw new Error("`moduleType` is required for `moduleType` expression"); + return moduleType === expr.pattern; + case "code": + if (code === void 0) throw new Error("`code` is required for `code` expression"); + return typeof expr.pattern === "string" ? code.includes(expr.pattern) : expr.pattern.test(code); + case "query": { + if (id === void 0) throw new Error("`id` is required for `Query` expression"); + if (!ctx.urlSearchParamsCache) { + let queryString = extractQueryWithoutFragment(id); + ctx.urlSearchParamsCache = new URLSearchParams(queryString); + } + let urlParams = ctx.urlSearchParamsCache; + if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key); + else return !urlParams.has(expr.key); + else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern; + else return expr.pattern.test(urlParams.get(expr.key) ?? ""); + } + default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`); + } +} +//#endregion +//#region src/filter/filter-vite-plugins.ts +/** +* Filters out Vite plugins that have `apply: 'serve'` set. +* +* Since Rolldown operates in build mode, plugins marked with `apply: 'serve'` +* are intended only for Vite's dev server and should be excluded from the build process. +* +* @param plugins - Array of plugins (can include nested arrays) +* @returns Filtered array with serve-only plugins removed +* +* @example +* ```ts +* import { defineConfig } from 'rolldown'; +* import { filterVitePlugins } from '@rolldown/pluginutils'; +* import viteReact from '@vitejs/plugin-react'; +* +* export default defineConfig({ +* plugins: filterVitePlugins([ +* viteReact(), +* { +* name: 'dev-only', +* apply: 'serve', // This will be filtered out +* // ... +* } +* ]) +* }); +* ``` +*/ +function filterVitePlugins(plugins) { + if (!plugins) return []; + const pluginArray = Array.isArray(plugins) ? plugins : [plugins]; + const result = []; + for (const plugin of pluginArray) { + if (!plugin) continue; + if (Array.isArray(plugin)) { + result.push(...filterVitePlugins(plugin)); + continue; + } + const pluginWithApply = plugin; + if ("apply" in pluginWithApply) { + const applyValue = pluginWithApply.apply; + if (typeof applyValue === "function") try { + if (applyValue({}, { + command: "build", + mode: "production" + })) result.push(plugin); + } catch { + result.push(plugin); + } + else if (applyValue === "serve") continue; + else result.push(plugin); + } else result.push(plugin); + } + return result; +} +//#endregion +//#region src/filter/simple-filters.ts +/** +* Constructs a RegExp that matches the exact string specified. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { exactRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: exactRegex('foo') }, +* handler(id) {} // will only be called for `foo` +* } +* } +* ``` +*/ +function exactRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}$`, flags); +} +/** +* Constructs a RegExp that matches a value that has the specified prefix. +* +* This is useful for plugin hook filters. +* +* @param str the string to match. +* @param flags flags for the RegExp. +* +* @example +* ```ts +* import { prefixRegex } from '@rolldown/pluginutils'; +* const plugin = { +* name: 'plugin', +* resolveId: { +* filter: { id: prefixRegex('foo') }, +* handler(id) {} // will only be called for IDs starting with `foo` +* } +* } +* ``` +*/ +function prefixRegex(str, flags) { + return new RegExp(`^${escapeRegex(str)}`, flags); +} +const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g; +function escapeRegex(str) { + return str.replace(escapeRegexRE, "\\$&"); +} +function makeIdFiltersToMatchWithQuery(input) { + if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input); + return input.map((i) => makeIdFilterToMatchWithQuery(i)); +} +function makeIdFilterToMatchWithQuery(input) { + if (typeof input === "string") return `${input}{?*,}`; + return makeRegexIdFilterToMatchWithQuery(input); +} +function makeRegexIdFilterToMatchWithQuery(input) { + return new RegExp(input.source.replace(/(?(plugins: T | T[] | null | undefined | false): T[]; +//#endregion +//#region src/filter/simple-filters.d.ts +/** + * Constructs a RegExp that matches the exact string specified. + * + * This is useful for plugin hook filters. + * + * @param str the string to match. + * @param flags flags for the RegExp. + * + * @example + * ```ts + * import { exactRegex } from '@rolldown/pluginutils'; + * const plugin = { + * name: 'plugin', + * resolveId: { + * filter: { id: exactRegex('foo') }, + * handler(id) {} // will only be called for `foo` + * } + * } + * ``` + */ +declare function exactRegex(str: string, flags?: string): RegExp; +/** + * Constructs a RegExp that matches a value that has the specified prefix. + * + * This is useful for plugin hook filters. + * + * @param str the string to match. + * @param flags flags for the RegExp. + * + * @example + * ```ts + * import { prefixRegex } from '@rolldown/pluginutils'; + * const plugin = { + * name: 'plugin', + * resolveId: { + * filter: { id: prefixRegex('foo') }, + * handler(id) {} // will only be called for IDs starting with `foo` + * } + * } + * ``` + */ +declare function prefixRegex(str: string, flags?: string): RegExp; +type WidenString = T extends string ? string : T; +/** + * Converts a id filter to match with an id with a query. + * + * @param input the id filters to convert. + * + * @example + * ```ts + * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils'; + * const plugin = { + * name: 'plugin', + * transform: { + * filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) }, + * // The handler will be called for IDs like: + * // - foo.js + * // - foo.js?foo + * // - foo.txt?foo.js + * // - foo.ts + * // - foo.ts?foo + * // - foo.txt?foo.ts + * handler(code, id) {} + * } + * } + * ``` + */ +declare function makeIdFiltersToMatchWithQuery(input: T): WidenString; +declare function makeIdFiltersToMatchWithQuery(input: readonly T[]): WidenString[]; +declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[]; +//#endregion +export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter/index.mjs b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter/index.mjs new file mode 100644 index 00000000..c1971997 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter/index.mjs @@ -0,0 +1,2 @@ +import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "../filter-B_mD-HGz.mjs"; +export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.d.mts b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.d.mts new file mode 100644 index 00000000..91d7daa3 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.d.mts @@ -0,0 +1,2 @@ +import { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query } from "./filter/index.mjs"; +export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.mjs b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.mjs new file mode 100644 index 00000000..2b584aa6 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/index.mjs @@ -0,0 +1,2 @@ +import { _ as queries, a as and, c as exprInterpreter, d as include, f as interpreter, g as or, h as not, i as filterVitePlugins, l as id, m as moduleType, n as makeIdFiltersToMatchWithQuery, o as code, p as interpreterImpl, r as prefixRegex, s as exclude, t as exactRegex, u as importerId, v as query } from "./filter-B_mD-HGz.mjs"; +export { and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query }; diff --git a/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/package.json b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/package.json new file mode 100644 index 00000000..0ab87332 --- /dev/null +++ b/backend/node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/package.json @@ -0,0 +1,40 @@ +{ + "name": "@rolldown/pluginutils", + "version": "1.0.1", + "description": "Plugin utilities for Rolldown", + "keywords": [ + "filter", + "plugin", + "rolldown" + ], + "homepage": "https://github.com/rolldown/plugins/tree/main/packages/pluginutils#readme", + "bugs": { + "url": "https://github.com/rolldown/plugins/issues" + }, + "license": "MIT", + "repository": { + "type": "git", + "url": "git+https://github.com/rolldown/plugins.git", + "directory": "packages/pluginutils" + }, + "files": [ + "dist" + ], + "type": "module", + "exports": { + ".": "./dist/index.mjs", + "./filter": "./dist/filter/index.mjs", + "./package.json": "./package.json" + }, + "devDependencies": { + "@types/picomatch": "^4.0.3", + "picomatch": "^4.0.4", + "typescript": "^5.9.3" + }, + "scripts": { + "dev": "tsdown --watch", + "build": "tsdown", + "test": "vitest --project pluginutils", + "test:types": "vitest --project pluginutils --typecheck.only" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/LICENSE b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/LICENSE new file mode 100644 index 00000000..9e841e7a --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + 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/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/README.md b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/README.md new file mode 100644 index 00000000..27c13567 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/README.md @@ -0,0 +1,15 @@ +# Installation +> `npm install --save @types/chai` + +# Summary +This package contains type definitions for chai (http://chaijs.com/). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chai. + +### Additional Details + * Last updated: Mon, 20 Oct 2025 23:32:35 GMT + * Dependencies: [@types/deep-eql](https://npmjs.com/package/@types/deep-eql), [assertion-error](https://npmjs.com/package/assertion-error) + +# Credits +These definitions were written by [Bart van der Schoor](https://github.com/Bartvds), [Andrew Brown](https://github.com/AGBrown), [Olivier Chevet](https://github.com/olivr70), [Matt Wistrand](https://github.com/mwistrand), [Shaun Luttin](https://github.com/shaunluttin), [Satana Charuwichitratana](https://github.com/micksatana), [Erik Schierboom](https://github.com/ErikSchierboom), [Bogdan Paranytsia](https://github.com/bparan), [CXuesong](https://github.com/CXuesong), and [Joey Kilpatrick](https://github.com/joeykilpatrick). diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/index.d.ts b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/index.d.ts new file mode 100644 index 00000000..4fed6b90 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/index.d.ts @@ -0,0 +1,2145 @@ +import deepEqual = require("deep-eql"); +import { AssertionError as ImportedAssertionError } from "assertion-error"; + +declare global { + namespace Chai { + export type Message = string | (() => string); + export type ObjectProperty = string | symbol | number; + + export interface PathInfo { + parent: object; + name: string; + value?: any; + exists: boolean; + } + + export interface Constructor { + new(...args: any[]): T; + } + + export interface ErrorConstructor { + new(...args: any[]): Error; + } + + export interface ChaiUtils { + addChainableMethod( + // object to define the method on, e.g. chai.Assertion.prototype + ctx: object, + // method name + name: string, + // method itself; any arguments + method: (...args: any[]) => void, + // called when property is accessed + chainingBehavior?: () => void, + ): void; + overwriteChainableMethod( + ctx: object, + name: string, + method: (...args: any[]) => void, + chainingBehavior?: () => void, + ): void; + addLengthGuard( + fn: Function, + assertionName: string, + isChainable: boolean, + ): void; + addMethod(ctx: object, name: string, method: Function): void; + addProperty(ctx: object, name: string, getter: () => any): void; + overwriteMethod(ctx: object, name: string, method: Function): void; + overwriteProperty(ctx: object, name: string, getter: (this: AssertionStatic, _super: any) => any): void; + compareByInspect(a: object, b: object): -1 | 1; + expectTypes(obj: object, types: string[]): void; + flag(obj: object, key: string, value?: any): any; + getActual(obj: object, args: AssertionArgs): any; + getProperties(obj: object): string[]; + getEnumerableProperties(obj: object): string[]; + getOwnEnumerablePropertySymbols(obj: object): symbol[]; + getOwnEnumerableProperties(obj: object): Array; + getMessage(errorLike: Error | string): string; + getMessage(obj: any, args: AssertionArgs): string; + inspect(obj: any, showHidden?: boolean, depth?: number, colors?: boolean): string; + isProxyEnabled(): boolean; + objDisplay(obj: object): void; + proxify(obj: object, nonChainableMethodName: string): object; + test(obj: object, args: AssertionArgs): boolean; + transferFlags(assertion: Assertion, obj: object, includeAll?: boolean): void; + compatibleInstance(thrown: Error, errorLike: Error | ErrorConstructor): boolean; + compatibleConstructor(thrown: Error, errorLike: Error | ErrorConstructor): boolean; + compatibleMessage(thrown: Error, errMatcher: string | RegExp): boolean; + getConstructorName(constructorFn: Function): string; + getFuncName(constructorFn: Function): string | null; + + // Reexports from pathval: + hasProperty(obj: object | undefined | null, name: ObjectProperty): boolean; + getPathInfo(obj: object, path: string): PathInfo; + getPathValue(obj: object, path: string): object | undefined; + + eql: typeof deepEqual; + } + + export type ChaiPlugin = (chai: ChaiStatic, utils: ChaiUtils) => void; + + export interface ChaiStatic { + expect: ExpectStatic; + should(): Should; + /** + * Provides a way to extend the internals of Chai + */ + use(fn: ChaiPlugin): ChaiStatic; + util: ChaiUtils; + assert: AssertStatic; + config: Config; + Assertion: AssertionStatic; + AssertionError: typeof AssertionError; + version: string; + } + + export interface ExpectStatic { + (val: any, message?: string): Assertion; + fail(message?: string): never; + fail(actual: any, expected: any, message?: string, operator?: Operator): never; + } + + export interface AssertStatic extends Assert { + } + + // chai.Assertion.prototype.assert arguments + export type AssertionArgs = [ + any, // expression to be tested + Message, // message or function that returns message to display if expression fails + Message, // negatedMessage or function that returns negatedMessage to display if expression fails + any?, // expected value + any?, // actual value + boolean?, // showDiff, when set to `true`, assert will display a diff in addition to the message if expression fails + ]; + + export interface AssertionPrototype { + assert(...args: AssertionArgs): void; + _obj: any; + } + + export interface AssertionStatic extends AssertionPrototype { + prototype: AssertionPrototype; + + new(target: any, message?: string, ssfi?: Function, lockSsfi?: boolean): Assertion; + + // Deprecated properties: + includeStack: boolean; + showDiff: boolean; + + // Partials of functions on ChaiUtils: + addProperty(name: string, getter: (this: AssertionStatic) => any): void; + addMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void; + addChainableMethod( + name: string, + method: (this: AssertionStatic, ...args: any[]) => void, + chainingBehavior?: () => void, + ): void; + overwriteProperty(name: string, getter: (this: AssertionStatic, _super: any) => any): void; + overwriteMethod(name: string, method: (this: AssertionStatic, ...args: any[]) => any): void; + overwriteChainableMethod( + name: string, + method: (this: AssertionStatic, ...args: any[]) => void, + chainingBehavior?: () => void, + ): void; + } + + export type Operator = string; // "==" | "===" | ">" | ">=" | "<" | "<=" | "!=" | "!=="; + + export type OperatorComparable = boolean | null | number | string | undefined | Date; + + export interface ShouldAssertion { + equal(value1: any, value2: any, message?: string): void; + Throw: ShouldThrow; + throw: ShouldThrow; + exist(value: any, message?: string): void; + } + + export interface Should extends ShouldAssertion { + not: ShouldAssertion; + fail(message?: string): never; + fail(actual: any, expected: any, message?: string, operator?: Operator): never; + } + + export interface ShouldThrow { + (actual: Function, expected?: string | RegExp, message?: string): void; + (actual: Function, constructor: Error | Function, expected?: string | RegExp, message?: string): void; + } + + export interface Assertion extends LanguageChains, NumericComparison, TypeComparison { + not: Assertion; + deep: Deep; + ordered: Ordered; + nested: Nested; + own: Own; + any: KeyFilter; + all: KeyFilter; + a: Assertion; + an: Assertion; + include: Include; + includes: Include; + contain: Include; + contains: Include; + ok: Assertion; + true: Assertion; + false: Assertion; + null: Assertion; + undefined: Assertion; + NaN: Assertion; + exist: Assertion; + empty: Assertion; + arguments: Assertion; + Arguments: Assertion; + finite: Assertion; + equal: Equal; + equals: Equal; + eq: Equal; + eql: Equal; + eqls: Equal; + containSubset: ContainSubset; + property: Property; + ownProperty: Property; + haveOwnProperty: Property; + ownPropertyDescriptor: OwnPropertyDescriptor; + haveOwnPropertyDescriptor: OwnPropertyDescriptor; + length: Length; + lengthOf: Length; + match: Match; + matches: Match; + string(string: string, message?: string): Assertion; + keys: Keys; + key(string: string): Assertion; + throw: Throw; + throws: Throw; + Throw: Throw; + respondTo: RespondTo; + respondsTo: RespondTo; + itself: Assertion; + satisfy: Satisfy; + satisfies: Satisfy; + closeTo: CloseTo; + approximately: CloseTo; + members: Members; + increase: PropertyChange; + increases: PropertyChange; + decrease: PropertyChange; + decreases: PropertyChange; + change: PropertyChange; + changes: PropertyChange; + extensible: Assertion; + sealed: Assertion; + frozen: Assertion; + oneOf: OneOf; + } + + export interface LanguageChains { + to: Assertion; + be: Assertion; + been: Assertion; + is: Assertion; + that: Assertion; + which: Assertion; + and: Assertion; + has: Assertion; + have: Assertion; + with: Assertion; + at: Assertion; + of: Assertion; + same: Assertion; + but: Assertion; + does: Assertion; + } + + export interface NumericComparison { + above: NumberComparer; + gt: NumberComparer; + greaterThan: NumberComparer; + least: NumberComparer; + gte: NumberComparer; + greaterThanOrEqual: NumberComparer; + below: NumberComparer; + lt: NumberComparer; + lessThan: NumberComparer; + most: NumberComparer; + lte: NumberComparer; + lessThanOrEqual: NumberComparer; + within(start: number, finish: number, message?: string): Assertion; + within(start: Date, finish: Date, message?: string): Assertion; + } + + export interface NumberComparer { + (value: number | Date, message?: string): Assertion; + } + + export interface TypeComparison { + (type: string, message?: string): Assertion; + instanceof: InstanceOf; + instanceOf: InstanceOf; + } + + export interface InstanceOf { + (constructor: any, message?: string): Assertion; + } + + export interface CloseTo { + (expected: number, delta: number, message?: string): Assertion; + } + + export interface Nested { + include: Include; + includes: Include; + contain: Include; + contains: Include; + property: Property; + members: Members; + } + + export interface Own { + include: Include; + includes: Include; + contain: Include; + contains: Include; + property: Property; + } + + export interface Deep extends KeyFilter { + be: Assertion; + equal: Equal; + equals: Equal; + eq: Equal; + include: Include; + includes: Include; + contain: Include; + contains: Include; + property: Property; + ordered: Ordered; + nested: Nested; + oneOf: OneOf; + own: Own; + } + + export interface Ordered { + members: Members; + } + + export interface KeyFilter { + keys: Keys; + members: Members; + } + + export interface Equal { + (value: any, message?: string): Assertion; + } + + export interface ContainSubset { + (expected: any): Assertion; + } + + export interface Property { + (name: string | symbol, value: any, message?: string): Assertion; + (name: string | symbol, message?: string): Assertion; + } + + export interface OwnPropertyDescriptor { + (name: string | symbol, descriptor: PropertyDescriptor, message?: string): Assertion; + (name: string | symbol, message?: string): Assertion; + } + + export interface Length extends LanguageChains, NumericComparison { + (length: number, message?: string): Assertion; + } + + export interface Include { + (value: any, message?: string): Assertion; + keys: Keys; + deep: Deep; + ordered: Ordered; + members: Members; + any: KeyFilter; + all: KeyFilter; + oneOf: OneOf; + } + + export interface OneOf { + (list: readonly unknown[], message?: string): Assertion; + } + + export interface Match { + (regexp: RegExp, message?: string): Assertion; + } + + export interface Keys { + (...keys: string[]): Assertion; + (keys: readonly any[] | Object): Assertion; + } + + export interface Throw { + (expected?: string | RegExp, message?: string): Assertion; + (constructor: Error | Function, expected?: string | RegExp, message?: string): Assertion; + } + + export interface RespondTo { + (method: string, message?: string): Assertion; + } + + export interface Satisfy { + (matcher: Function, message?: string): Assertion; + } + + export interface Members { + (set: readonly any[], message?: string): Assertion; + } + + export interface PropertyChange { + (object: Object, property?: string, message?: string): DeltaAssertion; + } + + export interface DeltaAssertion extends Assertion { + by(delta: number, msg?: string): Assertion; + } + + export interface Assert { + /** + * @param expression Expression to test for truthiness. + * @param message Message to display on error. + */ + (expression: any, message?: string): asserts expression; + + /** + * Throws a failure. + * + * @param message Message to display on error. + * @remarks Node.js assert module-compatible. + */ + fail(message?: string): never; + + /** + * Throws a failure. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + * @param operator Comparison operator, if not strict equality. + * @remarks Node.js assert module-compatible. + */ + fail(actual: T, expected: T, message?: string, operator?: Operator): never; + + /** + * Asserts that object is truthy. + * + * @param object Object to test. + * @param message Message to display on error. + */ + isOk(value: unknown, message?: string): asserts value; + + /** + * Asserts that object is truthy. + * + * @param object Object to test. + * @param message Message to display on error. + */ + ok(value: unknown, message?: string): asserts value; + + /** + * Asserts that object is falsy. + * + * T Type of object. + * @param object Object to test. + * @param message Message to display on error. + */ + isNotOk(value: T, message?: string): void; + + /** + * Asserts that object is falsy. + * + * T Type of object. + * @param object Object to test. + * @param message Message to display on error. + */ + notOk(value: T, message?: string): void; + + /** + * Asserts non-strict equality (==) of actual and expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + equal(actual: T, expected: T, message?: string): void; + + /** + * Asserts non-strict inequality (!=) of actual and expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + notEqual(actual: T, expected: T, message?: string): void; + + /** + * Asserts strict equality (===) of actual and expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + strictEqual(actual: T, expected: T, message?: string): void; + + /** + * Asserts strict inequality (!==) of actual and expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + notStrictEqual(actual: T, expected: T, message?: string): void; + + /** + * Asserts that actual is deeply equal to expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + deepEqual(actual: T, expected: T, message?: string): void; + + /** + * Asserts that actual is not deeply equal to expected. + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + notDeepEqual(actual: T, expected: T, message?: string): void; + + /** + * Alias to deepEqual + * + * T Type of the objects. + * @param actual Actual value. + * @param expected Potential expected value. + * @param message Message to display on error. + */ + deepStrictEqual(actual: T, expected: T, message?: string): void; + + /** + * Partially matches actual and expected. + * + * @param actual Actual value. + * @param expected Potential subset of the value. + * @param message Message to display on error. + */ + containSubset(val: any, exp: any, msg?: string): void; + + /** + * Partially matches actual and expected. + * + * @param actual Actual value. + * @param expected Potential subset of the value. + * @param message Message to display on error. + */ + containsSubset(val: any, exp: any, msg?: string): void; + + /** + * No partial match between actual and expected exists. + * + * @param actual Actual value. + * @param expected Potential subset of the value. + * @param message Message to display on error. + */ + doesNotContainSubset(val: any, exp: any, msg?: string): void; + + /** + * Asserts valueToCheck is strictly greater than (>) valueToBeAbove. + * + * @param valueToCheck Actual value. + * @param valueToBeAbove Minimum Potential expected value. + * @param message Message to display on error. + */ + isAbove(valueToCheck: number, valueToBeAbove: number, message?: string): void; + + /** + * Asserts valueToCheck is greater than or equal to (>=) valueToBeAtLeast. + * + * @param valueToCheck Actual value. + * @param valueToBeAtLeast Minimum Potential expected value. + * @param message Message to display on error. + */ + isAtLeast(valueToCheck: number, valueToBeAtLeast: number, message?: string): void; + + /** + * Asserts valueToCheck is strictly less than (<) valueToBeBelow. + * + * @param valueToCheck Actual value. + * @param valueToBeBelow Minimum Potential expected value. + * @param message Message to display on error. + */ + isBelow(valueToCheck: number, valueToBeBelow: number, message?: string): void; + + /** + * Asserts valueToCheck is less than or equal to (<=) valueToBeAtMost. + * + * @param valueToCheck Actual value. + * @param valueToBeAtMost Minimum Potential expected value. + * @param message Message to display on error. + */ + isAtMost(valueToCheck: number, valueToBeAtMost: number, message?: string): void; + + /** + * Asserts that value is true. + * + * @param value Actual value. + * @param message Message to display on error. + */ + isTrue(value: unknown, message?: string): asserts value is true; + + /** + * Asserts that value is false. + * + * @param value Actual value. + * @param message Message to display on error. + */ + isFalse(value: unknown, message?: string): asserts value is false; + + /** + * Asserts that value is not true. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotTrue(value: T, message?: string): asserts value is Exclude; + + /** + * Asserts that value is not false. + * + * @param value Actual value. + * @param message Message to display on error. + */ + isNotFalse(value: T, message?: string): asserts value is Exclude; + + /** + * Asserts that value is null. + * + * @param value Actual value. + * @param message Message to display on error. + */ + isNull(value: unknown, message?: string): asserts value is null; + + /** + * Asserts that value is not null. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotNull(value: T, message?: string): asserts value is Exclude; + + /** + * Asserts that value is NaN. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNaN(value: T, message?: string): void; + + /** + * Asserts that value is not NaN. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotNaN(value: T, message?: string): void; + + /** + * Asserts that the target is neither null nor undefined. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + exists(value: T, message?: string): asserts value is NonNullable; + + /** + * Asserts that the target is either null or undefined. + * + * @param value Actual value. + * @param message Message to display on error. + */ + notExists(value: unknown, message?: string): asserts value is + | null + | undefined; + + /** + * Asserts that value is undefined. + * + * @param value Actual value. + * @param message Message to display on error. + */ + isUndefined(value: unknown, message?: string): asserts value is undefined; + + /** + * Asserts that value is not undefined. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isDefined(value: T, message?: string): asserts value is Exclude; + + /** + * Asserts that value is a function. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isFunction(value: T, message?: string): void; + + /** + * Asserts that value is not a function. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotFunction(value: T, message?: string): void; + + /** + * Asserts that value is an object of type 'Object' + * (as revealed by Object.prototype.toString). + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + * @remarks The assertion does not match subclassed objects. + */ + isObject(value: T, message?: string): void; + + /** + * Asserts that value is not an object of type 'Object' + * (as revealed by Object.prototype.toString). + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotObject(value: T, message?: string): void; + + /** + * Asserts that value is an array. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isArray(value: T, message?: string): void; + + /** + * Asserts that value is not an array. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotArray(value: T, message?: string): void; + + /** + * Asserts that value is a string. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isString(value: T, message?: string): void; + + /** + * Asserts that value is not a string. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotString(value: T, message?: string): void; + + /** + * Asserts that value is a number. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNumber(value: T, message?: string): void; + + /** + * Asserts that value is not a number. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotNumber(value: T, message?: string): void; + + /** + * Asserts that value is a finite number. + * Unlike `.isNumber`, this will fail for `NaN` and `Infinity`. + * + * T Type of value + * @param value Actual value + * @param message Message to display on error. + */ + isFinite(value: T, message?: string): void; + + /** + * Asserts that value is a boolean. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isBoolean(value: T, message?: string): void; + + /** + * Asserts that value is not a boolean. + * + * T Type of value. + * @param value Actual value. + * @param message Message to display on error. + */ + isNotBoolean(value: T, message?: string): void; + + /** + * Asserts that value's type is name, as determined by Object.prototype.toString. + * + * T Type of value. + * @param value Actual value. + * @param name Potential expected type name of value. + * @param message Message to display on error. + */ + typeOf(value: T, name: string, message?: string): void; + + /** + * Asserts that value's type is not name, as determined by Object.prototype.toString. + * + * T Type of value. + * @param value Actual value. + * @param name Potential expected type name of value. + * @param message Message to display on error. + */ + notTypeOf(value: T, name: string, message?: string): void; + + /** + * Asserts that value is an instance of constructor. + * + * T Expected type of value. + * @param value Actual value. + * @param constructor Potential expected contructor of value. + * @param message Message to display on error. + */ + instanceOf( + value: unknown, + constructor: Constructor, + message?: string, + ): asserts value is T; + + /** + * Asserts that value is not an instance of constructor. + * + * T Type of value. + * U Type that value shouldn't be an instance of. + * @param value Actual value. + * @param constructor Potential expected contructor of value. + * @param message Message to display on error. + */ + notInstanceOf(value: T, type: Constructor, message?: string): asserts value is Exclude; + + /** + * Asserts that haystack includes needle. + * + * @param haystack Container string. + * @param needle Potential substring of haystack. + * @param message Message to display on error. + */ + include(haystack: string, needle: string, message?: string): void; + + /** + * Asserts that haystack includes needle. + * + * T Type of values in haystack. + * @param haystack Container array, set or map. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + include( + haystack: readonly T[] | ReadonlySet | ReadonlyMap, + needle: T, + message?: string, + ): void; + + /** + * Asserts that haystack includes needle. + * + * T Type of values in haystack. + * @param haystack WeakSet container. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + include(haystack: WeakSet, needle: T, message?: string): void; + + /** + * Asserts that haystack includes needle. + * + * T Type of haystack. + * @param haystack Object. + * @param needle Potential subset of the haystack's properties. + * @param message Message to display on error. + */ + include(haystack: T, needle: Partial, message?: string): void; + + /** + * Asserts that haystack does not include needle. + * + * @param haystack Container string. + * @param needle Potential substring of haystack. + * @param message Message to display on error. + */ + notInclude(haystack: string, needle: string, message?: string): void; + + /** + * Asserts that haystack does not include needle. + * + * T Type of values in haystack. + * @param haystack Container array, set or map. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + notInclude( + haystack: readonly T[] | ReadonlySet | ReadonlyMap, + needle: T, + message?: string, + ): void; + + /** + * Asserts that haystack does not include needle. + * + * T Type of values in haystack. + * @param haystack WeakSet container. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + notInclude(haystack: WeakSet, needle: T, message?: string): void; + + /** + * Asserts that haystack does not include needle. + * + * T Type of haystack. + * @param haystack Object. + * @param needle Potential subset of the haystack's properties. + * @param message Message to display on error. + */ + notInclude(haystack: T, needle: Partial, message?: string): void; + + /** + * Asserts that haystack includes needle. Deep equality is used. + * + * @param haystack Container string. + * @param needle Potential substring of haystack. + * @param message Message to display on error. + * + * @deprecated Does not have any effect on string. Use {@link Assert#include} instead. + */ + deepInclude(haystack: string, needle: string, message?: string): void; + + /** + * Asserts that haystack includes needle. Deep equality is used. + * + * T Type of values in haystack. + * @param haystack Container array, set or map. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + deepInclude( + haystack: readonly T[] | ReadonlySet | ReadonlyMap, + needle: T, + message?: string, + ): void; + + /** + * Asserts that haystack includes needle. Deep equality is used. + * + * T Type of haystack. + * @param haystack Object. + * @param needle Potential subset of the haystack's properties. + * @param message Message to display on error. + */ + deepInclude(haystack: T, needle: T extends WeakSet ? never : Partial, message?: string): void; + + /** + * Asserts that haystack does not include needle. Deep equality is used. + * + * @param haystack Container string. + * @param needle Potential substring of haystack. + * @param message Message to display on error. + * + * @deprecated Does not have any effect on string. Use {@link Assert#notInclude} instead. + */ + notDeepInclude(haystack: string, needle: string, message?: string): void; + + /** + * Asserts that haystack does not include needle. Deep equality is used. + * + * T Type of values in haystack. + * @param haystack Container array, set or map. + * @param needle Potential value contained in haystack. + * @param message Message to display on error. + */ + notDeepInclude( + haystack: readonly T[] | ReadonlySet | ReadonlyMap, + needle: T, + message?: string, + ): void; + + /** + * Asserts that haystack does not include needle. Deep equality is used. + * + * T Type of haystack. + * @param haystack Object. + * @param needle Potential subset of the haystack's properties. + * @param message Message to display on error. + */ + notDeepInclude(haystack: T, needle: T extends WeakSet ? never : Partial, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. + * + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. + * Can be used to assert the inclusion of a subset of properties in an object. + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + nestedInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object. + * + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. + * Can be used to assert the inclusion of a subset of properties in an object. + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + notNestedInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while checking for deep equality + * + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. + * Can be used to assert the inclusion of a subset of properties in an object. + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + deepNestedInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object while checking for deep equality. + * + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. + * Can be used to assert the inclusion of a subset of properties in an object. + * Enables the use of dot- and bracket-notation for referencing nested properties. + * ‘[]’ and ‘.’ in property names can be escaped using double backslashes. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + notDeepNestedInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + ownInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + notOwnInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for deep + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + deepOwnInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for deep equality. + * + * @param haystack + * @param needle + * @param message Message to display on error. + */ + notDeepOwnInclude(haystack: any, needle: any, message?: string): void; + + /** + * Asserts that value matches the regular expression regexp. + * + * @param value Actual value. + * @param regexp Potential match of value. + * @param message Message to display on error. + */ + match(value: string, regexp: RegExp, message?: string): void; + + /** + * Asserts that value does not match the regular expression regexp. + * + * @param value Actual value. + * @param regexp Potential match of value. + * @param message Message to display on error. + */ + notMatch(expected: any, regexp: RegExp, message?: string): void; + + /** + * Asserts that object has a property named by property. + * + * T Type of object. + * @param object Container object. + * @param property Potential contained property of object. + * @param message Message to display on error. + */ + property(object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that object does not have a property named by property. + * + * T Type of object. + * @param object Container object. + * @param property Potential contained property of object. + * @param message Message to display on error. + */ + notProperty(object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that object has a property named by property, which can be a string + * using dot- and bracket-notation for deep reference. + * + * T Type of object. + * @param object Container object. + * @param property Potential contained property of object. + * @param message Message to display on error. + */ + deepProperty(object: T, property: string, message?: string): void; + + /** + * Asserts that object does not have a property named by property, which can be a + * string using dot- and bracket-notation for deep reference. + * + * T Type of object. + * @param object Container object. + * @param property Potential contained property of object. + * @param message Message to display on error. + */ + notDeepProperty(object: T, property: string, message?: string): void; + + /** + * Asserts that object has a property named by property with value given by value. + * + * T Type of object. + * V Type of value. + * @param object Container object. + * @param property Potential contained property of object. + * @param value Potential expected property value. + * @param message Message to display on error. + */ + propertyVal(object: T, property: string, /* keyof T */ value: V, message?: string): void; + + /** + * Asserts that object has a property named by property with value given by value. + * + * T Type of object. + * V Type of value. + * @param object Container object. + * @param property Potential contained property of object. + * @param value Potential expected property value. + * @param message Message to display on error. + */ + notPropertyVal(object: T, property: string, /* keyof T */ value: V, message?: string): void; + + /** + * Asserts that object has a property named by property, which can be a string + * using dot- and bracket-notation for deep reference. + * + * T Type of object. + * V Type of value. + * @param object Container object. + * @param property Potential contained property of object. + * @param value Potential expected property value. + * @param message Message to display on error. + */ + deepPropertyVal(object: T, property: string, value: V, message?: string): void; + + /** + * Asserts that object does not have a property named by property, which can be a + * string using dot- and bracket-notation for deep reference. + * + * T Type of object. + * V Type of value. + * @param object Container object. + * @param property Potential contained property of object. + * @param value Potential expected property value. + * @param message Message to display on error. + */ + notDeepPropertyVal(object: T, property: string, value: V, message?: string): void; + + /** + * Asserts that object has a length property with the expected value. + * + * T Type of object. + * @param object Container object. + * @param length Potential expected length of object. + * @param message Message to display on error. + */ + lengthOf( + object: T, + length: number, + message?: string, + ): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errMsgMatcher Expected error message matcher. + * @param ignored Ignored parameter. + * @param message Message to display on error. + */ + throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errorLike Expected error constructor or error instance. + * @param errMsgMatcher Expected error message matcher. + * @param message Message to display on error. + */ + throw( + fn: () => void, + errorLike?: ErrorConstructor | Error | null, + errMsgMatcher?: RegExp | string | null, + message?: string, + ): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errMsgMatcher Expected error message matcher. + * @param ignored Ignored parameter. + * @param message Message to display on error. + */ + throws(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errorLike Expected error constructor or error instance. + * @param errMsgMatcher Expected error message matcher. + * @param message Message to display on error. + */ + throws( + fn: () => void, + errorLike?: ErrorConstructor | Error | null, + errMsgMatcher?: RegExp | string | null, + message?: string, + ): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errMsgMatcher Expected error message matcher. + * @param ignored Ignored parameter. + * @param message Message to display on error. + */ + Throw(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; + + /** + * Asserts that fn will throw an error. + * + * @param fn Function that may throw. + * @param errorLike Expected error constructor or error instance. + * @param errMsgMatcher Expected error message matcher. + * @param message Message to display on error. + */ + Throw( + fn: () => void, + errorLike?: ErrorConstructor | Error | null, + errMsgMatcher?: RegExp | string | null, + message?: string, + ): void; + + /** + * Asserts that fn will not throw an error. + * + * @param fn Function that may throw. + * @param errMsgMatcher Expected error message matcher. + * @param ignored Ignored parameter. + * @param message Message to display on error. + */ + doesNotThrow(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string): void; + + /** + * Asserts that fn will not throw an error. + * + * @param fn Function that may throw. + * @param errorLike Expected error constructor or error instance. + * @param errMsgMatcher Expected error message matcher. + * @param message Message to display on error. + */ + doesNotThrow( + fn: () => void, + errorLike?: ErrorConstructor | Error | null, + errMsgMatcher?: RegExp | string | null, + message?: string, + ): void; + + /** + * Compares two values using operator. + * + * @param val1 Left value during comparison. + * @param operator Comparison operator. + * @param val2 Right value during comparison. + * @param message Message to display on error. + */ + operator(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string): void; + + /** + * Asserts that the target is equal to expected, to within a +/- delta range. + * + * @param actual Actual value + * @param expected Potential expected value. + * @param delta Maximum differenced between values. + * @param message Message to display on error. + */ + closeTo(actual: number, expected: number, delta: number, message?: string): void; + + /** + * Asserts that the target is equal to expected, to within a +/- delta range. + * + * @param actual Actual value + * @param expected Potential expected value. + * @param delta Maximum differenced between values. + * @param message Message to display on error. + */ + approximately(act: number, exp: number, delta: number, message?: string): void; + + /** + * Asserts that set1 and set2 have the same members. Order is not take into account. + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + sameMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that set1 and set2 have the same members using deep equality checking. + * Order is not take into account. + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + sameDeepMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that `set1` and `set2` don't have the same members in any order. + * Uses a deep equality check. + * + * T Type of set values. + * @param set1 + * @param set2 + * @param message + */ + notSameDeepMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that set1 and set2 have the same members in the same order. + * Uses a strict equality check (===). + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + sameOrderedMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that set1 and set2 don’t have the same members in the same order. + * Uses a strict equality check (===). + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + notSameOrderedMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that set1 and set2 have the same members in the same order. + * Uses a deep equality check. + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + sameDeepOrderedMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that set1 and set2 don’t have the same members in the same order. + * Uses a deep equality check. + * + * T Type of set values. + * @param set1 Actual set of values. + * @param set2 Potential expected set of values. + * @param message Message to display on error. + */ + notSameDeepOrderedMembers(set1: T[], set2: T[], message?: string): void; + + /** + * Asserts that subset is included in superset in the same order beginning with the first element in superset. + * Uses a strict equality check (===). + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + includeOrderedMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. + * Uses a strict equality check (===). + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + notIncludeOrderedMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset is included in superset in the same order beginning with the first element in superset. + * Uses a deep equality check. + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + includeDeepOrderedMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. + * Uses a deep equality check. + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + notIncludeDeepOrderedMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset is included in superset. Order is not take into account. + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + includeMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset isn’t included in superset in any order. + * Uses a strict equality check (===). Duplicates are ignored. + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential not contained set of values. + * @param message Message to display on error. + */ + notIncludeMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that subset is included in superset using deep equality checking. + * Order is not take into account. + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + includeDeepMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that `subset` isn't included in `superset` in any order. Uses a + * deep equality check. Duplicates are ignored. + * + * assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members'); + * + * T Type of set values. + * @param superset Actual set of values. + * @param subset Potential contained set of values. + * @param message Message to display on error. + */ + notIncludeDeepMembers(superset: T[], subset: T[], message?: string): void; + + /** + * Asserts that non-object, non-array value inList appears in the flat array list. + * + * T Type of list values. + * @param inList Value expected to be in the list. + * @param list List of values. + * @param message Message to display on error. + */ + oneOf(inList: T, list: T[], message?: string): void; + + /** + * Asserts that a function changes the value of a property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected to be modified. + * @param message Message to display on error. + */ + changes(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function changes the value of a property by an amount (delta). + * + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + changesBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + changesBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts that a function does not change the value of a property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected not to be modified. + * @param message Message to display on error. + */ + doesNotChange(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function increases an object property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected to be increased. + * @param message Message to display on error. + */ + increases(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function increases a numeric object property or a function's return value by an amount (delta). + * + * T Type of object or function. + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + increasesBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + increasesBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts that a function does not increase an object property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected not to be increased. + * @param message Message to display on error. + */ + doesNotIncrease(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function does not increase a numeric object property or function's return value by an amount (delta). + * + * T Type of object or function. + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + + increasesButNotBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + increasesButNotBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts that a function decreases an object property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected to be decreased. + * @param message Message to display on error. + */ + decreases(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function decreases a numeric object property or a function's return value by an amount (delta) + * + * T Type of object or function. + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + + decreasesBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + decreasesBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts that a function does not decrease an object property. + * + * T Type of object. + * @param modifier Function to run. + * @param object Container object. + * @param property Property of object expected not to be decreased. + * @param message Message to display on error. + */ + doesNotDecrease(modifier: Function, object: T, property: string, /* keyof T */ message?: string): void; + + /** + * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta) + * + * T Type of object or function. + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + + doesNotDecreaseBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + doesNotDecreaseBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta) + * + * T Type of object or function. + * @param modifier function + * @param object or getter function + * @param property name _optional_ + * @param change amount (delta) + * @param message _optional_ + */ + + decreasesButNotBy( + modifier: Function, + object: T, + property: string, + /* keyof T */ change: number, + message?: string, + ): void; + decreasesButNotBy(modifier: Function, object: T, change: number, message?: string): void; + + /** + * Asserts if value is not a false value, and throws if it is a true value. + * + * T Type of object. + * @param object Actual value. + * @param message Message to display on error. + * @remarks This is added to allow for chai to be a drop-in replacement for + * Node’s assert class. + */ + ifError(object: T, message?: string): void; + + /** + * Asserts that object is extensible (can have new properties added to it). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isExtensible(object: T, message?: string): void; + + /** + * Asserts that object is extensible (can have new properties added to it). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + extensible(object: T, message?: string): void; + + /** + * Asserts that object is not extensible. + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isNotExtensible(object: T, message?: string): void; + + /** + * Asserts that object is not extensible. + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + notExtensible(object: T, message?: string): void; + + /** + * Asserts that object is sealed (can have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isSealed(object: T, message?: string): void; + + /** + * Asserts that object is sealed (can have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + sealed(object: T, message?: string): void; + + /** + * Asserts that object is not sealed. + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isNotSealed(object: T, message?: string): void; + + /** + * Asserts that object is not sealed. + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + notSealed(object: T, message?: string): void; + + /** + * Asserts that object is frozen (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isFrozen(object: T, message?: string): void; + + /** + * Asserts that object is frozen (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + frozen(object: T, message?: string): void; + + /** + * Asserts that object is not frozen (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isNotFrozen(object: T, message?: string): void; + + /** + * Asserts that object is not frozen (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + notFrozen(object: T, message?: string): void; + + /** + * Asserts that the target does not contain any values. For arrays and + * strings, it checks the length property. For Map and Set instances, it + * checks the size property. For non-function objects, it gets the count + * of own enumerable string keys. + * + * T Type of object + * @param object Actual value. + * @param message Message to display on error. + */ + isEmpty(object: T, message?: string): void; + + /** + * Asserts that the target contains values. For arrays and strings, it checks + * the length property. For Map and Set instances, it checks the size property. + * For non-function objects, it gets the count of own enumerable string keys. + * + * T Type of object. + * @param object Object to test. + * @param message Message to display on error. + */ + isNotEmpty(object: T, message?: string): void; + + /** + * Asserts that `object` has at least one of the `keys` provided. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + hasAnyKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; + + /** + * Asserts that `object` has all and only all of the `keys` provided. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + hasAllKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; + + /** + * Asserts that `object` has all of the `keys` provided but may have more keys not listed. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + containsAllKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that `object` has none of the `keys` provided. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + doesNotHaveAnyKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that `object` does not have at least one of the `keys` provided. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + doesNotHaveAllKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that `object` has at least one of the `keys` provided. + * Since Sets and Maps can have objects as keys you can use this assertion to perform + * a deep comparison. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + hasAnyDeepKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; + + /** + * Asserts that `object` has all and only all of the `keys` provided. + * Since Sets and Maps can have objects as keys you can use this assertion to perform + * a deep comparison. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + hasAllDeepKeys(object: T, keys: Array | { [key: string]: any }, message?: string): void; + + /** + * Asserts that `object` contains all of the `keys` provided. + * Since Sets and Maps can have objects as keys you can use this assertion to perform + * a deep comparison. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + containsAllDeepKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that `object` contains all of the `keys` provided. + * Since Sets and Maps can have objects as keys you can use this assertion to perform + * a deep comparison. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + doesNotHaveAnyDeepKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that `object` contains all of the `keys` provided. + * Since Sets and Maps can have objects as keys you can use this assertion to perform + * a deep comparison. + * You can also provide a single object instead of a `keys` array and its keys + * will be used as the expected set of keys. + * + * T Type of object. + * @param object Object to test. + * @param keys Keys to check + * @param message Message to display on error. + */ + doesNotHaveAllDeepKeys( + object: T, + keys: Array | { [key: string]: any }, + message?: string, + ): void; + + /** + * Asserts that object has a direct or inherited property named by property, + * which can be a string using dot- and bracket-notation for nested reference. + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param message Message to display on error. + */ + nestedProperty(object: T, property: string, message?: string): void; + + /** + * Asserts that object does not have a property named by property, + * which can be a string using dot- and bracket-notation for nested reference. + * The property cannot exist on the object nor anywhere in its prototype chain. + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param message Message to display on error. + */ + notNestedProperty(object: T, property: string, message?: string): void; + + /** + * Asserts that object has a property named by property with value given by value. + * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===). + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param value Value to test. + * @param message Message to display on error. + */ + nestedPropertyVal(object: T, property: string, value: any, message?: string): void; + + /** + * Asserts that object does not have a property named by property with value given by value. + * property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===). + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param value Value to test. + * @param message Message to display on error. + */ + notNestedPropertyVal(object: T, property: string, value: any, message?: string): void; + + /** + * Asserts that object has a property named by property with a value given by value. + * property can use dot- and bracket-notation for nested reference. Uses a deep equality check. + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param value Value to test. + * @param message Message to display on error. + */ + deepNestedPropertyVal(object: T, property: string, value: any, message?: string): void; + + /** + * Asserts that object does not have a property named by property with value given by value. + * property can use dot- and bracket-notation for nested reference. Uses a deep equality check. + * + * T Type of object. + * @param object Object to test. + * @param property Property to test. + * @param value Value to test. + * @param message Message to display on error. + */ + notDeepNestedPropertyVal(object: T, property: string, value: any, message?: string): void; + } + + export interface Config { + /** + * Default: false + */ + includeStack: boolean; + + /** + * Default: true + */ + showDiff: boolean; + + /** + * Default: 40 + */ + truncateThreshold: number; + + /** + * Default: true + */ + useProxy: boolean; + + /** + * Default: ['then', 'catch', 'inspect', 'toJSON'] + */ + proxyExcludedKeys: string[]; + + deepEqual: (expected: L, actual: R) => void; + } + + export type { ImportedAssertionError as AssertionError }; + } +} + +export function use(fn: Chai.ChaiPlugin): Chai.ChaiStatic; + +export const util: Chai.ChaiUtils; +export const config: Chai.Config; +export const Assertion: Chai.AssertionStatic; +export const AssertionError: typeof ImportedAssertionError; +export function should(): Chai.Should; +export function Should(): Chai.Should; +export const assert: Chai.AssertStatic; +export const expect: Chai.ExpectStatic; diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/package.json b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/package.json new file mode 100644 index 00000000..7aec8d1c --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/package.json @@ -0,0 +1,75 @@ +{ + "name": "@types/chai", + "version": "5.2.3", + "description": "TypeScript definitions for chai", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/chai", + "license": "MIT", + "contributors": [ + { + "name": "Bart van der Schoor", + "githubUsername": "Bartvds", + "url": "https://github.com/Bartvds" + }, + { + "name": "Andrew Brown", + "githubUsername": "AGBrown", + "url": "https://github.com/AGBrown" + }, + { + "name": "Olivier Chevet", + "githubUsername": "olivr70", + "url": "https://github.com/olivr70" + }, + { + "name": "Matt Wistrand", + "githubUsername": "mwistrand", + "url": "https://github.com/mwistrand" + }, + { + "name": "Shaun Luttin", + "githubUsername": "shaunluttin", + "url": "https://github.com/shaunluttin" + }, + { + "name": "Satana Charuwichitratana", + "githubUsername": "micksatana", + "url": "https://github.com/micksatana" + }, + { + "name": "Erik Schierboom", + "githubUsername": "ErikSchierboom", + "url": "https://github.com/ErikSchierboom" + }, + { + "name": "Bogdan Paranytsia", + "githubUsername": "bparan", + "url": "https://github.com/bparan" + }, + { + "name": "CXuesong", + "githubUsername": "CXuesong", + "url": "https://github.com/CXuesong" + }, + { + "name": "Joey Kilpatrick", + "githubUsername": "joeykilpatrick", + "url": "https://github.com/joeykilpatrick" + } + ], + "type": "module", + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/chai" + }, + "scripts": {}, + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + }, + "peerDependencies": {}, + "typesPublisherContentHash": "d9d83f1594f42010e624e46e4c8cfeee284bdd04cb05eb0730aec14140f2a833", + "typeScriptVersion": "5.2" +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/register-should.d.ts b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/register-should.d.ts new file mode 100644 index 00000000..1e14f93b --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/chai/register-should.d.ts @@ -0,0 +1,7 @@ +declare global { + interface Object { + should: Chai.Assertion; + } +} + +export {}; diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/deep-eql b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/deep-eql new file mode 120000 index 00000000..f414eb3d --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/@types/deep-eql @@ -0,0 +1 @@ +../../../@types+deep-eql@4.0.2/node_modules/@types/deep-eql \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/assertion-error b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/assertion-error new file mode 120000 index 00000000..b3c9e209 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+chai@5.2.3/node_modules/assertion-error @@ -0,0 +1 @@ +../../assertion-error@2.0.1/node_modules/assertion-error \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/LICENSE b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/LICENSE new file mode 100644 index 00000000..9e841e7a --- /dev/null +++ b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + 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/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/README.md b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/README.md new file mode 100644 index 00000000..48d96fc6 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/README.md @@ -0,0 +1,57 @@ +# Installation +> `npm install --save @types/deep-eql` + +# Summary +This package contains type definitions for deep-eql (https://github.com/chaijs/deep-eql). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/deep-eql. +## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/deep-eql/index.d.ts) +````ts +declare namespace deepEqual { + /** + * Memoization class used to speed up comparison. + */ + class MemoizeMap extends WeakMap {} + + interface DeepEqualOptions { + /** + * Override default algorithm, determining custom equality. + */ + comparator?: (leftHandOperand: T1, rightHandOperand: T2) => boolean | null; + + /** + * Provide a custom memoization object which will cache the results of + * complex objects for a speed boost. + * + * By passing `false` you can disable memoization, but this will cause circular + * references to blow the stack. + */ + memoize?: MemoizeMap | false; + } +} + +/** + * Assert deeply nested sameValue equality between two objects of any type. + * + * @param leftHandOperand + * @param rightHandOperand + * @param [options] Additional options + * @return equal match + */ +declare function deepEqual( + leftHandOperand: T1, + rightHandOperand: T2, + options?: deepEqual.DeepEqualOptions, +): boolean; + +export = deepEqual; + +```` + +### Additional Details + * Last updated: Mon, 06 Nov 2023 22:41:05 GMT + * Dependencies: none + +# Credits +These definitions were written by [Rodrigo Pietnechuk](https://github.com/ghnoob). diff --git a/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/index.d.ts b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/index.d.ts new file mode 100644 index 00000000..0cdbefe9 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/index.d.ts @@ -0,0 +1,38 @@ +declare namespace deepEqual { + /** + * Memoization class used to speed up comparison. + */ + class MemoizeMap extends WeakMap {} + + interface DeepEqualOptions { + /** + * Override default algorithm, determining custom equality. + */ + comparator?: (leftHandOperand: T1, rightHandOperand: T2) => boolean | null; + + /** + * Provide a custom memoization object which will cache the results of + * complex objects for a speed boost. + * + * By passing `false` you can disable memoization, but this will cause circular + * references to blow the stack. + */ + memoize?: MemoizeMap | false; + } +} + +/** + * Assert deeply nested sameValue equality between two objects of any type. + * + * @param leftHandOperand + * @param rightHandOperand + * @param [options] Additional options + * @return equal match + */ +declare function deepEqual( + leftHandOperand: T1, + rightHandOperand: T2, + options?: deepEqual.DeepEqualOptions, +): boolean; + +export = deepEqual; diff --git a/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/package.json b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/package.json new file mode 100644 index 00000000..87615815 --- /dev/null +++ b/backend/node_modules/.pnpm/@types+deep-eql@4.0.2/node_modules/@types/deep-eql/package.json @@ -0,0 +1,25 @@ +{ + "name": "@types/deep-eql", + "version": "4.0.2", + "description": "TypeScript definitions for deep-eql", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/deep-eql", + "license": "MIT", + "contributors": [ + { + "name": "Rodrigo Pietnechuk", + "githubUsername": "ghnoob", + "url": "https://github.com/ghnoob" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/deep-eql" + }, + "scripts": {}, + "dependencies": {}, + "typesPublisherContentHash": "3b8981ce557947fc00ca08cbd93b4206bfc0943360956867381a0a3f6b1eabf5", + "typeScriptVersion": "4.5" +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@eslint-community/regexpp b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@eslint-community/regexpp new file mode 120000 index 00000000..285c0a72 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@eslint-community/regexpp @@ -0,0 +1 @@ +../../../@eslint-community+regexpp@4.12.2/node_modules/@eslint-community/regexpp \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/LICENSE b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/LICENSE new file mode 100644 index 00000000..a1164108 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 typescript-eslint and other contributors + +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/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/README.md b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/README.md new file mode 100644 index 00000000..3f894c88 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/README.md @@ -0,0 +1,12 @@ +# `@typescript-eslint/eslint-plugin` + +An ESLint plugin which provides lint rules for TypeScript codebases. + +[![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/eslint-plugin.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) +[![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/eslint-plugin.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin) + +👉 See **https://typescript-eslint.io/getting-started** for our Getting Started docs. + +> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code. + + diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.d.ts new file mode 100644 index 00000000..c15bcce9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.d.ts @@ -0,0 +1,10 @@ +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + */ +declare const config: (style: 'glob' | 'minimatch') => { + files: string[]; + rules: Record; +}; +export = config; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.js new file mode 100644 index 00000000..0cd97d77 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslint-recommended-raw.js @@ -0,0 +1,47 @@ +"use strict"; +// NOTE: this file is isolated to be shared across legacy and flat configs. +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + */ +const config = (style) => ({ + files: style === 'glob' + ? // classic configs use glob syntax + ['*.ts', '*.tsx', '*.mts', '*.cts'] + : // flat configs use minimatch syntax + ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'], + rules: { + 'constructor-super': 'off', // ts(2335) & ts(2377) + 'getter-return': 'off', // ts(2378) + 'no-class-assign': 'off', // ts(2629) + 'no-const-assign': 'off', // ts(2588) + 'no-dupe-args': 'off', // ts(2300) + 'no-dupe-class-members': 'off', // ts(2393) & ts(2300) + 'no-dupe-keys': 'off', // ts(1117) + 'no-func-assign': 'off', // ts(2630) + 'no-import-assign': 'off', // ts(2632) & ts(2540) + 'no-new-native-nonconstructor': 'off', // ts(7009) + // "no-new-symbol" was deprecated in ESLint 9.0.0 and will be removed in + // ESLint v11.0.0. See: + // https://eslint.org/docs/latest/rules/no-new-symbol + // We need to keep the rule disabled until TSESLint drops support for + // ESlint 8. See: + // https://github.com/typescript-eslint/typescript-eslint/pull/8895 + 'no-new-symbol': 'off', // ts(7009) + 'no-obj-calls': 'off', // ts(2349) + 'no-redeclare': 'off', // ts(2451) + 'no-setter-return': 'off', // ts(2408) + 'no-this-before-super': 'off', // ts(2376) & ts(17009) + 'no-undef': 'off', // ts(2304) & ts(2552) + 'no-unreachable': 'off', // ts(7027) + 'no-unsafe-negation': 'off', // ts(2365) & ts(2322) & ts(2358) + 'no-var': 'error', // ts transpiles let/const to var, so no need for vars any more + 'no-with': 'off', // ts(1101) & ts(2410) + 'prefer-const': 'error', // ts provides better types with const + 'prefer-rest-params': 'error', // ts provides better types with rest args over arguments + 'prefer-spread': 'error', // ts transpiles spread to apply, so no need for manual apply + }, +}); +module.exports = config; +//# sourceMappingURL=eslint-recommended-raw.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts new file mode 100644 index 00000000..febec7cd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts @@ -0,0 +1,156 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + 'class-methods-use-this': "off"; + '@typescript-eslint/class-methods-use-this': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + 'consistent-return': "off"; + '@typescript-eslint/consistent-return': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/consistent-type-exports': "error"; + '@typescript-eslint/consistent-type-imports': "error"; + 'default-param-last': "off"; + '@typescript-eslint/default-param-last': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/explicit-function-return-type': "error"; + '@typescript-eslint/explicit-member-accessibility': "error"; + '@typescript-eslint/explicit-module-boundary-types': "error"; + 'init-declarations': "off"; + '@typescript-eslint/init-declarations': "error"; + 'max-params': "off"; + '@typescript-eslint/max-params': "error"; + '@typescript-eslint/member-ordering': "error"; + '@typescript-eslint/method-signature-style': "error"; + '@typescript-eslint/naming-convention': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + 'no-dupe-class-members': "off"; + '@typescript-eslint/no-dupe-class-members': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-import-type-side-effects': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + 'no-invalid-this': "off"; + '@typescript-eslint/no-invalid-this': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + 'no-magic-numbers': "off"; + '@typescript-eslint/no-magic-numbers': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + 'no-redeclare': "off"; + '@typescript-eslint/no-redeclare': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-restricted-types': "error"; + 'no-shadow': "off"; + '@typescript-eslint/no-shadow': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-parameter-property-assignment': "error"; + '@typescript-eslint/no-unnecessary-qualifier': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-type-assertion': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-private-class-members': "off"; + '@typescript-eslint/no-unused-private-class-members': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-use-before-define': "off"; + '@typescript-eslint/no-use-before-define': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-useless-empty-export': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/parameter-properties': "error"; + '@typescript-eslint/prefer-as-const': "error"; + 'prefer-destructuring': "off"; + '@typescript-eslint/prefer-destructuring': "error"; + '@typescript-eslint/prefer-enum-initializers': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-readonly': "error"; + '@typescript-eslint/prefer-readonly-parameter-types': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + '@typescript-eslint/promise-function-async': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + '@typescript-eslint/require-array-sort-compare': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + 'no-return-await': "off"; + '@typescript-eslint/return-await': "error"; + '@typescript-eslint/strict-boolean-expressions': "error"; + '@typescript-eslint/strict-void-return': "error"; + '@typescript-eslint/switch-exhaustiveness-check': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js new file mode 100644 index 00000000..8d3d4302 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js @@ -0,0 +1,163 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + 'class-methods-use-this': 'off', + '@typescript-eslint/class-methods-use-this': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + 'consistent-return': 'off', + '@typescript-eslint/consistent-return': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + '@typescript-eslint/consistent-type-exports': 'error', + '@typescript-eslint/consistent-type-imports': 'error', + 'default-param-last': 'off', + '@typescript-eslint/default-param-last': 'error', + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/explicit-function-return-type': 'error', + '@typescript-eslint/explicit-member-accessibility': 'error', + '@typescript-eslint/explicit-module-boundary-types': 'error', + 'init-declarations': 'off', + '@typescript-eslint/init-declarations': 'error', + 'max-params': 'off', + '@typescript-eslint/max-params': 'error', + '@typescript-eslint/member-ordering': 'error', + '@typescript-eslint/method-signature-style': 'error', + '@typescript-eslint/naming-convention': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + 'no-dupe-class-members': 'off', + '@typescript-eslint/no-dupe-class-members': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-import-type-side-effects': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + 'no-invalid-this': 'off', + '@typescript-eslint/no-invalid-this': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + 'no-magic-numbers': 'off', + '@typescript-eslint/no-magic-numbers': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + 'no-redeclare': 'off', + '@typescript-eslint/no-redeclare': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-restricted-types': 'error', + 'no-shadow': 'off', + '@typescript-eslint/no-shadow': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error', + '@typescript-eslint/no-unnecessary-qualifier': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-type-assertion': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-private-class-members': 'off', + '@typescript-eslint/no-unused-private-class-members': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-use-before-define': 'off', + '@typescript-eslint/no-use-before-define': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + '@typescript-eslint/no-useless-empty-export': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/parameter-properties': 'error', + '@typescript-eslint/prefer-as-const': 'error', + 'prefer-destructuring': 'off', + '@typescript-eslint/prefer-destructuring': 'error', + '@typescript-eslint/prefer-enum-initializers': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-readonly': 'error', + '@typescript-eslint/prefer-readonly-parameter-types': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + '@typescript-eslint/promise-function-async': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + '@typescript-eslint/require-array-sort-compare': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + 'no-return-await': 'off', + '@typescript-eslint/return-await': 'error', + '@typescript-eslint/strict-boolean-expressions': 'error', + '@typescript-eslint/strict-void-return': 'error', + '@typescript-eslint/switch-exhaustiveness-check': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/unified-signatures': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, +}; +//# sourceMappingURL=all.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.d.ts new file mode 100644 index 00000000..bcfb57e3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.d.ts @@ -0,0 +1,8 @@ +declare const _default: { + parser: string; + parserOptions: { + sourceType: "module"; + }; + plugins: string[]; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.js new file mode 100644 index 00000000..cb61c298 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/base.js @@ -0,0 +1,7 @@ +"use strict"; +module.exports = { + parser: '@typescript-eslint/parser', + parserOptions: { sourceType: 'module' }, + plugins: ['@typescript-eslint'], +}; +//# sourceMappingURL=base.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts new file mode 100644 index 00000000..1e6482c1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts @@ -0,0 +1,72 @@ +declare const _default: { + parserOptions: { + program: null; + project: false; + projectService: false; + }; + rules: { + '@typescript-eslint/await-thenable': "off"; + '@typescript-eslint/consistent-return': "off"; + '@typescript-eslint/consistent-type-exports': "off"; + '@typescript-eslint/dot-notation': "off"; + '@typescript-eslint/naming-convention': "off"; + '@typescript-eslint/no-array-delete': "off"; + '@typescript-eslint/no-base-to-string': "off"; + '@typescript-eslint/no-confusing-void-expression': "off"; + '@typescript-eslint/no-deprecated': "off"; + '@typescript-eslint/no-duplicate-type-constituents': "off"; + '@typescript-eslint/no-floating-promises': "off"; + '@typescript-eslint/no-for-in-array': "off"; + '@typescript-eslint/no-generated-empty-object-type': "off"; + '@typescript-eslint/no-implied-eval': "off"; + '@typescript-eslint/no-meaningless-void-operator': "off"; + '@typescript-eslint/no-misused-promises': "off"; + '@typescript-eslint/no-misused-spread': "off"; + '@typescript-eslint/no-mixed-enums': "off"; + '@typescript-eslint/no-redundant-type-constituents': "off"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "off"; + '@typescript-eslint/no-unnecessary-condition': "off"; + '@typescript-eslint/no-unnecessary-qualifier': "off"; + '@typescript-eslint/no-unnecessary-template-expression': "off"; + '@typescript-eslint/no-unnecessary-type-arguments': "off"; + '@typescript-eslint/no-unnecessary-type-assertion': "off"; + '@typescript-eslint/no-unnecessary-type-conversion': "off"; + '@typescript-eslint/no-unnecessary-type-parameters': "off"; + '@typescript-eslint/no-unsafe-argument': "off"; + '@typescript-eslint/no-unsafe-assignment': "off"; + '@typescript-eslint/no-unsafe-call': "off"; + '@typescript-eslint/no-unsafe-enum-comparison': "off"; + '@typescript-eslint/no-unsafe-member-access': "off"; + '@typescript-eslint/no-unsafe-return': "off"; + '@typescript-eslint/no-unsafe-type-assertion': "off"; + '@typescript-eslint/no-unsafe-unary-minus': "off"; + '@typescript-eslint/no-useless-default-assignment': "off"; + '@typescript-eslint/non-nullable-type-assertion-style': "off"; + '@typescript-eslint/only-throw-error': "off"; + '@typescript-eslint/prefer-destructuring': "off"; + '@typescript-eslint/prefer-find': "off"; + '@typescript-eslint/prefer-includes': "off"; + '@typescript-eslint/prefer-nullish-coalescing': "off"; + '@typescript-eslint/prefer-optional-chain': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-readonly': "off"; + '@typescript-eslint/prefer-readonly-parameter-types': "off"; + '@typescript-eslint/prefer-reduce-type-parameter': "off"; + '@typescript-eslint/prefer-regexp-exec': "off"; + '@typescript-eslint/prefer-return-this-type': "off"; + '@typescript-eslint/prefer-string-starts-ends-with': "off"; + '@typescript-eslint/promise-function-async': "off"; + '@typescript-eslint/related-getter-setter-pairs': "off"; + '@typescript-eslint/require-array-sort-compare': "off"; + '@typescript-eslint/require-await': "off"; + '@typescript-eslint/restrict-plus-operands': "off"; + '@typescript-eslint/restrict-template-expressions': "off"; + '@typescript-eslint/return-await': "off"; + '@typescript-eslint/strict-boolean-expressions': "off"; + '@typescript-eslint/strict-void-return': "off"; + '@typescript-eslint/switch-exhaustiveness-check': "off"; + '@typescript-eslint/unbound-method': "off"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "off"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js new file mode 100644 index 00000000..d712ebf6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js @@ -0,0 +1,75 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + parserOptions: { program: null, project: false, projectService: false }, + rules: { + '@typescript-eslint/await-thenable': 'off', + '@typescript-eslint/consistent-return': 'off', + '@typescript-eslint/consistent-type-exports': 'off', + '@typescript-eslint/dot-notation': 'off', + '@typescript-eslint/naming-convention': 'off', + '@typescript-eslint/no-array-delete': 'off', + '@typescript-eslint/no-base-to-string': 'off', + '@typescript-eslint/no-confusing-void-expression': 'off', + '@typescript-eslint/no-deprecated': 'off', + '@typescript-eslint/no-duplicate-type-constituents': 'off', + '@typescript-eslint/no-floating-promises': 'off', + '@typescript-eslint/no-for-in-array': 'off', + '@typescript-eslint/no-generated-empty-object-type': 'off', + '@typescript-eslint/no-implied-eval': 'off', + '@typescript-eslint/no-meaningless-void-operator': 'off', + '@typescript-eslint/no-misused-promises': 'off', + '@typescript-eslint/no-misused-spread': 'off', + '@typescript-eslint/no-mixed-enums': 'off', + '@typescript-eslint/no-redundant-type-constituents': 'off', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'off', + '@typescript-eslint/no-unnecessary-condition': 'off', + '@typescript-eslint/no-unnecessary-qualifier': 'off', + '@typescript-eslint/no-unnecessary-template-expression': 'off', + '@typescript-eslint/no-unnecessary-type-arguments': 'off', + '@typescript-eslint/no-unnecessary-type-assertion': 'off', + '@typescript-eslint/no-unnecessary-type-conversion': 'off', + '@typescript-eslint/no-unnecessary-type-parameters': 'off', + '@typescript-eslint/no-unsafe-argument': 'off', + '@typescript-eslint/no-unsafe-assignment': 'off', + '@typescript-eslint/no-unsafe-call': 'off', + '@typescript-eslint/no-unsafe-enum-comparison': 'off', + '@typescript-eslint/no-unsafe-member-access': 'off', + '@typescript-eslint/no-unsafe-return': 'off', + '@typescript-eslint/no-unsafe-type-assertion': 'off', + '@typescript-eslint/no-unsafe-unary-minus': 'off', + '@typescript-eslint/no-useless-default-assignment': 'off', + '@typescript-eslint/non-nullable-type-assertion-style': 'off', + '@typescript-eslint/only-throw-error': 'off', + '@typescript-eslint/prefer-destructuring': 'off', + '@typescript-eslint/prefer-find': 'off', + '@typescript-eslint/prefer-includes': 'off', + '@typescript-eslint/prefer-nullish-coalescing': 'off', + '@typescript-eslint/prefer-optional-chain': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-readonly': 'off', + '@typescript-eslint/prefer-readonly-parameter-types': 'off', + '@typescript-eslint/prefer-reduce-type-parameter': 'off', + '@typescript-eslint/prefer-regexp-exec': 'off', + '@typescript-eslint/prefer-return-this-type': 'off', + '@typescript-eslint/prefer-string-starts-ends-with': 'off', + '@typescript-eslint/promise-function-async': 'off', + '@typescript-eslint/related-getter-setter-pairs': 'off', + '@typescript-eslint/require-array-sort-compare': 'off', + '@typescript-eslint/require-await': 'off', + '@typescript-eslint/restrict-plus-operands': 'off', + '@typescript-eslint/restrict-template-expressions': 'off', + '@typescript-eslint/return-await': 'off', + '@typescript-eslint/strict-boolean-expressions': 'off', + '@typescript-eslint/strict-void-return': 'off', + '@typescript-eslint/switch-exhaustiveness-check': 'off', + '@typescript-eslint/unbound-method': 'off', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off', + }, +}; +//# sourceMappingURL=disable-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.d.ts new file mode 100644 index 00000000..0d9bd363 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.d.ts @@ -0,0 +1,12 @@ +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + */ +declare const _default: { + overrides: { + files: string[]; + rules: Record; + }[]; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.js new file mode 100644 index 00000000..a5b0e778 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/eslint-recommended.js @@ -0,0 +1,14 @@ +"use strict"; +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + */ +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +const eslint_recommended_raw_1 = __importDefault(require("../eslint-recommended-raw")); +module.exports = { + overrides: [(0, eslint_recommended_raw_1.default)('glob')], +}; +//# sourceMappingURL=eslint-recommended.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.d.ts new file mode 100644 index 00000000..07344941 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.d.ts @@ -0,0 +1,33 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/unbound-method': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.js new file mode 100644 index 00000000..a6bda969 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked-only.js @@ -0,0 +1,40 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + '@typescript-eslint/unbound-method': 'error', + }, +}; +//# sourceMappingURL=recommended-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.d.ts new file mode 100644 index 00000000..b7e0d71b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.d.ts @@ -0,0 +1,56 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.js new file mode 100644 index 00000000..ace3e8e9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended-type-checked.js @@ -0,0 +1,63 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + }, +}; +//# sourceMappingURL=recommended-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.d.ts new file mode 100644 index 00000000..916c900b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.d.ts @@ -0,0 +1,29 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.js new file mode 100644 index 00000000..f8bf02e7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/recommended.js @@ -0,0 +1,36 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/ban-ts-comment': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + }, +}; +//# sourceMappingURL=recommended.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.d.ts new file mode 100644 index 00000000..a91d844c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.d.ts @@ -0,0 +1,65 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.js new file mode 100644 index 00000000..c5c83657 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked-only.js @@ -0,0 +1,81 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNullish: false, + allowNumberAndString: false, + allowRegExp: false, + }, + ], + '@typescript-eslint/restrict-template-expressions': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNever: false, + allowNullish: false, + allowNumber: false, + allowRegExp: false, + }, + ], + 'no-return-await': 'off', + '@typescript-eslint/return-await': [ + 'error', + 'error-handling-correctness-only', + ], + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, +}; +//# sourceMappingURL=strict-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.d.ts new file mode 100644 index 00000000..2521f650 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.d.ts @@ -0,0 +1,99 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.js new file mode 100644 index 00000000..374d3266 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict-type-checked.js @@ -0,0 +1,116 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': [ + 'error', + { minimumDescriptionLength: 10 }, + ], + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNullish: false, + allowNumberAndString: false, + allowRegExp: false, + }, + ], + '@typescript-eslint/restrict-template-expressions': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNever: false, + allowNullish: false, + allowNumber: false, + allowRegExp: false, + }, + ], + 'no-return-await': 'off', + '@typescript-eslint/return-await': [ + 'error', + 'error-handling-correctness-only', + ], + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/unified-signatures': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, +}; +//# sourceMappingURL=strict-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.d.ts new file mode 100644 index 00000000..95ca8766 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.d.ts @@ -0,0 +1,40 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unified-signatures': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.js new file mode 100644 index 00000000..31efdc4e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/strict.js @@ -0,0 +1,48 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/ban-ts-comment': [ + 'error', + { minimumDescriptionLength: 10 }, + ], + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unified-signatures': 'error', + }, +}; +//# sourceMappingURL=strict.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.d.ts new file mode 100644 index 00000000..4fd6d629 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.d.ts @@ -0,0 +1,15 @@ +declare const _default: { + extends: string[]; + rules: { + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.js new file mode 100644 index 00000000..529d2084 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked-only.js @@ -0,0 +1,22 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + }, +}; +//# sourceMappingURL=stylistic-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.d.ts new file mode 100644 index 00000000..bafcb44d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.d.ts @@ -0,0 +1,29 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.js new file mode 100644 index 00000000..42f9fee1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic-type-checked.js @@ -0,0 +1,36 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + }, +}; +//# sourceMappingURL=stylistic-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.d.ts new file mode 100644 index 00000000..3c23f97d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.d.ts @@ -0,0 +1,20 @@ +declare const _default: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.js new file mode 100644 index 00000000..a0a7af25 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/stylistic.js @@ -0,0 +1,27 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +module.exports = { + extends: ['./configs/eslintrc/base', './configs/eslintrc/eslint-recommended'], + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + }, +}; +//# sourceMappingURL=stylistic.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts new file mode 100644 index 00000000..e6ad2739 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured. + * @see {@link https://typescript-eslint.io/users/configs#all} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js new file mode 100644 index 00000000..f7751515 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js @@ -0,0 +1,177 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Enables each the rules provided as a part of typescript-eslint. Note that many rules are not applicable in all codebases, or are meant to be configured. + * @see {@link https://typescript-eslint.io/users/configs#all} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/all', + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + 'class-methods-use-this': 'off', + '@typescript-eslint/class-methods-use-this': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + 'consistent-return': 'off', + '@typescript-eslint/consistent-return': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + '@typescript-eslint/consistent-type-exports': 'error', + '@typescript-eslint/consistent-type-imports': 'error', + 'default-param-last': 'off', + '@typescript-eslint/default-param-last': 'error', + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/explicit-function-return-type': 'error', + '@typescript-eslint/explicit-member-accessibility': 'error', + '@typescript-eslint/explicit-module-boundary-types': 'error', + 'init-declarations': 'off', + '@typescript-eslint/init-declarations': 'error', + 'max-params': 'off', + '@typescript-eslint/max-params': 'error', + '@typescript-eslint/member-ordering': 'error', + '@typescript-eslint/method-signature-style': 'error', + '@typescript-eslint/naming-convention': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + 'no-dupe-class-members': 'off', + '@typescript-eslint/no-dupe-class-members': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-import-type-side-effects': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + 'no-invalid-this': 'off', + '@typescript-eslint/no-invalid-this': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + 'no-magic-numbers': 'off', + '@typescript-eslint/no-magic-numbers': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + 'no-redeclare': 'off', + '@typescript-eslint/no-redeclare': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-restricted-types': 'error', + 'no-shadow': 'off', + '@typescript-eslint/no-shadow': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error', + '@typescript-eslint/no-unnecessary-qualifier': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-type-assertion': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-private-class-members': 'off', + '@typescript-eslint/no-unused-private-class-members': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-use-before-define': 'off', + '@typescript-eslint/no-use-before-define': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + '@typescript-eslint/no-useless-empty-export': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/parameter-properties': 'error', + '@typescript-eslint/prefer-as-const': 'error', + 'prefer-destructuring': 'off', + '@typescript-eslint/prefer-destructuring': 'error', + '@typescript-eslint/prefer-enum-initializers': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-readonly': 'error', + '@typescript-eslint/prefer-readonly-parameter-types': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + '@typescript-eslint/promise-function-async': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + '@typescript-eslint/require-array-sort-compare': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + 'no-return-await': 'off', + '@typescript-eslint/return-await': 'error', + '@typescript-eslint/strict-boolean-expressions': 'error', + '@typescript-eslint/strict-void-return': 'error', + '@typescript-eslint/switch-exhaustiveness-check': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/unified-signatures': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, + }, +]; +//# sourceMappingURL=all.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.d.ts new file mode 100644 index 00000000..30c2880e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.d.ts @@ -0,0 +1,8 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint. + * We don't recommend using this directly; instead, extend from an earlier recommended rule. + * @see {@link https://typescript-eslint.io/users/configs#base} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.Config; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.js new file mode 100644 index 00000000..b31c3f24 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/base.js @@ -0,0 +1,18 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * A minimal ruleset that sets only the required parser and plugin options needed to run typescript-eslint. + * We don't recommend using this directly; instead, extend from an earlier recommended rule. + * @see {@link https://typescript-eslint.io/users/configs#base} + */ +exports.default = (plugin, parser) => ({ + name: 'typescript-eslint/base', + languageOptions: { + parser, + sourceType: 'module', + }, + plugins: { + '@typescript-eslint': plugin, + }, +}); +//# sourceMappingURL=base.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts new file mode 100644 index 00000000..5353cfd1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project. + * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked} + */ +declare function _default(_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser): FlatConfig.Config; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js new file mode 100644 index 00000000..b2b15dd7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js @@ -0,0 +1,83 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * A utility ruleset that will disable type-aware linting and all type-aware rules available in our project. + * @see {@link https://typescript-eslint.io/users/configs#disable-type-checked} + */ +exports.default = (_plugin, _parser) => ({ + name: 'typescript-eslint/disable-type-checked', + rules: { + '@typescript-eslint/await-thenable': 'off', + '@typescript-eslint/consistent-return': 'off', + '@typescript-eslint/consistent-type-exports': 'off', + '@typescript-eslint/dot-notation': 'off', + '@typescript-eslint/naming-convention': 'off', + '@typescript-eslint/no-array-delete': 'off', + '@typescript-eslint/no-base-to-string': 'off', + '@typescript-eslint/no-confusing-void-expression': 'off', + '@typescript-eslint/no-deprecated': 'off', + '@typescript-eslint/no-duplicate-type-constituents': 'off', + '@typescript-eslint/no-floating-promises': 'off', + '@typescript-eslint/no-for-in-array': 'off', + '@typescript-eslint/no-generated-empty-object-type': 'off', + '@typescript-eslint/no-implied-eval': 'off', + '@typescript-eslint/no-meaningless-void-operator': 'off', + '@typescript-eslint/no-misused-promises': 'off', + '@typescript-eslint/no-misused-spread': 'off', + '@typescript-eslint/no-mixed-enums': 'off', + '@typescript-eslint/no-redundant-type-constituents': 'off', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'off', + '@typescript-eslint/no-unnecessary-condition': 'off', + '@typescript-eslint/no-unnecessary-qualifier': 'off', + '@typescript-eslint/no-unnecessary-template-expression': 'off', + '@typescript-eslint/no-unnecessary-type-arguments': 'off', + '@typescript-eslint/no-unnecessary-type-assertion': 'off', + '@typescript-eslint/no-unnecessary-type-conversion': 'off', + '@typescript-eslint/no-unnecessary-type-parameters': 'off', + '@typescript-eslint/no-unsafe-argument': 'off', + '@typescript-eslint/no-unsafe-assignment': 'off', + '@typescript-eslint/no-unsafe-call': 'off', + '@typescript-eslint/no-unsafe-enum-comparison': 'off', + '@typescript-eslint/no-unsafe-member-access': 'off', + '@typescript-eslint/no-unsafe-return': 'off', + '@typescript-eslint/no-unsafe-type-assertion': 'off', + '@typescript-eslint/no-unsafe-unary-minus': 'off', + '@typescript-eslint/no-useless-default-assignment': 'off', + '@typescript-eslint/non-nullable-type-assertion-style': 'off', + '@typescript-eslint/only-throw-error': 'off', + '@typescript-eslint/prefer-destructuring': 'off', + '@typescript-eslint/prefer-find': 'off', + '@typescript-eslint/prefer-includes': 'off', + '@typescript-eslint/prefer-nullish-coalescing': 'off', + '@typescript-eslint/prefer-optional-chain': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-readonly': 'off', + '@typescript-eslint/prefer-readonly-parameter-types': 'off', + '@typescript-eslint/prefer-reduce-type-parameter': 'off', + '@typescript-eslint/prefer-regexp-exec': 'off', + '@typescript-eslint/prefer-return-this-type': 'off', + '@typescript-eslint/prefer-string-starts-ends-with': 'off', + '@typescript-eslint/promise-function-async': 'off', + '@typescript-eslint/related-getter-setter-pairs': 'off', + '@typescript-eslint/require-array-sort-compare': 'off', + '@typescript-eslint/require-await': 'off', + '@typescript-eslint/restrict-plus-operands': 'off', + '@typescript-eslint/restrict-template-expressions': 'off', + '@typescript-eslint/return-await': 'off', + '@typescript-eslint/strict-boolean-expressions': 'off', + '@typescript-eslint/strict-void-return': 'off', + '@typescript-eslint/switch-exhaustiveness-check': 'off', + '@typescript-eslint/unbound-method': 'off', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off', + }, + languageOptions: { + parserOptions: { program: null, project: false, projectService: false }, + }, +}); +//# sourceMappingURL=disable-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.d.ts new file mode 100644 index 00000000..4ee76860 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.d.ts @@ -0,0 +1,9 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended} + */ +declare function _default(_plugin: FlatConfig.Plugin, _parser: FlatConfig.Parser): FlatConfig.Config; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.js new file mode 100644 index 00000000..5857c0b0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/eslint-recommended.js @@ -0,0 +1,17 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const eslint_recommended_raw_1 = __importDefault(require("../eslint-recommended-raw")); +/** + * This is a compatibility ruleset that: + * - disables rules from eslint:recommended which are already handled by TypeScript. + * - enables rules that make sense due to TS's typechecking / transpilation. + * @see {@link https://typescript-eslint.io/users/configs/#eslint-recommended} + */ +exports.default = (_plugin, _parser) => ({ + ...(0, eslint_recommended_raw_1.default)('minimatch'), + name: 'typescript-eslint/eslint-recommended', +}); +//# sourceMappingURL=eslint-recommended.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.d.ts new file mode 100644 index 00000000..20acb3e1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.js new file mode 100644 index 00000000..235ea806 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked-only.js @@ -0,0 +1,54 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * A version of `recommended` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked-only} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/recommended-type-checked-only', + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + '@typescript-eslint/unbound-method': 'error', + }, + }, +]; +//# sourceMappingURL=recommended-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.d.ts new file mode 100644 index 00000000..91704c53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Contains all of `recommended` along with additional recommended rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.js new file mode 100644 index 00000000..c69e2b21 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended-type-checked.js @@ -0,0 +1,77 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Contains all of `recommended` along with additional recommended rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#recommended-type-checked} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/recommended-type-checked', + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': 'error', + '@typescript-eslint/restrict-template-expressions': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + }, + }, +]; +//# sourceMappingURL=recommended-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.d.ts new file mode 100644 index 00000000..8f5fd856 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Recommended rules for code correctness that you can drop in without additional configuration. + * @see {@link https://typescript-eslint.io/users/configs#recommended} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.js new file mode 100644 index 00000000..780ac936 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/recommended.js @@ -0,0 +1,50 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Recommended rules for code correctness that you can drop in without additional configuration. + * @see {@link https://typescript-eslint.io/users/configs#recommended} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/recommended', + rules: { + '@typescript-eslint/ban-ts-comment': 'error', + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + }, + }, +]; +//# sourceMappingURL=recommended.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.d.ts new file mode 100644 index 00000000..a1ea1ea1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.js new file mode 100644 index 00000000..7a2739f6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked-only.js @@ -0,0 +1,95 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * A version of `strict` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked-only} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/strict-type-checked-only', + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNullish: false, + allowNumberAndString: false, + allowRegExp: false, + }, + ], + '@typescript-eslint/restrict-template-expressions': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNever: false, + allowNullish: false, + allowNumber: false, + allowRegExp: false, + }, + ], + 'no-return-await': 'off', + '@typescript-eslint/return-await': [ + 'error', + 'error-handling-correctness-only', + ], + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, + }, +]; +//# sourceMappingURL=strict-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.d.ts new file mode 100644 index 00000000..5ecdcbb7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Contains all of `recommended`, `recommended-type-checked`, and `strict`, along with additional strict rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.js new file mode 100644 index 00000000..c58aca7e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict-type-checked.js @@ -0,0 +1,130 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Contains all of `recommended`, `recommended-type-checked`, and `strict`, along with additional strict rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#strict-type-checked} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/strict-type-checked', + rules: { + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/ban-ts-comment': [ + 'error', + { minimumDescriptionLength: 10 }, + ], + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-array-delete': 'error', + '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-deprecated': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-for-in-array': 'error', + '@typescript-eslint/no-generated-empty-object-type': 'error', + 'no-implied-eval': 'off', + '@typescript-eslint/no-implied-eval': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-misused-promises': 'error', + '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-mixed-enums': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + '@typescript-eslint/no-redundant-type-constituents': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-unnecessary-condition': 'error', + '@typescript-eslint/no-unnecessary-template-expression': 'error', + '@typescript-eslint/no-unnecessary-type-arguments': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unnecessary-type-conversion': 'error', + '@typescript-eslint/no-unnecessary-type-parameters': 'error', + '@typescript-eslint/no-unsafe-argument': 'error', + '@typescript-eslint/no-unsafe-assignment': 'error', + '@typescript-eslint/no-unsafe-call': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-enum-comparison': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + '@typescript-eslint/no-unsafe-member-access': 'error', + '@typescript-eslint/no-unsafe-return': 'error', + '@typescript-eslint/no-unsafe-unary-minus': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-useless-default-assignment': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + 'no-throw-literal': 'off', + '@typescript-eslint/only-throw-error': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + 'prefer-promise-reject-errors': 'off', + '@typescript-eslint/prefer-promise-reject-errors': 'error', + '@typescript-eslint/prefer-reduce-type-parameter': 'error', + '@typescript-eslint/prefer-return-this-type': 'error', + '@typescript-eslint/related-getter-setter-pairs': 'error', + 'require-await': 'off', + '@typescript-eslint/require-await': 'error', + '@typescript-eslint/restrict-plus-operands': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNullish: false, + allowNumberAndString: false, + allowRegExp: false, + }, + ], + '@typescript-eslint/restrict-template-expressions': [ + 'error', + { + allowAny: false, + allowBoolean: false, + allowNever: false, + allowNullish: false, + allowNumber: false, + allowRegExp: false, + }, + ], + 'no-return-await': 'off', + '@typescript-eslint/return-await': [ + 'error', + 'error-handling-correctness-only', + ], + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unbound-method': 'error', + '@typescript-eslint/unified-signatures': 'error', + '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error', + }, + }, +]; +//# sourceMappingURL=strict-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.d.ts new file mode 100644 index 00000000..f3450d16 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Contains all of `recommended`, as well as additional strict rules that can also catch bugs. + * @see {@link https://typescript-eslint.io/users/configs#strict} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.js new file mode 100644 index 00000000..72d2bb1e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/strict.js @@ -0,0 +1,62 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Contains all of `recommended`, as well as additional strict rules that can also catch bugs. + * @see {@link https://typescript-eslint.io/users/configs#strict} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/strict', + rules: { + '@typescript-eslint/ban-ts-comment': [ + 'error', + { minimumDescriptionLength: 10 }, + ], + 'no-array-constructor': 'off', + '@typescript-eslint/no-array-constructor': 'error', + '@typescript-eslint/no-duplicate-enum-values': 'error', + '@typescript-eslint/no-dynamic-delete': 'error', + '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-extra-non-null-assertion': 'error', + '@typescript-eslint/no-extraneous-class': 'error', + '@typescript-eslint/no-invalid-void-type': 'error', + '@typescript-eslint/no-misused-new': 'error', + '@typescript-eslint/no-namespace': 'error', + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error', + '@typescript-eslint/no-non-null-asserted-optional-chain': 'error', + '@typescript-eslint/no-non-null-assertion': 'error', + '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-this-alias': 'error', + '@typescript-eslint/no-unnecessary-type-constraint': 'error', + '@typescript-eslint/no-unsafe-declaration-merging': 'error', + '@typescript-eslint/no-unsafe-function-type': 'error', + 'no-unused-expressions': 'off', + '@typescript-eslint/no-unused-expressions': 'error', + 'no-unused-vars': 'off', + '@typescript-eslint/no-unused-vars': 'error', + 'no-useless-constructor': 'off', + '@typescript-eslint/no-useless-constructor': 'error', + '@typescript-eslint/no-wrapper-object-types': 'error', + '@typescript-eslint/prefer-as-const': 'error', + '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-namespace-keyword': 'error', + '@typescript-eslint/triple-slash-reference': 'error', + '@typescript-eslint/unified-signatures': 'error', + }, + }, +]; +//# sourceMappingURL=strict.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.d.ts new file mode 100644 index 00000000..41a1ea14 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * A version of `stylistic` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked-only} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.js new file mode 100644 index 00000000..61b26cc9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked-only.js @@ -0,0 +1,36 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * A version of `stylistic` that only contains type-checked rules and disables of any corresponding core ESLint rules. + * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked-only} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/stylistic-type-checked-only', + rules: { + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + }, + }, +]; +//# sourceMappingURL=stylistic-type-checked-only.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.d.ts new file mode 100644 index 00000000..9441af3a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Contains all of `stylistic`, along with additional stylistic rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.js new file mode 100644 index 00000000..47405712 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic-type-checked.js @@ -0,0 +1,50 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Contains all of `stylistic`, along with additional stylistic rules that require type information. + * @see {@link https://typescript-eslint.io/users/configs#stylistic-type-checked} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/stylistic-type-checked', + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + 'dot-notation': 'off', + '@typescript-eslint/dot-notation': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + '@typescript-eslint/non-nullable-type-assertion-style': 'error', + '@typescript-eslint/prefer-find': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + '@typescript-eslint/prefer-includes': 'error', + '@typescript-eslint/prefer-nullish-coalescing': 'error', + '@typescript-eslint/prefer-optional-chain': 'error', + '@typescript-eslint/prefer-regexp-exec': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': 'error', + }, + }, +]; +//# sourceMappingURL=stylistic-type-checked.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.d.ts new file mode 100644 index 00000000..0cf2d969 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.d.ts @@ -0,0 +1,7 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +export default _default; +/** + * Rules considered to be best practice for modern TypeScript codebases, but that do not impact program logic. + * @see {@link https://typescript-eslint.io/users/configs#stylistic} + */ +declare function _default(plugin: FlatConfig.Plugin, parser: FlatConfig.Parser): FlatConfig.ConfigArray; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.js new file mode 100644 index 00000000..96f19edc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/stylistic.js @@ -0,0 +1,41 @@ +"use strict"; +// THIS CODE WAS AUTOMATICALLY GENERATED +// DO NOT EDIT THIS CODE BY HAND +// SEE https://typescript-eslint.io/users/configs +// +// For developers working in the typescript-eslint monorepo: +// You can regenerate it using `pnpm run generate-configs` +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const base_1 = __importDefault(require("./base")); +const eslint_recommended_1 = __importDefault(require("./eslint-recommended")); +/** + * Rules considered to be best practice for modern TypeScript codebases, but that do not impact program logic. + * @see {@link https://typescript-eslint.io/users/configs#stylistic} + */ +exports.default = (plugin, parser) => [ + (0, base_1.default)(plugin, parser), + (0, eslint_recommended_1.default)(plugin, parser), + { + name: 'typescript-eslint/stylistic', + rules: { + '@typescript-eslint/adjacent-overload-signatures': 'error', + '@typescript-eslint/array-type': 'error', + '@typescript-eslint/ban-tslint-comment': 'error', + '@typescript-eslint/class-literal-property-style': 'error', + '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-indexed-object-style': 'error', + '@typescript-eslint/consistent-type-assertions': 'error', + '@typescript-eslint/consistent-type-definitions': 'error', + '@typescript-eslint/no-confusing-non-null-assertion': 'error', + 'no-empty-function': 'off', + '@typescript-eslint/no-empty-function': 'error', + '@typescript-eslint/no-inferrable-types': 'error', + '@typescript-eslint/prefer-for-of': 'error', + '@typescript-eslint/prefer-function-type': 'error', + }, + }, +]; +//# sourceMappingURL=stylistic.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts new file mode 100644 index 00000000..71f40106 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts @@ -0,0 +1,1131 @@ +declare const _default: { + configs: { + all: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + 'class-methods-use-this': "off"; + '@typescript-eslint/class-methods-use-this': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + 'consistent-return': "off"; + '@typescript-eslint/consistent-return': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/consistent-type-exports': "error"; + '@typescript-eslint/consistent-type-imports': "error"; + 'default-param-last': "off"; + '@typescript-eslint/default-param-last': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/explicit-function-return-type': "error"; + '@typescript-eslint/explicit-member-accessibility': "error"; + '@typescript-eslint/explicit-module-boundary-types': "error"; + 'init-declarations': "off"; + '@typescript-eslint/init-declarations': "error"; + 'max-params': "off"; + '@typescript-eslint/max-params': "error"; + '@typescript-eslint/member-ordering': "error"; + '@typescript-eslint/method-signature-style': "error"; + '@typescript-eslint/naming-convention': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + 'no-dupe-class-members': "off"; + '@typescript-eslint/no-dupe-class-members': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-import-type-side-effects': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + 'no-invalid-this': "off"; + '@typescript-eslint/no-invalid-this': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + 'no-magic-numbers': "off"; + '@typescript-eslint/no-magic-numbers': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + 'no-redeclare': "off"; + '@typescript-eslint/no-redeclare': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-restricted-types': "error"; + 'no-shadow': "off"; + '@typescript-eslint/no-shadow': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-parameter-property-assignment': "error"; + '@typescript-eslint/no-unnecessary-qualifier': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-type-assertion': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-private-class-members': "off"; + '@typescript-eslint/no-unused-private-class-members': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-use-before-define': "off"; + '@typescript-eslint/no-use-before-define': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-useless-empty-export': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/parameter-properties': "error"; + '@typescript-eslint/prefer-as-const': "error"; + 'prefer-destructuring': "off"; + '@typescript-eslint/prefer-destructuring': "error"; + '@typescript-eslint/prefer-enum-initializers': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-readonly': "error"; + '@typescript-eslint/prefer-readonly-parameter-types': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + '@typescript-eslint/promise-function-async': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + '@typescript-eslint/require-array-sort-compare': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + 'no-return-await': "off"; + '@typescript-eslint/return-await': "error"; + '@typescript-eslint/strict-boolean-expressions': "error"; + '@typescript-eslint/strict-void-return': "error"; + '@typescript-eslint/switch-exhaustiveness-check': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + base: { + parser: string; + parserOptions: { + sourceType: "module"; + }; + plugins: string[]; + }; + 'disable-type-checked': { + parserOptions: { + program: null; + project: false; + projectService: false; + }; + rules: { + '@typescript-eslint/await-thenable': "off"; + '@typescript-eslint/consistent-return': "off"; + '@typescript-eslint/consistent-type-exports': "off"; + '@typescript-eslint/dot-notation': "off"; + '@typescript-eslint/naming-convention': "off"; + '@typescript-eslint/no-array-delete': "off"; + '@typescript-eslint/no-base-to-string': "off"; + '@typescript-eslint/no-confusing-void-expression': "off"; + '@typescript-eslint/no-deprecated': "off"; + '@typescript-eslint/no-duplicate-type-constituents': "off"; + '@typescript-eslint/no-floating-promises': "off"; + '@typescript-eslint/no-for-in-array': "off"; + '@typescript-eslint/no-generated-empty-object-type': "off"; + '@typescript-eslint/no-implied-eval': "off"; + '@typescript-eslint/no-meaningless-void-operator': "off"; + '@typescript-eslint/no-misused-promises': "off"; + '@typescript-eslint/no-misused-spread': "off"; + '@typescript-eslint/no-mixed-enums': "off"; + '@typescript-eslint/no-redundant-type-constituents': "off"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "off"; + '@typescript-eslint/no-unnecessary-condition': "off"; + '@typescript-eslint/no-unnecessary-qualifier': "off"; + '@typescript-eslint/no-unnecessary-template-expression': "off"; + '@typescript-eslint/no-unnecessary-type-arguments': "off"; + '@typescript-eslint/no-unnecessary-type-assertion': "off"; + '@typescript-eslint/no-unnecessary-type-conversion': "off"; + '@typescript-eslint/no-unnecessary-type-parameters': "off"; + '@typescript-eslint/no-unsafe-argument': "off"; + '@typescript-eslint/no-unsafe-assignment': "off"; + '@typescript-eslint/no-unsafe-call': "off"; + '@typescript-eslint/no-unsafe-enum-comparison': "off"; + '@typescript-eslint/no-unsafe-member-access': "off"; + '@typescript-eslint/no-unsafe-return': "off"; + '@typescript-eslint/no-unsafe-type-assertion': "off"; + '@typescript-eslint/no-unsafe-unary-minus': "off"; + '@typescript-eslint/no-useless-default-assignment': "off"; + '@typescript-eslint/non-nullable-type-assertion-style': "off"; + '@typescript-eslint/only-throw-error': "off"; + '@typescript-eslint/prefer-destructuring': "off"; + '@typescript-eslint/prefer-find': "off"; + '@typescript-eslint/prefer-includes': "off"; + '@typescript-eslint/prefer-nullish-coalescing': "off"; + '@typescript-eslint/prefer-optional-chain': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-readonly': "off"; + '@typescript-eslint/prefer-readonly-parameter-types': "off"; + '@typescript-eslint/prefer-reduce-type-parameter': "off"; + '@typescript-eslint/prefer-regexp-exec': "off"; + '@typescript-eslint/prefer-return-this-type': "off"; + '@typescript-eslint/prefer-string-starts-ends-with': "off"; + '@typescript-eslint/promise-function-async': "off"; + '@typescript-eslint/related-getter-setter-pairs': "off"; + '@typescript-eslint/require-array-sort-compare': "off"; + '@typescript-eslint/require-await': "off"; + '@typescript-eslint/restrict-plus-operands': "off"; + '@typescript-eslint/restrict-template-expressions': "off"; + '@typescript-eslint/return-await': "off"; + '@typescript-eslint/strict-boolean-expressions': "off"; + '@typescript-eslint/strict-void-return': "off"; + '@typescript-eslint/switch-exhaustiveness-check': "off"; + '@typescript-eslint/unbound-method': "off"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "off"; + }; + }; + 'eslint-recommended': { + overrides: { + files: string[]; + rules: Record; + }[]; + }; + recommended: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + }; + }; + 'recommended-requiring-type-checking': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + 'recommended-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + 'recommended-type-checked-only': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + strict: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unified-signatures': "error"; + }; + }; + 'strict-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + 'strict-type-checked-only': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + stylistic: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + }; + }; + 'stylistic-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; + }; + 'stylistic-type-checked-only': { + extends: string[]; + rules: { + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; + }; + }; + meta: { + name: string; + namespace: string; + version: string; + }; + rules: { + 'adjacent-overload-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<"adjacentSignature", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'array-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'await-thenable': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'ban-ts-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'ban-tslint-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentDetected", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'class-literal-property-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'class-methods-use-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", import("./rules/class-methods-use-this").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-generic-constructors': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-indexed-object-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({ + treatUndefinedAsUnspecified?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-type-assertions': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-type-definitions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-type-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-type-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'default-param-last': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeLast", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'dot-notation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{ + allowIndexSignaturePropertyAccess?: boolean; + allowKeywords?: boolean; + allowPattern?: string; + allowPrivateClassPropertyAccess?: boolean; + allowProtectedClassPropertyAccess?: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'explicit-function-return-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", import("./rules/explicit-function-return-type").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'explicit-member-accessibility': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'explicit-module-boundary-types': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'init-declarations': import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({ + ignoreForLoopInit?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'max-params': import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({ + countVoidThis?: boolean; + max: number; + } | { + countVoidThis?: boolean; + maximum: number; + })[], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'member-ordering': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'method-signature-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'naming-convention': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-array-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLiteral", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-array-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-base-to-string': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-confusing-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-confusing-void-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-deprecated': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deprecated" | "deprecatedWithReason", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-dupe-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-duplicate-enum-values': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateValue", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-duplicate-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-dynamic-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-empty-function': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestComment" | "unexpected", [{ + allow?: string[]; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-empty-interface': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-explicit-any': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-extra-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExtraNonNullAssertion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-extraneous-class': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-floating-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-generated-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-import-type-side-effects': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useTopLevelQualifier", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-inferrable-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", import("./rules/no-inferrable-types").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-invalid-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({ + capIsConstructor?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-invalid-void-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-loop-func': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeRefs", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-loss-of-precision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-magic-numbers': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{ + detectObjects?: boolean; + enforceConst?: boolean; + ignore?: (number | string)[]; + ignoreArrayIndexes?: boolean; + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; + ignoreTypeIndexes?: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-misused-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-misused-spread': import("@typescript-eslint/utils/ts-eslint").RuleModule<"addAwait" | "noArraySpreadInObject" | "noClassDeclarationSpreadInObject" | "noClassInstanceSpreadInObject" | "noFunctionSpreadInObject" | "noIterableSpreadInObject" | "noMapSpreadInObject" | "noPromiseSpreadInObject" | "noStringSpread" | "replaceMapSpreadInObject", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-mixed-enums': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-namespace': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", import("./rules/no-namespace").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-asserted-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullOptionalChain" | "suggestRemovingNonNull", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-shadow': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-this-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-type-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-boolean-literal-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-condition': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-parameter-property-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryAssign", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-qualifier': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryQualifier", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-template-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUnnecessaryTemplateExpression", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeObjectPattern", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-call': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedExpression", [{ + allowShortCircuit?: boolean; + allowTaggedTemplates?: boolean; + allowTernary?: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-private-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedPrivateClassMember", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./rules/no-use-before-define").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{ + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-var-requires': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVarReqs", import("./rules/no-var-requires").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-wrapper-object-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedClassType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'non-nullable-type-assertion-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonNullAssertion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'only-throw-error': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'parameter-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-as-const': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferDestructuring", import("./rules/prefer-destructuring").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-enum-initializers': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-find': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferFind" | "preferFindSuggestion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-for-of': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferForOf", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-includes': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-literal-enum-member': import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{ + allowBitwiseExpressions: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-namespace-keyword': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-promise-reject-errors': import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", import("./rules/prefer-promise-reject-errors").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-readonly': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferReadonly", import("./rules/prefer-readonly").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-readonly-parameter-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", import("./rules/prefer-readonly-parameter-types").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-reduce-type-parameter': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-regexp-exec': import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-return-this-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-string-starts-ends-with': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-ts-expect-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'promise-function-async': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'related-getter-setter-pairs': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'require-array-sort-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", import("./rules/require-array-sort-compare").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'require-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'restrict-plus-operands': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'restrict-template-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", import("./rules/restrict-template-expressions").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'return-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'sort-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{ + allowReturnAny?: boolean; + }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'triple-slash-reference': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", import("./rules/triple-slash-reference").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + typedef: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'unbound-method': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'unified-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'use-unknown-in-catch-callback-variable': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.js new file mode 100644 index 00000000..0b3f1048 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/index.js @@ -0,0 +1,54 @@ +"use strict"; +/* eslint-disable import/first -- intentionally executing code before rest of the require()s. This will not work with ESM. */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +const ts = __importStar(require("typescript")); +const [versionMajor, _versionMinor] = ts.versionMajorMinor + .split('.') + .map(Number); +if (versionMajor >= 7) { + // eslint-disable-next-line no-console + console.error([ + 'typescript-eslint does not support TS 7.0.', + 'Please see https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/#running-side-by-side-with-typescript-6.0 to run typescript-eslint using the TS 6 API.', + "See also https://github.com/typescript-eslint/typescript-eslint/issues/10940 for tracking typescript-eslint's support for TS >=7.1", + ].join('\n')); + throw new Error('typescript-eslint does not support TS 7.0.'); +} +const raw_plugin_1 = __importDefault(require("./raw-plugin")); +module.exports = raw_plugin_1.default.plugin; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts new file mode 100644 index 00000000..be22676f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts @@ -0,0 +1,1155 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; +declare const _default: { + flatConfigs: { + 'flat/all': FlatConfig.ConfigArray; + 'flat/base': FlatConfig.Config; + 'flat/disable-type-checked': FlatConfig.Config; + 'flat/eslint-recommended': FlatConfig.Config; + 'flat/recommended': FlatConfig.ConfigArray; + 'flat/recommended-type-checked': FlatConfig.ConfigArray; + 'flat/recommended-type-checked-only': FlatConfig.ConfigArray; + 'flat/strict': FlatConfig.ConfigArray; + 'flat/strict-type-checked': FlatConfig.ConfigArray; + 'flat/strict-type-checked-only': FlatConfig.ConfigArray; + 'flat/stylistic': FlatConfig.ConfigArray; + 'flat/stylistic-type-checked': FlatConfig.ConfigArray; + 'flat/stylistic-type-checked-only': FlatConfig.ConfigArray; + }; + parser: { + meta?: { [K in keyof TSESLint.Parser.ParserMeta]?: TSESLint.Parser.ParserMeta[K] | undefined; }; + parseForESLint(text: string, options?: unknown): { [k in keyof TSESLint.Parser.ParseResult]: unknown; }; + }; + plugin: { + configs: { + all: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + 'class-methods-use-this': "off"; + '@typescript-eslint/class-methods-use-this': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + 'consistent-return': "off"; + '@typescript-eslint/consistent-return': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/consistent-type-exports': "error"; + '@typescript-eslint/consistent-type-imports': "error"; + 'default-param-last': "off"; + '@typescript-eslint/default-param-last': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/explicit-function-return-type': "error"; + '@typescript-eslint/explicit-member-accessibility': "error"; + '@typescript-eslint/explicit-module-boundary-types': "error"; + 'init-declarations': "off"; + '@typescript-eslint/init-declarations': "error"; + 'max-params': "off"; + '@typescript-eslint/max-params': "error"; + '@typescript-eslint/member-ordering': "error"; + '@typescript-eslint/method-signature-style': "error"; + '@typescript-eslint/naming-convention': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + 'no-dupe-class-members': "off"; + '@typescript-eslint/no-dupe-class-members': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-import-type-side-effects': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + 'no-invalid-this': "off"; + '@typescript-eslint/no-invalid-this': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + 'no-magic-numbers': "off"; + '@typescript-eslint/no-magic-numbers': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + 'no-redeclare': "off"; + '@typescript-eslint/no-redeclare': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-restricted-types': "error"; + 'no-shadow': "off"; + '@typescript-eslint/no-shadow': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-parameter-property-assignment': "error"; + '@typescript-eslint/no-unnecessary-qualifier': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-type-assertion': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-private-class-members': "off"; + '@typescript-eslint/no-unused-private-class-members': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-use-before-define': "off"; + '@typescript-eslint/no-use-before-define': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-useless-empty-export': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/parameter-properties': "error"; + '@typescript-eslint/prefer-as-const': "error"; + 'prefer-destructuring': "off"; + '@typescript-eslint/prefer-destructuring': "error"; + '@typescript-eslint/prefer-enum-initializers': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-readonly': "error"; + '@typescript-eslint/prefer-readonly-parameter-types': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + '@typescript-eslint/promise-function-async': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + '@typescript-eslint/require-array-sort-compare': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + 'no-return-await': "off"; + '@typescript-eslint/return-await': "error"; + '@typescript-eslint/strict-boolean-expressions': "error"; + '@typescript-eslint/strict-void-return': "error"; + '@typescript-eslint/switch-exhaustiveness-check': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + base: { + parser: string; + parserOptions: { + sourceType: "module"; + }; + plugins: string[]; + }; + 'disable-type-checked': { + parserOptions: { + program: null; + project: false; + projectService: false; + }; + rules: { + '@typescript-eslint/await-thenable': "off"; + '@typescript-eslint/consistent-return': "off"; + '@typescript-eslint/consistent-type-exports': "off"; + '@typescript-eslint/dot-notation': "off"; + '@typescript-eslint/naming-convention': "off"; + '@typescript-eslint/no-array-delete': "off"; + '@typescript-eslint/no-base-to-string': "off"; + '@typescript-eslint/no-confusing-void-expression': "off"; + '@typescript-eslint/no-deprecated': "off"; + '@typescript-eslint/no-duplicate-type-constituents': "off"; + '@typescript-eslint/no-floating-promises': "off"; + '@typescript-eslint/no-for-in-array': "off"; + '@typescript-eslint/no-generated-empty-object-type': "off"; + '@typescript-eslint/no-implied-eval': "off"; + '@typescript-eslint/no-meaningless-void-operator': "off"; + '@typescript-eslint/no-misused-promises': "off"; + '@typescript-eslint/no-misused-spread': "off"; + '@typescript-eslint/no-mixed-enums': "off"; + '@typescript-eslint/no-redundant-type-constituents': "off"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "off"; + '@typescript-eslint/no-unnecessary-condition': "off"; + '@typescript-eslint/no-unnecessary-qualifier': "off"; + '@typescript-eslint/no-unnecessary-template-expression': "off"; + '@typescript-eslint/no-unnecessary-type-arguments': "off"; + '@typescript-eslint/no-unnecessary-type-assertion': "off"; + '@typescript-eslint/no-unnecessary-type-conversion': "off"; + '@typescript-eslint/no-unnecessary-type-parameters': "off"; + '@typescript-eslint/no-unsafe-argument': "off"; + '@typescript-eslint/no-unsafe-assignment': "off"; + '@typescript-eslint/no-unsafe-call': "off"; + '@typescript-eslint/no-unsafe-enum-comparison': "off"; + '@typescript-eslint/no-unsafe-member-access': "off"; + '@typescript-eslint/no-unsafe-return': "off"; + '@typescript-eslint/no-unsafe-type-assertion': "off"; + '@typescript-eslint/no-unsafe-unary-minus': "off"; + '@typescript-eslint/no-useless-default-assignment': "off"; + '@typescript-eslint/non-nullable-type-assertion-style': "off"; + '@typescript-eslint/only-throw-error': "off"; + '@typescript-eslint/prefer-destructuring': "off"; + '@typescript-eslint/prefer-find': "off"; + '@typescript-eslint/prefer-includes': "off"; + '@typescript-eslint/prefer-nullish-coalescing': "off"; + '@typescript-eslint/prefer-optional-chain': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-readonly': "off"; + '@typescript-eslint/prefer-readonly-parameter-types': "off"; + '@typescript-eslint/prefer-reduce-type-parameter': "off"; + '@typescript-eslint/prefer-regexp-exec': "off"; + '@typescript-eslint/prefer-return-this-type': "off"; + '@typescript-eslint/prefer-string-starts-ends-with': "off"; + '@typescript-eslint/promise-function-async': "off"; + '@typescript-eslint/related-getter-setter-pairs': "off"; + '@typescript-eslint/require-array-sort-compare': "off"; + '@typescript-eslint/require-await': "off"; + '@typescript-eslint/restrict-plus-operands': "off"; + '@typescript-eslint/restrict-template-expressions': "off"; + '@typescript-eslint/return-await': "off"; + '@typescript-eslint/strict-boolean-expressions': "off"; + '@typescript-eslint/strict-void-return': "off"; + '@typescript-eslint/switch-exhaustiveness-check': "off"; + '@typescript-eslint/unbound-method': "off"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "off"; + }; + }; + 'eslint-recommended': { + overrides: { + files: string[]; + rules: Record; + }[]; + }; + recommended: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + }; + }; + /** @deprecated - please use "recommended-type-checked" instead. */ + 'recommended-requiring-type-checking': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + 'recommended-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': "error"; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + 'recommended-type-checked-only': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': "error"; + '@typescript-eslint/restrict-template-expressions': "error"; + '@typescript-eslint/unbound-method': "error"; + }; + }; + strict: { + extends: string[]; + rules: { + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unified-signatures': "error"; + }; + }; + 'strict-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/ban-ts-comment': ["error", { + minimumDescriptionLength: number; + }]; + 'no-array-constructor': "off"; + '@typescript-eslint/no-array-constructor': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-enum-values': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-dynamic-delete': "error"; + '@typescript-eslint/no-empty-object-type': "error"; + '@typescript-eslint/no-explicit-any': "error"; + '@typescript-eslint/no-extra-non-null-assertion': "error"; + '@typescript-eslint/no-extraneous-class': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-invalid-void-type': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-new': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-namespace': "error"; + '@typescript-eslint/no-non-null-asserted-nullish-coalescing': "error"; + '@typescript-eslint/no-non-null-asserted-optional-chain': "error"; + '@typescript-eslint/no-non-null-assertion': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-require-imports': "error"; + '@typescript-eslint/no-this-alias': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-constraint': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-declaration-merging': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-function-type': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + 'no-unused-expressions': "off"; + '@typescript-eslint/no-unused-expressions': "error"; + 'no-unused-vars': "off"; + '@typescript-eslint/no-unused-vars': "error"; + 'no-useless-constructor': "off"; + '@typescript-eslint/no-useless-constructor': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + '@typescript-eslint/no-wrapper-object-types': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + '@typescript-eslint/prefer-as-const': "error"; + '@typescript-eslint/prefer-literal-enum-member': "error"; + '@typescript-eslint/prefer-namespace-keyword': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/triple-slash-reference': "error"; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/unified-signatures': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + 'strict-type-checked-only': { + extends: string[]; + rules: { + '@typescript-eslint/await-thenable': "error"; + '@typescript-eslint/no-array-delete': "error"; + '@typescript-eslint/no-base-to-string': "error"; + '@typescript-eslint/no-confusing-void-expression': "error"; + '@typescript-eslint/no-deprecated': "error"; + '@typescript-eslint/no-duplicate-type-constituents': "error"; + '@typescript-eslint/no-floating-promises': "error"; + '@typescript-eslint/no-for-in-array': "error"; + '@typescript-eslint/no-generated-empty-object-type': "error"; + 'no-implied-eval': "off"; + '@typescript-eslint/no-implied-eval': "error"; + '@typescript-eslint/no-meaningless-void-operator': "error"; + '@typescript-eslint/no-misused-promises': "error"; + '@typescript-eslint/no-misused-spread': "error"; + '@typescript-eslint/no-mixed-enums': "error"; + '@typescript-eslint/no-redundant-type-constituents': "error"; + '@typescript-eslint/no-unnecessary-boolean-literal-compare': "error"; + '@typescript-eslint/no-unnecessary-condition': "error"; + '@typescript-eslint/no-unnecessary-template-expression': "error"; + '@typescript-eslint/no-unnecessary-type-arguments': "error"; + '@typescript-eslint/no-unnecessary-type-assertion': "error"; + '@typescript-eslint/no-unnecessary-type-conversion': "error"; + '@typescript-eslint/no-unnecessary-type-parameters': "error"; + '@typescript-eslint/no-unsafe-argument': "error"; + '@typescript-eslint/no-unsafe-assignment': "error"; + '@typescript-eslint/no-unsafe-call': "error"; + '@typescript-eslint/no-unsafe-enum-comparison': "error"; + '@typescript-eslint/no-unsafe-member-access': "error"; + '@typescript-eslint/no-unsafe-return': "error"; + '@typescript-eslint/no-unsafe-unary-minus': "error"; + '@typescript-eslint/no-useless-default-assignment': "error"; + 'no-throw-literal': "off"; + '@typescript-eslint/only-throw-error': "error"; + 'prefer-promise-reject-errors': "off"; + '@typescript-eslint/prefer-promise-reject-errors': "error"; + '@typescript-eslint/prefer-reduce-type-parameter': "error"; + '@typescript-eslint/prefer-return-this-type': "error"; + '@typescript-eslint/related-getter-setter-pairs': "error"; + 'require-await': "off"; + '@typescript-eslint/require-await': "error"; + '@typescript-eslint/restrict-plus-operands': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNullish: boolean; + allowNumberAndString: boolean; + allowRegExp: boolean; + }]; + '@typescript-eslint/restrict-template-expressions': ["error", { + allowAny: boolean; + allowBoolean: boolean; + allowNever: boolean; + allowNullish: boolean; + allowNumber: boolean; + allowRegExp: boolean; + }]; + 'no-return-await': "off"; + '@typescript-eslint/return-await': ["error", string]; + '@typescript-eslint/unbound-method': "error"; + '@typescript-eslint/use-unknown-in-catch-callback-variable': "error"; + }; + }; + stylistic: { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + }; + }; + 'stylistic-type-checked': { + extends: string[]; + rules: { + '@typescript-eslint/adjacent-overload-signatures': "error"; + '@typescript-eslint/array-type': "error"; + '@typescript-eslint/ban-tslint-comment': "error"; + '@typescript-eslint/class-literal-property-style': "error"; + '@typescript-eslint/consistent-generic-constructors': "error"; + '@typescript-eslint/consistent-indexed-object-style': "error"; + '@typescript-eslint/consistent-type-assertions': "error"; + '@typescript-eslint/consistent-type-definitions': "error"; + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/no-confusing-non-null-assertion': "error"; + 'no-empty-function': "off"; + '@typescript-eslint/no-empty-function': "error"; + '@typescript-eslint/no-inferrable-types': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-for-of': "error"; + '@typescript-eslint/prefer-function-type': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; + }; + 'stylistic-type-checked-only': { + extends: string[]; + rules: { + 'dot-notation': "off"; + '@typescript-eslint/dot-notation': "error"; + '@typescript-eslint/non-nullable-type-assertion-style': "error"; + '@typescript-eslint/prefer-find': "error"; + '@typescript-eslint/prefer-includes': "error"; + '@typescript-eslint/prefer-nullish-coalescing': "error"; + '@typescript-eslint/prefer-optional-chain': "error"; + '@typescript-eslint/prefer-regexp-exec': "error"; + '@typescript-eslint/prefer-string-starts-ends-with': "error"; + }; + }; + }; + meta: { + name: string; + namespace: string; + version: string; + }; + rules: { + 'adjacent-overload-signatures': TSESLint.RuleModule<"adjacentSignature", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'array-type': TSESLint.RuleModule & { + name: string; + }; + 'await-thenable': TSESLint.RuleModule & { + name: string; + }; + 'ban-ts-comment': TSESLint.RuleModule & { + name: string; + }; + 'ban-tslint-comment': TSESLint.RuleModule<"commentDetected", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'class-literal-property-style': TSESLint.RuleModule & { + name: string; + }; + 'class-methods-use-this': TSESLint.RuleModule<"missingThis", import("./rules/class-methods-use-this").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'consistent-generic-constructors': TSESLint.RuleModule & { + name: string; + }; + 'consistent-indexed-object-style': TSESLint.RuleModule & { + name: string; + }; + 'consistent-return': TSESLint.RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({ + treatUndefinedAsUnspecified?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'consistent-type-assertions': TSESLint.RuleModule & { + name: string; + }; + 'consistent-type-definitions': TSESLint.RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'consistent-type-exports': TSESLint.RuleModule & { + name: string; + }; + 'consistent-type-imports': TSESLint.RuleModule & { + name: string; + }; + 'default-param-last': TSESLint.RuleModule<"shouldBeLast", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'dot-notation': TSESLint.RuleModule<"useBrackets" | "useDot", [{ + allowIndexSignaturePropertyAccess?: boolean; + allowKeywords?: boolean; + allowPattern?: string; + allowPrivateClassPropertyAccess?: boolean; + allowProtectedClassPropertyAccess?: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'explicit-function-return-type': TSESLint.RuleModule<"missingReturnType", import("./rules/explicit-function-return-type").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'explicit-member-accessibility': TSESLint.RuleModule & { + name: string; + }; + 'explicit-module-boundary-types': TSESLint.RuleModule & { + name: string; + }; + 'init-declarations': TSESLint.RuleModule<"initialized" | "notInitialized", ["always" | "never", ({ + ignoreForLoopInit?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'max-params': TSESLint.RuleModule<"exceed", ({ + countVoidThis?: boolean; + max: number; + } | { + countVoidThis?: boolean; + maximum: number; + })[], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'member-ordering': TSESLint.RuleModule & { + name: string; + }; + 'method-signature-style': TSESLint.RuleModule & { + name: string; + }; + 'naming-convention': TSESLint.RuleModule & { + name: string; + }; + 'no-array-constructor': TSESLint.RuleModule<"useLiteral", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-array-delete': TSESLint.RuleModule & { + name: string; + }; + 'no-base-to-string': TSESLint.RuleModule & { + name: string; + }; + 'no-confusing-non-null-assertion': TSESLint.RuleModule & { + name: string; + }; + 'no-confusing-void-expression': TSESLint.RuleModule & { + name: string; + }; + 'no-deprecated': TSESLint.RuleModule<"deprecated" | "deprecatedWithReason", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-dupe-class-members': TSESLint.RuleModule<"unexpected", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-duplicate-enum-values': TSESLint.RuleModule<"duplicateValue", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-duplicate-type-constituents': TSESLint.RuleModule & { + name: string; + }; + 'no-dynamic-delete': TSESLint.RuleModule<"dynamicDelete", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-empty-function': TSESLint.RuleModule<"suggestComment" | "unexpected", [{ + allow?: string[]; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-empty-interface': TSESLint.RuleModule & { + name: string; + }; + 'no-empty-object-type': TSESLint.RuleModule & { + name: string; + }; + 'no-explicit-any': TSESLint.RuleModule & { + name: string; + }; + 'no-extra-non-null-assertion': TSESLint.RuleModule<"noExtraNonNullAssertion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-extraneous-class': TSESLint.RuleModule & { + name: string; + }; + 'no-floating-promises': TSESLint.RuleModule & { + name: string; + }; + 'no-for-in-array': TSESLint.RuleModule<"forInViolation", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-generated-empty-object-type': TSESLint.RuleModule<"noGeneratedEmptyObjectType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-implied-eval': TSESLint.RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-import-type-side-effects': TSESLint.RuleModule<"useTopLevelQualifier", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-inferrable-types': TSESLint.RuleModule<"noInferrableType", import("./rules/no-inferrable-types").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-invalid-this': TSESLint.RuleModule<"unexpectedThis", [({ + capIsConstructor?: boolean; + } | undefined)?], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-invalid-void-type': TSESLint.RuleModule & { + name: string; + }; + 'no-loop-func': TSESLint.RuleModule<"unsafeRefs", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-loss-of-precision': TSESLint.RuleModule<"noLossOfPrecision", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-magic-numbers': TSESLint.RuleModule<"noMagic", [{ + detectObjects?: boolean; + enforceConst?: boolean; + ignore?: (number | string)[]; + ignoreArrayIndexes?: boolean; + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; + ignoreTypeIndexes?: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-meaningless-void-operator': TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./rules/no-meaningless-void-operator").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-misused-new': TSESLint.RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-misused-promises': TSESLint.RuleModule & { + name: string; + }; + 'no-misused-spread': TSESLint.RuleModule<"addAwait" | "noArraySpreadInObject" | "noClassDeclarationSpreadInObject" | "noClassInstanceSpreadInObject" | "noFunctionSpreadInObject" | "noIterableSpreadInObject" | "noMapSpreadInObject" | "noPromiseSpreadInObject" | "noStringSpread" | "replaceMapSpreadInObject", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-mixed-enums': TSESLint.RuleModule<"mixed", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-namespace': TSESLint.RuleModule<"moduleSyntaxIsPreferred", import("./rules/no-namespace").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-non-null-asserted-nullish-coalescing': TSESLint.RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-non-null-asserted-optional-chain': TSESLint.RuleModule<"noNonNullOptionalChain" | "suggestRemovingNonNull", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-non-null-assertion': TSESLint.RuleModule & { + name: string; + }; + 'no-redeclare': TSESLint.RuleModule & { + name: string; + }; + 'no-redundant-type-constituents': TSESLint.RuleModule<"errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-require-imports': TSESLint.RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-restricted-imports': TSESLint.RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-restricted-types': TSESLint.RuleModule & { + name: string; + }; + 'no-shadow': TSESLint.RuleModule & { + name: string; + }; + 'no-this-alias': TSESLint.RuleModule & { + name: string; + }; + 'no-type-alias': TSESLint.RuleModule & { + name: string; + }; + 'no-unnecessary-boolean-literal-compare': TSESLint.RuleModule & { + name: string; + }; + 'no-unnecessary-condition': TSESLint.RuleModule & { + name: string; + }; + 'no-unnecessary-parameter-property-assignment': TSESLint.RuleModule<"unnecessaryAssign", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-qualifier': TSESLint.RuleModule<"unnecessaryQualifier", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-template-expression': TSESLint.RuleModule<"noUnnecessaryTemplateExpression", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-type-arguments': TSESLint.RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-type-assertion': TSESLint.RuleModule & { + name: string; + }; + 'no-unnecessary-type-constraint': TSESLint.RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-type-conversion': TSESLint.RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unnecessary-type-parameters': TSESLint.RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-argument': TSESLint.RuleModule & { + name: string; + }; + 'no-unsafe-assignment': TSESLint.RuleModule<"anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeObjectPattern", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-call': TSESLint.RuleModule & { + name: string; + }; + 'no-unsafe-declaration-merging': TSESLint.RuleModule<"unsafeMerging", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-enum-comparison': TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-function-type': TSESLint.RuleModule<"bannedFunctionType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-member-access': TSESLint.RuleModule & { + name: string; + }; + 'no-unsafe-return': TSESLint.RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-type-assertion': TSESLint.RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unsafe-unary-minus': TSESLint.RuleModule<"unaryMinus", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unused-expressions': TSESLint.RuleModule<"unusedExpression", [{ + allowShortCircuit?: boolean; + allowTaggedTemplates?: boolean; + allowTernary?: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unused-private-class-members': TSESLint.RuleModule<"unusedPrivateClassMember", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-unused-vars': TSESLint.RuleModule & { + name: string; + }; + 'no-use-before-define': TSESLint.RuleModule<"noUseBeforeDefine", import("./rules/no-use-before-define").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-useless-constructor': TSESLint.RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-useless-default-assignment': TSESLint.RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{ + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-useless-empty-export': TSESLint.RuleModule<"uselessExport", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-var-requires': TSESLint.RuleModule<"noVarReqs", import("./rules/no-var-requires").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'no-wrapper-object-types': TSESLint.RuleModule<"bannedClassType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'non-nullable-type-assertion-style': TSESLint.RuleModule<"preferNonNullAssertion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'only-throw-error': TSESLint.RuleModule & { + name: string; + }; + 'parameter-properties': TSESLint.RuleModule & { + name: string; + }; + 'prefer-as-const': TSESLint.RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-destructuring': TSESLint.RuleModule<"preferDestructuring", import("./rules/prefer-destructuring").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-enum-initializers': TSESLint.RuleModule & { + name: string; + }; + 'prefer-find': TSESLint.RuleModule<"preferFind" | "preferFindSuggestion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-for-of': TSESLint.RuleModule<"preferForOf", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-function-type': TSESLint.RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-includes': TSESLint.RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-literal-enum-member': TSESLint.RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{ + allowBitwiseExpressions: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-namespace-keyword': TSESLint.RuleModule<"useNamespace", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-nullish-coalescing': TSESLint.RuleModule & { + name: string; + }; + 'prefer-optional-chain': TSESLint.RuleModule & { + name: string; + }; + 'prefer-promise-reject-errors': TSESLint.RuleModule<"rejectAnError", import("./rules/prefer-promise-reject-errors").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-readonly': TSESLint.RuleModule<"preferReadonly", import("./rules/prefer-readonly").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-readonly-parameter-types': TSESLint.RuleModule<"shouldBeReadonly", import("./rules/prefer-readonly-parameter-types").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-reduce-type-parameter': TSESLint.RuleModule<"preferTypeParameter", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-regexp-exec': TSESLint.RuleModule<"regExpExecOverStringMatch", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-return-this-type': TSESLint.RuleModule<"useThisType", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'prefer-string-starts-ends-with': TSESLint.RuleModule & { + name: string; + }; + 'prefer-ts-expect-error': TSESLint.RuleModule<"preferExpectErrorComment", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'promise-function-async': TSESLint.RuleModule & { + name: string; + }; + 'related-getter-setter-pairs': TSESLint.RuleModule<"mismatch", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'require-array-sort-compare': TSESLint.RuleModule<"requireCompare", import("./rules/require-array-sort-compare").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'require-await': TSESLint.RuleModule<"missingAwait" | "removeAsync", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'restrict-plus-operands': TSESLint.RuleModule & { + name: string; + }; + 'restrict-template-expressions': TSESLint.RuleModule<"invalidType", import("./rules/restrict-template-expressions").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'return-await': TSESLint.RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'sort-type-constituents': TSESLint.RuleModule & { + name: string; + }; + 'strict-boolean-expressions': TSESLint.RuleModule & { + name: string; + }; + 'strict-void-return': TSESLint.RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{ + allowReturnAny?: boolean; + }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + 'switch-exhaustiveness-check': TSESLint.RuleModule & { + name: string; + }; + 'triple-slash-reference': TSESLint.RuleModule<"tripleSlashReference", import("./rules/triple-slash-reference").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; + }; + typedef: TSESLint.RuleModule & { + name: string; + }; + 'unbound-method': TSESLint.RuleModule & { + name: string; + }; + 'unified-signatures': TSESLint.RuleModule & { + name: string; + }; + 'use-unknown-in-catch-callback-variable': TSESLint.RuleModule & { + name: string; + }; + }; + }; +}; +export = _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.js new file mode 100644 index 00000000..7c30155d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.js @@ -0,0 +1,123 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +const parserBase = __importStar(require("@typescript-eslint/parser")); +const all_1 = __importDefault(require("./configs/eslintrc/all")); +const base_1 = __importDefault(require("./configs/eslintrc/base")); +const disable_type_checked_1 = __importDefault(require("./configs/eslintrc/disable-type-checked")); +const eslint_recommended_1 = __importDefault(require("./configs/eslintrc/eslint-recommended")); +const recommended_1 = __importDefault(require("./configs/eslintrc/recommended")); +const recommended_type_checked_1 = __importDefault(require("./configs/eslintrc/recommended-type-checked")); +const recommended_type_checked_only_1 = __importDefault(require("./configs/eslintrc/recommended-type-checked-only")); +const strict_1 = __importDefault(require("./configs/eslintrc/strict")); +const strict_type_checked_1 = __importDefault(require("./configs/eslintrc/strict-type-checked")); +const strict_type_checked_only_1 = __importDefault(require("./configs/eslintrc/strict-type-checked-only")); +const stylistic_1 = __importDefault(require("./configs/eslintrc/stylistic")); +const stylistic_type_checked_1 = __importDefault(require("./configs/eslintrc/stylistic-type-checked")); +const stylistic_type_checked_only_1 = __importDefault(require("./configs/eslintrc/stylistic-type-checked-only")); +const all_2 = __importDefault(require("./configs/flat/all")); +const base_2 = __importDefault(require("./configs/flat/base")); +const disable_type_checked_2 = __importDefault(require("./configs/flat/disable-type-checked")); +const eslint_recommended_2 = __importDefault(require("./configs/flat/eslint-recommended")); +const recommended_2 = __importDefault(require("./configs/flat/recommended")); +const recommended_type_checked_2 = __importDefault(require("./configs/flat/recommended-type-checked")); +const recommended_type_checked_only_2 = __importDefault(require("./configs/flat/recommended-type-checked-only")); +const strict_2 = __importDefault(require("./configs/flat/strict")); +const strict_type_checked_2 = __importDefault(require("./configs/flat/strict-type-checked")); +const strict_type_checked_only_2 = __importDefault(require("./configs/flat/strict-type-checked-only")); +const stylistic_2 = __importDefault(require("./configs/flat/stylistic")); +const stylistic_type_checked_2 = __importDefault(require("./configs/flat/stylistic-type-checked")); +const stylistic_type_checked_only_2 = __importDefault(require("./configs/flat/stylistic-type-checked-only")); +const rules_1 = __importDefault(require("./rules")); +const parser = { + meta: parserBase.meta, + parseForESLint: parserBase.parseForESLint, +}; +// note - cannot migrate this to an import statement because it will make TSC copy the package.json to the dist folder +const { name, version } = require('../package.json'); +const plugin = { + // not fully initialized yet. + // See https://eslint.org/docs/latest/extend/plugins#configs-in-plugins + configs: { + all: all_1.default, + base: base_1.default, + 'disable-type-checked': disable_type_checked_1.default, + 'eslint-recommended': eslint_recommended_1.default, + recommended: recommended_1.default, + /** @deprecated - please use "recommended-type-checked" instead. */ + 'recommended-requiring-type-checking': recommended_type_checked_1.default, + 'recommended-type-checked': recommended_type_checked_1.default, + 'recommended-type-checked-only': recommended_type_checked_only_1.default, + strict: strict_1.default, + 'strict-type-checked': strict_type_checked_1.default, + 'strict-type-checked-only': strict_type_checked_only_1.default, + stylistic: stylistic_1.default, + 'stylistic-type-checked': stylistic_type_checked_1.default, + 'stylistic-type-checked-only': stylistic_type_checked_only_1.default, + }, + meta: { + name, + namespace: '@typescript-eslint', + version, + }, + rules: rules_1.default, +}; +// @ts-expect-error -- upstream type incompatibility stuff +const flatPlugin = plugin; +// included due to https://github.com/eslint/eslint/issues/19513 +const flatConfigs = { + 'flat/all': (0, all_2.default)(flatPlugin, parser), + 'flat/base': (0, base_2.default)(flatPlugin, parser), + 'flat/disable-type-checked': (0, disable_type_checked_2.default)(flatPlugin, parser), + 'flat/eslint-recommended': (0, eslint_recommended_2.default)(flatPlugin, parser), + 'flat/recommended': (0, recommended_2.default)(flatPlugin, parser), + 'flat/recommended-type-checked': (0, recommended_type_checked_2.default)(flatPlugin, parser), + 'flat/recommended-type-checked-only': (0, recommended_type_checked_only_2.default)(flatPlugin, parser), + 'flat/strict': (0, strict_2.default)(flatPlugin, parser), + 'flat/strict-type-checked': (0, strict_type_checked_2.default)(flatPlugin, parser), + 'flat/strict-type-checked-only': (0, strict_type_checked_only_2.default)(flatPlugin, parser), + 'flat/stylistic': (0, stylistic_2.default)(flatPlugin, parser), + 'flat/stylistic-type-checked': (0, stylistic_type_checked_2.default)(flatPlugin, parser), + 'flat/stylistic-type-checked-only': (0, stylistic_type_checked_only_2.default)(flatPlugin, parser), +}; +Object.assign(plugin.configs, flatConfigs); +module.exports = { + flatConfigs, + parser, + plugin, +}; +//# sourceMappingURL=raw-plugin.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.d.ts new file mode 100644 index 00000000..c984bfa8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"adjacentSignature", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js new file mode 100644 index 00000000..0bf8a18d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js @@ -0,0 +1,125 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'adjacent-overload-signatures', + meta: { + type: 'suggestion', + docs: { + description: 'Require that function overload signatures be consecutive', + recommended: 'stylistic', + }, + messages: { + adjacentSignature: 'All {{name}} signatures should be adjacent.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + /** + * Gets the name and attribute of the member being processed. + * @param member the member being processed. + * @returns the name and attribute of the member or null if it's a member not relevant to the rule. + */ + function getMemberMethod(member) { + switch (member.type) { + case utils_1.AST_NODE_TYPES.ExportDefaultDeclaration: + case utils_1.AST_NODE_TYPES.ExportNamedDeclaration: { + // export statements (e.g. export { a };) + // have no declarations, so ignore them + if (!member.declaration) { + return null; + } + return getMemberMethod(member.declaration); + } + case utils_1.AST_NODE_TYPES.TSDeclareFunction: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: { + const name = member.id?.name ?? null; + if (name == null) { + return null; + } + return { + name, + type: util_1.MemberNameType.Normal, + callSignature: false, + }; + } + case utils_1.AST_NODE_TYPES.TSMethodSignature: + case utils_1.AST_NODE_TYPES.MethodDefinition: + return { + ...(0, util_1.getNameFromMember)(member, context.sourceCode), + callSignature: false, + static: member.static, + }; + case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration: + return { + name: 'call', + type: util_1.MemberNameType.Normal, + callSignature: true, + }; + case utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration: + return { + name: 'new', + type: util_1.MemberNameType.Normal, + callSignature: false, + }; + } + return null; + } + function isSameMethod(method1, method2) { + return (!!method2 && + method1.name === method2.name && + method1.static === method2.static && + method1.callSignature === method2.callSignature && + method1.type === method2.type); + } + function getMembers(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.ClassBody: + case utils_1.AST_NODE_TYPES.Program: + case utils_1.AST_NODE_TYPES.TSModuleBlock: + case utils_1.AST_NODE_TYPES.TSInterfaceBody: + case utils_1.AST_NODE_TYPES.BlockStatement: + return node.body; + case utils_1.AST_NODE_TYPES.TSTypeLiteral: + return node.members; + } + } + function checkBodyForOverloadMethods(node) { + const members = getMembers(node); + let lastMethod = null; + const seenMethods = []; + members.forEach(member => { + const method = getMemberMethod(member); + if (method == null) { + lastMethod = null; + return; + } + const index = seenMethods.findIndex(seenMethod => isSameMethod(method, seenMethod)); + if (index > -1 && !isSameMethod(method, lastMethod)) { + context.report({ + node: member, + messageId: 'adjacentSignature', + data: { + name: `${method.static ? 'static ' : ''}${method.name}`, + }, + }); + } + else if (index === -1) { + seenMethods.push(method); + } + lastMethod = method; + }); + } + return { + BlockStatement: checkBodyForOverloadMethods, + ClassBody: checkBodyForOverloadMethods, + Program: checkBodyForOverloadMethods, + TSInterfaceBody: checkBodyForOverloadMethods, + TSModuleBlock: checkBodyForOverloadMethods, + TSTypeLiteral: checkBodyForOverloadMethods, + }; + }, +}); +//# sourceMappingURL=adjacent-overload-signatures.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.d.ts new file mode 100644 index 00000000..644e209b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.d.ts @@ -0,0 +1,12 @@ +export type OptionString = 'array' | 'array-simple' | 'generic'; +export type Options = [ + { + default: OptionString; + readonly?: OptionString; + } +]; +export type MessageIds = 'errorStringArray' | 'errorStringArrayReadonly' | 'errorStringArraySimple' | 'errorStringArraySimpleReadonly' | 'errorStringGeneric' | 'errorStringGenericSimple'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.js new file mode 100644 index 00000000..2ba96407 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/array-type.js @@ -0,0 +1,225 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +/** + * Check whatever node can be considered as simple + * @param node the node to be evaluated. + */ +function isSimpleType(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.Identifier: + case utils_1.AST_NODE_TYPES.TSAnyKeyword: + case utils_1.AST_NODE_TYPES.TSBooleanKeyword: + case utils_1.AST_NODE_TYPES.TSNeverKeyword: + case utils_1.AST_NODE_TYPES.TSNumberKeyword: + case utils_1.AST_NODE_TYPES.TSBigIntKeyword: + case utils_1.AST_NODE_TYPES.TSObjectKeyword: + case utils_1.AST_NODE_TYPES.TSStringKeyword: + case utils_1.AST_NODE_TYPES.TSSymbolKeyword: + case utils_1.AST_NODE_TYPES.TSUnknownKeyword: + case utils_1.AST_NODE_TYPES.TSVoidKeyword: + case utils_1.AST_NODE_TYPES.TSNullKeyword: + case utils_1.AST_NODE_TYPES.TSArrayType: + case utils_1.AST_NODE_TYPES.TSUndefinedKeyword: + case utils_1.AST_NODE_TYPES.TSThisType: + case utils_1.AST_NODE_TYPES.TSQualifiedName: + return true; + case utils_1.AST_NODE_TYPES.TSTypeReference: + if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + node.typeName.name === 'Array') { + if (!node.typeArguments) { + return true; + } + if (node.typeArguments.params.length === 1) { + return isSimpleType(node.typeArguments.params[0]); + } + } + else { + if (node.typeArguments) { + return false; + } + return isSimpleType(node.typeName); + } + return false; + default: + return false; + } +} +/** + * Check if node needs parentheses + * @param node the node to be evaluated. + */ +function typeNeedsParentheses(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSTypeReference: + return typeNeedsParentheses(node.typeName); + case utils_1.AST_NODE_TYPES.TSUnionType: + case utils_1.AST_NODE_TYPES.TSFunctionType: + case utils_1.AST_NODE_TYPES.TSIntersectionType: + case utils_1.AST_NODE_TYPES.TSTypeOperator: + case utils_1.AST_NODE_TYPES.TSInferType: + case utils_1.AST_NODE_TYPES.TSConstructorType: + case utils_1.AST_NODE_TYPES.TSConditionalType: + return true; + case utils_1.AST_NODE_TYPES.Identifier: + return node.name === 'ReadonlyArray'; + default: + return false; + } +} +exports.default = (0, util_1.createRule)({ + name: 'array-type', + meta: { + type: 'suggestion', + docs: { + description: 'Require consistently using either `T[]` or `Array` for arrays', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + errorStringArray: "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}[]' instead.", + errorStringArrayReadonly: "Array type using '{{className}}<{{type}}>' is forbidden. Use '{{readonlyPrefix}}{{type}}' instead.", + errorStringArraySimple: "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}[]' instead.", + errorStringArraySimpleReadonly: "Array type using '{{className}}<{{type}}>' is forbidden for simple types. Use '{{readonlyPrefix}}{{type}}' instead.", + errorStringGeneric: "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden. Use '{{className}}<{{type}}>' instead.", + errorStringGenericSimple: "Array type using '{{readonlyPrefix}}{{type}}[]' is forbidden for non-simple types. Use '{{className}}<{{type}}>' instead.", + }, + schema: [ + { + type: 'object', + $defs: { + arrayOption: { + type: 'string', + enum: ['array', 'generic', 'array-simple'], + }, + }, + additionalProperties: false, + properties: { + default: { + $ref: '#/items/0/$defs/arrayOption', + description: 'The array type expected for mutable cases.', + }, + readonly: { + $ref: '#/items/0/$defs/arrayOption', + description: 'The array type expected for readonly cases. If omitted, the value for `default` will be used.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + default: 'array', + }, + ], + create(context, [options]) { + const defaultOption = options.default; + const readonlyOption = options.readonly ?? defaultOption; + /** + * @param node the node to be evaluated. + */ + function getMessageType(node) { + if (isSimpleType(node)) { + return context.sourceCode.getText(node); + } + return 'T'; + } + return { + TSArrayType(node) { + const isReadonly = node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + node.parent.operator === 'readonly'; + const currentOption = isReadonly ? readonlyOption : defaultOption; + if (currentOption === 'array' || + (currentOption === 'array-simple' && isSimpleType(node.elementType))) { + return; + } + const messageId = currentOption === 'generic' + ? 'errorStringGeneric' + : 'errorStringGenericSimple'; + const errorNode = isReadonly ? node.parent : node; + context.report({ + node: errorNode, + messageId, + data: { + type: getMessageType(node.elementType), + className: isReadonly ? 'ReadonlyArray' : 'Array', + readonlyPrefix: isReadonly ? 'readonly ' : '', + }, + fix(fixer) { + const typeNode = node.elementType; + const arrayType = isReadonly ? 'ReadonlyArray' : 'Array'; + return [ + fixer.replaceTextRange([errorNode.range[0], typeNode.range[0]], `${arrayType}<`), + fixer.replaceTextRange([typeNode.range[1], errorNode.range[1]], '>'), + ]; + }, + }); + }, + TSTypeReference(node) { + if (node.typeName.type !== utils_1.AST_NODE_TYPES.Identifier || + !(node.typeName.name === 'Array' || + node.typeName.name === 'ReadonlyArray' || + node.typeName.name === 'Readonly') || + (node.typeName.name === 'Readonly' && + node.typeArguments?.params[0].type !== utils_1.AST_NODE_TYPES.TSArrayType)) { + return; + } + for (let scope = context.sourceCode.getScope(node); scope.upper; scope = scope.upper) { + if (scope.set.has(node.typeName.name)) { + return; + } + } + const isReadonlyWithGenericArrayType = node.typeName.name === 'Readonly' && + node.typeArguments?.params[0].type === utils_1.AST_NODE_TYPES.TSArrayType; + const isReadonlyArrayType = node.typeName.name === 'ReadonlyArray' || + isReadonlyWithGenericArrayType; + const currentOption = isReadonlyArrayType + ? readonlyOption + : defaultOption; + if (currentOption === 'generic') { + return; + } + const readonlyPrefix = isReadonlyArrayType ? 'readonly ' : ''; + const typeParams = node.typeArguments?.params; + const messageId = currentOption === 'array' + ? isReadonlyWithGenericArrayType + ? 'errorStringArrayReadonly' + : 'errorStringArray' + : isReadonlyArrayType && node.typeName.name !== 'ReadonlyArray' + ? 'errorStringArraySimpleReadonly' + : 'errorStringArraySimple'; + if (!typeParams) { + return; + } + if (typeParams.length !== 1 || + (currentOption === 'array-simple' && !isSimpleType(typeParams[0]))) { + return; + } + const type = typeParams[0]; + const typeParens = typeNeedsParentheses(type); + const parentParens = readonlyPrefix && + node.parent.type === utils_1.AST_NODE_TYPES.TSArrayType && + !(0, util_1.isParenthesized)(node.parent.elementType, context.sourceCode); + const start = `${parentParens ? '(' : ''}${readonlyPrefix}${typeParens ? '(' : ''}`; + const end = `${typeParens ? ')' : ''}${isReadonlyWithGenericArrayType ? '' : `[]`}${parentParens ? ')' : ''}`; + context.report({ + node, + messageId, + data: { + type: getMessageType(type), + className: isReadonlyArrayType ? node.typeName.name : 'Array', + readonlyPrefix, + }, + fix(fixer) { + return [ + fixer.replaceTextRange([node.range[0], type.range[0]], start), + fixer.replaceTextRange([type.range[1], node.range[1]], end), + ]; + }, + }); + }, + }; + }, +}); +//# sourceMappingURL=array-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.d.ts new file mode 100644 index 00000000..7b33d78e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageId = 'await' | 'awaitUsingOfNonAsyncDisposable' | 'convertToOrdinaryFor' | 'forAwaitOfNonAsyncIterable' | 'invalidPromiseAggregatorInput' | 'removeAwait'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js new file mode 100644 index 00000000..bbc651f8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js @@ -0,0 +1,240 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +const getForStatementHeadLoc_1 = require("../util/getForStatementHeadLoc"); +const isPromiseAggregatorMethod_1 = require("../util/isPromiseAggregatorMethod"); +exports.default = (0, util_1.createRule)({ + name: 'await-thenable', + meta: { + type: 'problem', + docs: { + description: 'Disallow awaiting a value that is not a Thenable', + recommended: 'recommended', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.', + awaitUsingOfNonAsyncDisposable: 'Unexpected `await using` of a value that is not async disposable.', + convertToOrdinaryFor: 'Convert to an ordinary `for...of` loop.', + forAwaitOfNonAsyncIterable: 'Unexpected `for await...of` of a value that is not async iterable.', + invalidPromiseAggregatorInput: 'Unexpected iterable of non-Promise (non-"Thenable") values passed to promise aggregator.', + removeAwait: 'Remove unnecessary `await`.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + return { + AwaitExpression(node) { + const awaitArgumentEsNode = node.argument; + const awaitArgumentType = services.getTypeAtLocation(awaitArgumentEsNode); + const awaitArgumentTsNode = services.esTreeNodeToTSNodeMap.get(awaitArgumentEsNode); + const certainty = (0, util_1.needsToBeAwaited)(checker, awaitArgumentTsNode, awaitArgumentType); + if (certainty === util_1.Awaitable.Never) { + context.report({ + node, + messageId: 'await', + suggest: [ + { + messageId: 'removeAwait', + fix(fixer) { + const awaitKeyword = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await expression')); + const awaitTokenRemovalRange = (0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitKeyword); + const awaitRemovalFix = fixer.removeRange(awaitTokenRemovalRange); + const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitKeyword), util_1.NullThrowsReasons.MissingToken('operand', 'await expression')); + if ((0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode) || + (0, util_1.isStartOfExpressionStatementNeedingParentheses)(node, firstOperandToken)) { + return [ + awaitRemovalFix, + fixer.insertTextBefore(awaitArgumentEsNode, '('), + fixer.insertTextAfter(awaitArgumentEsNode, ')'), + ]; + } + return awaitRemovalFix; + }, + }, + ], + }); + } + }, + CallExpression(node) { + if (!(0, isPromiseAggregatorMethod_1.isPromiseAggregatorMethod)(context, services, node)) { + return; + } + const argument = node.arguments.at(0); + if (argument == null) { + return; + } + if (argument.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression) { + for (const element of argument.elements) { + if (element == null) { + continue; + } + const type = (0, util_1.getConstrainedTypeAtLocation)(services, element); + const tsNode = services.esTreeNodeToTSNodeMap.get(element); + if (isAlwaysNonAwaitableType(type, tsNode, checker)) { + context.report({ + node: element, + messageId: 'invalidPromiseAggregatorInput', + }); + } + } + return; + } + const type = (0, util_1.getConstrainedTypeAtLocation)(services, argument); + if (isInvalidPromiseAggregatorInput(checker, services.esTreeNodeToTSNodeMap.get(argument), type)) { + context.report({ + node: argument, + messageId: 'invalidPromiseAggregatorInput', + }); + } + }, + 'ForOfStatement[await=true]'(node) { + const type = services.getTypeAtLocation(node.right); + if ((0, util_1.isTypeAnyType)(type)) { + return; + } + const hasAsyncIteratorSymbol = tsutils + .unionConstituents(type) + .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncIterator', checker) != null); + if (!hasAsyncIteratorSymbol) { + context.report({ + loc: (0, getForStatementHeadLoc_1.getForStatementHeadLoc)(context.sourceCode, node), + messageId: 'forAwaitOfNonAsyncIterable', + suggest: [ + // Note that this suggestion causes broken code for sync iterables + // of promises, since the loop variable is not awaited. + { + messageId: 'convertToOrdinaryFor', + fix(fixer) { + const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'for await loop')); + return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken)); + }, + }, + ], + }); + } + }, + 'VariableDeclaration[kind="await using"]'(node) { + for (const declarator of node.declarations) { + const init = declarator.init; + if (init == null) { + continue; + } + const type = services.getTypeAtLocation(init); + if ((0, util_1.isTypeAnyType)(type)) { + continue; + } + const hasAsyncDisposeSymbol = tsutils + .unionConstituents(type) + .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncDispose', checker) != null); + if (!hasAsyncDisposeSymbol) { + context.report({ + node: init, + messageId: 'awaitUsingOfNonAsyncDisposable', + // let the user figure out what to do if there's + // await using a = b, c = d, e = f; + // it's rare and not worth the complexity to handle. + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: node.declarations.length === 1 ? 'suggest' : 'none', + suggestion: { + messageId: 'removeAwait', + fix(fixer) { + const awaitToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword), util_1.NullThrowsReasons.MissingToken('await', 'await using')); + return fixer.removeRange((0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken)); + }, + }, + }), + }); + } + } + }, + }; + }, +}); +function isInvalidPromiseAggregatorInput(checker, node, type) { + // non array/tuple/iterable types already show up as a type error + if (!isIterable(type, checker)) { + return false; + } + for (const part of tsutils.unionConstituents(type)) { + const valueTypes = getValueTypesOfArrayLike(part, checker); + if (valueTypes != null) { + for (const typeArgument of valueTypes) { + if (containsNonAwaitableType(typeArgument, node, checker)) { + return true; + } + } + } + } + return false; +} +function getValueTypesOfArrayLike(type, checker) { + if (checker.isTupleType(type)) { + return checker.getTypeArguments(type); + } + if (checker.isArrayLikeType(type)) { + return [ + (0, util_1.nullThrows)(type.getNumberIndexType(), 'number index type should exist on an array-like'), + ]; + } + // `Iterable<...>` + if (tsutils.isTypeReference(type)) { + return checker.getTypeArguments(type).slice(0, 1); + } + return null; +} +function isAlwaysNonAwaitableType(type, node, checker) { + return tsutils + .unionConstituents(type) + .every(typeArgumentPart => (0, util_1.needsToBeAwaited)(checker, node, typeArgumentPart) === util_1.Awaitable.Never); +} +function containsNonAwaitableType(type, node, checker) { + return tsutils + .unionConstituents(type) + .some(typeArgumentPart => (0, util_1.needsToBeAwaited)(checker, node, typeArgumentPart) === util_1.Awaitable.Never); +} +function isIterable(type, checker) { + return tsutils + .unionConstituents(type) + .every(part => !!tsutils.getWellKnownSymbolPropertyOfType(part, 'iterator', checker)); +} +//# sourceMappingURL=await-thenable.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.d.ts new file mode 100644 index 00000000..0b1cbd5b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.d.ts @@ -0,0 +1,17 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type DirectiveConfig = boolean | 'allow-with-description' | { + descriptionFormat: string; +}; +export interface OptionsShape { + minimumDescriptionLength?: number; + 'ts-check'?: DirectiveConfig; + 'ts-expect-error'?: DirectiveConfig; + 'ts-ignore'?: DirectiveConfig; + 'ts-nocheck'?: DirectiveConfig; +} +export type Options = [OptionsShape]; +export type MessageIds = 'replaceTsIgnoreWithTsExpectError' | 'tsDirectiveComment' | 'tsDirectiveCommentDescriptionNotMatchPattern' | 'tsDirectiveCommentRequiresDescription' | 'tsIgnoreInsteadOfExpectError'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js new file mode 100644 index 00000000..77e2281d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js @@ -0,0 +1,196 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const defaultMinimumDescriptionLength = 3; +exports.default = (0, util_1.createRule)({ + name: 'ban-ts-comment', + meta: { + type: 'problem', + docs: { + description: 'Disallow `@ts-` comments or require descriptions after directives', + recommended: { + recommended: true, + strict: [{ minimumDescriptionLength: 10 }], + }, + }, + hasSuggestions: true, + messages: { + replaceTsIgnoreWithTsExpectError: 'Replace "@ts-ignore" with "@ts-expect-error".', + tsDirectiveComment: 'Do not use "@ts-{{directive}}" because it alters compilation errors.', + tsDirectiveCommentDescriptionNotMatchPattern: 'The description for the "@ts-{{directive}}" directive must match the {{format}} format.', + tsDirectiveCommentRequiresDescription: 'Include a description after the "@ts-{{directive}}" directive to explain why the @ts-{{directive}} is necessary. The description must be {{minimumDescriptionLength}} characters or longer.', + tsIgnoreInsteadOfExpectError: 'Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free.', + }, + schema: [ + { + type: 'object', + $defs: { + directiveConfigSchema: { + oneOf: [ + { + type: 'boolean', + default: true, + }, + { + type: 'string', + enum: ['allow-with-description'], + }, + { + type: 'object', + additionalProperties: false, + properties: { + descriptionFormat: { type: 'string' }, + }, + }, + ], + }, + }, + additionalProperties: false, + properties: { + minimumDescriptionLength: { + type: 'number', + description: 'A minimum character length for descriptions when `allow-with-description` is enabled.', + }, + 'ts-check': { + $ref: '#/items/0/$defs/directiveConfigSchema', + description: 'Whether to allow ts-check directives, and with which restrictions.', + }, + 'ts-expect-error': { + $ref: '#/items/0/$defs/directiveConfigSchema', + description: 'Whether to allow ts-expect-error directives, and with which restrictions.', + }, + 'ts-ignore': { + $ref: '#/items/0/$defs/directiveConfigSchema', + description: 'Whether to allow ts-ignore directives, and with which restrictions.', + }, + 'ts-nocheck': { + $ref: '#/items/0/$defs/directiveConfigSchema', + description: 'Whether to allow ts-nocheck directives, and with which restrictions.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + minimumDescriptionLength: defaultMinimumDescriptionLength, + 'ts-check': false, + 'ts-expect-error': 'allow-with-description', + 'ts-ignore': true, + 'ts-nocheck': true, + }, + ], + create(context, [options]) { + // https://github.com/microsoft/TypeScript/blob/6f1ad5ad8bec5671f7e951a3524b62d82ec4be68/src/compiler/parser.ts#L10591 + const singleLinePragmaRegEx = /^\/\/\/?\s*@ts-(?check|nocheck)(?.*)$/; + /* + The regex used are taken from the ones used in the official TypeScript repo - + https://github.com/microsoft/TypeScript/blob/6f1ad5ad8bec5671f7e951a3524b62d82ec4be68/src/compiler/scanner.ts#L340-L348 + */ + const commentDirectiveRegExSingleLine = /^\/*\s*@ts-(?expect-error|ignore)(?.*)/; + const commentDirectiveRegExMultiLine = /^\s*(?:\/|\*)*\s*@ts-(?expect-error|ignore)(?.*)/; + const descriptionFormats = new Map(); + for (const directive of [ + 'ts-expect-error', + 'ts-ignore', + 'ts-nocheck', + 'ts-check', + ]) { + const option = options[directive]; + if (typeof option === 'object' && option.descriptionFormat) { + descriptionFormats.set(directive, new RegExp(option.descriptionFormat)); + } + } + function execDirectiveRegEx(regex, str) { + const match = regex.exec(str); + if (!match) { + return null; + } + const { description, directive } = (0, util_1.nullThrows)(match.groups, 'RegExp should contain groups'); + return { + description: (0, util_1.nullThrows)(description, 'RegExp should contain "description" group'), + directive: (0, util_1.nullThrows)(directive, 'RegExp should contain "directive" group'), + }; + } + function findDirectiveInComment(comment) { + if (comment.type === utils_1.AST_TOKEN_TYPES.Line) { + const matchedPragma = execDirectiveRegEx(singleLinePragmaRegEx, `//${comment.value}`); + if (matchedPragma) { + return matchedPragma; + } + return execDirectiveRegEx(commentDirectiveRegExSingleLine, comment.value); + } + const commentLines = comment.value.split(utils_1.ASTUtils.LINEBREAK_MATCHER); + return execDirectiveRegEx(commentDirectiveRegExMultiLine, commentLines[commentLines.length - 1]); + } + return { + Program(node) { + const firstStatement = node.body.at(0); + const comments = context.sourceCode.getAllComments(); + comments.forEach(comment => { + const match = findDirectiveInComment(comment); + if (!match) { + return; + } + const { description, directive } = match; + if (directive === 'nocheck' && + firstStatement && + firstStatement.loc.start.line <= comment.loc.start.line) { + return; + } + const fullDirective = `ts-${directive}`; + const option = options[fullDirective]; + if (option === true) { + if (directive === 'ignore') { + // Special case to suggest @ts-expect-error instead of @ts-ignore + context.report({ + node: comment, + messageId: 'tsIgnoreInsteadOfExpectError', + suggest: [ + { + messageId: 'replaceTsIgnoreWithTsExpectError', + fix(fixer) { + const commentText = comment.value.replace(/@ts-ignore/, '@ts-expect-error'); + return fixer.replaceText(comment, comment.type === utils_1.AST_TOKEN_TYPES.Line + ? `//${commentText}` + : `/*${commentText}*/`); + }, + }, + ], + }); + } + else { + context.report({ + node: comment, + messageId: 'tsDirectiveComment', + data: { directive }, + }); + } + } + if (option === 'allow-with-description' || + (typeof option === 'object' && option.descriptionFormat)) { + const { minimumDescriptionLength } = options; + const format = descriptionFormats.get(fullDirective); + if ((0, util_1.getStringLength)(description.trim()) < + (0, util_1.nullThrows)(minimumDescriptionLength, 'Expected minimumDescriptionLength to be set')) { + context.report({ + node: comment, + messageId: 'tsDirectiveCommentRequiresDescription', + data: { directive, minimumDescriptionLength }, + }); + } + else if (format && !format.test(description)) { + context.report({ + node: comment, + messageId: 'tsDirectiveCommentDescriptionNotMatchPattern', + data: { directive, format: format.source }, + }); + } + } + }); + }, + }; + }, +}); +//# sourceMappingURL=ban-ts-comment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.d.ts new file mode 100644 index 00000000..05af06c4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentDetected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.js new file mode 100644 index 00000000..f34d601f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-tslint-comment.js @@ -0,0 +1,54 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +// tslint regex +// https://github.com/palantir/tslint/blob/95d9d958833fd9dc0002d18cbe34db20d0fbf437/src/enableDisableRules.ts#L32 +const ENABLE_DISABLE_REGEX = /^\s*tslint:(enable|disable)(?:-(line|next-line))?(:|\s|$)/; +const toText = (text, type) => type === utils_1.AST_TOKEN_TYPES.Line + ? ['//', text.trim()].join(' ') + : ['/*', text.trim(), '*/'].join(' '); +exports.default = (0, util_1.createRule)({ + name: 'ban-tslint-comment', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow `// tslint:` comments', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + commentDetected: 'tslint comment detected: "{{ text }}"', + }, + schema: [], + }, + defaultOptions: [], + create: context => { + return { + Program() { + const comments = context.sourceCode.getAllComments(); + comments.forEach(c => { + if (ENABLE_DISABLE_REGEX.test(c.value)) { + context.report({ + node: c, + messageId: 'commentDetected', + data: { text: toText(c.value, c.type) }, + fix(fixer) { + const rangeStart = context.sourceCode.getIndexFromLoc({ + column: c.loc.start.column > 0 ? c.loc.start.column - 1 : 0, + line: c.loc.start.line, + }); + const rangeEnd = context.sourceCode.getIndexFromLoc({ + column: c.loc.end.column, + line: c.loc.end.line, + }); + return fixer.removeRange([rangeStart, rangeEnd + 1]); + }, + }); + } + }); + }, + }; + }, +}); +//# sourceMappingURL=ban-tslint-comment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.d.ts new file mode 100644 index 00000000..356b645b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.d.ts @@ -0,0 +1,7 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = ['fields' | 'getters']; +export type MessageIds = 'preferFieldStyle' | 'preferFieldStyleSuggestion' | 'preferGetterStyle' | 'preferGetterStyleSuggestion'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.js new file mode 100644 index 00000000..af095b47 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-literal-property-style.js @@ -0,0 +1,168 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const printNodeModifiers = (node, final) => `${node.accessibility ?? ''}${node.static ? ' static' : ''} ${final} `.trimStart(); +const isSupportedLiteral = (node) => { + switch (node.type) { + case utils_1.AST_NODE_TYPES.Literal: + return true; + case utils_1.AST_NODE_TYPES.TaggedTemplateExpression: + return node.quasi.quasis.length === 1; + case utils_1.AST_NODE_TYPES.TemplateLiteral: + return node.quasis.length === 1; + default: + return false; + } +}; +exports.default = (0, util_1.createRule)({ + name: 'class-literal-property-style', + meta: { + type: 'problem', + docs: { + description: 'Enforce that literals on classes are exposed in a consistent style', + recommended: 'stylistic', + }, + hasSuggestions: true, + messages: { + preferFieldStyle: 'Literals should be exposed using readonly fields.', + preferFieldStyleSuggestion: 'Replace the literals with readonly fields.', + preferGetterStyle: 'Literals should be exposed using getters.', + preferGetterStyleSuggestion: 'Replace the literals with getters.', + }, + schema: [ + { + type: 'string', + description: 'Which literal class member syntax to prefer.', + enum: ['fields', 'getters'], + }, + ], + }, + defaultOptions: ['fields'], + create(context, [style]) { + const propertiesInfoStack = []; + function enterClassBody() { + propertiesInfoStack.push({ + excludeSet: new Set(), + properties: [], + }); + } + function exitClassBody() { + const { excludeSet, properties } = (0, util_1.nullThrows)(propertiesInfoStack.pop(), 'Stack should exist on class exit'); + properties.forEach(node => { + const { value } = node; + if (!value || !isSupportedLiteral(value)) { + return; + } + const name = (0, util_1.getStaticMemberAccessValue)(node, context); + if (name && excludeSet.has(name)) { + return; + } + context.report({ + node: node.key, + messageId: 'preferGetterStyle', + suggest: [ + { + messageId: 'preferGetterStyleSuggestion', + fix(fixer) { + const name = context.sourceCode.getText(node.key); + let text = ''; + text += printNodeModifiers(node, 'get'); + text += node.computed ? `[${name}]` : name; + text += `() { return ${context.sourceCode.getText(value)}; }`; + return fixer.replaceText(node, text); + }, + }, + ], + }); + }); + } + function excludeAssignedProperty(node) { + if ((0, util_1.isAssignee)(node)) { + const { excludeSet } = propertiesInfoStack[propertiesInfoStack.length - 1]; + const name = (0, util_1.getStaticMemberAccessValue)(node, context); + if (name) { + excludeSet.add(name); + } + } + } + return { + ...(style === 'fields' && { + MethodDefinition(node) { + if (node.kind !== 'get' || + node.override || + !node.value.body || + node.value.body.body.length === 0) { + return; + } + const [statement] = node.value.body.body; + if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement) { + return; + } + const { argument } = statement; + if (!argument || !isSupportedLiteral(argument)) { + return; + } + const name = (0, util_1.getStaticMemberAccessValue)(node, context); + const hasDuplicateKeySetter = name && + node.parent.body.some(element => { + return (element.type === utils_1.AST_NODE_TYPES.MethodDefinition && + element.kind === 'set' && + (0, util_1.isStaticMemberAccessOfValue)(element, context, name)); + }); + if (hasDuplicateKeySetter) { + return; + } + const getterBody = node.value.body; + context.report({ + node: node.key, + messageId: 'preferFieldStyle', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: node.decorators.length === 0 ? 'suggest' : 'none', + suggestion: { + messageId: 'preferFieldStyleSuggestion', + fix(fixer) { + const name = context.sourceCode.getText(node.key); + const closingParen = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.value.returnType ?? getterBody), 'Getter should have a closing parenthesis.'); + const betweenParensAndBody = context.sourceCode + .getText() + .slice(closingParen.range[1], getterBody.range[0]); + let text = ''; + text += printNodeModifiers(node, 'readonly'); + text += node.computed ? `[${name}]` : name; + text += betweenParensAndBody; + text += `= ${context.sourceCode.getText(argument)};`; + return fixer.replaceText(node, text); + }, + }, + }), + }); + }, + }), + ...(style === 'getters' && { + ClassBody: enterClassBody, + 'ClassBody:exit': exitClassBody, + 'MethodDefinition[kind="constructor"] ThisExpression'(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression) { + let parent = node.parent; + while (!(0, util_1.isFunction)(parent)) { + parent = parent.parent; + } + if (parent.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + parent.parent.kind === 'constructor') { + excludeAssignedProperty(node.parent); + } + } + }, + PropertyDefinition(node) { + if (!node.readonly || node.declare || node.override) { + return; + } + const { properties } = propertiesInfoStack[propertiesInfoStack.length - 1]; + properties.push(node); + }, + }), + }; + }, +}); +//# sourceMappingURL=class-literal-property-style.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.d.ts new file mode 100644 index 00000000..a921125f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.d.ts @@ -0,0 +1,13 @@ +export type Options = [ + { + enforceForClassFields?: boolean; + exceptMethods?: string[]; + ignoreClassesThatImplementAnInterface?: boolean | 'public-fields'; + ignoreOverrideMethods?: boolean; + } +]; +export type MessageIds = 'missingThis'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.js new file mode 100644 index 00000000..8ad29939 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-methods-use-this.js @@ -0,0 +1,220 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'class-methods-use-this', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce that class methods utilize `this`', + extendsBaseRule: true, + requiresTypeChecking: false, + }, + messages: { + missingThis: "Expected 'this' to be used by class {{name}}.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + enforceForClassFields: { + type: 'boolean', + description: 'Enforces that functions used as instance field initializers utilize `this`.', + }, + exceptMethods: { + type: 'array', + description: 'Allows specified method names to be ignored with this rule.', + items: { + type: 'string', + }, + }, + ignoreClassesThatImplementAnInterface: { + description: 'Whether to ignore class members that are defined within a class that `implements` a type.', + oneOf: [ + { + type: 'boolean', + description: 'Ignore all classes that implement an interface', + }, + { + type: 'string', + description: 'Ignore only the public fields of classes that implement an interface', + enum: ['public-fields'], + }, + ], + }, + ignoreOverrideMethods: { + type: 'boolean', + description: 'Whether to ignore members marked with the `override` modifier.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + enforceForClassFields: true, + exceptMethods: [], + ignoreClassesThatImplementAnInterface: false, + ignoreOverrideMethods: false, + }, + ], + create(context, [{ enforceForClassFields, exceptMethods: exceptMethodsRaw, ignoreClassesThatImplementAnInterface, ignoreOverrideMethods, },]) { + const exceptMethods = new Set(exceptMethodsRaw); + let stack; + function pushContext(member) { + if (member?.parent.type === utils_1.AST_NODE_TYPES.ClassBody) { + stack = { + class: member.parent.parent, + member, + parent: stack, + usesThis: false, + }; + } + else { + stack = { + class: null, + member: null, + parent: stack, + usesThis: false, + }; + } + } + function enterFunction(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition || + node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition || + node.parent.type === utils_1.AST_NODE_TYPES.AccessorProperty) { + pushContext(node.parent); + } + else { + pushContext(); + } + } + /** + * Pop `this` used flag from the stack. + */ + function popContext() { + const oldStack = stack; + stack = stack?.parent; + return oldStack; + } + function isPublicField(accessibility) { + if (!accessibility || accessibility === 'public') { + return true; + } + return false; + } + /** + * Check if the node is an instance method not excluded by config + */ + function isIncludedInstanceMethod(node) { + if (node.static || + (node.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.kind === 'constructor') || + ((node.type === utils_1.AST_NODE_TYPES.PropertyDefinition || + node.type === utils_1.AST_NODE_TYPES.AccessorProperty) && + !enforceForClassFields)) { + return false; + } + if (node.computed || exceptMethods.size === 0) { + return true; + } + const hashIfNeeded = node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier ? '#' : ''; + const name = (0, util_1.getStaticMemberAccessValue)(node, context); + return (typeof name !== 'string' || !exceptMethods.has(hashIfNeeded + name)); + } + /** + * Checks if we are leaving a function that is a method, and reports if 'this' has not been used. + * Static methods and the constructor are exempt. + * Then pops the context off the stack. + */ + function exitFunction(node) { + const stackContext = popContext(); + if (stackContext?.member == null || + stackContext.usesThis || + (ignoreOverrideMethods && stackContext.member.override) || + (ignoreClassesThatImplementAnInterface === true && + stackContext.class.implements.length > 0) || + (ignoreClassesThatImplementAnInterface === 'public-fields' && + stackContext.class.implements.length > 0 && + isPublicField(stackContext.member.accessibility))) { + return; + } + if (isIncludedInstanceMethod(stackContext.member)) { + context.report({ + loc: (0, util_1.getFunctionHeadLoc)(node, context.sourceCode), + node, + messageId: 'missingThis', + data: { + name: (0, util_1.getFunctionNameWithKind)(node), + }, + }); + } + } + return { + // function declarations have their own `this` context + FunctionDeclaration() { + pushContext(); + }, + 'FunctionDeclaration:exit'() { + popContext(); + }, + FunctionExpression(node) { + enterFunction(node); + }, + 'FunctionExpression:exit'(node) { + exitFunction(node); + }, + ...(enforceForClassFields + ? { + 'AccessorProperty > ArrowFunctionExpression.value'(node) { + enterFunction(node); + }, + 'AccessorProperty > ArrowFunctionExpression.value:exit'(node) { + exitFunction(node); + }, + 'PropertyDefinition > ArrowFunctionExpression.value'(node) { + enterFunction(node); + }, + 'PropertyDefinition > ArrowFunctionExpression.value:exit'(node) { + exitFunction(node); + }, + } + : {}), + /* + * Class field value are implicit functions. + */ + 'AccessorProperty:exit'() { + popContext(); + }, + 'AccessorProperty > *.key:exit'() { + pushContext(); + }, + 'PropertyDefinition:exit'() { + popContext(); + }, + 'PropertyDefinition > *.key:exit'() { + pushContext(); + }, + /* + * Class static blocks are implicit functions. They aren't required to use `this`, + * but we have to push context so that it captures any use of `this` in the static block + * separately from enclosing contexts, because static blocks have their own `this` and it + * shouldn't count as used `this` in enclosing contexts. + */ + StaticBlock() { + pushContext(); + }, + 'StaticBlock:exit'() { + popContext(); + }, + 'ThisExpression, Super'() { + if (stack) { + stack.usesThis = true; + } + }, + }; + }, +}); +//# sourceMappingURL=class-methods-use-this.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.d.ts new file mode 100644 index 00000000..7d65d34f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.d.ts @@ -0,0 +1,6 @@ +export type MessageIds = 'preferConstructor' | 'preferTypeAnnotation'; +export type Options = ['constructor' | 'type-annotation']; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.js new file mode 100644 index 00000000..20aa2de0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-generic-constructors.js @@ -0,0 +1,127 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const builtInArrays = new Set([ + 'Float32Array', + 'Float64Array', + 'Int16Array', + 'Int32Array', + 'Int8Array', + 'Uint16Array', + 'Uint32Array', + 'Uint8Array', + 'Uint8ClampedArray', +]); +exports.default = (0, util_1.createRule)({ + name: 'consistent-generic-constructors', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce specifying generic type arguments on type annotation or constructor name of a constructor call', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + preferConstructor: 'The generic type arguments should be specified as part of the constructor type arguments.', + preferTypeAnnotation: 'The generic type arguments should be specified as part of the type annotation.', + }, + schema: [ + { + type: 'string', + description: 'Which constructor call syntax to prefer.', + enum: ['type-annotation', 'constructor'], + }, + ], + }, + defaultOptions: ['constructor'], + create(context, [mode]) { + return { + 'VariableDeclarator,PropertyDefinition,AccessorProperty,:matches(FunctionDeclaration,FunctionExpression) > AssignmentPattern'(node) { + function getLHSRHS() { + switch (node.type) { + case utils_1.AST_NODE_TYPES.VariableDeclarator: + return [node.id, node.init]; + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.AccessorProperty: + return [node, node.value]; + case utils_1.AST_NODE_TYPES.AssignmentPattern: + return [node.left, node.right]; + default: + throw new Error(`Unhandled node type: ${node.type}`); + } + } + function isBuiltInArray(typeName) { + return (builtInArrays.has(typeName.name) && + (0, util_1.isReferenceToGlobalFunction)(typeName.name, typeName, context.sourceCode)); + } + const [lhsName, rhs] = getLHSRHS(); + const lhs = lhsName.typeAnnotation?.typeAnnotation; + if (rhs?.type !== utils_1.AST_NODE_TYPES.NewExpression || + rhs.callee.type !== utils_1.AST_NODE_TYPES.Identifier) { + return; + } + if (lhs && + (lhs.type !== utils_1.AST_NODE_TYPES.TSTypeReference || + lhs.typeName.type !== utils_1.AST_NODE_TYPES.Identifier || + lhs.typeName.name !== rhs.callee.name || + isBuiltInArray(lhs.typeName))) { + return; + } + if (mode === 'type-annotation') { + if (!lhs && rhs.typeArguments) { + const { callee, typeArguments } = rhs; + const typeAnnotation = context.sourceCode.getText(callee) + + context.sourceCode.getText(typeArguments); + context.report({ + node, + messageId: 'preferTypeAnnotation', + fix(fixer) { + function getIDToAttachAnnotation() { + if (node.type !== utils_1.AST_NODE_TYPES.PropertyDefinition && + node.type !== utils_1.AST_NODE_TYPES.AccessorProperty) { + return lhsName; + } + if (!node.computed) { + return node.key; + } + // If the property's computed, we have to attach the + // annotation after the square bracket, not the enclosed expression + return (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.key), util_1.NullThrowsReasons.MissingToken(']', 'key')); + } + return [ + fixer.remove(typeArguments), + fixer.insertTextAfter(getIDToAttachAnnotation(), `: ${typeAnnotation}`), + ]; + }, + }); + } + return; + } + const isolatedDeclarations = context.languageOptions.parserOptions.isolatedDeclarations; + if (!isolatedDeclarations && lhs?.typeArguments && !rhs.typeArguments) { + const hasParens = context.sourceCode.getTokenAfter(rhs.callee)?.value === '('; + const extraComments = new Set(context.sourceCode.getCommentsInside(lhs.parent)); + context.sourceCode + .getCommentsInside(lhs.typeArguments) + .forEach(c => extraComments.delete(c)); + context.report({ + node, + messageId: 'preferConstructor', + *fix(fixer) { + yield fixer.remove(lhs.parent); + for (const comment of extraComments) { + yield fixer.insertTextAfter(rhs.callee, context.sourceCode.getText(comment)); + } + yield fixer.insertTextAfter(rhs.callee, context.sourceCode.getText(lhs.typeArguments)); + if (!hasParens) { + yield fixer.insertTextAfter(rhs.callee, '()'); + } + }, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=consistent-generic-constructors.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.d.ts new file mode 100644 index 00000000..ba458433 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.d.ts @@ -0,0 +1,7 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'preferIndexSignature' | 'preferIndexSignatureSuggestion' | 'preferRecord' | 'preferRecordSuggestion'; +export type Options = ['index-signature' | 'record']; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.js new file mode 100644 index 00000000..595b417a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.js @@ -0,0 +1,286 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'consistent-indexed-object-style', + meta: { + type: 'suggestion', + docs: { + description: 'Require or disallow the `Record` type', + recommended: 'stylistic', + }, + fixable: 'code', + // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- suggestions are exposed through a helper. + hasSuggestions: true, + messages: { + preferIndexSignature: 'An index signature is preferred over a record.', + preferIndexSignatureSuggestion: 'Change into an index signature instead of a record.', + preferRecord: 'A record is preferred over an index signature.', + preferRecordSuggestion: 'Change into a record instead of an index signature.', + }, + schema: [ + { + type: 'string', + description: 'Which indexed object syntax to prefer.', + enum: ['record', 'index-signature'], + }, + ], + }, + defaultOptions: ['record'], + create(context, [mode]) { + // The fixers rebuild the type from the text of a few sub-nodes, so a + // comment inside `node` but outside all of those preserved sub-nodes would + // be dropped by the fix. Returns true when at least one such comment exists. + function hasUnpreservedComments(node, ...preserved) { + return context.sourceCode + .getCommentsInside(node) + .some(comment => preserved.every(target => target == null || + comment.range[0] < target.range[0] || + comment.range[1] > target.range[1])); + } + function checkMembers(members, node, parentId, prefix, postfix, safeFix = true) { + if (members.length !== 1) { + return; + } + const [member] = members; + if (member.type !== utils_1.AST_NODE_TYPES.TSIndexSignature) { + return; + } + const parameter = member.parameters.at(0); + if (parameter?.type !== utils_1.AST_NODE_TYPES.Identifier) { + return; + } + const keyType = parameter.typeAnnotation; + if (!keyType) { + return; + } + const valueType = member.typeAnnotation; + if (!valueType) { + return; + } + if (parentId) { + const scope = context.sourceCode.getScope(parentId); + const superVar = utils_1.ASTUtils.findVariable(scope, parentId.name); + if (superVar && + isDeeplyReferencingType(node, superVar, new Set([parentId]))) { + return; + } + } + context.report({ + node, + messageId: 'preferRecord', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: !safeFix + ? 'none' + : hasUnpreservedComments(node, keyType.typeAnnotation, valueType.typeAnnotation) + ? 'suggest' + : 'fix', + suggestion: { + messageId: 'preferRecordSuggestion', + fix: (fixer) => { + const key = context.sourceCode.getText(keyType.typeAnnotation); + const value = context.sourceCode.getText(valueType.typeAnnotation); + const record = member.readonly + ? `Readonly>` + : `Record<${key}, ${value}>`; + return fixer.replaceText(node, `${prefix}${record}${postfix}`); + }, + }, + }), + }); + } + return { + ...(mode === 'index-signature' && { + TSTypeReference(node) { + const typeName = node.typeName; + if (typeName.type !== utils_1.AST_NODE_TYPES.Identifier) { + return; + } + if (typeName.name !== 'Record') { + return; + } + const params = node.typeArguments?.params; + if (params?.length !== 2) { + return; + } + const indexParam = params[0]; + const shouldFix = indexParam.type === utils_1.AST_NODE_TYPES.TSStringKeyword || + indexParam.type === utils_1.AST_NODE_TYPES.TSNumberKeyword || + indexParam.type === utils_1.AST_NODE_TYPES.TSSymbolKeyword; + context.report({ + node, + messageId: 'preferIndexSignature', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: shouldFix && !hasUnpreservedComments(node, params[0], params[1]) + ? 'fix' + : 'suggest', + suggestion: { + messageId: 'preferIndexSignatureSuggestion', + fix: fixer => { + const key = context.sourceCode.getText(params[0]); + const type = context.sourceCode.getText(params[1]); + return fixer.replaceText(node, `{ [key: ${key}]: ${type} }`); + }, + }, + }), + }); + }, + }), + ...(mode === 'record' && { + TSInterfaceDeclaration(node) { + let genericTypes = ''; + if (node.typeParameters?.params.length) { + genericTypes = `<${node.typeParameters.params + .map(p => context.sourceCode.getText(p)) + .join(', ')}>`; + } + checkMembers(node.body.body, node, node.id, `type ${node.id.name}${genericTypes} = `, ';', !node.extends.length && + node.parent.type !== utils_1.AST_NODE_TYPES.ExportDefaultDeclaration); + }, + TSMappedType(node) { + const key = node.key; + const scope = context.sourceCode.getScope(key); + const scopeManagerKey = (0, util_1.nullThrows)(scope.variables.find(value => value.name === key.name && value.isTypeVariable), 'key type parameter must be a defined type variable in its scope'); + // If the key is used to compute the value, we can't convert to a Record. + if (scopeManagerKey.references.some(reference => reference.isTypeReference)) { + return; + } + const constraint = node.constraint; + if (constraint.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + constraint.operator === 'keyof' && + !(0, util_1.isParenthesized)(constraint, context.sourceCode)) { + // This is a weird special case, since modifiers are preserved by + // the mapped type, but not by the Record type. So this type is not, + // in general, equivalent to a Record type. + return; + } + // If the mapped type is circular, we can't convert it to a Record. + const parentId = findParentDeclaration(node)?.id; + if (parentId) { + const scope = context.sourceCode.getScope(key); + const superVar = utils_1.ASTUtils.findVariable(scope, parentId.name); + if (superVar) { + const isCircular = isDeeplyReferencingType(node.parent, superVar, new Set([parentId])); + if (isCircular) { + return; + } + } + } + context.report({ + node, + messageId: 'preferRecord', + ...(0, util_1.getFixOrSuggest)({ + // There's no builtin Mutable type, so a `-readonly` mapped + // type can't be represented as a Record and is left untouched. + fixOrSuggest: node.readonly === '-' + ? 'none' + : hasUnpreservedComments(node, constraint, node.typeAnnotation) + ? 'suggest' + : 'fix', + suggestion: { + messageId: 'preferRecordSuggestion', + fix: (fixer) => { + const keyType = context.sourceCode.getText(constraint); + const valueType = node.typeAnnotation + ? context.sourceCode.getText(node.typeAnnotation) + : 'any'; + let recordText = `Record<${keyType}, ${valueType}>`; + if (node.optional === '+' || node.optional === true) { + recordText = `Partial<${recordText}>`; + } + else if (node.optional === '-') { + recordText = `Required<${recordText}>`; + } + if (node.readonly === '+' || node.readonly === true) { + recordText = `Readonly<${recordText}>`; + } + return fixer.replaceText(node, recordText); + }, + }, + }), + }); + }, + TSTypeLiteral(node) { + const parent = findParentDeclaration(node); + checkMembers(node.members, node, parent?.id, '', ''); + }, + }), + }; + }, +}); +function findParentDeclaration(node) { + if (node.parent && node.parent.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) { + return node.parent; + } + return findParentDeclaration(node.parent); + } + return undefined; +} +function isDeeplyReferencingType(node, superVar, visited) { + if (visited.has(node)) { + // something on the chain is circular but it's not the reference being checked + return false; + } + visited.add(node); + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSTypeLiteral: + return node.members.some(member => isDeeplyReferencingType(member, superVar, visited)); + case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration: + return isDeeplyReferencingType(node.typeAnnotation, superVar, visited); + case utils_1.AST_NODE_TYPES.TSIndexedAccessType: + return [node.indexType, node.objectType].some(type => isDeeplyReferencingType(type, superVar, visited)); + case utils_1.AST_NODE_TYPES.TSMappedType: + if (node.typeAnnotation) { + return isDeeplyReferencingType(node.typeAnnotation, superVar, visited); + } + break; + case utils_1.AST_NODE_TYPES.TSConditionalType: + return [ + node.checkType, + node.extendsType, + node.falseType, + node.trueType, + ].some(type => isDeeplyReferencingType(type, superVar, visited)); + case utils_1.AST_NODE_TYPES.TSUnionType: + case utils_1.AST_NODE_TYPES.TSIntersectionType: + return node.types.some(type => isDeeplyReferencingType(type, superVar, visited)); + case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: + return node.body.body.some(type => isDeeplyReferencingType(type, superVar, visited)); + case utils_1.AST_NODE_TYPES.TSTypeAnnotation: + return isDeeplyReferencingType(node.typeAnnotation, superVar, visited); + case utils_1.AST_NODE_TYPES.TSIndexSignature: { + if (node.typeAnnotation) { + return isDeeplyReferencingType(node.typeAnnotation, superVar, visited); + } + break; + } + case utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation: { + return node.params.some(param => isDeeplyReferencingType(param, superVar, visited)); + } + case utils_1.AST_NODE_TYPES.TSTypeReference: { + if (isDeeplyReferencingType(node.typeName, superVar, visited)) { + return true; + } + if (node.typeArguments && + isDeeplyReferencingType(node.typeArguments, superVar, visited)) { + return true; + } + break; + } + case utils_1.AST_NODE_TYPES.Identifier: { + // check if the identifier is a reference of the type being checked + if (superVar.references.some(ref => (0, util_1.isNodeEqual)(ref.identifier, node))) { + return true; + } + // otherwise, follow its definition(s) + const refVar = utils_1.ASTUtils.findVariable(superVar.scope, node.name); + if (refVar) { + return refVar.defs.some(def => isDeeplyReferencingType(def.node, superVar, visited)); + } + } + } + return false; +} +//# sourceMappingURL=consistent-indexed-object-style.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.d.ts new file mode 100644 index 00000000..21076d92 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.d.ts @@ -0,0 +1,18 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({ + treatUndefinedAsUnspecified?: boolean; +} | undefined)?], unknown, { + 'ArrowFunctionExpression:exit'(node: TSESTree.ArrowFunctionExpression): void; + 'FunctionDeclaration:exit'(node: TSESTree.FunctionDeclaration): void; + 'FunctionExpression:exit'(node: TSESTree.FunctionExpression): void; + ReturnStatement(node: TSESTree.ReturnStatement): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({ + treatUndefinedAsUnspecified?: boolean; +} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.js new file mode 100644 index 00000000..05223f3d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-return.js @@ -0,0 +1,136 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('consistent-return'); +const defaultOptions = [{ treatUndefinedAsUnspecified: false }]; +exports.default = (0, util_1.createRule)({ + name: 'consistent-return', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Require `return` statements to either always or never specify values', + extendsBaseRule: true, + requiresTypeChecking: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions, + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const rules = baseRule.create(context); + const functions = []; + const treatUndefinedAsUnspecified = options?.treatUndefinedAsUnspecified === true; + function enterFunction(node) { + functions.push(node); + } + function exitFunction() { + functions.pop(); + } + function getCurrentFunction() { + return functions[functions.length - 1] ?? null; + } + function isPromiseVoid(node, type) { + if (tsutils.isThenableType(checker, node, type) && + tsutils.isTypeReference(type)) { + const awaitedType = type.typeArguments?.[0]; + if (awaitedType) { + if ((0, util_1.isTypeFlagSet)(awaitedType, ts.TypeFlags.Void)) { + return true; + } + return isPromiseVoid(node, awaitedType); + } + } + return false; + } + function isReturnVoidOrThenableVoid(node) { + const functionType = services.getTypeAtLocation(node); + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + const callSignatures = functionType.getCallSignatures(); + return callSignatures.some(signature => { + const returnType = signature.getReturnType(); + if (node.async) { + return isPromiseVoid(tsNode, returnType); + } + return (0, util_1.isTypeFlagSet)(returnType, ts.TypeFlags.Void); + }); + } + return { + ...rules, + ArrowFunctionExpression: enterFunction, + 'ArrowFunctionExpression:exit'(node) { + exitFunction(); + rules['ArrowFunctionExpression:exit'](node); + }, + FunctionDeclaration: enterFunction, + 'FunctionDeclaration:exit'(node) { + exitFunction(); + rules['FunctionDeclaration:exit'](node); + }, + FunctionExpression: enterFunction, + 'FunctionExpression:exit'(node) { + exitFunction(); + rules['FunctionExpression:exit'](node); + }, + ReturnStatement(node) { + const functionNode = getCurrentFunction(); + if (!node.argument && + functionNode && + isReturnVoidOrThenableVoid(functionNode)) { + return; + } + if (treatUndefinedAsUnspecified && node.argument) { + const returnValueType = services.getTypeAtLocation(node.argument); + if (returnValueType.flags === ts.TypeFlags.Undefined) { + rules.ReturnStatement({ + ...node, + argument: null, + }); + return; + } + } + rules.ReturnStatement(node); + }, + }; + }, +}); +//# sourceMappingURL=consistent-return.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.d.ts new file mode 100644 index 00000000..7bbcda15 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.d.ts @@ -0,0 +1,14 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'angle-bracket' | 'as' | 'never' | 'replaceArrayTypeAssertionWithAnnotation' | 'replaceArrayTypeAssertionWithSatisfies' | 'replaceObjectTypeAssertionWithAnnotation' | 'replaceObjectTypeAssertionWithSatisfies' | 'unexpectedArrayTypeAssertion' | 'unexpectedObjectTypeAssertion'; +type OptUnion = { + assertionStyle: 'angle-bracket' | 'as'; + objectLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never'; + arrayLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never'; +} | { + assertionStyle: 'never'; +}; +export type Options = readonly [OptUnion]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.js new file mode 100644 index 00000000..a115c8dd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-assertions.js @@ -0,0 +1,257 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getWrappedCode_1 = require("../util/getWrappedCode"); +exports.default = (0, util_1.createRule)({ + name: 'consistent-type-assertions', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce consistent usage of type assertions', + recommended: 'stylistic', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + 'angle-bracket': "Use '<{{cast}}>' instead of 'as {{cast}}'.", + as: "Use 'as {{cast}}' instead of '<{{cast}}>'.", + never: 'Do not use any type assertions.', + replaceArrayTypeAssertionWithAnnotation: 'Use const x: {{cast}} = [ ... ] instead.', + replaceArrayTypeAssertionWithSatisfies: 'Use const x = [ ... ] satisfies {{cast}} instead.', + replaceObjectTypeAssertionWithAnnotation: 'Use const x: {{cast}} = { ... } instead.', + replaceObjectTypeAssertionWithSatisfies: 'Use const x = { ... } satisfies {{cast}} instead.', + unexpectedArrayTypeAssertion: 'Always prefer const x: T[] = [ ... ].', + unexpectedObjectTypeAssertion: 'Always prefer const x: T = { ... }.', + }, + schema: [ + { + oneOf: [ + { + type: 'object', + additionalProperties: false, + properties: { + assertionStyle: { + type: 'string', + description: 'The expected assertion style to enforce.', + enum: ['never'], + }, + }, + required: ['assertionStyle'], + }, + { + type: 'object', + additionalProperties: false, + properties: { + arrayLiteralTypeAssertions: { + type: 'string', + description: 'Whether to always prefer type declarations for array literals used as variable initializers, rather than type assertions.', + enum: ['allow', 'allow-as-parameter', 'never'], + }, + assertionStyle: { + type: 'string', + description: 'The expected assertion style to enforce.', + enum: ['as', 'angle-bracket'], + }, + objectLiteralTypeAssertions: { + type: 'string', + description: 'Whether to always prefer type declarations for object literals used as variable initializers, rather than type assertions.', + enum: ['allow', 'allow-as-parameter', 'never'], + }, + }, + }, + ], + }, + ], + }, + defaultOptions: [ + { + arrayLiteralTypeAssertions: 'allow', + assertionStyle: 'as', + objectLiteralTypeAssertions: 'allow', + }, + ], + create(context, [options]) { + function isConst(node) { + if (node.type !== utils_1.AST_NODE_TYPES.TSTypeReference) { + return false; + } + return (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + node.typeName.name === 'const'); + } + function reportIncorrectAssertionType(node) { + const messageId = options.assertionStyle; + // If this node is `as const`, then don't report an error. + if (isConst(node.typeAnnotation) && messageId === 'never') { + return; + } + context.report({ + node, + messageId, + data: messageId !== 'never' + ? { cast: context.sourceCode.getText(node.typeAnnotation) } + : {}, + fix: messageId === 'as' + ? (fixer) => { + // lazily access parserServices to avoid crashing on non TS files (#9860) + const tsNode = (0, util_1.getParserServices)(context, true).esTreeNodeToTSNodeMap.get(node); + const expressionCode = context.sourceCode.getText(node.expression); + const typeAnnotationCode = context.sourceCode.getText(node.typeAnnotation); + const asPrecedence = (0, util_1.getOperatorPrecedence)(ts.SyntaxKind.AsExpression, ts.SyntaxKind.Unknown); + const parentPrecedence = (0, util_1.getOperatorPrecedence)(tsNode.parent.kind, ts.isBinaryExpression(tsNode.parent) + ? tsNode.parent.operatorToken.kind + : ts.SyntaxKind.Unknown, ts.isNewExpression(tsNode.parent) + ? tsNode.parent.arguments != null && + tsNode.parent.arguments.length > 0 + : undefined); + const expressionPrecedence = (0, util_1.getOperatorPrecedenceForNode)(node.expression); + const expressionCodeWrapped = (0, getWrappedCode_1.getWrappedCode)(expressionCode, expressionPrecedence, asPrecedence); + const text = `${expressionCodeWrapped} as ${typeAnnotationCode}`; + return fixer.replaceText(node, (0, util_1.isParenthesized)(node, context.sourceCode) + ? text + : (0, getWrappedCode_1.getWrappedCode)(text, asPrecedence, parentPrecedence)); + } + : undefined, + }); + } + function checkType(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSAnyKeyword: + case utils_1.AST_NODE_TYPES.TSUnknownKeyword: + return false; + case utils_1.AST_NODE_TYPES.TSTypeReference: + return ( + // Ignore `as const` and `` + !isConst(node) || + // Allow qualified names which have dots between identifiers, `Foo.Bar` + node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName); + default: + return true; + } + } + function getSuggestions(node, annotationMessageId, satisfiesMessageId) { + const suggestions = []; + if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && + !node.parent.id.typeAnnotation) { + const { parent } = node; + suggestions.push({ + messageId: annotationMessageId, + data: { cast: context.sourceCode.getText(node.typeAnnotation) }, + fix: fixer => [ + fixer.insertTextAfter(parent.id, `: ${context.sourceCode.getText(node.typeAnnotation)}`), + fixer.replaceText(node, (0, util_1.getTextWithParentheses)(context.sourceCode, node.expression)), + ], + }); + } + suggestions.push({ + messageId: satisfiesMessageId, + data: { cast: context.sourceCode.getText(node.typeAnnotation) }, + fix: fixer => [ + fixer.replaceText(node, (0, util_1.getTextWithParentheses)(context.sourceCode, node.expression)), + fixer.insertTextAfter(node, ` satisfies ${context.sourceCode.getText(node.typeAnnotation)}`), + ], + }); + return suggestions; + } + function isAsParameter(node) { + return (node.parent.type === utils_1.AST_NODE_TYPES.NewExpression || + node.parent.type === utils_1.AST_NODE_TYPES.CallExpression || + node.parent.type === utils_1.AST_NODE_TYPES.ThrowStatement || + node.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern || + node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer || + (node.parent.type === utils_1.AST_NODE_TYPES.TemplateLiteral && + node.parent.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression)); + } + function checkExpressionForObjectAssertion(node) { + if (options.assertionStyle === 'never' || + options.objectLiteralTypeAssertions === 'allow' || + node.expression.type !== utils_1.AST_NODE_TYPES.ObjectExpression) { + return; + } + if (options.objectLiteralTypeAssertions === 'allow-as-parameter' && + isAsParameter(node)) { + return; + } + if (checkType(node.typeAnnotation)) { + const suggest = getSuggestions(node, 'replaceObjectTypeAssertionWithAnnotation', 'replaceObjectTypeAssertionWithSatisfies'); + context.report({ + node, + messageId: 'unexpectedObjectTypeAssertion', + suggest, + }); + } + } + function checkExpressionForArrayAssertion(node) { + if (options.assertionStyle === 'never' || + options.arrayLiteralTypeAssertions === 'allow' || + node.expression.type !== utils_1.AST_NODE_TYPES.ArrayExpression) { + return; + } + if (options.arrayLiteralTypeAssertions === 'allow-as-parameter' && + isAsParameter(node)) { + return; + } + if (checkType(node.typeAnnotation)) { + const suggest = getSuggestions(node, 'replaceArrayTypeAssertionWithAnnotation', 'replaceArrayTypeAssertionWithSatisfies'); + context.report({ + node, + messageId: 'unexpectedArrayTypeAssertion', + suggest, + }); + } + } + return { + TSAsExpression(node) { + if (options.assertionStyle !== 'as') { + reportIncorrectAssertionType(node); + return; + } + checkExpressionForObjectAssertion(node); + checkExpressionForArrayAssertion(node); + }, + TSTypeAssertion(node) { + if (options.assertionStyle !== 'angle-bracket') { + reportIncorrectAssertionType(node); + return; + } + checkExpressionForObjectAssertion(node); + checkExpressionForArrayAssertion(node); + }, + }; + }, +}); +//# sourceMappingURL=consistent-type-assertions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.d.ts new file mode 100644 index 00000000..eba15c7a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js new file mode 100644 index 00000000..7e70451f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js @@ -0,0 +1,101 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'consistent-type-definitions', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce type definitions to consistently use either `interface` or `type`', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + interfaceOverType: 'Use an `interface` instead of a `type`.', + typeOverInterface: 'Use a `type` instead of an `interface`.', + }, + schema: [ + { + type: 'string', + description: 'Which type definition syntax to prefer.', + enum: ['interface', 'type'], + }, + ], + }, + defaultOptions: ['interface'], + create(context, [option]) { + /** + * Iterates from the highest parent to the currently traversed node + * to determine whether any node in tree is globally declared module declaration + */ + function isCurrentlyTraversedNodeWithinModuleDeclaration(node) { + return context.sourceCode + .getAncestors(node) + .some(node => node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration && + node.declare && + node.kind === 'global'); + } + return { + ...(option === 'interface' && { + "TSTypeAliasDeclaration[typeAnnotation.type='TSTypeLiteral']"(node) { + context.report({ + node: node.id, + messageId: 'interfaceOverType', + fix(fixer) { + const typeToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.id, token => token.value === 'type'), util_1.NullThrowsReasons.MissingToken('type keyword', 'type alias')); + const equalsToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.value === '='), util_1.NullThrowsReasons.MissingToken('=', 'type alias')); + const beforeEqualsToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(equalsToken, { + includeComments: true, + }), util_1.NullThrowsReasons.MissingToken('before =', 'type alias')); + return [ + // replace 'type' with 'interface'. + fixer.replaceText(typeToken, 'interface'), + // delete from the = to the { of the type, and put a space to be pretty. + fixer.replaceTextRange([beforeEqualsToken.range[1], node.typeAnnotation.range[0]], ' '), + // remove from the closing } through the end of the statement. + fixer.removeRange([ + node.typeAnnotation.range[1], + node.range[1], + ]), + ]; + }, + }); + }, + }), + ...(option === 'type' && { + TSInterfaceDeclaration(node) { + const fix = isCurrentlyTraversedNodeWithinModuleDeclaration(node) + ? null + : (fixer) => { + const typeNode = node.typeParameters ?? node.id; + const fixes = []; + const firstToken = context.sourceCode.getTokenBefore(node.id); + if (firstToken) { + fixes.push(fixer.replaceText(firstToken, 'type')); + fixes.push(fixer.replaceTextRange([typeNode.range[1], node.body.range[0]], ' = ')); + } + node.extends.forEach(heritage => { + const typeIdentifier = context.sourceCode.getText(heritage); + fixes.push(fixer.insertTextAfter(node.body, ` & ${typeIdentifier}`)); + }); + if (node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) { + fixes.push(fixer.removeRange([node.parent.range[0], node.range[0]]), fixer.insertTextAfter(node.body, `\nexport default ${node.id.name}`)); + } + return fixes; + }; + context.report({ + node: node.id, + messageId: 'typeOverInterface', + /** + * remove automatically fix when the interface is within a declare global + * @see {@link https://github.com/typescript-eslint/typescript-eslint/issues/2707} + */ + fix, + }); + }, + }), + }; + }, +}); +//# sourceMappingURL=consistent-type-definitions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.d.ts new file mode 100644 index 00000000..70be43b1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.d.ts @@ -0,0 +1,11 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + fixMixedExportsWithInlineTypeSpecifier: boolean; + } +]; +export type MessageIds = 'multipleExportsAreTypes' | 'singleExportIsType' | 'typeOverValue'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.js new file mode 100644 index 00000000..b37d197e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-exports.js @@ -0,0 +1,336 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'consistent-type-exports', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce consistent usage of type exports', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + multipleExportsAreTypes: 'Type exports {{exportNames}} are not values and should be exported using `export type`.', + singleExportIsType: 'Type export {{exportNames}} is not a value and should be exported using `export type`.', + typeOverValue: 'All exports in the declaration are only used as types. Use `export type`.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + fixMixedExportsWithInlineTypeSpecifier: { + type: 'boolean', + description: 'Whether the rule will autofix "mixed" export cases using TS inline type specifiers.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + fixMixedExportsWithInlineTypeSpecifier: false, + }, + ], + create(context, [{ fixMixedExportsWithInlineTypeSpecifier }]) { + const sourceExportsMap = {}; + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + /** + * Helper for identifying if a symbol resolves to a + * JavaScript value or a TypeScript type. + * + * @returns True/false if is a type or not, or undefined if the specifier + * can't be resolved. + */ + function isSymbolTypeBased(symbol) { + if (!symbol || checker.isUnknownSymbol(symbol)) { + return undefined; + } + if (symbol.getDeclarations()?.some(ts.isTypeOnlyImportOrExportDeclaration)) { + return true; + } + if (tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Value)) { + return false; + } + return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias) + ? isSymbolTypeBased(checker.getImmediateAliasedSymbol(symbol)) + : true; + } + return { + ExportAllDeclaration(node) { + if (node.exportKind === 'type') { + return; + } + const sourceModule = ts.resolveModuleName(node.source.value, context.filename, services.program.getCompilerOptions(), ts.sys); + if (sourceModule.resolvedModule == null) { + return; + } + const sourceFile = services.program.getSourceFile(sourceModule.resolvedModule.resolvedFileName); + if (sourceFile == null) { + return; + } + const sourceFileSymbol = checker.getSymbolAtLocation(sourceFile); + if (sourceFileSymbol == null) { + return; + } + const sourceFileType = checker.getTypeOfSymbol(sourceFileSymbol); + // Module can explicitly export types or values, and it's not difficult + // to distinguish one from the other, since we can get the flags of + // the exported symbols or check if symbol export declaration has + // the "type" keyword in it. + // + // Things get a lot more complicated when we're dealing with + // export * from './module-with-type-only-exports' + // export type * from './module-with-type-and-value-exports' + // + // TS checker has an internal function getExportsOfModuleWorker that + // recursively visits all module exports, including "export *". It then + // puts type-only-star-exported symbols into the typeOnlyExportStarMap + // property of sourceFile's SymbolLinks. Since symbol links aren't + // exposed outside the checker, we cannot access it directly. + // + // Therefore, to filter out value properties, we use the following hack: + // checker.getPropertiesOfType returns all exports that were originally + // values, but checker.getPropertyOfType returns undefined for + // properties that are mentioned in the typeOnlyExportStarMap. + const isThereAnyExportedValue = checker + .getPropertiesOfType(sourceFileType) + .some(propertyTypeSymbol => checker.getPropertyOfType(sourceFileType, propertyTypeSymbol.escapedName.toString()) != null); + if (isThereAnyExportedValue) { + return; + } + context.report({ + node, + messageId: 'typeOverValue', + fix(fixer) { + const asteriskToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === '*'), util_1.NullThrowsReasons.MissingToken('asterisk', 'export all declaration')); + return fixer.insertTextBefore(asteriskToken, 'type '); + }, + }); + }, + ExportNamedDeclaration(node) { + // Coerce the source into a string for use as a lookup entry. + const source = getSourceFromExport(node) ?? 'undefined'; + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + const sourceExports = (sourceExportsMap[source] ||= { + reportValueExports: [], + source, + typeOnlyNamedExport: null, + valueOnlyNamedExport: null, + }); + // Cache the first encountered exports for the package. We will need to come + // back to these later when fixing the problems. + if (node.exportKind === 'type') { + // The export is a type export + sourceExports.typeOnlyNamedExport ??= node; + } + else { + // The export is a value export + sourceExports.valueOnlyNamedExport ??= node; + } + // Next for the current export, we will separate type/value specifiers. + const typeBasedSpecifiers = []; + const inlineTypeSpecifiers = []; + const valueSpecifiers = []; + // Note: it is valid to export values as types. We will avoid reporting errors + // when this is encountered. + if (node.exportKind !== 'type') { + for (const specifier of node.specifiers) { + if (specifier.exportKind === 'type') { + inlineTypeSpecifiers.push(specifier); + continue; + } + const isTypeBased = isSymbolTypeBased(services.getSymbolAtLocation(specifier.exported)); + if (isTypeBased === true) { + typeBasedSpecifiers.push(specifier); + } + else if (isTypeBased === false) { + // When isTypeBased is undefined, we should avoid reporting them. + valueSpecifiers.push(specifier); + } + } + } + if ((node.exportKind === 'value' && typeBasedSpecifiers.length) || + (node.exportKind === 'type' && valueSpecifiers.length)) { + sourceExports.reportValueExports.push({ + node, + inlineTypeSpecifiers, + typeBasedSpecifiers, + valueSpecifiers, + }); + } + }, + 'Program:exit'() { + for (const sourceExports of Object.values(sourceExportsMap)) { + // If this export has no issues, move on. + if (sourceExports.reportValueExports.length === 0) { + continue; + } + for (const report of sourceExports.reportValueExports) { + if (report.valueSpecifiers.length === 0) { + // Export is all type-only with no type specifiers; convert the entire export to `export type`. + context.report({ + node: report.node, + messageId: 'typeOverValue', + *fix(fixer) { + yield* fixExportInsertType(fixer, context.sourceCode, report.node); + }, + }); + continue; + } + // We have both type and value violations. + const allExportNames = report.typeBasedSpecifiers.map(specifier => specifier.local.type === utils_1.AST_NODE_TYPES.Identifier + ? specifier.local.name + : specifier.local.value); + if (allExportNames.length === 1) { + const exportNames = allExportNames[0]; + context.report({ + node: report.node, + messageId: 'singleExportIsType', + data: { exportNames }, + *fix(fixer) { + if (fixMixedExportsWithInlineTypeSpecifier) { + yield* fixAddTypeSpecifierToNamedExports(fixer, report); + } + else { + yield* fixSeparateNamedExports(fixer, context.sourceCode, report); + } + }, + }); + } + else { + const exportNames = (0, util_1.formatWordList)(allExportNames); + context.report({ + node: report.node, + messageId: 'multipleExportsAreTypes', + data: { exportNames }, + *fix(fixer) { + if (fixMixedExportsWithInlineTypeSpecifier) { + yield* fixAddTypeSpecifierToNamedExports(fixer, report); + } + else { + yield* fixSeparateNamedExports(fixer, context.sourceCode, report); + } + }, + }); + } + } + } + }, + }; + }, +}); +/** + * Inserts "type" into an export. + * + * Example: + * + * export type { Foo } from 'foo'; + * ^^^^ + */ +function* fixExportInsertType(fixer, sourceCode, node) { + const exportToken = (0, util_1.nullThrows)(sourceCode.getFirstToken(node), util_1.NullThrowsReasons.MissingToken('export', node.type)); + yield fixer.insertTextAfter(exportToken, ' type'); + for (const specifier of node.specifiers) { + if (specifier.exportKind === 'type') { + const kindToken = (0, util_1.nullThrows)(sourceCode.getFirstToken(specifier), util_1.NullThrowsReasons.MissingToken('export', specifier.type)); + const firstTokenAfter = (0, util_1.nullThrows)(sourceCode.getTokenAfter(kindToken, { + includeComments: true, + }), 'Missing token following the export kind.'); + yield fixer.removeRange([kindToken.range[0], firstTokenAfter.range[0]]); + } + } +} +/** + * Separates the exports which mismatch the kind of export the given + * node represents. For example, a type export's named specifiers which + * represent values will be inserted in a separate `export` statement. + */ +function* fixSeparateNamedExports(fixer, sourceCode, report) { + const { node, inlineTypeSpecifiers, typeBasedSpecifiers, valueSpecifiers } = report; + const typeSpecifiers = [...typeBasedSpecifiers, ...inlineTypeSpecifiers]; + const source = getSourceFromExport(node); + const specifierNames = typeSpecifiers.map(getSpecifierText).join(', '); + const exportToken = (0, util_1.nullThrows)(sourceCode.getFirstToken(node), util_1.NullThrowsReasons.MissingToken('export', node.type)); + // Filter the bad exports from the current line. + const filteredSpecifierNames = valueSpecifiers + .map(getSpecifierText) + .join(', '); + const openToken = (0, util_1.nullThrows)(sourceCode.getFirstToken(node, util_1.isOpeningBraceToken), util_1.NullThrowsReasons.MissingToken('{', node.type)); + const closeToken = (0, util_1.nullThrows)(sourceCode.getLastToken(node, util_1.isClosingBraceToken), util_1.NullThrowsReasons.MissingToken('}', node.type)); + // Remove exports from the current line which we're going to re-insert. + yield fixer.replaceTextRange([openToken.range[1], closeToken.range[0]], ` ${filteredSpecifierNames} `); + // Insert the bad exports into a new export line above. + yield fixer.insertTextBefore(exportToken, `export type { ${specifierNames} }${source ? ` from '${source}'` : ''};\n`); +} +function* fixAddTypeSpecifierToNamedExports(fixer, report) { + if (report.node.exportKind === 'type') { + return; + } + for (const specifier of report.typeBasedSpecifiers) { + yield fixer.insertTextBefore(specifier, 'type '); + } +} +/** + * Returns the source of the export, or undefined if the named export has no source. + */ +function getSourceFromExport(node) { + if (node.source?.type === utils_1.AST_NODE_TYPES.Literal && + typeof node.source.value === 'string') { + return node.source.value; + } + return undefined; +} +/** + * Returns the specifier text for the export. If it is aliased, we take care to return + * the proper formatting. + */ +function getSpecifierText(specifier) { + const exportedName = specifier.exported.type === utils_1.AST_NODE_TYPES.Literal + ? specifier.exported.raw + : specifier.exported.name; + const localName = specifier.local.type === utils_1.AST_NODE_TYPES.Literal + ? specifier.local.raw + : specifier.local.name; + return `${localName}${exportedName !== localName ? ` as ${exportedName}` : ''}`; +} +//# sourceMappingURL=consistent-type-exports.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.d.ts new file mode 100644 index 00000000..61be0599 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.d.ts @@ -0,0 +1,16 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +import type { RuleListener } from '@typescript-eslint/utils/eslint-utils'; +type Prefer = 'no-type-imports' | 'type-imports'; +type FixStyle = 'inline-type-imports' | 'separate-type-imports'; +export type Options = [ + { + disallowTypeAnnotations?: boolean; + fixStyle?: FixStyle; + prefer?: Prefer; + } +]; +export type MessageIds = 'avoidImportType' | 'noImportTypeAnnotations' | 'someImportsAreOnlyTypes' | 'typeOverValue'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js new file mode 100644 index 00000000..62943c1a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-imports.js @@ -0,0 +1,609 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'consistent-type-imports', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce consistent usage of type imports', + }, + fixable: 'code', + messages: { + avoidImportType: 'Use an `import` instead of an `import type`.', + noImportTypeAnnotations: '`import()` type annotations are forbidden.', + someImportsAreOnlyTypes: 'Imports {{typeImports}} are only used as type.', + typeOverValue: 'All imports in the declaration are only used as types. Use `import type`.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + disallowTypeAnnotations: { + type: 'boolean', + description: 'Whether to disallow type imports in type annotations (`import()`).', + }, + fixStyle: { + type: 'string', + description: 'The expected type modifier to be added when an import is detected as used only in the type position.', + enum: ['separate-type-imports', 'inline-type-imports'], + }, + prefer: { + type: 'string', + description: 'The expected import kind for type-only imports.', + enum: ['type-imports', 'no-type-imports'], + }, + }, + }, + ], + }, + defaultOptions: [ + { + disallowTypeAnnotations: true, + fixStyle: 'separate-type-imports', + prefer: 'type-imports', + }, + ], + create(context, [option]) { + const prefer = option.prefer ?? 'type-imports'; + const disallowTypeAnnotations = option.disallowTypeAnnotations !== false; + const selectors = {}; + if (disallowTypeAnnotations) { + selectors.TSImportType = (node) => { + context.report({ + node, + messageId: 'noImportTypeAnnotations', + }); + }; + } + if (prefer === 'no-type-imports') { + return { + ...selectors, + 'ImportDeclaration[importKind = "type"]'(node) { + context.report({ + node, + messageId: 'avoidImportType', + fix(fixer) { + return fixRemoveTypeSpecifierFromImportDeclaration(fixer, node); + }, + }); + }, + 'ImportSpecifier[importKind = "type"]'(node) { + context.report({ + node, + messageId: 'avoidImportType', + fix(fixer) { + return fixRemoveTypeSpecifierFromImportSpecifier(fixer, node); + }, + }); + }, + }; + } + // prefer type imports + const fixStyle = option.fixStyle ?? 'separate-type-imports'; + let hasDecoratorMetadata = false; + const sourceImportsMap = {}; + const emitDecoratorMetadata = (0, util_1.getParserServices)(context, true).emitDecoratorMetadata ?? false; + const experimentalDecorators = (0, util_1.getParserServices)(context, true).experimentalDecorators ?? false; + if (experimentalDecorators && emitDecoratorMetadata) { + selectors.Decorator = () => { + hasDecoratorMetadata = true; + }; + } + return { + ...selectors, + ImportDeclaration(node) { + const source = node.source.value; + // sourceImports is the object containing all the specifics for a particular import source, type or value + sourceImportsMap[source] ??= { + reportValueImports: [], // if there is a mismatch where type importKind but value specifiers + source, + typeOnlyNamedImport: null, // if only type imports + valueImport: null, // if only value imports + valueOnlyNamedImport: null, // if only value imports with named specifiers + }; + const sourceImports = sourceImportsMap[source]; + if (node.importKind === 'type') { + if (!sourceImports.typeOnlyNamedImport && + node.specifiers.every(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier)) { + // definitely import type { TypeX } + sourceImports.typeOnlyNamedImport = node; + } + } + else if (!sourceImports.valueOnlyNamedImport && + node.specifiers.length && + node.specifiers.every(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier)) { + sourceImports.valueOnlyNamedImport = node; + sourceImports.valueImport = node; + } + else if (!sourceImports.valueImport && + node.specifiers.some(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier)) { + sourceImports.valueImport = node; + } + const typeSpecifiers = []; + const inlineTypeSpecifiers = []; + const valueSpecifiers = []; + const unusedSpecifiers = []; + for (const specifier of node.specifiers) { + if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier && + specifier.importKind === 'type') { + inlineTypeSpecifiers.push(specifier); + continue; + } + const [variable] = context.sourceCode.getDeclaredVariables(specifier); + if (variable.references.length === 0) { + unusedSpecifiers.push(specifier); + } + else { + const onlyHasTypeReferences = variable.references.every(ref => { + /** + * keep origin import kind when export + * export { Type } + * export default Type; + * export = Type; + */ + if ((ref.identifier.parent.type === + utils_1.AST_NODE_TYPES.ExportSpecifier || + ref.identifier.parent.type === + utils_1.AST_NODE_TYPES.ExportDefaultDeclaration || + ref.identifier.parent.type === + utils_1.AST_NODE_TYPES.TSExportAssignment) && + ref.isValueReference && + ref.isTypeReference) { + return node.importKind === 'type'; + } + if (ref.isValueReference) { + let parent = ref.identifier.parent; + let child = ref.identifier; + while (parent) { + switch (parent.type) { + // CASE 1: + // `type T = typeof foo` will create a value reference because "foo" must be a value type + // however this value reference is safe to use with type-only imports + case utils_1.AST_NODE_TYPES.TSTypeQuery: + return true; + case utils_1.AST_NODE_TYPES.TSQualifiedName: + // TSTypeQuery must have a TSESTree.EntityName as its child, so we can filter here and break early + if (parent.left !== child) { + return false; + } + child = parent; + parent = parent.parent; + continue; + // END CASE 1 + ////////////// + // CASE 2: + // `type T = { [foo]: string }` will create a value reference because "foo" must be a value type + // however this value reference is safe to use with type-only imports. + // Also this is represented as a non-type AST - hence it uses MemberExpression + case utils_1.AST_NODE_TYPES.TSPropertySignature: + return parent.key === child; + case utils_1.AST_NODE_TYPES.MemberExpression: + if (parent.object !== child) { + return false; + } + child = parent; + parent = parent.parent; + continue; + // END CASE 2 + default: + return false; + } + } + } + return ref.isTypeReference; + }); + if (onlyHasTypeReferences) { + typeSpecifiers.push(specifier); + } + else { + valueSpecifiers.push(specifier); + } + } + } + if (node.importKind === 'value' && typeSpecifiers.length) { + sourceImports.reportValueImports.push({ + node, + inlineTypeSpecifiers, + typeSpecifiers, + unusedSpecifiers, + valueSpecifiers, + }); + } + }, + 'Program:exit'() { + if (hasDecoratorMetadata) { + // Experimental decorator metadata is bowl of poop that cannot be + // supported based on pure syntactic analysis. + // + // So we can do one of two things: + // 1) add type-information to the rule in a breaking change and + // prevent users from using it so that we can fully support this + // case. + // 2) make the rule ignore all imports that are used in a file that + // might have decorator metadata. + // + // (1) is has huge impact and prevents the rule from being used by 99% + // of users Frankly - it's a straight-up bad option. So instead we + // choose with option (2) and just avoid reporting on any imports in a + // file with both emitDecoratorMetadata AND decorators + // + // For more context see the discussion in this issue and its linked + // issues: + // https://github.com/typescript-eslint/typescript-eslint/issues/5468 + // + // + // NOTE - in TS 5.0 `experimentalDecorators` became the legacy option, + // replaced with un-flagged, stable decorators and thus the type-aware + // emitDecoratorMetadata implementation also became legacy. in TS 5.2 + // support for the new, stable decorator metadata proposal was added - + // however this proposal does not include type information + // + // + // PHEW. So TL;DR what does all this mean? + // - if you use experimentalDecorators:true, + // emitDecoratorMetadata:true, and have a decorator in the file - + // the rule will do nothing in the file out of an abundance of + // caution. + // - else the rule will work as normal. + return; + } + for (const sourceImports of Object.values(sourceImportsMap)) { + if (sourceImports.reportValueImports.length === 0) { + // nothing to fix. value specifiers and type specifiers are correctly written + continue; + } + for (const report of sourceImports.reportValueImports) { + if (report.valueSpecifiers.length === 0 && + report.unusedSpecifiers.length === 0 && + report.node.importKind !== 'type') { + /** + * checks if import has type assertions + * @example + * ```ts + * import * as type from 'mod' assert \{ type: 'json' \}; + * ``` + * https://github.com/typescript-eslint/typescript-eslint/issues/7527 + */ + if (report.node.attributes.length === 0) { + context.report({ + node: report.node, + messageId: 'typeOverValue', + *fix(fixer) { + yield* fixToTypeImportDeclaration(fixer, report, sourceImports); + }, + }); + } + } + else { + // we have a mixed type/value import or just value imports, so we need to split them out into multiple imports if separate-type-imports is configured + const importNames = report.typeSpecifiers.map(specifier => `"${specifier.local.name}"`); + const message = (() => { + const typeImports = (0, util_1.formatWordList)(importNames); + if (importNames.length === 1) { + return { + messageId: 'someImportsAreOnlyTypes', + data: { + typeImports, + }, + }; + } + return { + messageId: 'someImportsAreOnlyTypes', + data: { + typeImports, + }, + }; + })(); + context.report({ + node: report.node, + ...message, + *fix(fixer) { + // take all the typeSpecifiers and put them on a new line + yield* fixToTypeImportDeclaration(fixer, report, sourceImports); + }, + }); + } + } + } + }, + }; + function classifySpecifier(node) { + const defaultSpecifier = node.specifiers[0].type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier + ? node.specifiers[0] + : null; + const namespaceSpecifier = node.specifiers.find((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) ?? null; + const namedSpecifiers = node.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier); + return { + defaultSpecifier, + namedSpecifiers, + namespaceSpecifier, + }; + } + /** + * Returns information for fixing named specifiers, type or value + */ + function getFixesNamedSpecifiers(fixer, node, subsetNamedSpecifiers, allNamedSpecifiers) { + if (allNamedSpecifiers.length === 0) { + return { + removeTypeNamedSpecifiers: [], + typeNamedSpecifiersText: '', + }; + } + const typeNamedSpecifiersTexts = []; + const removeTypeNamedSpecifiers = []; + if (subsetNamedSpecifiers.length === allNamedSpecifiers.length) { + // import Foo, {Type1, Type2} from 'foo' + // import DefType, {Type1, Type2} from 'foo' + const openingBraceToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(subsetNamedSpecifiers[0], util_1.isOpeningBraceToken), util_1.NullThrowsReasons.MissingToken('{', node.type)); + const commaToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(openingBraceToken, util_1.isCommaToken), util_1.NullThrowsReasons.MissingToken(',', node.type)); + const closingBraceToken = (0, util_1.nullThrows)(context.sourceCode.getFirstTokenBetween(openingBraceToken, node.source, util_1.isClosingBraceToken), util_1.NullThrowsReasons.MissingToken('}', node.type)); + // import DefType, {...} from 'foo' + // ^^^^^^^ remove + removeTypeNamedSpecifiers.push(fixer.removeRange([commaToken.range[0], closingBraceToken.range[1]])); + typeNamedSpecifiersTexts.push(context.sourceCode.text.slice(openingBraceToken.range[1], closingBraceToken.range[0])); + } + else { + const namedSpecifierGroups = []; + let group = []; + for (const namedSpecifier of allNamedSpecifiers) { + if (subsetNamedSpecifiers.includes(namedSpecifier)) { + group.push(namedSpecifier); + } + else if (group.length) { + namedSpecifierGroups.push(group); + group = []; + } + } + if (group.length) { + namedSpecifierGroups.push(group); + } + for (const namedSpecifiers of namedSpecifierGroups) { + const { removeRange, textRange } = getNamedSpecifierRanges(namedSpecifiers, allNamedSpecifiers); + removeTypeNamedSpecifiers.push(fixer.removeRange(removeRange)); + typeNamedSpecifiersTexts.push(context.sourceCode.text.slice(...textRange)); + } + } + return { + removeTypeNamedSpecifiers, + typeNamedSpecifiersText: typeNamedSpecifiersTexts.join(','), + }; + } + /** + * Returns ranges for fixing named specifier. + */ + function getNamedSpecifierRanges(namedSpecifierGroup, allNamedSpecifiers) { + const first = namedSpecifierGroup[0]; + const last = namedSpecifierGroup[namedSpecifierGroup.length - 1]; + const removeRange = [first.range[0], last.range[1]]; + const textRange = [...removeRange]; + const before = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(first), util_1.NullThrowsReasons.MissingToken('token', 'first specifier')); + textRange[0] = before.range[1]; + if ((0, util_1.isCommaToken)(before)) { + removeRange[0] = before.range[0]; + } + else { + removeRange[0] = before.range[1]; + } + const isFirst = allNamedSpecifiers[0] === first; + const isLast = allNamedSpecifiers[allNamedSpecifiers.length - 1] === last; + const after = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(last), util_1.NullThrowsReasons.MissingToken('token', 'last specifier')); + textRange[1] = after.range[0]; + if ((isFirst || isLast) && (0, util_1.isCommaToken)(after)) { + removeRange[1] = after.range[1]; + } + return { + removeRange, + textRange, + }; + } + /** + * insert specifiers to named import node. + * e.g. + * import type { Already, Type1, Type2 } from 'foo' + * ^^^^^^^^^^^^^ insert + */ + function fixInsertNamedSpecifiersInNamedSpecifierList(fixer, target, insertText) { + const closingBraceToken = (0, util_1.nullThrows)(context.sourceCode.getFirstTokenBetween((0, util_1.nullThrows)(context.sourceCode.getFirstToken(target), util_1.NullThrowsReasons.MissingToken('token before', 'import')), target.source, util_1.isClosingBraceToken), util_1.NullThrowsReasons.MissingToken('}', target.type)); + const before = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(closingBraceToken), util_1.NullThrowsReasons.MissingToken('token before', 'closing brace')); + if (!(0, util_1.isCommaToken)(before) && !(0, util_1.isOpeningBraceToken)(before)) { + insertText = `,${insertText}`; + } + return fixer.insertTextBefore(closingBraceToken, insertText); + } + /** + * insert type keyword to named import node. + * e.g. + * import ADefault, { Already, type Type1, type Type2 } from 'foo' + * ^^^^ insert + */ + function* fixInsertTypeKeywordInNamedSpecifierList(fixer, typeSpecifiers) { + for (const spec of typeSpecifiers) { + const insertText = context.sourceCode.text.slice(...spec.range); + yield fixer.replaceTextRange(spec.range, `type ${insertText}`); + } + } + function* fixInlineTypeImportDeclaration(fixer, report, sourceImports) { + const { node } = report; + // For a value import, will only add an inline type to named specifiers + const { namedSpecifiers } = classifySpecifier(node); + const typeNamedSpecifiers = namedSpecifiers.filter(specifier => report.typeSpecifiers.includes(specifier)); + if (sourceImports.valueImport) { + // add import named type specifiers to its value import + // import ValueA, { type A } + // ^^^^ insert + const { namedSpecifiers: valueImportNamedSpecifiers } = classifySpecifier(sourceImports.valueImport); + if (sourceImports.valueOnlyNamedImport || + valueImportNamedSpecifiers.length) { + yield* fixInsertTypeKeywordInNamedSpecifierList(fixer, typeNamedSpecifiers); + } + } + } + function* fixToTypeImportDeclaration(fixer, report, sourceImports) { + const { node } = report; + const { defaultSpecifier, namedSpecifiers, namespaceSpecifier } = classifySpecifier(node); + if (namespaceSpecifier && !defaultSpecifier) { + // import * as types from 'foo' + // checks for presence of import assertions + if (node.attributes.length === 0) { + yield* fixInsertTypeSpecifierForImportDeclaration(fixer, node, false); + } + return; + } + if (defaultSpecifier) { + if (report.typeSpecifiers.includes(defaultSpecifier) && + namedSpecifiers.length === 0 && + !namespaceSpecifier) { + // import Type from 'foo' + yield* fixInsertTypeSpecifierForImportDeclaration(fixer, node, true); + return; + } + if (fixStyle === 'inline-type-imports' && + !report.typeSpecifiers.includes(defaultSpecifier) && + namedSpecifiers.length > 0 && + !namespaceSpecifier) { + // if there is a default specifier but it isn't a type specifier, then just add the inline type modifier to the named specifiers + // import AValue, {BValue, Type1, Type2} from 'foo' + yield* fixInlineTypeImportDeclaration(fixer, report, sourceImports); + return; + } + } + else if (!namespaceSpecifier) { + if (fixStyle === 'inline-type-imports' && + namedSpecifiers.some(specifier => report.typeSpecifiers.includes(specifier))) { + // import {AValue, Type1, Type2} from 'foo' + yield* fixInlineTypeImportDeclaration(fixer, report, sourceImports); + return; + } + if (namedSpecifiers.every(specifier => report.typeSpecifiers.includes(specifier))) { + // import {Type1, Type2} from 'foo' + yield* fixInsertTypeSpecifierForImportDeclaration(fixer, node, false); + return; + } + } + const typeNamedSpecifiers = namedSpecifiers.filter(specifier => report.typeSpecifiers.includes(specifier)); + const fixesNamedSpecifiers = getFixesNamedSpecifiers(fixer, node, typeNamedSpecifiers, namedSpecifiers); + const afterFixes = []; + if (typeNamedSpecifiers.length) { + if (sourceImports.typeOnlyNamedImport) { + const insertTypeNamedSpecifiers = fixInsertNamedSpecifiersInNamedSpecifierList(fixer, sourceImports.typeOnlyNamedImport, fixesNamedSpecifiers.typeNamedSpecifiersText); + if (sourceImports.typeOnlyNamedImport.range[1] <= node.range[0]) { + yield insertTypeNamedSpecifiers; + } + else { + afterFixes.push(insertTypeNamedSpecifiers); + } + } + else { + // The import is both default and named. Insert named on new line because can't mix default type import and named type imports + // eslint-disable-next-line no-lonely-if + if (fixStyle === 'inline-type-imports') { + yield fixer.insertTextBefore(node, `import {${typeNamedSpecifiers + .map(spec => { + const insertText = context.sourceCode.text.slice(...spec.range); + return `type ${insertText}`; + }) + .join(', ')}} from ${context.sourceCode.getText(node.source)};\n`); + } + else { + yield fixer.insertTextBefore(node, `import type {${fixesNamedSpecifiers.typeNamedSpecifiersText}} from ${context.sourceCode.getText(node.source)};\n`); + } + } + } + const fixesRemoveTypeNamespaceSpecifier = []; + if (namespaceSpecifier && + report.typeSpecifiers.includes(namespaceSpecifier)) { + // import Foo, * as Type from 'foo' + // import DefType, * as Type from 'foo' + // import DefType, * as Type from 'foo' + const commaToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(namespaceSpecifier, util_1.isCommaToken), util_1.NullThrowsReasons.MissingToken(',', node.type)); + // import Def, * as Ns from 'foo' + // ^^^^^^^^^ remove + fixesRemoveTypeNamespaceSpecifier.push(fixer.removeRange([commaToken.range[0], namespaceSpecifier.range[1]])); + // import type * as Ns from 'foo' + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ insert + yield fixer.insertTextBefore(node, `import type ${context.sourceCode.getText(namespaceSpecifier)} from ${context.sourceCode.getText(node.source)};\n`); + } + if (defaultSpecifier && + report.typeSpecifiers.includes(defaultSpecifier)) { + if (report.typeSpecifiers.length === node.specifiers.length) { + const importToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isImportKeyword), util_1.NullThrowsReasons.MissingToken('import', node.type)); + // import type Type from 'foo' + // ^^^^ insert + yield fixer.insertTextAfter(importToken, ' type'); + } + else { + const commaToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(defaultSpecifier, util_1.isCommaToken), util_1.NullThrowsReasons.MissingToken(',', defaultSpecifier.type)); + // import Type , {...} from 'foo' + // ^^^^^ pick + const defaultText = context.sourceCode.text + .slice(defaultSpecifier.range[0], commaToken.range[0]) + .trim(); + yield fixer.insertTextBefore(node, `import type ${defaultText} from ${context.sourceCode.getText(node.source)};\n`); + const afterToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(commaToken, { + includeComments: true, + }), util_1.NullThrowsReasons.MissingToken('any token', node.type)); + // import Type , {...} from 'foo' + // ^^^^^^^ remove + yield fixer.removeRange([ + defaultSpecifier.range[0], + afterToken.range[0], + ]); + } + } + yield* fixesNamedSpecifiers.removeTypeNamedSpecifiers; + yield* fixesRemoveTypeNamespaceSpecifier; + yield* afterFixes; + } + function* fixInsertTypeSpecifierForImportDeclaration(fixer, node, isDefaultImport) { + // import type Foo from 'foo' + // ^^^^^ insert + const importToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isImportKeyword), util_1.NullThrowsReasons.MissingToken('import', node.type)); + yield fixer.insertTextAfter(importToken, ' type'); + if (isDefaultImport) { + // Has default import + const openingBraceToken = context.sourceCode.getFirstTokenBetween(importToken, node.source, util_1.isOpeningBraceToken); + if (openingBraceToken) { + // Only braces. e.g. import Foo, {} from 'foo' + const commaToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(openingBraceToken, util_1.isCommaToken), util_1.NullThrowsReasons.MissingToken(',', node.type)); + const closingBraceToken = (0, util_1.nullThrows)(context.sourceCode.getFirstTokenBetween(openingBraceToken, node.source, util_1.isClosingBraceToken), util_1.NullThrowsReasons.MissingToken('}', node.type)); + // import type Foo, {} from 'foo' + // ^^ remove + yield fixer.removeRange([ + commaToken.range[0], + closingBraceToken.range[1], + ]); + const specifiersText = context.sourceCode.text.slice(commaToken.range[1], closingBraceToken.range[1]); + if (node.specifiers.length > 1) { + yield fixer.insertTextAfter(node, `\nimport type${specifiersText} from ${context.sourceCode.getText(node.source)};`); + } + } + } + // make sure we don't do anything like `import type {type T} from 'foo';` + for (const specifier of node.specifiers) { + if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier && + specifier.importKind === 'type') { + yield* fixRemoveTypeSpecifierFromImportSpecifier(fixer, specifier); + } + } + } + function* fixRemoveTypeSpecifierFromImportDeclaration(fixer, node) { + // import type Foo from 'foo' + // ^^^^ remove + const importToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isImportKeyword), util_1.NullThrowsReasons.MissingToken('import', node.type)); + const typeToken = (0, util_1.nullThrows)(context.sourceCode.getFirstTokenBetween(importToken, node.specifiers[0]?.local ?? node.source, util_1.isTypeKeyword), util_1.NullThrowsReasons.MissingToken('type', node.type)); + const afterToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(typeToken, { includeComments: true }), util_1.NullThrowsReasons.MissingToken('any token', node.type)); + yield fixer.removeRange([typeToken.range[0], afterToken.range[0]]); + } + function* fixRemoveTypeSpecifierFromImportSpecifier(fixer, node) { + // import { type Foo } from 'foo' + // ^^^^ remove + const typeToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isTypeKeyword), util_1.NullThrowsReasons.MissingToken('type', node.type)); + const afterToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(typeToken, { includeComments: true }), util_1.NullThrowsReasons.MissingToken('any token', node.type)); + yield fixer.removeRange([typeToken.range[0], afterToken.range[0]]); + } + }, +}); +//# sourceMappingURL=consistent-type-imports.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.d.ts new file mode 100644 index 00000000..009391c6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeLast", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.js new file mode 100644 index 00000000..30744e49 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/default-param-last.js @@ -0,0 +1,69 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'default-param-last', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce default parameters to be last', + extendsBaseRule: true, + frozen: true, + }, + messages: { + shouldBeLast: 'Default parameters should be last.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + /** + * checks if node is optional parameter + * @param node the node to be evaluated + * @private + */ + function isOptionalParam(node) { + return ((node.type === utils_1.AST_NODE_TYPES.ArrayPattern || + node.type === utils_1.AST_NODE_TYPES.AssignmentPattern || + node.type === utils_1.AST_NODE_TYPES.Identifier || + node.type === utils_1.AST_NODE_TYPES.ObjectPattern || + node.type === utils_1.AST_NODE_TYPES.RestElement) && + node.optional); + } + /** + * checks if node is plain parameter + * @param node the node to be evaluated + * @private + */ + function isPlainParam(node) { + return !(node.type === utils_1.AST_NODE_TYPES.AssignmentPattern || + node.type === utils_1.AST_NODE_TYPES.RestElement || + isOptionalParam(node)); + } + function checkDefaultParamLast(node) { + let hasSeenPlainParam = false; + for (let i = node.params.length - 1; i >= 0; i--) { + const current = node.params[i]; + const param = current.type === utils_1.AST_NODE_TYPES.TSParameterProperty + ? current.parameter + : current; + if (isPlainParam(param)) { + hasSeenPlainParam = true; + continue; + } + if (hasSeenPlainParam && + (isOptionalParam(param) || + param.type === utils_1.AST_NODE_TYPES.AssignmentPattern)) { + context.report({ node: current, messageId: 'shouldBeLast' }); + } + } + } + return { + ArrowFunctionExpression: checkDefaultParamLast, + FunctionDeclaration: checkDefaultParamLast, + FunctionExpression: checkDefaultParamLast, + }; + }, +}); +//# sourceMappingURL=default-param-last.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.d.ts new file mode 100644 index 00000000..fd80d596 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.d.ts @@ -0,0 +1,23 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{ + allowIndexSignaturePropertyAccess?: boolean; + allowKeywords?: boolean; + allowPattern?: string; + allowPrivateClassPropertyAccess?: boolean; + allowProtectedClassPropertyAccess?: boolean; +}], unknown, { + MemberExpression(node: TSESTree.MemberExpression): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{ + allowIndexSignaturePropertyAccess?: boolean; + allowKeywords?: boolean; + allowPattern?: string; + allowPrivateClassPropertyAccess?: boolean; + allowProtectedClassPropertyAccess?: boolean; +}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.js new file mode 100644 index 00000000..cc4e51a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/dot-notation.js @@ -0,0 +1,140 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('dot-notation'); +const defaultOptions = [ + { + allowIndexSignaturePropertyAccess: false, + allowKeywords: true, + allowPattern: '', + allowPrivateClassPropertyAccess: false, + allowProtectedClassPropertyAccess: false, + }, +]; +exports.default = (0, util_1.createRule)({ + name: 'dot-notation', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Enforce dot notation whenever possible', + extendsBaseRule: true, + frozen: true, + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: baseRule.meta.fixable, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowIndexSignaturePropertyAccess: { + type: 'boolean', + description: 'Whether to allow accessing properties matching an index signature with array notation.', + }, + allowKeywords: { + type: 'boolean', + description: 'Whether to allow keywords such as ["class"]`.', + }, + allowPattern: { + type: 'string', + description: 'Regular expression of names to allow.', + }, + allowPrivateClassPropertyAccess: { + type: 'boolean', + description: 'Whether to allow accessing class members marked as `private` with array notation.', + }, + allowProtectedClassPropertyAccess: { + type: 'boolean', + description: 'Whether to allow accessing class members marked as `protected` with array notation.', + }, + }, + }, + ], + }, + defaultOptions, + create(context, [options]) { + const rules = baseRule.create(context); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const allowPrivateClassPropertyAccess = options.allowPrivateClassPropertyAccess; + const allowProtectedClassPropertyAccess = options.allowProtectedClassPropertyAccess; + const allowIndexSignaturePropertyAccess = (options.allowIndexSignaturePropertyAccess ?? false) || + tsutils.isCompilerOptionEnabled(services.program.getCompilerOptions(), 'noPropertyAccessFromIndexSignature'); + return { + MemberExpression(node) { + if ((allowPrivateClassPropertyAccess || + allowProtectedClassPropertyAccess || + allowIndexSignaturePropertyAccess) && + node.computed) { + // for perf reasons - only fetch symbols if we have to + const propertySymbol = services.getSymbolAtLocation(node.property) ?? + services + .getTypeAtLocation(node.object) + .getNonNullableType() + .getProperties() + .find(propertySymbol => node.property.type === utils_1.AST_NODE_TYPES.Literal && + propertySymbol.escapedName === node.property.value); + const modifierKind = (0, util_1.getModifiers)(propertySymbol?.getDeclarations()?.[0])?.[0].kind; + if ((allowPrivateClassPropertyAccess && + modifierKind === ts.SyntaxKind.PrivateKeyword) || + (allowProtectedClassPropertyAccess && + modifierKind === ts.SyntaxKind.ProtectedKeyword)) { + return; + } + if (propertySymbol == null && allowIndexSignaturePropertyAccess) { + const objectType = services + .getTypeAtLocation(node.object) + .getNonNullableType(); + const indexInfos = checker.getIndexInfosOfType(objectType); + if (indexInfos.some(info => tsutils.isTypeFlagSet(info.keyType, ts.TypeFlags.StringLike))) { + return; + } + } + } + rules.MemberExpression(node); + }, + }; + }, +}); +//# sourceMappingURL=dot-notation.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.d.ts new file mode 100644 index 00000000..bd8594d7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.d.ts @@ -0,0 +1,41 @@ +import * as ts from 'typescript'; +/** + * Retrieve only the Enum literals from a type. for example: + * - 123 --> [] + * - {} --> [] + * - Fruit.Apple --> [Fruit.Apple] + * - Fruit.Apple | Vegetable.Lettuce --> [Fruit.Apple, Vegetable.Lettuce] + * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit.Apple, Vegetable.Lettuce] + * - T extends Fruit --> [Fruit] + */ +export declare function getEnumLiterals(type: ts.Type): ts.LiteralType[]; +/** + * A type can have 0 or more enum types. For example: + * - 123 --> [] + * - {} --> [] + * - Fruit.Apple --> [Fruit] + * - Fruit.Apple | Vegetable.Lettuce --> [Fruit, Vegetable] + * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit, Vegetable] + * - T extends Fruit --> [Fruit] + */ +export declare function getEnumTypes(typeChecker: ts.TypeChecker, type: ts.Type): ts.Type[]; +/** + * @returns Whether two types compare unsafely because an enum value is being + * compared against a non-enum value of the same primitive kind. + */ +export declare function isMismatchedEnumComparisonTypes(typeChecker: ts.TypeChecker, leftType: ts.Type, rightType: ts.Type): boolean; +/** + * Returns the enum key that matches the given literal node, or null if none + * match. For example: + * ```ts + * enum Fruit { + * Apple = 'apple', + * Banana = 'banana', + * } + * + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'apple') --> 'Fruit.Apple' + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'banana') --> 'Fruit.Banana' + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'cherry') --> null + * ``` + */ +export declare function getEnumKeyForLiteral(enumLiterals: ts.LiteralType[], literal: unknown): string | null; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.js new file mode 100644 index 00000000..b28ca1ca --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.js @@ -0,0 +1,189 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getEnumLiterals = getEnumLiterals; +exports.getEnumTypes = getEnumTypes; +exports.isMismatchedEnumComparisonTypes = isMismatchedEnumComparisonTypes; +exports.getEnumKeyForLiteral = getEnumKeyForLiteral; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../../util"); +/* + * If passed an enum member, returns the type of the parent. Otherwise, + * returns itself. + * + * For example: + * - `Fruit` --> `Fruit` + * - `Fruit.Apple` --> `Fruit` + */ +function getBaseEnumType(typeChecker, type) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const symbol = type.getSymbol(); + if (!tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.EnumMember)) { + return type; + } + return typeChecker.getTypeAtLocation(symbol.valueDeclaration.parent); +} +/** + * Retrieve only the Enum literals from a type. for example: + * - 123 --> [] + * - {} --> [] + * - Fruit.Apple --> [Fruit.Apple] + * - Fruit.Apple | Vegetable.Lettuce --> [Fruit.Apple, Vegetable.Lettuce] + * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit.Apple, Vegetable.Lettuce] + * - T extends Fruit --> [Fruit] + */ +function getEnumLiterals(type) { + return tsutils + .unionConstituents(type) + .filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral)); +} +/** + * A type can have 0 or more enum types. For example: + * - 123 --> [] + * - {} --> [] + * - Fruit.Apple --> [Fruit] + * - Fruit.Apple | Vegetable.Lettuce --> [Fruit, Vegetable] + * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit, Vegetable] + * - T extends Fruit --> [Fruit] + */ +function getEnumTypes(typeChecker, type) { + return getEnumLiterals(type).map(type => getBaseEnumType(typeChecker, type)); +} +/** + * @returns Whether two types compare unsafely because an enum value is being + * compared against a non-enum value of the same primitive kind. + */ +function isMismatchedEnumComparisonTypes(typeChecker, leftType, rightType) { + // Allow comparisons that don't have anything to do with enums: + // + // ```ts + // 1 === 2; + // ``` + const leftEnumTypes = getEnumTypes(typeChecker, leftType); + const rightEnumTypes = new Set(getEnumTypes(typeChecker, rightType)); + if (leftEnumTypes.length === 0 && rightEnumTypes.size === 0) { + return false; + } + // Allow comparisons that share an enum type: + // + // ```ts + // Fruit.Apple === Fruit.Banana; + // ``` + for (const leftEnumType of leftEnumTypes) { + if (rightEnumTypes.has(leftEnumType)) { + return false; + } + } + // We need to split the type into the union type parts in order to find + // valid enum comparisons like: + // + // ```ts + // declare const something: Fruit | Vegetable; + // something === Fruit.Apple; + // ``` + const leftTypeParts = tsutils.unionConstituents(leftType); + const rightTypeParts = tsutils.unionConstituents(rightType); + // If a type exists in both sides, we consider this comparison safe: + // + // ```ts + // declare const fruit: Fruit.Apple | 0; + // fruit === 0; + // ``` + for (const leftTypePart of leftTypeParts) { + if (rightTypeParts.includes(leftTypePart)) { + return false; + } + } + return (typeViolates(leftTypeParts, rightType) || + typeViolates(rightTypeParts, leftType)); +} +/** + * @returns Whether the right type is an unsafe comparison against any left type. + */ +function typeViolates(leftTypeParts, rightType) { + const leftEnumValueTypes = new Set(leftTypeParts.map(getEnumValueType)); + return ((leftEnumValueTypes.has(ts.TypeFlags.Number) && (0, util_1.isNumberLike)(rightType)) || + (leftEnumValueTypes.has(ts.TypeFlags.String) && (0, util_1.isStringLike)(rightType))); +} +/** + * @returns What type a type's enum value is (number or string), if either. + */ +function getEnumValueType(type) { + return tsutils.isTypeFlagSet(type, ts.TypeFlags.EnumLike) + ? tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLiteral) + ? ts.TypeFlags.Number + : ts.TypeFlags.String + : undefined; +} +/** + * Returns the enum key that matches the given literal node, or null if none + * match. For example: + * ```ts + * enum Fruit { + * Apple = 'apple', + * Banana = 'banana', + * } + * + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'apple') --> 'Fruit.Apple' + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'banana') --> 'Fruit.Banana' + * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'cherry') --> null + * ``` + */ +function getEnumKeyForLiteral(enumLiterals, literal) { + for (const enumLiteral of enumLiterals) { + if (enumLiteral.value === literal) { + const { symbol } = enumLiteral; + const memberDeclaration = symbol.valueDeclaration; + const enumDeclaration = memberDeclaration.parent; + const memberNameIdentifier = memberDeclaration.name; + const enumName = enumDeclaration.name.text; + switch (memberNameIdentifier.kind) { + case ts.SyntaxKind.Identifier: + return `${enumName}.${memberNameIdentifier.text}`; + case ts.SyntaxKind.StringLiteral: { + const memberName = memberNameIdentifier.text.replaceAll("'", "\\'"); + return `${enumName}['${memberName}']`; + } + case ts.SyntaxKind.ComputedPropertyName: + return `${enumName}[${memberNameIdentifier.expression.getText()}]`; + default: + break; + } + } + } + return null; +} +//# sourceMappingURL=shared.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.d.ts new file mode 100644 index 00000000..18d6b808 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.d.ts @@ -0,0 +1,17 @@ +export type Options = [ + { + allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean; + allowDirectConstAssertionInArrowFunctions?: boolean; + allowedNames?: string[]; + allowExpressions?: boolean; + allowFunctionsWithoutTypeParameters?: boolean; + allowHigherOrderFunctions?: boolean; + allowIIFEs?: boolean; + allowTypedFunctionExpressions?: boolean; + } +]; +export type MessageIds = 'missingReturnType'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js new file mode 100644 index 00000000..eaf377de --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js @@ -0,0 +1,180 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils"); +exports.default = (0, util_1.createRule)({ + name: 'explicit-function-return-type', + meta: { + type: 'problem', + docs: { + description: 'Require explicit return types on functions and class methods', + }, + messages: { + missingReturnType: 'Missing return type on function.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowConciseArrowFunctionExpressionsStartingWithVoid: { + type: 'boolean', + description: 'Whether to allow arrow functions that start with the `void` keyword.', + }, + allowDirectConstAssertionInArrowFunctions: { + type: 'boolean', + description: 'Whether to ignore arrow functions immediately returning a `as const` value.', + }, + allowedNames: { + type: 'array', + description: 'An array of function/method names that will not have their arguments or return values checked.', + items: { + type: 'string', + }, + }, + allowExpressions: { + type: 'boolean', + description: 'Whether to ignore function expressions (functions which are not part of a declaration).', + }, + allowFunctionsWithoutTypeParameters: { + type: 'boolean', + description: "Whether to ignore functions that don't have generic type parameters.", + }, + allowHigherOrderFunctions: { + type: 'boolean', + description: 'Whether to ignore functions immediately returning another function expression.', + }, + allowIIFEs: { + type: 'boolean', + description: 'Whether to ignore immediately invoked function expressions (IIFEs).', + }, + allowTypedFunctionExpressions: { + type: 'boolean', + description: 'Whether to ignore type annotations on the variable of function expressions.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowConciseArrowFunctionExpressionsStartingWithVoid: false, + allowDirectConstAssertionInArrowFunctions: true, + allowedNames: [], + allowExpressions: false, + allowFunctionsWithoutTypeParameters: false, + allowHigherOrderFunctions: true, + allowIIFEs: false, + allowTypedFunctionExpressions: true, + }, + ], + create(context, [options]) { + const functionInfoStack = []; + function enterFunction(node) { + functionInfoStack.push({ + node, + returns: [], + }); + } + function popFunctionInfo(exitNodeType) { + return (0, util_1.nullThrows)(functionInfoStack.pop(), `Stack should exist on ${exitNodeType} exit`); + } + function isAllowedFunction(node) { + if (options.allowFunctionsWithoutTypeParameters && !node.typeParameters) { + return true; + } + if (options.allowIIFEs && isIIFE(node)) { + return true; + } + if (!options.allowedNames?.length) { + return false; + } + if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + node.type === utils_1.AST_NODE_TYPES.FunctionExpression) { + const parent = node.parent; + let funcName; + if (node.id?.name) { + funcName = node.id.name; + } + else { + switch (parent.type) { + case utils_1.AST_NODE_TYPES.VariableDeclarator: { + if (parent.id.type === utils_1.AST_NODE_TYPES.Identifier) { + funcName = parent.id.name; + } + break; + } + case utils_1.AST_NODE_TYPES.MethodDefinition: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.Property: { + if (parent.key.type === utils_1.AST_NODE_TYPES.Identifier && + !parent.computed) { + funcName = parent.key.name; + } + break; + } + } + } + if (!!funcName && options.allowedNames.includes(funcName)) { + return true; + } + } + if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && + node.id && + options.allowedNames.includes(node.id.name)) { + return true; + } + return false; + } + function isIIFE(node) { + return node.parent.type === utils_1.AST_NODE_TYPES.CallExpression; + } + function exitFunctionExpression(node) { + const info = popFunctionInfo('function expression'); + if (options.allowConciseArrowFunctionExpressionsStartingWithVoid && + node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + node.expression && + node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression && + node.body.operator === 'void') { + return; + } + if (isAllowedFunction(node)) { + return; + } + if (options.allowTypedFunctionExpressions && + ((0, explicitReturnTypeUtils_1.isValidFunctionExpressionReturnType)(node, options) || + (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node))) { + return; + } + (0, explicitReturnTypeUtils_1.checkFunctionReturnType)(info, options, context.sourceCode, loc => context.report({ + loc, + node, + messageId: 'missingReturnType', + })); + } + return { + 'ArrowFunctionExpression, FunctionExpression, FunctionDeclaration': enterFunction, + 'ArrowFunctionExpression:exit': exitFunctionExpression, + 'FunctionDeclaration:exit'(node) { + const info = popFunctionInfo('function declaration'); + if (isAllowedFunction(node)) { + return; + } + if (options.allowTypedFunctionExpressions && node.returnType) { + return; + } + (0, explicitReturnTypeUtils_1.checkFunctionReturnType)(info, options, context.sourceCode, loc => context.report({ + loc, + node, + messageId: 'missingReturnType', + })); + }, + 'FunctionExpression:exit': exitFunctionExpression, + ReturnStatement(node) { + functionInfoStack.at(-1)?.returns.push(node); + }, + }; + }, +}); +//# sourceMappingURL=explicit-function-return-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.d.ts new file mode 100644 index 00000000..6941d091 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.d.ts @@ -0,0 +1,19 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +type AccessibilityLevel = 'explicit' | 'no-public' | 'off'; +export interface Config { + accessibility?: AccessibilityLevel; + ignoredMethodNames?: string[]; + overrides?: { + accessors?: AccessibilityLevel; + constructors?: AccessibilityLevel; + methods?: AccessibilityLevel; + parameterProperties?: AccessibilityLevel; + properties?: AccessibilityLevel; + }; +} +export type Options = [Config]; +export type MessageIds = 'addExplicitAccessibility' | 'missingAccessibility' | 'unwantedPublicAccessibility'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js new file mode 100644 index 00000000..be6fd9f4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js @@ -0,0 +1,300 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getMemberHeadLoc_1 = require("../util/getMemberHeadLoc"); +const rangeToLoc_1 = require("../util/rangeToLoc"); +exports.default = (0, util_1.createRule)({ + name: 'explicit-member-accessibility', + meta: { + type: 'problem', + docs: { + description: 'Require explicit accessibility modifiers on class properties and methods', + // too opinionated to be recommended + }, + fixable: 'code', + hasSuggestions: true, + messages: { + addExplicitAccessibility: "Add '{{ type }}' accessibility modifier", + missingAccessibility: 'Missing accessibility modifier on {{type}} {{name}}.', + unwantedPublicAccessibility: 'Public accessibility modifier on {{type}} {{name}}.', + }, + schema: [ + { + type: 'object', + $defs: { + accessibilityLevel: { + oneOf: [ + { + type: 'string', + description: 'Always require an accessor.', + enum: ['explicit'], + }, + { + type: 'string', + description: 'Require an accessor except when public.', + enum: ['no-public'], + }, + { + type: 'string', + description: 'Never check whether there is an accessor.', + enum: ['off'], + }, + ], + }, + }, + additionalProperties: false, + properties: { + accessibility: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which accessibility modifier is required to exist or not exist.', + }, + ignoredMethodNames: { + type: 'array', + description: 'Specific method names that may be ignored.', + items: { + type: 'string', + }, + }, + overrides: { + type: 'object', + additionalProperties: false, + description: 'Changes to required accessibility modifiers for specific kinds of class members.', + properties: { + accessors: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which member accessibility modifier requirements to apply for accessors.', + }, + constructors: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which member accessibility modifier requirements to apply for constructors.', + }, + methods: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which member accessibility modifier requirements to apply for methods.', + }, + parameterProperties: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which member accessibility modifier requirements to apply for parameterProperties.', + }, + properties: { + $ref: '#/items/0/$defs/accessibilityLevel', + description: 'Which member accessibility modifier requirements to apply for properties.', + }, + }, + }, + }, + }, + ], + }, + defaultOptions: [{ accessibility: 'explicit' }], + create(context, [option]) { + const baseCheck = option.accessibility ?? 'explicit'; + const overrides = option.overrides ?? {}; + const ctorCheck = overrides.constructors ?? baseCheck; + const accessorCheck = overrides.accessors ?? baseCheck; + const methodCheck = overrides.methods ?? baseCheck; + const propCheck = overrides.properties ?? baseCheck; + const paramPropCheck = overrides.parameterProperties ?? baseCheck; + const ignoredMethodNames = new Set(option.ignoredMethodNames ?? []); + /** + * Checks if a method declaration has an accessibility modifier. + * @param methodDefinition The node representing a MethodDefinition. + */ + function checkMethodAccessibilityModifier(methodDefinition) { + if (methodDefinition.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return; + } + let nodeType = 'method definition'; + let check = baseCheck; + switch (methodDefinition.kind) { + case 'method': + check = methodCheck; + break; + case 'constructor': + check = ctorCheck; + break; + case 'get': + case 'set': + check = accessorCheck; + nodeType = `${methodDefinition.kind} property accessor`; + break; + } + const { name: methodName } = (0, util_1.getNameFromMember)(methodDefinition, context.sourceCode); + if (check === 'off' || ignoredMethodNames.has(methodName)) { + return; + } + if (check === 'no-public' && + methodDefinition.accessibility === 'public') { + const publicKeyword = findPublicKeyword(methodDefinition); + context.report({ + loc: (0, rangeToLoc_1.rangeToLoc)(context.sourceCode, publicKeyword.range), + messageId: 'unwantedPublicAccessibility', + data: { + name: methodName, + type: nodeType, + }, + fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove), + }); + } + else if (check === 'explicit' && !methodDefinition.accessibility) { + context.report({ + loc: (0, getMemberHeadLoc_1.getMemberHeadLoc)(context.sourceCode, methodDefinition), + messageId: 'missingAccessibility', + data: { + name: methodName, + type: nodeType, + }, + suggest: getMissingAccessibilitySuggestions(methodDefinition), + }); + } + } + /** + * Returns an object containing a range that corresponds to the "public" + * keyword for a node, and the range that would need to be removed to + * remove the "public" keyword (including associated whitespace). + */ + function findPublicKeyword(node) { + const tokens = context.sourceCode.getTokens(node); + let rangeToRemove; + let keywordRange; + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i]; + if (token.type === utils_1.AST_TOKEN_TYPES.Keyword && + token.value === 'public') { + keywordRange = structuredClone(token.range); + const commentsAfterPublicKeyword = context.sourceCode.getCommentsAfter(token); + if (commentsAfterPublicKeyword.length) { + // public /* Hi there! */ static foo() + // ^^^^^^^ + rangeToRemove = [ + token.range[0], + commentsAfterPublicKeyword[0].range[0], + ]; + break; + } + else { + // public static foo() + // ^^^^^^^ + rangeToRemove = [token.range[0], tokens[i + 1].range[0]]; + break; + } + } + } + return { range: keywordRange, rangeToRemove }; + } + /** + * Creates a fixer that adds an accessibility modifier keyword + */ + function getMissingAccessibilitySuggestions(node) { + function fix(accessibility, fixer) { + if (node.decorators.length) { + const lastDecorator = node.decorators[node.decorators.length - 1]; + const nextToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(lastDecorator), util_1.NullThrowsReasons.MissingToken('token', 'last decorator')); + return fixer.insertTextBefore(nextToken, `${accessibility} `); + } + return fixer.insertTextBefore(node, `${accessibility} `); + } + return [ + { + messageId: 'addExplicitAccessibility', + data: { type: 'public' }, + fix: fixer => fix('public', fixer), + }, + { + messageId: 'addExplicitAccessibility', + data: { type: 'private' }, + fix: fixer => fix('private', fixer), + }, + { + messageId: 'addExplicitAccessibility', + data: { type: 'protected' }, + fix: fixer => fix('protected', fixer), + }, + ]; + } + /** + * Checks if property has an accessibility modifier. + * @param propertyDefinition The node representing a PropertyDefinition. + */ + function checkPropertyAccessibilityModifier(propertyDefinition) { + if (propertyDefinition.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return; + } + const nodeType = 'class property'; + const { name: propertyName } = (0, util_1.getNameFromMember)(propertyDefinition, context.sourceCode); + if (propCheck === 'no-public' && + propertyDefinition.accessibility === 'public') { + const publicKeywordRange = findPublicKeyword(propertyDefinition); + context.report({ + loc: (0, rangeToLoc_1.rangeToLoc)(context.sourceCode, publicKeywordRange.range), + messageId: 'unwantedPublicAccessibility', + data: { + name: propertyName, + type: nodeType, + }, + fix: fixer => fixer.removeRange(publicKeywordRange.rangeToRemove), + }); + } + else if (propCheck === 'explicit' && + !propertyDefinition.accessibility) { + context.report({ + loc: (0, getMemberHeadLoc_1.getMemberHeadLoc)(context.sourceCode, propertyDefinition), + messageId: 'missingAccessibility', + data: { + name: propertyName, + type: nodeType, + }, + suggest: getMissingAccessibilitySuggestions(propertyDefinition), + }); + } + } + /** + * Checks that the parameter property has the desired accessibility modifiers set. + * @param node The node representing a Parameter Property + */ + function checkParameterPropertyAccessibilityModifier(node) { + const nodeType = 'parameter property'; + const nodeName = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier + ? node.parameter.name + : node.parameter.left.name; + switch (paramPropCheck) { + case 'explicit': { + if (!node.accessibility) { + context.report({ + loc: (0, getMemberHeadLoc_1.getParameterPropertyHeadLoc)(context.sourceCode, node, nodeName), + messageId: 'missingAccessibility', + data: { + name: nodeName, + type: nodeType, + }, + suggest: getMissingAccessibilitySuggestions(node), + }); + } + break; + } + case 'no-public': { + if (node.accessibility === 'public' && node.readonly) { + const publicKeyword = findPublicKeyword(node); + context.report({ + loc: (0, rangeToLoc_1.rangeToLoc)(context.sourceCode, publicKeyword.range), + messageId: 'unwantedPublicAccessibility', + data: { + name: nodeName, + type: nodeType, + }, + fix: fixer => fixer.removeRange(publicKeyword.rangeToRemove), + }); + } + break; + } + } + } + return { + 'MethodDefinition, TSAbstractMethodDefinition': checkMethodAccessibilityModifier, + 'PropertyDefinition, TSAbstractPropertyDefinition, AccessorProperty, TSAbstractAccessorProperty': checkPropertyAccessibilityModifier, + TSParameterProperty: checkParameterPropertyAccessibilityModifier, + }; + }, +}); +//# sourceMappingURL=explicit-member-accessibility.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.d.ts new file mode 100644 index 00000000..9b53522f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.d.ts @@ -0,0 +1,15 @@ +export type Options = [ + { + allowArgumentsExplicitlyTypedAsAny?: boolean; + allowDirectConstAssertionInArrowFunctions?: boolean; + allowedNames?: string[]; + allowHigherOrderFunctions?: boolean; + allowTypedFunctionExpressions?: boolean; + allowOverloadFunctions?: boolean; + } +]; +export type MessageIds = 'anyTypedArg' | 'anyTypedArgUnnamed' | 'missingArgType' | 'missingArgTypeUnnamed' | 'missingReturnType'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.js new file mode 100644 index 00000000..b9b6d128 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-module-boundary-types.js @@ -0,0 +1,387 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils"); +exports.default = (0, util_1.createRule)({ + name: 'explicit-module-boundary-types', + meta: { + type: 'problem', + docs: { + description: "Require explicit return and argument types on exported functions' and classes' public class methods", + }, + messages: { + anyTypedArg: "Argument '{{name}}' should be typed with a non-any type.", + anyTypedArgUnnamed: '{{type}} argument should be typed with a non-any type.', + missingArgType: "Argument '{{name}}' should be typed.", + missingArgTypeUnnamed: '{{type}} argument should be typed.', + missingReturnType: 'Missing return type on function.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowArgumentsExplicitlyTypedAsAny: { + type: 'boolean', + description: 'Whether to ignore arguments that are explicitly typed as `any`.', + }, + allowDirectConstAssertionInArrowFunctions: { + type: 'boolean', + description: [ + 'Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.', + 'You must still type the parameters of the function.', + ].join('\n'), + }, + allowedNames: { + type: 'array', + description: 'An array of function/method names that will not have their arguments or return values checked.', + items: { + type: 'string', + }, + }, + allowHigherOrderFunctions: { + type: 'boolean', + description: [ + 'Whether to ignore return type annotations on functions immediately returning another function expression.', + 'You must still type the parameters of the function.', + ].join('\n'), + }, + allowOverloadFunctions: { + type: 'boolean', + description: 'Whether to ignore return type annotations on functions with overload signatures.', + }, + allowTypedFunctionExpressions: { + type: 'boolean', + description: 'Whether to ignore type annotations on the variable of a function expression.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowArgumentsExplicitlyTypedAsAny: false, + allowDirectConstAssertionInArrowFunctions: true, + allowedNames: [], + allowHigherOrderFunctions: true, + allowOverloadFunctions: false, + allowTypedFunctionExpressions: true, + }, + ], + create(context, [options]) { + // tracks all of the functions we've already checked + const checkedFunctions = new Set(); + const functionStack = []; + const functionReturnsMap = new Map(); + // all nodes visited, avoids infinite recursion for cyclic references + // (such as class member referring to itself) + const alreadyVisited = new Set(); + function getReturnsInFunction(node) { + return functionReturnsMap.get(node) ?? []; + } + function enterFunction(node) { + functionStack.push(node); + functionReturnsMap.set(node, []); + } + function exitFunction() { + functionStack.pop(); + } + /* + # How the rule works: + + As the rule traverses the AST, it immediately checks every single function that it finds is exported. + "exported" means that it is either directly exported, or that its name is exported. + + It also collects a list of every single function it finds on the way, but does not check them. + After it's finished traversing the AST, it then iterates through the list of found functions, and checks to see if + any of them are part of a higher-order function + */ + return { + 'ArrowFunctionExpression, FunctionDeclaration, FunctionExpression': enterFunction, + 'ArrowFunctionExpression:exit': exitFunction, + 'ExportDefaultDeclaration:exit'(node) { + checkNode(node.declaration); + }, + 'ExportNamedDeclaration:not([source]):exit'(node) { + if (node.declaration) { + checkNode(node.declaration); + } + else { + for (const specifier of node.specifiers) { + followReference(specifier.local); + } + } + }, + 'FunctionDeclaration:exit': exitFunction, + 'FunctionExpression:exit': exitFunction, + 'Program:exit'() { + for (const [node, returns] of functionReturnsMap) { + if (isExportedHigherOrderFunction({ node, returns })) { + checkNode(node); + } + } + }, + ReturnStatement(node) { + const current = functionStack[functionStack.length - 1]; + functionReturnsMap.get(current)?.push(node); + }, + 'TSExportAssignment:exit'(node) { + checkNode(node.expression); + }, + }; + function checkParameters(node) { + function checkParameter(param) { + function report(namedMessageId, unnamedMessageId) { + if (param.type === utils_1.AST_NODE_TYPES.Identifier) { + context.report({ + node: param, + messageId: namedMessageId, + data: { name: param.name }, + }); + } + else if (param.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + context.report({ + node: param, + messageId: unnamedMessageId, + data: { type: 'Array pattern' }, + }); + } + else if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + context.report({ + node: param, + messageId: unnamedMessageId, + data: { type: 'Object pattern' }, + }); + } + else if (param.type === utils_1.AST_NODE_TYPES.RestElement) { + if (param.argument.type === utils_1.AST_NODE_TYPES.Identifier) { + context.report({ + node: param, + messageId: namedMessageId, + data: { name: param.argument.name }, + }); + } + else { + context.report({ + node: param, + messageId: unnamedMessageId, + data: { type: 'Rest' }, + }); + } + } + } + switch (param.type) { + case utils_1.AST_NODE_TYPES.ArrayPattern: + case utils_1.AST_NODE_TYPES.Identifier: + case utils_1.AST_NODE_TYPES.ObjectPattern: + case utils_1.AST_NODE_TYPES.RestElement: + if (!param.typeAnnotation) { + report('missingArgType', 'missingArgTypeUnnamed'); + } + else if (options.allowArgumentsExplicitlyTypedAsAny !== true && + param.typeAnnotation.typeAnnotation.type === + utils_1.AST_NODE_TYPES.TSAnyKeyword) { + report('anyTypedArg', 'anyTypedArgUnnamed'); + } + return; + case utils_1.AST_NODE_TYPES.TSParameterProperty: + return checkParameter(param.parameter); + case utils_1.AST_NODE_TYPES.AssignmentPattern: // ignored as it has a type via its assignment + return; + } + } + for (const arg of node.params) { + checkParameter(arg); + } + } + /** + * Checks if a function name is allowed and should not be checked. + */ + function isAllowedName(node) { + if (!node || !options.allowedNames || options.allowedNames.length === 0) { + return false; + } + if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator || + node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) { + return (node.id?.type === utils_1.AST_NODE_TYPES.Identifier && + options.allowedNames.includes(node.id.name)); + } + if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition || + node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition || + (node.type === utils_1.AST_NODE_TYPES.Property && node.method) || + node.type === utils_1.AST_NODE_TYPES.PropertyDefinition || + node.type === utils_1.AST_NODE_TYPES.AccessorProperty) { + return (0, util_1.isStaticMemberAccessOfValue)(node, context, ...options.allowedNames); + } + return false; + } + function isExportedHigherOrderFunction({ node, }) { + let current = node.parent; + while (current) { + if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement) { + // the parent of a return will always be a block statement, so we can skip over it + current = current.parent.parent; + continue; + } + if (!(0, util_1.isFunction)(current)) { + return false; + } + const returns = getReturnsInFunction(current); + if (!(0, explicitReturnTypeUtils_1.doesImmediatelyReturnFunctionExpression)({ node: current, returns })) { + return false; + } + if (checkedFunctions.has(current)) { + return true; + } + current = current.parent; + } + return false; + } + function followReference(node) { + const scope = context.sourceCode.getScope(node); + const variable = scope.set.get(node.name); + /* istanbul ignore if */ if (!variable) { + return; + } + // check all of the definitions + for (const definition of variable.defs) { + // cases we don't care about in this rule + if ([ + scope_manager_1.DefinitionType.CatchClause, + scope_manager_1.DefinitionType.ImplicitGlobalVariable, + scope_manager_1.DefinitionType.ImportBinding, + scope_manager_1.DefinitionType.Parameter, + ].includes(definition.type)) { + continue; + } + checkNode(definition.node); + } + // follow references to find writes to the variable + for (const reference of variable.references) { + if ( + // we don't want to check the initialization ref, as this is handled by the declaration check + !reference.init && + reference.writeExpr) { + checkNode(reference.writeExpr); + } + } + } + function checkNode(node) { + if (node == null || alreadyVisited.has(node)) { + return; + } + alreadyVisited.add(node); + switch (node.type) { + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: { + const returns = getReturnsInFunction(node); + return checkFunctionExpression({ node, returns }); + } + case utils_1.AST_NODE_TYPES.ArrayExpression: + for (const element of node.elements) { + checkNode(element); + } + return; + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.AccessorProperty: + case utils_1.AST_NODE_TYPES.MethodDefinition: + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + if (node.accessibility === 'private' || + node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return; + } + return checkNode(node.value); + case utils_1.AST_NODE_TYPES.ClassDeclaration: + case utils_1.AST_NODE_TYPES.ClassExpression: + for (const element of node.body.body) { + checkNode(element); + } + return; + case utils_1.AST_NODE_TYPES.FunctionDeclaration: { + const returns = getReturnsInFunction(node); + return checkFunction({ node, returns }); + } + case utils_1.AST_NODE_TYPES.Identifier: + return followReference(node); + case utils_1.AST_NODE_TYPES.ObjectExpression: + for (const property of node.properties) { + checkNode(property); + } + return; + case utils_1.AST_NODE_TYPES.Property: + return checkNode(node.value); + case utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression: + return checkEmptyBodyFunctionExpression(node); + case utils_1.AST_NODE_TYPES.VariableDeclaration: + for (const declaration of node.declarations) { + checkNode(declaration); + } + return; + case utils_1.AST_NODE_TYPES.VariableDeclarator: + return checkNode(node.init); + } + } + function checkEmptyBodyFunctionExpression(node) { + const isConstructor = node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.parent.kind === 'constructor'; + const isSetAccessor = (node.parent.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition || + node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) && + node.parent.kind === 'set'; + if (!isConstructor && !isSetAccessor && !node.returnType) { + context.report({ + node, + messageId: 'missingReturnType', + }); + } + checkParameters(node); + } + function checkFunctionExpression({ node, returns, }) { + if (checkedFunctions.has(node)) { + return; + } + checkedFunctions.add(node); + if (isAllowedName(node.parent) || + (0, explicitReturnTypeUtils_1.isTypedFunctionExpression)(node, options) || + (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node)) { + return; + } + if (options.allowOverloadFunctions && + node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + (0, util_1.hasOverloadSignatures)(node.parent, context)) { + return; + } + (0, explicitReturnTypeUtils_1.checkFunctionExpressionReturnType)({ node, returns }, options, context.sourceCode, loc => { + context.report({ + loc, + node, + messageId: 'missingReturnType', + }); + }); + checkParameters(node); + } + function checkFunction({ node, returns, }) { + if (checkedFunctions.has(node)) { + return; + } + checkedFunctions.add(node); + if (isAllowedName(node) || (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node)) { + return; + } + if (options.allowOverloadFunctions && + (0, util_1.hasOverloadSignatures)(node, context)) { + return; + } + (0, explicitReturnTypeUtils_1.checkFunctionReturnType)({ node, returns }, options, context.sourceCode, loc => { + context.report({ + loc, + node, + messageId: 'missingReturnType', + }); + }); + checkParameters(node); + } + }, +}); +//# sourceMappingURL=explicit-module-boundary-types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts new file mode 100644 index 00000000..d542fb74 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts @@ -0,0 +1,451 @@ +declare const rules: { + 'adjacent-overload-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<"adjacentSignature", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'array-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'await-thenable': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'ban-ts-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'ban-tslint-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentDetected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'class-literal-property-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'class-methods-use-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", import("./class-methods-use-this").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-generic-constructors': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-indexed-object-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({ + treatUndefinedAsUnspecified?: boolean; + } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-type-assertions': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-type-definitions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'consistent-type-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'consistent-type-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'default-param-last': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeLast", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'dot-notation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{ + allowIndexSignaturePropertyAccess?: boolean; + allowKeywords?: boolean; + allowPattern?: string; + allowPrivateClassPropertyAccess?: boolean; + allowProtectedClassPropertyAccess?: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'explicit-function-return-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", import("./explicit-function-return-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'explicit-member-accessibility': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'explicit-module-boundary-types': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'init-declarations': import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({ + ignoreForLoopInit?: boolean; + } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'max-params': import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({ + countVoidThis?: boolean; + max: number; + } | { + countVoidThis?: boolean; + maximum: number; + })[], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'member-ordering': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'method-signature-style': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'naming-convention': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-array-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLiteral", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-array-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-base-to-string': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-confusing-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-confusing-void-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-deprecated': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deprecated" | "deprecatedWithReason", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-dupe-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-duplicate-enum-values': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateValue", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-duplicate-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-dynamic-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-empty-function': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestComment" | "unexpected", [{ + allow?: string[]; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-empty-interface': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-explicit-any': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-extra-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExtraNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-extraneous-class': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-floating-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-generated-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-import-type-side-effects': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useTopLevelQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-inferrable-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", import("./no-inferrable-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-invalid-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({ + capIsConstructor?: boolean; + } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-invalid-void-type': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-loop-func': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeRefs", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-loss-of-precision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-magic-numbers': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{ + detectObjects?: boolean; + enforceConst?: boolean; + ignore?: (number | string)[]; + ignoreArrayIndexes?: boolean; + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; + ignoreTypeIndexes?: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-misused-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-misused-spread': import("@typescript-eslint/utils/ts-eslint").RuleModule<"addAwait" | "noArraySpreadInObject" | "noClassDeclarationSpreadInObject" | "noClassInstanceSpreadInObject" | "noFunctionSpreadInObject" | "noIterableSpreadInObject" | "noMapSpreadInObject" | "noPromiseSpreadInObject" | "noStringSpread" | "replaceMapSpreadInObject", [{ + allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[]; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-mixed-enums': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-namespace': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", import("./no-namespace").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-asserted-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullOptionalChain" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./no-require-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-shadow': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-this-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-type-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-boolean-literal-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-condition': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-parameter-property-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryAssign", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-qualifier': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-template-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUnnecessaryTemplateExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeObjectPattern", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-call': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedExpression", [{ + allowShortCircuit?: boolean; + allowTaggedTemplates?: boolean; + allowTernary?: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-private-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedPrivateClassMember", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./no-use-before-define").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "removeDefaultAssignment" | "useOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{ + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-var-requires': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVarReqs", import("./no-var-requires").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'no-wrapper-object-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedClassType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'non-nullable-type-assertion-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'only-throw-error': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'parameter-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-as-const': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferDestructuring", import("./prefer-destructuring").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-enum-initializers': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-find': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferFind" | "preferFindSuggestion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-for-of': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferForOf", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-includes': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-literal-enum-member': import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{ + allowBitwiseExpressions: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-namespace-keyword': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-promise-reject-errors': import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", import("./prefer-promise-reject-errors").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-readonly': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferReadonly", import("./prefer-readonly").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-readonly-parameter-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", import("./prefer-readonly-parameter-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-reduce-type-parameter': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-regexp-exec': import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-return-this-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'prefer-string-starts-ends-with': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'prefer-ts-expect-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'promise-function-async': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'related-getter-setter-pairs': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'require-array-sort-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", import("./require-array-sort-compare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'require-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'restrict-plus-operands': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'restrict-template-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", import("./restrict-template-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'return-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'sort-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn" | "suggestAddVoidOp" | "suggestWrapInAsyncIIFE", [{ + allowReturnAny?: boolean; + }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + 'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'triple-slash-reference': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", import("./triple-slash-reference").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; + }; + typedef: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'unbound-method': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'unified-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; + 'use-unknown-in-catch-callback-variable': import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; + }; +}; +export = rules; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.js new file mode 100644 index 00000000..5164fc78 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.js @@ -0,0 +1,278 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +const adjacent_overload_signatures_1 = __importDefault(require("./adjacent-overload-signatures")); +const array_type_1 = __importDefault(require("./array-type")); +const await_thenable_1 = __importDefault(require("./await-thenable")); +const ban_ts_comment_1 = __importDefault(require("./ban-ts-comment")); +const ban_tslint_comment_1 = __importDefault(require("./ban-tslint-comment")); +const class_literal_property_style_1 = __importDefault(require("./class-literal-property-style")); +const class_methods_use_this_1 = __importDefault(require("./class-methods-use-this")); +const consistent_generic_constructors_1 = __importDefault(require("./consistent-generic-constructors")); +const consistent_indexed_object_style_1 = __importDefault(require("./consistent-indexed-object-style")); +const consistent_return_1 = __importDefault(require("./consistent-return")); +const consistent_type_assertions_1 = __importDefault(require("./consistent-type-assertions")); +const consistent_type_definitions_1 = __importDefault(require("./consistent-type-definitions")); +const consistent_type_exports_1 = __importDefault(require("./consistent-type-exports")); +const consistent_type_imports_1 = __importDefault(require("./consistent-type-imports")); +const default_param_last_1 = __importDefault(require("./default-param-last")); +const dot_notation_1 = __importDefault(require("./dot-notation")); +const explicit_function_return_type_1 = __importDefault(require("./explicit-function-return-type")); +const explicit_member_accessibility_1 = __importDefault(require("./explicit-member-accessibility")); +const explicit_module_boundary_types_1 = __importDefault(require("./explicit-module-boundary-types")); +const init_declarations_1 = __importDefault(require("./init-declarations")); +const max_params_1 = __importDefault(require("./max-params")); +const member_ordering_1 = __importDefault(require("./member-ordering")); +const method_signature_style_1 = __importDefault(require("./method-signature-style")); +const naming_convention_1 = __importDefault(require("./naming-convention")); +const no_array_constructor_1 = __importDefault(require("./no-array-constructor")); +const no_array_delete_1 = __importDefault(require("./no-array-delete")); +const no_base_to_string_1 = __importDefault(require("./no-base-to-string")); +const no_confusing_non_null_assertion_1 = __importDefault(require("./no-confusing-non-null-assertion")); +const no_confusing_void_expression_1 = __importDefault(require("./no-confusing-void-expression")); +const no_deprecated_1 = __importDefault(require("./no-deprecated")); +const no_dupe_class_members_1 = __importDefault(require("./no-dupe-class-members")); +const no_duplicate_enum_values_1 = __importDefault(require("./no-duplicate-enum-values")); +const no_duplicate_type_constituents_1 = __importDefault(require("./no-duplicate-type-constituents")); +const no_dynamic_delete_1 = __importDefault(require("./no-dynamic-delete")); +const no_empty_function_1 = __importDefault(require("./no-empty-function")); +const no_empty_interface_1 = __importDefault(require("./no-empty-interface")); +const no_empty_object_type_1 = __importDefault(require("./no-empty-object-type")); +const no_explicit_any_1 = __importDefault(require("./no-explicit-any")); +const no_extra_non_null_assertion_1 = __importDefault(require("./no-extra-non-null-assertion")); +const no_extraneous_class_1 = __importDefault(require("./no-extraneous-class")); +const no_floating_promises_1 = __importDefault(require("./no-floating-promises")); +const no_for_in_array_1 = __importDefault(require("./no-for-in-array")); +const no_generated_empty_object_type_1 = __importDefault(require("./no-generated-empty-object-type")); +const no_implied_eval_1 = __importDefault(require("./no-implied-eval")); +const no_import_type_side_effects_1 = __importDefault(require("./no-import-type-side-effects")); +const no_inferrable_types_1 = __importDefault(require("./no-inferrable-types")); +const no_invalid_this_1 = __importDefault(require("./no-invalid-this")); +const no_invalid_void_type_1 = __importDefault(require("./no-invalid-void-type")); +const no_loop_func_1 = __importDefault(require("./no-loop-func")); +const no_loss_of_precision_1 = __importDefault(require("./no-loss-of-precision")); +const no_magic_numbers_1 = __importDefault(require("./no-magic-numbers")); +const no_meaningless_void_operator_1 = __importDefault(require("./no-meaningless-void-operator")); +const no_misused_new_1 = __importDefault(require("./no-misused-new")); +const no_misused_promises_1 = __importDefault(require("./no-misused-promises")); +const no_misused_spread_1 = __importDefault(require("./no-misused-spread")); +const no_mixed_enums_1 = __importDefault(require("./no-mixed-enums")); +const no_namespace_1 = __importDefault(require("./no-namespace")); +const no_non_null_asserted_nullish_coalescing_1 = __importDefault(require("./no-non-null-asserted-nullish-coalescing")); +const no_non_null_asserted_optional_chain_1 = __importDefault(require("./no-non-null-asserted-optional-chain")); +const no_non_null_assertion_1 = __importDefault(require("./no-non-null-assertion")); +const no_redeclare_1 = __importDefault(require("./no-redeclare")); +const no_redundant_type_constituents_1 = __importDefault(require("./no-redundant-type-constituents")); +const no_require_imports_1 = __importDefault(require("./no-require-imports")); +const no_restricted_imports_1 = __importDefault(require("./no-restricted-imports")); +const no_restricted_types_1 = __importDefault(require("./no-restricted-types")); +const no_shadow_1 = __importDefault(require("./no-shadow")); +const no_this_alias_1 = __importDefault(require("./no-this-alias")); +const no_type_alias_1 = __importDefault(require("./no-type-alias")); +const no_unnecessary_boolean_literal_compare_1 = __importDefault(require("./no-unnecessary-boolean-literal-compare")); +const no_unnecessary_condition_1 = __importDefault(require("./no-unnecessary-condition")); +const no_unnecessary_parameter_property_assignment_1 = __importDefault(require("./no-unnecessary-parameter-property-assignment")); +const no_unnecessary_qualifier_1 = __importDefault(require("./no-unnecessary-qualifier")); +const no_unnecessary_template_expression_1 = __importDefault(require("./no-unnecessary-template-expression")); +const no_unnecessary_type_arguments_1 = __importDefault(require("./no-unnecessary-type-arguments")); +const no_unnecessary_type_assertion_1 = __importDefault(require("./no-unnecessary-type-assertion")); +const no_unnecessary_type_constraint_1 = __importDefault(require("./no-unnecessary-type-constraint")); +const no_unnecessary_type_conversion_1 = __importDefault(require("./no-unnecessary-type-conversion")); +const no_unnecessary_type_parameters_1 = __importDefault(require("./no-unnecessary-type-parameters")); +const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument")); +const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment")); +const no_unsafe_call_1 = __importDefault(require("./no-unsafe-call")); +const no_unsafe_declaration_merging_1 = __importDefault(require("./no-unsafe-declaration-merging")); +const no_unsafe_enum_comparison_1 = __importDefault(require("./no-unsafe-enum-comparison")); +const no_unsafe_function_type_1 = __importDefault(require("./no-unsafe-function-type")); +const no_unsafe_member_access_1 = __importDefault(require("./no-unsafe-member-access")); +const no_unsafe_return_1 = __importDefault(require("./no-unsafe-return")); +const no_unsafe_type_assertion_1 = __importDefault(require("./no-unsafe-type-assertion")); +const no_unsafe_unary_minus_1 = __importDefault(require("./no-unsafe-unary-minus")); +const no_unused_expressions_1 = __importDefault(require("./no-unused-expressions")); +const no_unused_private_class_members_1 = __importDefault(require("./no-unused-private-class-members")); +const no_unused_vars_1 = __importDefault(require("./no-unused-vars")); +const no_use_before_define_1 = __importDefault(require("./no-use-before-define")); +const no_useless_constructor_1 = __importDefault(require("./no-useless-constructor")); +const no_useless_default_assignment_1 = __importDefault(require("./no-useless-default-assignment")); +const no_useless_empty_export_1 = __importDefault(require("./no-useless-empty-export")); +const no_var_requires_1 = __importDefault(require("./no-var-requires")); +const no_wrapper_object_types_1 = __importDefault(require("./no-wrapper-object-types")); +const non_nullable_type_assertion_style_1 = __importDefault(require("./non-nullable-type-assertion-style")); +const only_throw_error_1 = __importDefault(require("./only-throw-error")); +const parameter_properties_1 = __importDefault(require("./parameter-properties")); +const prefer_as_const_1 = __importDefault(require("./prefer-as-const")); +const prefer_destructuring_1 = __importDefault(require("./prefer-destructuring")); +const prefer_enum_initializers_1 = __importDefault(require("./prefer-enum-initializers")); +const prefer_find_1 = __importDefault(require("./prefer-find")); +const prefer_for_of_1 = __importDefault(require("./prefer-for-of")); +const prefer_function_type_1 = __importDefault(require("./prefer-function-type")); +const prefer_includes_1 = __importDefault(require("./prefer-includes")); +const prefer_literal_enum_member_1 = __importDefault(require("./prefer-literal-enum-member")); +const prefer_namespace_keyword_1 = __importDefault(require("./prefer-namespace-keyword")); +const prefer_nullish_coalescing_1 = __importDefault(require("./prefer-nullish-coalescing")); +const prefer_optional_chain_1 = __importDefault(require("./prefer-optional-chain")); +const prefer_promise_reject_errors_1 = __importDefault(require("./prefer-promise-reject-errors")); +const prefer_readonly_1 = __importDefault(require("./prefer-readonly")); +const prefer_readonly_parameter_types_1 = __importDefault(require("./prefer-readonly-parameter-types")); +const prefer_reduce_type_parameter_1 = __importDefault(require("./prefer-reduce-type-parameter")); +const prefer_regexp_exec_1 = __importDefault(require("./prefer-regexp-exec")); +const prefer_return_this_type_1 = __importDefault(require("./prefer-return-this-type")); +const prefer_string_starts_ends_with_1 = __importDefault(require("./prefer-string-starts-ends-with")); +const prefer_ts_expect_error_1 = __importDefault(require("./prefer-ts-expect-error")); +const promise_function_async_1 = __importDefault(require("./promise-function-async")); +const related_getter_setter_pairs_1 = __importDefault(require("./related-getter-setter-pairs")); +const require_array_sort_compare_1 = __importDefault(require("./require-array-sort-compare")); +const require_await_1 = __importDefault(require("./require-await")); +const restrict_plus_operands_1 = __importDefault(require("./restrict-plus-operands")); +const restrict_template_expressions_1 = __importDefault(require("./restrict-template-expressions")); +const return_await_1 = __importDefault(require("./return-await")); +const sort_type_constituents_1 = __importDefault(require("./sort-type-constituents")); +const strict_boolean_expressions_1 = __importDefault(require("./strict-boolean-expressions")); +const strict_void_return_1 = __importDefault(require("./strict-void-return")); +const switch_exhaustiveness_check_1 = __importDefault(require("./switch-exhaustiveness-check")); +const triple_slash_reference_1 = __importDefault(require("./triple-slash-reference")); +const typedef_1 = __importDefault(require("./typedef")); +const unbound_method_1 = __importDefault(require("./unbound-method")); +const unified_signatures_1 = __importDefault(require("./unified-signatures")); +const use_unknown_in_catch_callback_variable_1 = __importDefault(require("./use-unknown-in-catch-callback-variable")); +const rules = { + 'adjacent-overload-signatures': adjacent_overload_signatures_1.default, + 'array-type': array_type_1.default, + 'await-thenable': await_thenable_1.default, + 'ban-ts-comment': ban_ts_comment_1.default, + 'ban-tslint-comment': ban_tslint_comment_1.default, + 'class-literal-property-style': class_literal_property_style_1.default, + 'class-methods-use-this': class_methods_use_this_1.default, + 'consistent-generic-constructors': consistent_generic_constructors_1.default, + 'consistent-indexed-object-style': consistent_indexed_object_style_1.default, + 'consistent-return': consistent_return_1.default, + 'consistent-type-assertions': consistent_type_assertions_1.default, + 'consistent-type-definitions': consistent_type_definitions_1.default, + 'consistent-type-exports': consistent_type_exports_1.default, + 'consistent-type-imports': consistent_type_imports_1.default, + 'default-param-last': default_param_last_1.default, + 'dot-notation': dot_notation_1.default, + 'explicit-function-return-type': explicit_function_return_type_1.default, + 'explicit-member-accessibility': explicit_member_accessibility_1.default, + 'explicit-module-boundary-types': explicit_module_boundary_types_1.default, + 'init-declarations': init_declarations_1.default, + 'max-params': max_params_1.default, + 'member-ordering': member_ordering_1.default, + 'method-signature-style': method_signature_style_1.default, + 'naming-convention': naming_convention_1.default, + 'no-array-constructor': no_array_constructor_1.default, + 'no-array-delete': no_array_delete_1.default, + 'no-base-to-string': no_base_to_string_1.default, + 'no-confusing-non-null-assertion': no_confusing_non_null_assertion_1.default, + 'no-confusing-void-expression': no_confusing_void_expression_1.default, + 'no-deprecated': no_deprecated_1.default, + 'no-dupe-class-members': no_dupe_class_members_1.default, + 'no-duplicate-enum-values': no_duplicate_enum_values_1.default, + 'no-duplicate-type-constituents': no_duplicate_type_constituents_1.default, + 'no-dynamic-delete': no_dynamic_delete_1.default, + 'no-empty-function': no_empty_function_1.default, + 'no-empty-interface': no_empty_interface_1.default, + 'no-empty-object-type': no_empty_object_type_1.default, + 'no-explicit-any': no_explicit_any_1.default, + 'no-extra-non-null-assertion': no_extra_non_null_assertion_1.default, + 'no-extraneous-class': no_extraneous_class_1.default, + 'no-floating-promises': no_floating_promises_1.default, + 'no-for-in-array': no_for_in_array_1.default, + 'no-generated-empty-object-type': no_generated_empty_object_type_1.default, + 'no-implied-eval': no_implied_eval_1.default, + 'no-import-type-side-effects': no_import_type_side_effects_1.default, + 'no-inferrable-types': no_inferrable_types_1.default, + 'no-invalid-this': no_invalid_this_1.default, + 'no-invalid-void-type': no_invalid_void_type_1.default, + 'no-loop-func': no_loop_func_1.default, + 'no-loss-of-precision': no_loss_of_precision_1.default, + 'no-magic-numbers': no_magic_numbers_1.default, + 'no-meaningless-void-operator': no_meaningless_void_operator_1.default, + 'no-misused-new': no_misused_new_1.default, + 'no-misused-promises': no_misused_promises_1.default, + 'no-misused-spread': no_misused_spread_1.default, + 'no-mixed-enums': no_mixed_enums_1.default, + 'no-namespace': no_namespace_1.default, + 'no-non-null-asserted-nullish-coalescing': no_non_null_asserted_nullish_coalescing_1.default, + 'no-non-null-asserted-optional-chain': no_non_null_asserted_optional_chain_1.default, + 'no-non-null-assertion': no_non_null_assertion_1.default, + 'no-redeclare': no_redeclare_1.default, + 'no-redundant-type-constituents': no_redundant_type_constituents_1.default, + 'no-require-imports': no_require_imports_1.default, + 'no-restricted-imports': no_restricted_imports_1.default, + 'no-restricted-types': no_restricted_types_1.default, + 'no-shadow': no_shadow_1.default, + 'no-this-alias': no_this_alias_1.default, + 'no-type-alias': no_type_alias_1.default, + 'no-unnecessary-boolean-literal-compare': no_unnecessary_boolean_literal_compare_1.default, + 'no-unnecessary-condition': no_unnecessary_condition_1.default, + 'no-unnecessary-parameter-property-assignment': no_unnecessary_parameter_property_assignment_1.default, + 'no-unnecessary-qualifier': no_unnecessary_qualifier_1.default, + 'no-unnecessary-template-expression': no_unnecessary_template_expression_1.default, + 'no-unnecessary-type-arguments': no_unnecessary_type_arguments_1.default, + 'no-unnecessary-type-assertion': no_unnecessary_type_assertion_1.default, + 'no-unnecessary-type-constraint': no_unnecessary_type_constraint_1.default, + 'no-unnecessary-type-conversion': no_unnecessary_type_conversion_1.default, + 'no-unnecessary-type-parameters': no_unnecessary_type_parameters_1.default, + 'no-unsafe-argument': no_unsafe_argument_1.default, + 'no-unsafe-assignment': no_unsafe_assignment_1.default, + 'no-unsafe-call': no_unsafe_call_1.default, + 'no-unsafe-declaration-merging': no_unsafe_declaration_merging_1.default, + 'no-unsafe-enum-comparison': no_unsafe_enum_comparison_1.default, + 'no-unsafe-function-type': no_unsafe_function_type_1.default, + 'no-unsafe-member-access': no_unsafe_member_access_1.default, + 'no-unsafe-return': no_unsafe_return_1.default, + 'no-unsafe-type-assertion': no_unsafe_type_assertion_1.default, + 'no-unsafe-unary-minus': no_unsafe_unary_minus_1.default, + 'no-unused-expressions': no_unused_expressions_1.default, + 'no-unused-private-class-members': no_unused_private_class_members_1.default, + 'no-unused-vars': no_unused_vars_1.default, + 'no-use-before-define': no_use_before_define_1.default, + 'no-useless-constructor': no_useless_constructor_1.default, + 'no-useless-default-assignment': no_useless_default_assignment_1.default, + 'no-useless-empty-export': no_useless_empty_export_1.default, + 'no-var-requires': no_var_requires_1.default, + 'no-wrapper-object-types': no_wrapper_object_types_1.default, + 'non-nullable-type-assertion-style': non_nullable_type_assertion_style_1.default, + 'only-throw-error': only_throw_error_1.default, + 'parameter-properties': parameter_properties_1.default, + 'prefer-as-const': prefer_as_const_1.default, + 'prefer-destructuring': prefer_destructuring_1.default, + 'prefer-enum-initializers': prefer_enum_initializers_1.default, + 'prefer-find': prefer_find_1.default, + 'prefer-for-of': prefer_for_of_1.default, + 'prefer-function-type': prefer_function_type_1.default, + 'prefer-includes': prefer_includes_1.default, + 'prefer-literal-enum-member': prefer_literal_enum_member_1.default, + 'prefer-namespace-keyword': prefer_namespace_keyword_1.default, + 'prefer-nullish-coalescing': prefer_nullish_coalescing_1.default, + 'prefer-optional-chain': prefer_optional_chain_1.default, + 'prefer-promise-reject-errors': prefer_promise_reject_errors_1.default, + 'prefer-readonly': prefer_readonly_1.default, + 'prefer-readonly-parameter-types': prefer_readonly_parameter_types_1.default, + 'prefer-reduce-type-parameter': prefer_reduce_type_parameter_1.default, + 'prefer-regexp-exec': prefer_regexp_exec_1.default, + 'prefer-return-this-type': prefer_return_this_type_1.default, + 'prefer-string-starts-ends-with': prefer_string_starts_ends_with_1.default, + 'prefer-ts-expect-error': prefer_ts_expect_error_1.default, + 'promise-function-async': promise_function_async_1.default, + 'related-getter-setter-pairs': related_getter_setter_pairs_1.default, + 'require-array-sort-compare': require_array_sort_compare_1.default, + 'require-await': require_await_1.default, + 'restrict-plus-operands': restrict_plus_operands_1.default, + 'restrict-template-expressions': restrict_template_expressions_1.default, + 'return-await': return_await_1.default, + 'sort-type-constituents': sort_type_constituents_1.default, + 'strict-boolean-expressions': strict_boolean_expressions_1.default, + 'strict-void-return': strict_void_return_1.default, + 'switch-exhaustiveness-check': switch_exhaustiveness_check_1.default, + 'triple-slash-reference': triple_slash_reference_1.default, + typedef: typedef_1.default, + 'unbound-method': unbound_method_1.default, + 'unified-signatures': unified_signatures_1.default, + 'use-unknown-in-catch-callback-variable': use_unknown_in_catch_callback_variable_1.default, +}; +module.exports = rules; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.d.ts new file mode 100644 index 00000000..a8b84795 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.d.ts @@ -0,0 +1,15 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({ + ignoreForLoopInit?: boolean; +} | undefined)?], unknown, { + 'VariableDeclaration:exit'(node: TSESTree.VariableDeclaration): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({ + ignoreForLoopInit?: boolean; +} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.js new file mode 100644 index 00000000..c3e91524 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/init-declarations.js @@ -0,0 +1,106 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('init-declarations'); +exports.default = (0, util_1.createRule)({ + name: 'init-declarations', + meta: { + type: 'suggestion', + // defaultOptions, -- base rule does not use defaultOptions + docs: { + description: 'Require or disallow initialization in variable declarations', + extendsBaseRule: true, + frozen: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions: ['always'], + create(context, [mode]) { + // Make a custom context to adjust the loc of reports where the base + // rule's behavior is a bit too aggressive with TS-specific syntax (namely, + // type annotations). + function getBaseContextOverride() { + const reportOverride = descriptor => { + if ('node' in descriptor && descriptor.loc == null) { + const { node, ...rest } = descriptor; + // We only want to special case the report loc when reporting on + // variables declarations that are not initialized. Declarations that + // _are_ initialized get reported by the base rule due to a setting to + // prohibit initializing variables entirely, in which case underlining + // the whole node including the type annotation and initializer is + // appropriate. + if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && + node.init == null) { + context.report({ + ...rest, + loc: getReportLoc(node), + }); + return; + } + } + context.report(descriptor); + }; + // `return { ...context, report: reportOverride }` isn't safe because the + // `context` object has some getters that need to be preserved. + // + // `return new Proxy(context, ...)` doesn't work because `context` has + // non-configurable properties that throw when constructing a Proxy. + // + // So, we'll just use Proxy on a dummy object and use the `get` trap to + // proxy `context`'s properties. + return new Proxy({}, { + get: (target, prop, receiver) => prop === 'report' + ? reportOverride + : Reflect.get(context, prop, receiver), + }); + } + const rules = baseRule.create(getBaseContextOverride()); + return { + 'VariableDeclaration:exit'(node) { + if (mode === 'always') { + if (node.declare) { + return; + } + if (isAncestorNamespaceDeclared(node)) { + return; + } + } + rules['VariableDeclaration:exit'](node); + }, + }; + function isAncestorNamespaceDeclared(node) { + let ancestor = node.parent; + while (ancestor) { + if (ancestor.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration && + ancestor.declare) { + return true; + } + ancestor = ancestor.parent; + } + return false; + } + }, +}); +/** + * When reporting an uninitialized variable declarator, get the loc excluding + * the type annotation. + */ +function getReportLoc(node) { + const start = structuredClone(node.loc.start); + const end = { + line: node.loc.start.line, + // `if (id.type === AST_NODE_TYPES.Identifier)` is a condition for + // reporting in the base rule (as opposed to things like destructuring + // assignment), so the type assertion should always be valid. + column: node.loc.start.column + node.id.name.length, + }; + return { + start, + end, + }; +} +//# sourceMappingURL=init-declarations.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.d.ts new file mode 100644 index 00000000..8700ecf4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.d.ts @@ -0,0 +1,25 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({ + countVoidThis?: boolean; + max: number; +} | { + countVoidThis?: boolean; + maximum: number; +})[], unknown, { + ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void; + FunctionDeclaration(node: TSESTree.FunctionDeclaration | TSESTree.TSDeclareFunction | TSESTree.TSFunctionType): void; + FunctionExpression(node: TSESTree.FunctionExpression): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({ + countVoidThis?: boolean; + max: number; +} | { + countVoidThis?: boolean; + maximum: number; +})[], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.js new file mode 100644 index 00000000..e3e807aa --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/max-params.js @@ -0,0 +1,73 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('max-params'); +exports.default = (0, util_1.createRule)({ + name: 'max-params', + meta: { + type: 'suggestion', + // defaultOptions, -- base rule does not use defaultOptions + docs: { + description: 'Enforce a maximum number of parameters in function definitions', + extendsBaseRule: true, + }, + messages: baseRule.meta.messages, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + countVoidThis: { + type: 'boolean', + description: 'Whether to count a `this` declaration when the type is `void`.', + }, + max: { + type: 'integer', + description: 'A maximum number of parameters in function definitions.', + minimum: 0, + }, + maximum: { + type: 'integer', + description: '(deprecated) A maximum number of parameters in function definitions.', + minimum: 0, + }, + }, + }, + ], + }, + defaultOptions: [{ countVoidThis: false, max: 3 }], + create(context, [{ countVoidThis }]) { + const baseRules = baseRule.create(context); + if (countVoidThis === true) { + return baseRules; + } + const removeVoidThisParam = (node) => { + if (node.params.length === 0 || + node.params[0].type !== utils_1.AST_NODE_TYPES.Identifier || + node.params[0].name !== 'this' || + node.params[0].typeAnnotation?.typeAnnotation.type !== + utils_1.AST_NODE_TYPES.TSVoidKeyword) { + return node; + } + return { + ...node, + params: node.params.slice(1), + }; + }; + const wrapListener = (listener) => { + return (node) => { + listener(removeVoidThisParam(node)); + }; + }; + return { + ArrowFunctionExpression: wrapListener(baseRules.ArrowFunctionExpression), + FunctionDeclaration: wrapListener(baseRules.FunctionDeclaration), + FunctionExpression: wrapListener(baseRules.FunctionExpression), + TSDeclareFunction: wrapListener(baseRules.FunctionDeclaration), + TSFunctionType: wrapListener(baseRules.FunctionDeclaration), + }; + }, +}); +//# sourceMappingURL=max-params.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.d.ts new file mode 100644 index 00000000..15f3b91b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.d.ts @@ -0,0 +1,33 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +export type MessageIds = 'incorrectGroupOrder' | 'incorrectOrder' | 'incorrectRequiredMembersOrder'; +type ReadonlyType = 'readonly-field' | 'readonly-signature'; +type MemberKind = 'accessor' | 'call-signature' | 'constructor' | 'field' | 'get' | 'method' | 'set' | 'signature' | 'static-initialization' | ReadonlyType; +type DecoratedMemberKind = 'accessor' | 'field' | 'get' | 'method' | 'set' | Exclude; +type NonCallableMemberKind = Exclude; +type MemberScope = 'abstract' | 'instance' | 'static'; +type Accessibility = '#private' | TSESTree.Accessibility; +type BaseMemberType = `${Accessibility}-${Exclude}` | `${Accessibility}-${MemberScope}-${NonCallableMemberKind}` | `${Accessibility}-decorated-${DecoratedMemberKind}` | `${MemberScope}-${NonCallableMemberKind}` | `decorated-${DecoratedMemberKind}` | MemberKind; +type MemberType = BaseMemberType | BaseMemberType[]; +type AlphabeticalOrder = 'alphabetically' | 'alphabetically-case-insensitive' | 'natural' | 'natural-case-insensitive'; +type Order = 'as-written' | AlphabeticalOrder; +interface SortedOrderConfig { + memberTypes?: 'never' | MemberType[]; + optionalityOrder?: OptionalityOrder; + order?: Order; +} +type OrderConfig = 'never' | MemberType[] | SortedOrderConfig; +type OptionalityOrder = 'optional-first' | 'required-first'; +export type Options = [ + { + classes?: OrderConfig; + classExpressions?: OrderConfig; + default?: OrderConfig; + interfaces?: OrderConfig; + typeLiterals?: OrderConfig; + } +]; +export declare const defaultOrder: MemberType[]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.js new file mode 100644 index 00000000..a9034f58 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.js @@ -0,0 +1,890 @@ +"use strict"; +// This rule was feature-frozen before we enabled no-property-in-node. +/* eslint-disable eslint-plugin/no-property-in-node */ +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.defaultOrder = void 0; +const utils_1 = require("@typescript-eslint/utils"); +const natural_compare_1 = __importDefault(require("natural-compare")); +const util_1 = require("../util"); +const neverConfig = { + type: 'string', + enum: ['never'], +}; +const arrayConfig = (memberTypes) => ({ + type: 'array', + items: { + oneOf: [ + { + $ref: memberTypes, + }, + { + type: 'array', + items: { + $ref: memberTypes, + }, + }, + ], + }, +}); +const objectConfig = (memberTypes) => ({ + type: 'object', + additionalProperties: false, + properties: { + memberTypes: { + oneOf: [arrayConfig(memberTypes), neverConfig], + }, + optionalityOrder: { + $ref: '#/items/0/$defs/optionalityOrderOptions', + }, + order: { + $ref: '#/items/0/$defs/orderOptions', + }, + }, +}); +exports.defaultOrder = [ + // Index signature + 'signature', + 'call-signature', + // Fields + 'public-static-field', + 'protected-static-field', + 'private-static-field', + '#private-static-field', + 'public-decorated-field', + 'protected-decorated-field', + 'private-decorated-field', + 'public-instance-field', + 'protected-instance-field', + 'private-instance-field', + '#private-instance-field', + 'public-abstract-field', + 'protected-abstract-field', + 'public-field', + 'protected-field', + 'private-field', + '#private-field', + 'static-field', + 'instance-field', + 'abstract-field', + 'decorated-field', + 'field', + // Static initialization + 'static-initialization', + // Constructors + 'public-constructor', + 'protected-constructor', + 'private-constructor', + 'constructor', + // Accessors + 'public-static-accessor', + 'protected-static-accessor', + 'private-static-accessor', + '#private-static-accessor', + 'public-decorated-accessor', + 'protected-decorated-accessor', + 'private-decorated-accessor', + 'public-instance-accessor', + 'protected-instance-accessor', + 'private-instance-accessor', + '#private-instance-accessor', + 'public-abstract-accessor', + 'protected-abstract-accessor', + 'public-accessor', + 'protected-accessor', + 'private-accessor', + '#private-accessor', + 'static-accessor', + 'instance-accessor', + 'abstract-accessor', + 'decorated-accessor', + 'accessor', + // Getters + 'public-static-get', + 'protected-static-get', + 'private-static-get', + '#private-static-get', + 'public-decorated-get', + 'protected-decorated-get', + 'private-decorated-get', + 'public-instance-get', + 'protected-instance-get', + 'private-instance-get', + '#private-instance-get', + 'public-abstract-get', + 'protected-abstract-get', + 'public-get', + 'protected-get', + 'private-get', + '#private-get', + 'static-get', + 'instance-get', + 'abstract-get', + 'decorated-get', + 'get', + // Setters + 'public-static-set', + 'protected-static-set', + 'private-static-set', + '#private-static-set', + 'public-decorated-set', + 'protected-decorated-set', + 'private-decorated-set', + 'public-instance-set', + 'protected-instance-set', + 'private-instance-set', + '#private-instance-set', + 'public-abstract-set', + 'protected-abstract-set', + 'public-set', + 'protected-set', + 'private-set', + '#private-set', + 'static-set', + 'instance-set', + 'abstract-set', + 'decorated-set', + 'set', + // Methods + 'public-static-method', + 'protected-static-method', + 'private-static-method', + '#private-static-method', + 'public-decorated-method', + 'protected-decorated-method', + 'private-decorated-method', + 'public-instance-method', + 'protected-instance-method', + 'private-instance-method', + '#private-instance-method', + 'public-abstract-method', + 'protected-abstract-method', + 'public-method', + 'protected-method', + 'private-method', + '#private-method', + 'static-method', + 'instance-method', + 'abstract-method', + 'decorated-method', + 'method', +]; +const allMemberTypes = [ + ...new Set([ + 'readonly-signature', + 'signature', + 'readonly-field', + 'field', + 'method', + 'call-signature', + 'constructor', + 'accessor', + 'get', + 'set', + 'static-initialization', + ].flatMap(type => [ + type, + ...['public', 'protected', 'private', '#private'] + .flatMap(accessibility => [ + type !== 'readonly-signature' && + type !== 'signature' && + type !== 'static-initialization' && + type !== 'call-signature' && + !(type === 'constructor' && accessibility === '#private') + ? `${accessibility}-${type}` // e.g. `public-field` + : [], + // Only class instance fields, methods, accessors, get and set can have decorators attached to them + accessibility !== '#private' && + (type === 'readonly-field' || + type === 'field' || + type === 'method' || + type === 'accessor' || + type === 'get' || + type === 'set') + ? [`${accessibility}-decorated-${type}`, `decorated-${type}`] + : [], + type !== 'constructor' && + type !== 'readonly-signature' && + type !== 'signature' && + type !== 'call-signature' + ? [ + 'static', + 'instance', + // There is no `static-constructor` or `instance-constructor` or `abstract-constructor` + ...(accessibility === '#private' || + accessibility === 'private' + ? [] + : ['abstract']), + ].flatMap(scope => [ + `${scope}-${type}`, + `${accessibility}-${scope}-${type}`, + ]) + : [], + ]) + .flat(), + ])), +]; +const functionExpressions = [ + utils_1.AST_NODE_TYPES.FunctionExpression, + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, +]; +/** + * Gets the node type. + * + * @param node the node to be evaluated. + */ +function getNodeType(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + case utils_1.AST_NODE_TYPES.MethodDefinition: + case utils_1.AST_NODE_TYPES.TSMethodSignature: + return node.kind; + case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration: + return 'call-signature'; + case utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration: + return 'constructor'; + case utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition: + case utils_1.AST_NODE_TYPES.TSPropertySignature: + return node.readonly ? 'readonly-field' : 'field'; + case utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty: + case utils_1.AST_NODE_TYPES.AccessorProperty: + return 'accessor'; + case utils_1.AST_NODE_TYPES.PropertyDefinition: + return node.value && functionExpressions.includes(node.value.type) + ? 'method' + : node.readonly + ? 'readonly-field' + : 'field'; + case utils_1.AST_NODE_TYPES.TSIndexSignature: + return node.readonly ? 'readonly-signature' : 'signature'; + case utils_1.AST_NODE_TYPES.StaticBlock: + return 'static-initialization'; + default: + return null; + } +} +/** + * Gets the raw string value of a member's name + */ +function getMemberRawName(member, sourceCode) { + const { name, type } = (0, util_1.getNameFromMember)(member, sourceCode); + if (type === util_1.MemberNameType.Quoted) { + return name.slice(1, -1); + } + if (type === util_1.MemberNameType.Private) { + return name.slice(1); + } + return name; +} +/** + * Gets the member name based on the member type. + * + * @param node the node to be evaluated. + */ +function getMemberName(node, sourceCode) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSPropertySignature: + case utils_1.AST_NODE_TYPES.TSMethodSignature: + case utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty: + case utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition: + case utils_1.AST_NODE_TYPES.AccessorProperty: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + return getMemberRawName(node, sourceCode); + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + case utils_1.AST_NODE_TYPES.MethodDefinition: + return node.kind === 'constructor' + ? 'constructor' + : getMemberRawName(node, sourceCode); + case utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration: + return 'new'; + case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration: + return 'call'; + case utils_1.AST_NODE_TYPES.TSIndexSignature: + return (0, util_1.getNameFromIndexSignature)(node); + case utils_1.AST_NODE_TYPES.StaticBlock: + return 'static block'; + default: + return null; + } +} +/** + * Returns true if the member is optional based on the member type. + * + * @param node the node to be evaluated. + * + * @returns Whether the member is optional, or false if it cannot be optional at all. + */ +function isMemberOptional(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSPropertySignature: + case utils_1.AST_NODE_TYPES.TSMethodSignature: + case utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty: + case utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition: + case utils_1.AST_NODE_TYPES.AccessorProperty: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + case utils_1.AST_NODE_TYPES.MethodDefinition: + return node.optional; + } + return false; +} +function getMemberInitializer(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.AccessorProperty: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + return node.value; + } + return undefined; +} +function getThisPropertyName(node) { + return node.computed + ? (0, util_1.getStaticStringValue)(node.property) + : node.property.name; +} +function isEvaluatedLater(node, initializer) { + for (let current = node; current !== initializer.parent; current = (0, util_1.nullThrows)(current.parent, util_1.NullThrowsReasons.MissingParent)) { + if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + current.type === utils_1.AST_NODE_TYPES.ClassBody || + current.type === utils_1.AST_NODE_TYPES.FunctionExpression) { + return true; + } + } + return false; +} +function collectImmediateThisPropertyNames(initializer) { + const names = new Set(); + (0, util_1.forEachChildESTree)(initializer, node => { + if (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.object.type === utils_1.AST_NODE_TYPES.ThisExpression && + !isEvaluatedLater(node, initializer)) { + const name = getThisPropertyName(node); + if (name != null) { + names.add(name); + } + } + return null; + }); + return names; +} +function isBlockedByEarlierMemberReferences(member, members, fromIndex, toIndex, sourceCode) { + const initializer = getMemberInitializer(member); + if (!initializer) { + return false; + } + const referencedNames = collectImmediateThisPropertyNames(initializer); + return members.slice(fromIndex, toIndex).some(other => { + const otherName = getMemberName(other, sourceCode); + return (otherName != null && + getMemberInitializer(other) != null && + referencedNames.has(otherName)); + }); +} +/** + * Gets the calculated rank using the provided method definition. + * The algorithm is as follows: + * - Get the rank based on the accessibility-scope-type name, e.g. public-instance-field + * - If there is no order for accessibility-scope-type, then strip out the accessibility. + * - If there is no order for scope-type, then strip out the scope. + * - If there is no order for type, then return -1 + * @param memberGroups the valid names to be validated. + * @param orderConfig the current order to be validated. + * + * @return Index of the matching member type in the order configuration. + */ +function getRankOrder(memberGroups, orderConfig) { + let rank = -1; + const stack = [...memberGroups]; // Get a copy of the member groups + while (stack.length > 0 && rank === -1) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const memberGroup = stack.shift(); + rank = orderConfig.findIndex(memberType => Array.isArray(memberType) + ? memberType.includes(memberGroup) + : memberType === memberGroup); + } + return rank; +} +function getAccessibility(node) { + if ('accessibility' in node && node.accessibility) { + return node.accessibility; + } + if ('key' in node && node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return '#private'; + } + return 'public'; +} +/** + * Gets the rank of the node given the order. + * @param node the node to be evaluated. + * @param orderConfig the current order to be validated. + * @param supportsModifiers a flag indicating whether the type supports modifiers (scope or accessibility) or not. + */ +function getRank(node, orderConfig, supportsModifiers) { + const type = getNodeType(node); + if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + return -1; + } + if (type == null) { + // shouldn't happen but just in case, put it on the end + return orderConfig.length - 1; + } + const abstract = node.type === utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty || + node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition || + node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition; + const scope = 'static' in node && node.static + ? 'static' + : abstract + ? 'abstract' + : 'instance'; + const accessibility = getAccessibility(node); + // Collect all existing member groups that apply to this node... + // (e.g. 'public-instance-field', 'instance-field', 'public-field', 'constructor' etc.) + const memberGroups = []; + if (supportsModifiers) { + const decorated = 'decorators' in node && node.decorators.length > 0; + if (decorated && + (type === 'readonly-field' || + type === 'field' || + type === 'method' || + type === 'accessor' || + type === 'get' || + type === 'set')) { + memberGroups.push(`${accessibility}-decorated-${type}`); + memberGroups.push(`decorated-${type}`); + if (type === 'readonly-field') { + memberGroups.push(`${accessibility}-decorated-field`); + memberGroups.push(`decorated-field`); + } + } + if (type !== 'readonly-signature' && + type !== 'signature' && + type !== 'static-initialization') { + if (type !== 'constructor') { + // Constructors have no scope + memberGroups.push(`${accessibility}-${scope}-${type}`); + memberGroups.push(`${scope}-${type}`); + if (type === 'readonly-field') { + memberGroups.push(`${accessibility}-${scope}-field`); + memberGroups.push(`${scope}-field`); + } + } + memberGroups.push(`${accessibility}-${type}`); + if (type === 'readonly-field') { + memberGroups.push(`${accessibility}-field`); + } + } + } + memberGroups.push(type); + if (type === 'readonly-signature') { + memberGroups.push('signature'); + } + else if (type === 'readonly-field') { + memberGroups.push('field'); + } + // ...then get the rank order for those member groups based on the node + return getRankOrder(memberGroups, orderConfig); +} +/** + * Groups members into arrays of consecutive members with the same rank. + * If, for example, the memberSet parameter looks like the following... + * @example + * ``` + * interface Foo { + * [a: string]: number; + * + * a: x; + * B: x; + * c: x; + * + * c(): void; + * B(): void; + * a(): void; + * + * (): Baz; + * + * new (): Bar; + * } + * ``` + * ...the resulting array will look like: [[a, B, c], [c, B, a]]. + * @param memberSet The members to be grouped. + * @param memberType The configured order of member types. + * @param supportsModifiers It'll get passed to getRank(). + * @returns The array of groups of members. + */ +function groupMembersByType(members, memberTypes, supportsModifiers) { + const groupedMembers = []; + const memberRanks = members.map(member => getRank(member, memberTypes, supportsModifiers)); + let previousRank = undefined; + members.forEach((member, index) => { + if (index === members.length - 1) { + return; + } + const rankOfCurrentMember = memberRanks[index]; + const rankOfNextMember = memberRanks[index + 1]; + if (rankOfCurrentMember === previousRank) { + groupedMembers.at(-1)?.push(member); + } + else if (rankOfCurrentMember === rankOfNextMember) { + groupedMembers.push([member]); + previousRank = rankOfCurrentMember; + } + }); + return groupedMembers; +} +/** + * Gets the lowest possible rank(s) higher than target. + * e.g. given the following order: + * ... + * public-static-method + * protected-static-method + * private-static-method + * public-instance-method + * protected-instance-method + * private-instance-method + * ... + * and considering that a public-instance-method has already been declared, so ranks contains + * public-instance-method, then the lowest possible rank for public-static-method is + * public-instance-method. + * If a lowest possible rank is a member group, a comma separated list of ranks is returned. + * @param ranks the existing ranks in the object. + * @param target the minimum target rank to filter on. + * @param order the current order to be validated. + * @returns the name(s) of the lowest possible rank without dashes (-). + */ +function getLowestRank(ranks, target, order) { + let lowest = ranks[ranks.length - 1]; + ranks.forEach(rank => { + if (rank > target) { + lowest = Math.min(lowest, rank); + } + }); + const lowestRank = order[lowest]; + const lowestRanks = Array.isArray(lowestRank) ? lowestRank : [lowestRank]; + return lowestRanks.map(rank => rank.replaceAll('-', ' ')).join(', '); +} +exports.default = (0, util_1.createRule)({ + name: 'member-ordering', + meta: { + type: 'suggestion', + docs: { + description: 'Require a consistent member declaration order', + frozen: true, + }, + messages: { + incorrectGroupOrder: 'Member {{name}} should be declared before all {{rank}} definitions.', + incorrectOrder: 'Member {{member}} should be declared before member {{beforeMember}}.', + incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`, + }, + schema: [ + { + type: 'object', + $defs: { + allItems: { + type: 'string', + enum: allMemberTypes, + }, + optionalityOrderOptions: { + type: 'string', + enum: ['optional-first', 'required-first'], + }, + orderOptions: { + type: 'string', + enum: [ + 'alphabetically', + 'alphabetically-case-insensitive', + 'as-written', + 'natural', + 'natural-case-insensitive', + ], + }, + typeItems: { + type: 'string', + enum: [ + 'readonly-signature', + 'signature', + 'readonly-field', + 'field', + 'method', + 'constructor', + ], + }, + // ajv is order-dependent; these configs must come last + baseConfig: { + oneOf: [ + neverConfig, + arrayConfig('#/items/0/$defs/allItems'), + objectConfig('#/items/0/$defs/allItems'), + ], + }, + typesConfig: { + oneOf: [ + neverConfig, + arrayConfig('#/items/0/$defs/typeItems'), + objectConfig('#/items/0/$defs/typeItems'), + ], + }, + }, + additionalProperties: false, + properties: { + classes: { + $ref: '#/items/0/$defs/baseConfig', + description: 'Which ordering to enforce for classes.', + }, + classExpressions: { + $ref: '#/items/0/$defs/baseConfig', + description: 'Which ordering to enforce for classExpressions.', + }, + default: { + $ref: '#/items/0/$defs/baseConfig', + description: 'Which ordering to enforce for default.', + }, + interfaces: { + $ref: '#/items/0/$defs/typesConfig', + description: 'Which ordering to enforce for interfaces.', + }, + typeLiterals: { + $ref: '#/items/0/$defs/typesConfig', + description: 'Which ordering to enforce for typeLiterals.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + default: { + memberTypes: exports.defaultOrder, + }, + }, + ], + create(context, [options]) { + /** + * Checks if the member groups are correctly sorted. + * + * @param members Members to be validated. + * @param groupOrder Group order to be validated. + * @param supportsModifiers A flag indicating whether the type supports modifiers (scope or accessibility) or not. + * + * @return Array of member groups or null if one of the groups is not correctly sorted. + */ + function checkGroupSort(members, groupOrder, supportsModifiers) { + const previousRanks = []; + const memberGroups = []; + let isCorrectlySorted = true; + // Find first member which isn't correctly sorted + for (const member of members) { + const rank = getRank(member, groupOrder, supportsModifiers); + const name = getMemberName(member, context.sourceCode); + const rankLastMember = previousRanks[previousRanks.length - 1]; + if (rank === -1) { + continue; + } + // Works for 1st item because x < undefined === false for any x (typeof string) + if (rank < rankLastMember) { + context.report({ + node: member, + messageId: 'incorrectGroupOrder', + data: { + name, + rank: getLowestRank(previousRanks, rank, groupOrder), + }, + }); + isCorrectlySorted = false; + } + else if (rank === rankLastMember) { + // Same member group --> Push to existing member group array + memberGroups[memberGroups.length - 1].push(member); + } + else { + // New member group --> Create new member group array + previousRanks.push(rank); + memberGroups.push([member]); + } + } + return isCorrectlySorted ? memberGroups : null; + } + /** + * Checks if the members are alphabetically sorted. + * + * @param members Members to be validated. + * @param order What order the members should be sorted in. + * + * @return True if all members are correctly sorted. + */ + function checkAlphaSort(members, order) { + let previousName = ''; + let previousIndex = 0; + let isCorrectlySorted = true; + // Find first member which isn't correctly sorted + members.forEach((member, index) => { + const name = getMemberName(member, context.sourceCode); + // Note: Not all members have names + if (name) { + if (naturalOutOfOrder(name, previousName, order)) { + if (isBlockedByEarlierMemberReferences(member, members, previousIndex, index, context.sourceCode)) { + return; + } + context.report({ + node: member, + messageId: 'incorrectOrder', + data: { + beforeMember: previousName, + member: name, + }, + }); + isCorrectlySorted = false; + } + previousName = name; + previousIndex = index; + } + }); + return isCorrectlySorted; + } + function naturalOutOfOrder(name, previousName, order) { + if (name === previousName) { + return false; + } + switch (order) { + case 'alphabetically': + return name < previousName; + case 'alphabetically-case-insensitive': + return name.toLowerCase() < previousName.toLowerCase(); + case 'natural': + return (0, natural_compare_1.default)(name, previousName) !== 1; + case 'natural-case-insensitive': + return ((0, natural_compare_1.default)(name.toLowerCase(), previousName.toLowerCase()) !== 1); + } + } + /** + * Checks if the order of optional and required members is correct based + * on the given 'required' parameter. + * + * @param members Members to be validated. + * @param optionalityOrder Where to place optional members, if not intermixed. + * + * @return True if all required and optional members are correctly sorted. + */ + function checkRequiredOrder(members, optionalityOrder) { + const switchIndex = members.findIndex((member, i) => i && isMemberOptional(member) !== isMemberOptional(members[i - 1])); + const report = (member) => context.report({ + loc: member.loc, + messageId: 'incorrectRequiredMembersOrder', + data: { + member: getMemberName(member, context.sourceCode), + optionalOrRequired: optionalityOrder === 'required-first' ? 'required' : 'optional', + }, + }); + // if the optionality of the first item is correct (based on optionalityOrder) + // then the first 0 inclusive to switchIndex exclusive members all + // have the correct optionality + if (isMemberOptional(members[0]) !== + (optionalityOrder === 'optional-first')) { + report(members[0]); + return false; + } + for (let i = switchIndex + 1; i < members.length; i++) { + if (isMemberOptional(members[i]) !== + isMemberOptional(members[switchIndex])) { + report(members[switchIndex]); + return false; + } + } + return true; + } + /** + * Validates if all members are correctly sorted. + * + * @param members Members to be validated. + * @param orderConfig Order config to be validated. + * @param supportsModifiers A flag indicating whether the type supports modifiers (scope or accessibility) or not. + */ + function validateMembersOrder(members, orderConfig, supportsModifiers) { + if (orderConfig === 'never') { + return; + } + // Standardize config + let order; + let memberTypes; + let optionalityOrder; + /** + * It runs an alphabetic sort on the groups of the members of the class in the source code. + * @param memberSet The members in the class of the source code on which the grouping operation will be performed. + */ + const checkAlphaSortForAllMembers = (memberSet) => { + const hasAlphaSort = !!(order && order !== 'as-written'); + if (hasAlphaSort && Array.isArray(memberTypes)) { + groupMembersByType(memberSet, memberTypes, supportsModifiers).forEach(members => { + checkAlphaSort(members, order); + }); + } + }; + // returns true if everything is good and false if an error was reported + const checkOrder = (memberSet) => { + const hasAlphaSort = !!(order && order !== 'as-written'); + // Check order + if (Array.isArray(memberTypes)) { + const grouped = checkGroupSort(memberSet, memberTypes, supportsModifiers); + if (grouped == null) { + checkAlphaSortForAllMembers(members); + return false; + } + if (hasAlphaSort) { + grouped.map(groupMember => checkAlphaSort(groupMember, order)); + } + } + else if (hasAlphaSort) { + return checkAlphaSort(memberSet, order); + } + return false; + }; + if (Array.isArray(orderConfig)) { + memberTypes = orderConfig; + } + else { + order = orderConfig.order; + memberTypes = orderConfig.memberTypes; + optionalityOrder = orderConfig.optionalityOrder; + } + if (!optionalityOrder) { + checkOrder(members); + return; + } + const switchIndex = members.findIndex((member, i) => i && isMemberOptional(member) !== isMemberOptional(members[i - 1])); + if (switchIndex !== -1) { + if (!checkRequiredOrder(members, optionalityOrder)) { + return; + } + checkOrder(members.slice(0, switchIndex)); + checkOrder(members.slice(switchIndex)); + } + else { + checkOrder(members); + } + } + // https://github.com/typescript-eslint/typescript-eslint/issues/5439 + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + return { + ClassDeclaration(node) { + validateMembersOrder(node.body.body, options.classes ?? options.default, true); + }, + 'ClassDeclaration, FunctionDeclaration'(node) { + if ('superClass' in node) { + // ... + } + }, + ClassExpression(node) { + validateMembersOrder(node.body.body, options.classExpressions ?? options.default, true); + }, + TSInterfaceDeclaration(node) { + validateMembersOrder(node.body.body, options.interfaces ?? options.default, false); + }, + TSTypeLiteral(node) { + validateMembersOrder(node.members, options.typeLiterals ?? options.default, false); + }, + }; + /* eslint-enable @typescript-eslint/no-non-null-assertion */ + }, +}); +//# sourceMappingURL=member-ordering.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.d.ts new file mode 100644 index 00000000..bd0ceb16 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.d.ts @@ -0,0 +1,6 @@ +export type Options = [('method' | 'property')?]; +export type MessageIds = 'convertToMethodSignature' | 'errorMethod' | 'errorProperty'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.js new file mode 100644 index 00000000..84109393 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.js @@ -0,0 +1,200 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'method-signature-style', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce using a particular method signature syntax', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + convertToMethodSignature: 'Convert to a method signature. This removes the `readonly` modifier, allowing the member to be reassigned.', + errorMethod: 'Shorthand method signature is forbidden. Use a function property instead.', + errorProperty: 'Function property signature is forbidden. Use a method shorthand instead.', + }, + schema: [ + { + type: 'string', + description: 'The method signature style to enforce using.', + enum: ['property', 'method'], + }, + ], + }, + defaultOptions: ['property'], + create(context, [mode]) { + function getMethodKey(node) { + let key = context.sourceCode.getText(node.key); + if (node.computed) { + key = `[${key}]`; + } + if (node.optional) { + key = `${key}?`; + } + return key; + } + function getMethodParams(node) { + let params = '()'; + if (node.params.length > 0) { + const openingParen = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.params[0], util_1.isOpeningParenToken), 'Missing opening paren before first parameter'); + const closingParen = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.params[node.params.length - 1], util_1.isClosingParenToken), 'Missing closing paren after last parameter'); + params = context.sourceCode.text.substring(openingParen.range[0], closingParen.range[1]); + } + if (node.typeParameters != null) { + const typeParams = context.sourceCode.getText(node.typeParameters); + params = `${typeParams}${params}`; + } + return params; + } + function getMethodReturnType(node) { + return node.returnType == null + ? // if the method has no return type, it implicitly has an `any` return type + // we just make it explicit here so we can do the fix + 'any' + : context.sourceCode.getText(node.returnType.typeAnnotation); + } + function getDelimiter(node) { + const lastToken = context.sourceCode.getLastToken(node); + if (lastToken && + ((0, util_1.isSemicolonToken)(lastToken) || (0, util_1.isCommaToken)(lastToken))) { + return lastToken.value; + } + return ''; + } + function isNodeParentModuleDeclaration(node) { + if (!node.parent) { + return false; + } + if (node.parent.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration) { + return true; + } + if (node.parent.type === utils_1.AST_NODE_TYPES.Program) { + return false; + } + return isNodeParentModuleDeclaration(node.parent); + } + return { + ...(mode === 'property' && { + TSMethodSignature(methodNode) { + if (methodNode.kind !== 'method') { + return; + } + const skipFix = returnTypeReferencesThisType(methodNode.returnType); + const parent = methodNode.parent; + const members = parent.type === utils_1.AST_NODE_TYPES.TSInterfaceBody + ? parent.body + : parent.members; + const duplicatedKeyMethodNodes = members.filter((element) => element.type === utils_1.AST_NODE_TYPES.TSMethodSignature && + element !== methodNode && + getMethodKey(element) === getMethodKey(methodNode)); + const isParentModule = isNodeParentModuleDeclaration(methodNode); + if (duplicatedKeyMethodNodes.length > 0) { + if (isParentModule) { + context.report({ + node: methodNode, + messageId: 'errorMethod', + }); + } + else { + context.report({ + node: methodNode, + messageId: 'errorMethod', + fix: skipFix + ? undefined + : function* fix(fixer) { + const methodNodes = [ + methodNode, + ...duplicatedKeyMethodNodes, + ].sort((a, b) => (a.range[0] < b.range[0] ? -1 : 1)); + const typeString = methodNodes + .map(node => { + const params = getMethodParams(node); + const returnType = getMethodReturnType(node); + return `(${params} => ${returnType})`; + }) + .join(' & '); + const key = getMethodKey(methodNode); + const delimiter = getDelimiter(methodNode); + yield fixer.replaceText(methodNode, `${key}: ${typeString}${delimiter}`); + for (const node of duplicatedKeyMethodNodes) { + const lastToken = context.sourceCode.getLastToken(node); + if (lastToken) { + const nextToken = context.sourceCode.getTokenAfter(lastToken); + if (nextToken) { + yield fixer.remove(node); + yield fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], ''); + } + } + } + }, + }); + } + return; + } + if (isParentModule) { + context.report({ + node: methodNode, + messageId: 'errorMethod', + }); + } + else { + context.report({ + node: methodNode, + messageId: 'errorMethod', + fix: skipFix + ? undefined + : fixer => { + const key = getMethodKey(methodNode); + const params = getMethodParams(methodNode); + const returnType = getMethodReturnType(methodNode); + const delimiter = getDelimiter(methodNode); + return fixer.replaceText(methodNode, `${key}: ${params} => ${returnType}${delimiter}`); + }, + }); + } + }, + }), + ...(mode === 'method' && { + TSPropertySignature(propertyNode) { + const typeNode = propertyNode.typeAnnotation?.typeAnnotation; + if (typeNode?.type !== utils_1.AST_NODE_TYPES.TSFunctionType) { + return; + } + const fix = fixer => { + const key = getMethodKey(propertyNode); + const params = getMethodParams(typeNode); + const returnType = getMethodReturnType(typeNode); + const delimiter = getDelimiter(propertyNode); + return fixer.replaceText(propertyNode, `${key}${params}: ${returnType}${delimiter}`); + }; + // There is no syntax for a `readonly` method signature, so converting + // a `readonly` function-typed property drops the `readonly` modifier. + // That is a behavioral change (a method may be reassigned, a + // `readonly` property may not), so it is offered as a suggestion + // rather than applied as an autofix. + if (propertyNode.readonly) { + context.report({ + node: propertyNode, + messageId: 'errorProperty', + suggest: [{ messageId: 'convertToMethodSignature', fix }], + }); + return; + } + context.report({ + node: propertyNode, + messageId: 'errorProperty', + fix, + }); + }, + }), + }; + }, +}); +function returnTypeReferencesThisType(node) { + return (node && + (0, util_1.forEachChildESTree)(node.typeAnnotation, child => child.type === utils_1.AST_NODE_TYPES.TSThisType)); +} +//# sourceMappingURL=method-signature-style.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.d.ts new file mode 100644 index 00000000..78b209aa --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.d.ts @@ -0,0 +1,79 @@ +export declare enum PredefinedFormats { + camelCase = 1, + strictCamelCase = 2, + PascalCase = 3, + StrictPascalCase = 4, + snake_case = 5, + UPPER_CASE = 6 +} +export type PredefinedFormatsString = keyof typeof PredefinedFormats; +export declare enum UnderscoreOptions { + forbid = 1, + allow = 2, + require = 3, + requireDouble = 4, + allowDouble = 5, + allowSingleOrDouble = 6 +} +export type UnderscoreOptionsString = keyof typeof UnderscoreOptions; +export declare enum Selectors { + variable = 1, + function = 2, + parameter = 4, + parameterProperty = 8, + classicAccessor = 16, + enumMember = 32, + classMethod = 64, + objectLiteralMethod = 128, + typeMethod = 256, + classProperty = 512, + objectLiteralProperty = 1024, + typeProperty = 2048, + autoAccessor = 4096, + class = 8192, + interface = 16384, + typeAlias = 32768, + enum = 65536, + typeParameter = 131072, + import = 262144 +} +export type SelectorsString = keyof typeof Selectors; +export declare enum MetaSelectors { + default = -1, + variableLike = 7, + memberLike = 8184, + typeLike = 253952, + method = 448, + property = 3584, + accessor = 4112 +} +export type MetaSelectorsString = keyof typeof MetaSelectors; +export type IndividualAndMetaSelectorsString = MetaSelectorsString | SelectorsString; +export declare enum Modifiers { + const = 1, + readonly = 2, + static = 4, + public = 8, + protected = 16, + private = 32, + '#private' = 64, + abstract = 128, + destructured = 256, + global = 512, + exported = 1024, + unused = 2048, + requiresQuotes = 4096, + override = 8192, + async = 16384, + default = 32768, + namespace = 65536 +} +export type ModifiersString = keyof typeof Modifiers; +export declare enum TypeModifiers { + boolean = 131072, + string = 262144, + number = 524288, + function = 1048576, + array = 2097152 +} +export type TypeModifiersString = keyof typeof TypeModifiers; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.js new file mode 100644 index 00000000..6adc8f77 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/enums.js @@ -0,0 +1,103 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TypeModifiers = exports.Modifiers = exports.MetaSelectors = exports.Selectors = exports.UnderscoreOptions = exports.PredefinedFormats = void 0; +var PredefinedFormats; +(function (PredefinedFormats) { + PredefinedFormats[PredefinedFormats["camelCase"] = 1] = "camelCase"; + PredefinedFormats[PredefinedFormats["strictCamelCase"] = 2] = "strictCamelCase"; + PredefinedFormats[PredefinedFormats["PascalCase"] = 3] = "PascalCase"; + PredefinedFormats[PredefinedFormats["StrictPascalCase"] = 4] = "StrictPascalCase"; + PredefinedFormats[PredefinedFormats["snake_case"] = 5] = "snake_case"; + PredefinedFormats[PredefinedFormats["UPPER_CASE"] = 6] = "UPPER_CASE"; +})(PredefinedFormats || (exports.PredefinedFormats = PredefinedFormats = {})); +var UnderscoreOptions; +(function (UnderscoreOptions) { + UnderscoreOptions[UnderscoreOptions["forbid"] = 1] = "forbid"; + UnderscoreOptions[UnderscoreOptions["allow"] = 2] = "allow"; + UnderscoreOptions[UnderscoreOptions["require"] = 3] = "require"; + // special cases as it's common practice to use double underscore + UnderscoreOptions[UnderscoreOptions["requireDouble"] = 4] = "requireDouble"; + UnderscoreOptions[UnderscoreOptions["allowDouble"] = 5] = "allowDouble"; + UnderscoreOptions[UnderscoreOptions["allowSingleOrDouble"] = 6] = "allowSingleOrDouble"; +})(UnderscoreOptions || (exports.UnderscoreOptions = UnderscoreOptions = {})); +var Selectors; +(function (Selectors) { + // variableLike + Selectors[Selectors["variable"] = 1] = "variable"; + Selectors[Selectors["function"] = 2] = "function"; + Selectors[Selectors["parameter"] = 4] = "parameter"; + // memberLike + Selectors[Selectors["parameterProperty"] = 8] = "parameterProperty"; + Selectors[Selectors["classicAccessor"] = 16] = "classicAccessor"; + Selectors[Selectors["enumMember"] = 32] = "enumMember"; + Selectors[Selectors["classMethod"] = 64] = "classMethod"; + Selectors[Selectors["objectLiteralMethod"] = 128] = "objectLiteralMethod"; + Selectors[Selectors["typeMethod"] = 256] = "typeMethod"; + Selectors[Selectors["classProperty"] = 512] = "classProperty"; + Selectors[Selectors["objectLiteralProperty"] = 1024] = "objectLiteralProperty"; + Selectors[Selectors["typeProperty"] = 2048] = "typeProperty"; + Selectors[Selectors["autoAccessor"] = 4096] = "autoAccessor"; + // typeLike + Selectors[Selectors["class"] = 8192] = "class"; + Selectors[Selectors["interface"] = 16384] = "interface"; + Selectors[Selectors["typeAlias"] = 32768] = "typeAlias"; + Selectors[Selectors["enum"] = 65536] = "enum"; + Selectors[Selectors["typeParameter"] = 131072] = "typeParameter"; + // other + Selectors[Selectors["import"] = 262144] = "import"; +})(Selectors || (exports.Selectors = Selectors = {})); +var MetaSelectors; +(function (MetaSelectors) { + /* eslint-disable @typescript-eslint/prefer-literal-enum-member */ + MetaSelectors[MetaSelectors["default"] = -1] = "default"; + MetaSelectors[MetaSelectors["variableLike"] = 7] = "variableLike"; + MetaSelectors[MetaSelectors["memberLike"] = 8184] = "memberLike"; + MetaSelectors[MetaSelectors["typeLike"] = 253952] = "typeLike"; + MetaSelectors[MetaSelectors["method"] = 448] = "method"; + MetaSelectors[MetaSelectors["property"] = 3584] = "property"; + MetaSelectors[MetaSelectors["accessor"] = 4112] = "accessor"; + /* eslint-enable @typescript-eslint/prefer-literal-enum-member */ +})(MetaSelectors || (exports.MetaSelectors = MetaSelectors = {})); +var Modifiers; +(function (Modifiers) { + // const variable + Modifiers[Modifiers["const"] = 1] = "const"; + // readonly members + Modifiers[Modifiers["readonly"] = 2] = "readonly"; + // static members + Modifiers[Modifiers["static"] = 4] = "static"; + // member accessibility + Modifiers[Modifiers["public"] = 8] = "public"; + Modifiers[Modifiers["protected"] = 16] = "protected"; + Modifiers[Modifiers["private"] = 32] = "private"; + Modifiers[Modifiers["#private"] = 64] = "#private"; + Modifiers[Modifiers["abstract"] = 128] = "abstract"; + // destructured variable + Modifiers[Modifiers["destructured"] = 256] = "destructured"; + // variables declared in the top-level scope + Modifiers[Modifiers["global"] = 512] = "global"; + // things that are exported + Modifiers[Modifiers["exported"] = 1024] = "exported"; + // things that are unused + Modifiers[Modifiers["unused"] = 2048] = "unused"; + // properties that require quoting + Modifiers[Modifiers["requiresQuotes"] = 4096] = "requiresQuotes"; + // class members that are overridden + Modifiers[Modifiers["override"] = 8192] = "override"; + // class methods, object function properties, or functions that are async via the `async` keyword + Modifiers[Modifiers["async"] = 16384] = "async"; + // default imports + Modifiers[Modifiers["default"] = 32768] = "default"; + // namespace imports + Modifiers[Modifiers["namespace"] = 65536] = "namespace"; + // make sure TypeModifiers starts at Modifiers + 1 or else sorting won't work +})(Modifiers || (exports.Modifiers = Modifiers = {})); +var TypeModifiers; +(function (TypeModifiers) { + TypeModifiers[TypeModifiers["boolean"] = 131072] = "boolean"; + TypeModifiers[TypeModifiers["string"] = 262144] = "string"; + TypeModifiers[TypeModifiers["number"] = 524288] = "number"; + TypeModifiers[TypeModifiers["function"] = 1048576] = "function"; + TypeModifiers[TypeModifiers["array"] = 2097152] = "array"; +})(TypeModifiers || (exports.TypeModifiers = TypeModifiers = {})); +//# sourceMappingURL=enums.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.d.ts new file mode 100644 index 00000000..8ed01dac --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.d.ts @@ -0,0 +1,2 @@ +import { PredefinedFormats } from './enums'; +export declare const PredefinedFormatToCheckFunction: Readonly boolean>>; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.js new file mode 100644 index 00000000..f66d7a70 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/format.js @@ -0,0 +1,90 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PredefinedFormatToCheckFunction = void 0; +const enums_1 = require("./enums"); +/* +These format functions are taken from `tslint-consistent-codestyle/naming-convention`: +https://github.com/ajafff/tslint-consistent-codestyle/blob/ab156cc8881bcc401236d999f4ce034b59039e81/rules/namingConventionRule.ts#L603-L645 + +The license for the code can be viewed here: +https://github.com/ajafff/tslint-consistent-codestyle/blob/ab156cc8881bcc401236d999f4ce034b59039e81/LICENSE +*/ +/* +Why not regex here? Because it's actually really, really difficult to create a regex to handle +all of the unicode cases, and we have many non-english users that use non-english characters. +https://gist.github.com/mathiasbynens/6334847 +*/ +function isPascalCase(name) { + return (name.length === 0 || + (name[0] === name[0].toUpperCase() && !name.includes('_'))); +} +function isStrictPascalCase(name) { + return (name.length === 0 || + (name[0] === name[0].toUpperCase() && hasStrictCamelHumps(name, true))); +} +function isCamelCase(name) { + return (name.length === 0 || + (name[0] === name[0].toLowerCase() && !name.includes('_'))); +} +function isStrictCamelCase(name) { + return (name.length === 0 || + (name[0] === name[0].toLowerCase() && hasStrictCamelHumps(name, false))); +} +function hasStrictCamelHumps(name, isUpper) { + function isUppercaseChar(char) { + return char === char.toUpperCase() && char !== char.toLowerCase(); + } + if (name.startsWith('_')) { + return false; + } + for (let i = 1; i < name.length; ++i) { + if (name[i] === '_') { + return false; + } + if (isUpper === isUppercaseChar(name[i])) { + if (isUpper) { + return false; + } + } + else { + isUpper = !isUpper; + } + } + return true; +} +function isSnakeCase(name) { + return (name.length === 0 || + (name === name.toLowerCase() && validateUnderscores(name))); +} +function isUpperCase(name) { + return (name.length === 0 || + (name === name.toUpperCase() && validateUnderscores(name))); +} +/** Check for leading trailing and adjacent underscores */ +function validateUnderscores(name) { + if (name.startsWith('_')) { + return false; + } + let wasUnderscore = false; + for (let i = 1; i < name.length; ++i) { + if (name[i] === '_') { + if (wasUnderscore) { + return false; + } + wasUnderscore = true; + } + else { + wasUnderscore = false; + } + } + return !wasUnderscore; +} +exports.PredefinedFormatToCheckFunction = { + [enums_1.PredefinedFormats.camelCase]: isCamelCase, + [enums_1.PredefinedFormats.PascalCase]: isPascalCase, + [enums_1.PredefinedFormats.snake_case]: isSnakeCase, + [enums_1.PredefinedFormats.strictCamelCase]: isStrictCamelCase, + [enums_1.PredefinedFormats.StrictPascalCase]: isStrictPascalCase, + [enums_1.PredefinedFormats.UPPER_CASE]: isUpperCase, +}; +//# sourceMappingURL=format.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.d.ts new file mode 100644 index 00000000..11d3953c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.d.ts @@ -0,0 +1,6 @@ +export { Modifiers } from './enums'; +export type { PredefinedFormatsString } from './enums'; +export { parseOptions } from './parse-options'; +export { SCHEMA } from './schema'; +export { selectorTypeToMessageString } from './shared'; +export type { Context, Selector, ValidatorFunction } from './types'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.js new file mode 100644 index 00000000..c6f1fe36 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/index.js @@ -0,0 +1,12 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.selectorTypeToMessageString = exports.SCHEMA = exports.parseOptions = exports.Modifiers = void 0; +var enums_1 = require("./enums"); +Object.defineProperty(exports, "Modifiers", { enumerable: true, get: function () { return enums_1.Modifiers; } }); +var parse_options_1 = require("./parse-options"); +Object.defineProperty(exports, "parseOptions", { enumerable: true, get: function () { return parse_options_1.parseOptions; } }); +var schema_1 = require("./schema"); +Object.defineProperty(exports, "SCHEMA", { enumerable: true, get: function () { return schema_1.SCHEMA; } }); +var shared_1 = require("./shared"); +Object.defineProperty(exports, "selectorTypeToMessageString", { enumerable: true, get: function () { return shared_1.selectorTypeToMessageString; } }); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.d.ts new file mode 100644 index 00000000..dec2fee2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.d.ts @@ -0,0 +1,2 @@ +import type { Context, ParsedOptions } from './types'; +export declare function parseOptions(context: Context): ParsedOptions; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.js new file mode 100644 index 00000000..58ebafbb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/parse-options.js @@ -0,0 +1,70 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseOptions = parseOptions; +const util_1 = require("../../util"); +const enums_1 = require("./enums"); +const shared_1 = require("./shared"); +const validator_1 = require("./validator"); +function normalizeOption(option) { + let weight = 0; + option.modifiers?.forEach(mod => { + weight |= enums_1.Modifiers[mod]; + }); + option.types?.forEach(mod => { + weight |= enums_1.TypeModifiers[mod]; + }); + // give selectors with a filter the _highest_ priority + if (option.filter) { + weight |= 1 << 30; + } + const normalizedOption = { + // format options + custom: option.custom + ? { + match: option.custom.match, + regex: new RegExp(option.custom.regex, 'u'), + } + : null, + filter: option.filter != null + ? typeof option.filter === 'string' + ? { + match: true, + regex: new RegExp(option.filter, 'u'), + } + : { + match: option.filter.match, + regex: new RegExp(option.filter.regex, 'u'), + } + : null, + format: option.format ? option.format.map(f => enums_1.PredefinedFormats[f]) : null, + leadingUnderscore: option.leadingUnderscore != null + ? enums_1.UnderscoreOptions[option.leadingUnderscore] + : null, + modifiers: option.modifiers?.map(m => enums_1.Modifiers[m]) ?? null, + prefix: option.prefix && option.prefix.length > 0 ? option.prefix : null, + suffix: option.suffix && option.suffix.length > 0 ? option.suffix : null, + trailingUnderscore: option.trailingUnderscore != null + ? enums_1.UnderscoreOptions[option.trailingUnderscore] + : null, + types: option.types?.map(m => enums_1.TypeModifiers[m]) ?? null, + // calculated ordering weight based on modifiers + modifierWeight: weight, + }; + const selectors = Array.isArray(option.selector) + ? option.selector + : [option.selector]; + return selectors.map(selector => ({ + selector: (0, shared_1.isMetaSelector)(selector) + ? enums_1.MetaSelectors[selector] + : enums_1.Selectors[selector], + ...normalizedOption, + })); +} +function parseOptions(context) { + const normalizedOptions = context.options.flatMap(normalizeOption); + return Object.fromEntries((0, util_1.getEnumNames)(enums_1.Selectors).map(k => [ + k, + (0, validator_1.createValidator)(k, context, normalizedOptions), + ])); +} +//# sourceMappingURL=parse-options.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.d.ts new file mode 100644 index 00000000..fc72dffc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.d.ts @@ -0,0 +1,2 @@ +import type { JSONSchema } from '@typescript-eslint/utils'; +export declare const SCHEMA: JSONSchema.JSONSchema4; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.js new file mode 100644 index 00000000..fc154b19 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.js @@ -0,0 +1,306 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SCHEMA = void 0; +const util_1 = require("../../util"); +const enums_1 = require("./enums"); +const $DEFS = { + // enums + predefinedFormats: { + enum: (0, util_1.getEnumNames)(enums_1.PredefinedFormats), + type: 'string', + }, + typeModifiers: { + enum: (0, util_1.getEnumNames)(enums_1.TypeModifiers), + type: 'string', + }, + underscoreOptions: { + enum: (0, util_1.getEnumNames)(enums_1.UnderscoreOptions), + type: 'string', + }, + // repeated types + formatOptionsConfig: { + oneOf: [ + { + additionalItems: false, + items: { + $ref: '#/$defs/predefinedFormats', + }, + type: 'array', + }, + { + type: 'null', + }, + ], + }, + matchRegexConfig: { + additionalProperties: false, + properties: { + match: { type: 'boolean' }, + regex: { type: 'string' }, + }, + required: ['match', 'regex'], + type: 'object', + }, + prefixSuffixConfig: { + additionalItems: false, + items: { + minLength: 1, + type: 'string', + }, + type: 'array', + }, +}; +const UNDERSCORE_SCHEMA = { + $ref: '#/$defs/underscoreOptions', +}; +const PREFIX_SUFFIX_SCHEMA = { + $ref: '#/$defs/prefixSuffixConfig', +}; +const MATCH_REGEX_SCHEMA = { + $ref: '#/$defs/matchRegexConfig', +}; +const FORMAT_OPTIONS_PROPERTIES = { + custom: MATCH_REGEX_SCHEMA, + failureMessage: { + type: 'string', + }, + format: { + $ref: '#/$defs/formatOptionsConfig', + }, + leadingUnderscore: UNDERSCORE_SCHEMA, + prefix: PREFIX_SUFFIX_SCHEMA, + suffix: PREFIX_SUFFIX_SCHEMA, + trailingUnderscore: UNDERSCORE_SCHEMA, +}; +function selectorSchema(selectorString, allowType, modifiers) { + const selector = { + filter: { + oneOf: [ + { + minLength: 1, + type: 'string', + }, + MATCH_REGEX_SCHEMA, + ], + }, + selector: { + enum: [selectorString], + type: 'string', + }, + }; + if (modifiers && modifiers.length > 0) { + selector.modifiers = { + additionalItems: false, + items: { + enum: modifiers, + type: 'string', + }, + type: 'array', + }; + } + if (allowType) { + selector.types = { + additionalItems: false, + items: { + $ref: '#/$defs/typeModifiers', + }, + type: 'array', + }; + } + return [ + { + additionalProperties: false, + description: `Selector '${selectorString}'`, + properties: { + ...FORMAT_OPTIONS_PROPERTIES, + ...selector, + }, + required: ['selector', 'format'], + type: 'object', + }, + ]; +} +function selectorsSchema() { + return { + additionalProperties: false, + description: 'Multiple selectors in one config', + properties: { + ...FORMAT_OPTIONS_PROPERTIES, + filter: { + oneOf: [ + { + minLength: 1, + type: 'string', + }, + MATCH_REGEX_SCHEMA, + ], + }, + modifiers: { + additionalItems: false, + items: { + enum: (0, util_1.getEnumNames)(enums_1.Modifiers), + type: 'string', + }, + type: 'array', + }, + selector: { + additionalItems: false, + items: { + enum: [...(0, util_1.getEnumNames)(enums_1.MetaSelectors), ...(0, util_1.getEnumNames)(enums_1.Selectors)], + type: 'string', + }, + type: 'array', + }, + types: { + additionalItems: false, + items: { + $ref: '#/$defs/typeModifiers', + }, + type: 'array', + }, + }, + required: ['selector', 'format'], + type: 'object', + }; +} +exports.SCHEMA = { + $defs: $DEFS, + additionalItems: false, + items: { + oneOf: [ + selectorsSchema(), + ...selectorSchema('default', false, (0, util_1.getEnumNames)(enums_1.Modifiers)), + ...selectorSchema('variableLike', false, ['unused', 'async']), + ...selectorSchema('variable', true, [ + 'const', + 'destructured', + 'exported', + 'global', + 'unused', + 'async', + ]), + ...selectorSchema('function', false, [ + 'exported', + 'global', + 'unused', + 'async', + ]), + ...selectorSchema('parameter', true, ['destructured', 'unused']), + ...selectorSchema('memberLike', false, [ + 'abstract', + 'private', + '#private', + 'protected', + 'public', + 'readonly', + 'requiresQuotes', + 'static', + 'override', + 'async', + ]), + ...selectorSchema('classProperty', true, [ + 'abstract', + 'private', + '#private', + 'protected', + 'public', + 'readonly', + 'requiresQuotes', + 'static', + 'override', + ]), + ...selectorSchema('objectLiteralProperty', true, [ + 'public', + 'requiresQuotes', + ]), + ...selectorSchema('typeProperty', true, [ + 'public', + 'readonly', + 'requiresQuotes', + ]), + ...selectorSchema('parameterProperty', true, [ + 'private', + 'protected', + 'public', + 'readonly', + ]), + ...selectorSchema('property', true, [ + 'abstract', + 'private', + '#private', + 'protected', + 'public', + 'readonly', + 'requiresQuotes', + 'static', + 'override', + 'async', + ]), + ...selectorSchema('classMethod', false, [ + 'abstract', + 'private', + '#private', + 'protected', + 'public', + 'requiresQuotes', + 'static', + 'override', + 'async', + ]), + ...selectorSchema('objectLiteralMethod', false, [ + 'public', + 'requiresQuotes', + 'async', + ]), + ...selectorSchema('typeMethod', false, ['public', 'requiresQuotes']), + ...selectorSchema('method', false, [ + 'abstract', + 'private', + '#private', + 'protected', + 'public', + 'requiresQuotes', + 'static', + 'override', + 'async', + ]), + ...selectorSchema('classicAccessor', true, [ + 'abstract', + 'private', + 'protected', + 'public', + 'requiresQuotes', + 'static', + 'override', + ]), + ...selectorSchema('autoAccessor', true, [ + 'abstract', + 'private', + 'protected', + 'public', + 'requiresQuotes', + 'static', + 'override', + ]), + ...selectorSchema('accessor', true, [ + 'abstract', + 'private', + 'protected', + 'public', + 'requiresQuotes', + 'static', + 'override', + ]), + ...selectorSchema('enumMember', false, ['requiresQuotes']), + ...selectorSchema('typeLike', false, ['abstract', 'exported', 'unused']), + ...selectorSchema('class', false, ['abstract', 'exported', 'unused']), + ...selectorSchema('interface', false, ['exported', 'unused']), + ...selectorSchema('typeAlias', false, ['exported', 'unused']), + ...selectorSchema('enum', false, ['exported', 'unused']), + ...selectorSchema('typeParameter', false, ['unused']), + ...selectorSchema('import', false, ['default', 'namespace']), + ], + }, + type: 'array', +}; +//# sourceMappingURL=schema.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.d.ts new file mode 100644 index 00000000..66cc6bcf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.d.ts @@ -0,0 +1,5 @@ +import type { IndividualAndMetaSelectorsString, MetaSelectorsString, Selectors, SelectorsString } from './enums'; +import { MetaSelectors } from './enums'; +export declare function selectorTypeToMessageString(selectorType: SelectorsString): string; +export declare function isMetaSelector(selector: IndividualAndMetaSelectorsString | MetaSelectors | Selectors): selector is MetaSelectorsString; +export declare function isMethodOrPropertySelector(selector: IndividualAndMetaSelectorsString | MetaSelectors | Selectors): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.js new file mode 100644 index 00000000..cee7f2d1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.selectorTypeToMessageString = selectorTypeToMessageString; +exports.isMetaSelector = isMetaSelector; +exports.isMethodOrPropertySelector = isMethodOrPropertySelector; +const enums_1 = require("./enums"); +function selectorTypeToMessageString(selectorType) { + const notCamelCase = selectorType.replaceAll(/([A-Z])/g, ' $1'); + return notCamelCase.charAt(0).toUpperCase() + notCamelCase.slice(1); +} +function isMetaSelector(selector) { + return selector in enums_1.MetaSelectors; +} +function isMethodOrPropertySelector(selector) { + return (selector === enums_1.MetaSelectors.method || selector === enums_1.MetaSelectors.property); +} +//# sourceMappingURL=shared.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.d.ts new file mode 100644 index 00000000..4cbb3c43 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.d.ts @@ -0,0 +1,39 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +import type { MessageIds, Options } from '../naming-convention'; +import type { IndividualAndMetaSelectorsString, MetaSelectors, Modifiers, ModifiersString, PredefinedFormats, PredefinedFormatsString, Selectors, SelectorsString, TypeModifiers, TypeModifiersString, UnderscoreOptions, UnderscoreOptionsString } from './enums'; +export interface MatchRegex { + match: boolean; + regex: string; +} +export interface Selector { + custom?: MatchRegex; + filter?: string | MatchRegex; + format: PredefinedFormatsString[] | null; + leadingUnderscore?: UnderscoreOptionsString; + modifiers?: ModifiersString[]; + prefix?: string[]; + selector: IndividualAndMetaSelectorsString | IndividualAndMetaSelectorsString[]; + suffix?: string[]; + trailingUnderscore?: UnderscoreOptionsString; + types?: TypeModifiersString[]; +} +export interface NormalizedMatchRegex { + match: boolean; + regex: RegExp; +} +export interface NormalizedSelector { + custom: NormalizedMatchRegex | null; + filter: NormalizedMatchRegex | null; + format: PredefinedFormats[] | null; + leadingUnderscore: UnderscoreOptions | null; + modifiers: Modifiers[] | null; + modifierWeight: number; + prefix: string[] | null; + selector: MetaSelectors | Selectors; + suffix: string[] | null; + trailingUnderscore: UnderscoreOptions | null; + types: TypeModifiers[] | null; +} +export type ValidatorFunction = (node: TSESTree.Identifier | TSESTree.Literal | TSESTree.PrivateIdentifier, modifiers?: Set) => void; +export type ParsedOptions = Record; +export type Context = Readonly>; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.js new file mode 100644 index 00000000..11e638d1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.d.ts new file mode 100644 index 00000000..61ef3fa5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.d.ts @@ -0,0 +1,3 @@ +import type { SelectorsString } from './enums'; +import type { Context, NormalizedSelector, ValidatorFunction } from './types'; +export declare function createValidator(type: SelectorsString, context: Context, allConfigs: NormalizedSelector[]): ValidatorFunction; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.js new file mode 100644 index 00000000..abaa1070 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.js @@ -0,0 +1,350 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createValidator = createValidator; +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../../util"); +const enums_1 = require("./enums"); +const format_1 = require("./format"); +const shared_1 = require("./shared"); +function createValidator(type, context, allConfigs) { + // make sure the "highest priority" configs are checked first + const selectorType = enums_1.Selectors[type]; + const configs = allConfigs + // gather all of the applicable selectors + .filter(c => (c.selector & selectorType) !== 0 || + c.selector === enums_1.MetaSelectors.default) + .sort((a, b) => { + if (a.selector === b.selector) { + // in the event of the same selector, order by modifier weight + // sort descending - the type modifiers are "more important" + return b.modifierWeight - a.modifierWeight; + } + const aIsMeta = (0, shared_1.isMetaSelector)(a.selector); + const bIsMeta = (0, shared_1.isMetaSelector)(b.selector); + // non-meta selectors should go ahead of meta selectors + if (aIsMeta && !bIsMeta) { + return 1; + } + if (!aIsMeta && bIsMeta) { + return -1; + } + const aIsMethodOrProperty = (0, shared_1.isMethodOrPropertySelector)(a.selector); + const bIsMethodOrProperty = (0, shared_1.isMethodOrPropertySelector)(b.selector); + // for backward compatibility, method and property have higher precedence than other meta selectors + if (aIsMethodOrProperty && !bIsMethodOrProperty) { + return -1; + } + if (!aIsMethodOrProperty && bIsMethodOrProperty) { + return 1; + } + // both aren't meta selectors + // sort descending - the meta selectors are "least important" + return b.selector - a.selector; + }); + return (node, modifiers = new Set()) => { + const originalName = node.type === utils_1.AST_NODE_TYPES.Identifier || + node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier + ? node.name + : `${node.value}`; + // return will break the loop and stop checking configs + // it is only used when the name is known to have failed or succeeded a config. + for (const config of configs) { + if (config.filter?.regex.test(originalName) !== config.filter?.match) { + // name does not match the filter + continue; + } + if (config.modifiers?.some(modifier => !modifiers.has(modifier))) { + // does not have the required modifiers + continue; + } + if (!isCorrectType(node, config, context, selectorType)) { + // is not the correct type + continue; + } + let name = originalName; + name = validateUnderscore('leading', config, name, node, originalName); + if (name == null) { + // fail + return; + } + name = validateUnderscore('trailing', config, name, node, originalName); + if (name == null) { + // fail + return; + } + name = validateAffix('prefix', config, name, node, originalName); + if (name == null) { + // fail + return; + } + name = validateAffix('suffix', config, name, node, originalName); + if (name == null) { + // fail + return; + } + if (!validateCustom(config, name, node, originalName)) { + // fail + return; + } + if (!validatePredefinedFormat(config, name, node, originalName, modifiers)) { + // fail + return; + } + // it's valid for this config, so we don't need to check any more configs + return; + } + }; + // centralizes the logic for formatting the report data + function formatReportData({ affixes, count, custom, formats, originalName, position, processedName, }) { + return { + affixes: affixes?.join(', '), + count, + formats: formats?.map(f => enums_1.PredefinedFormats[f]).join(', '), + name: originalName, + position, + processedName, + regex: custom?.regex.toString(), + regexMatch: custom?.match === true + ? 'match' + : custom?.match === false + ? 'not match' + : null, + type: (0, shared_1.selectorTypeToMessageString)(type), + }; + } + /** + * @returns the name with the underscore removed, if it is valid according to the specified underscore option, null otherwise + */ + function validateUnderscore(position, config, name, node, originalName) { + const option = position === 'leading' + ? config.leadingUnderscore + : config.trailingUnderscore; + if (!option) { + return name; + } + const hasSingleUnderscore = position === 'leading' + ? () => name.startsWith('_') + : () => name.endsWith('_'); + const trimSingleUnderscore = position === 'leading' + ? () => name.slice(1) + : () => name.slice(0, -1); + const hasDoubleUnderscore = position === 'leading' + ? () => name.startsWith('__') + : () => name.endsWith('__'); + const trimDoubleUnderscore = position === 'leading' + ? () => name.slice(2) + : () => name.slice(0, -2); + switch (option) { + // ALLOW - no conditions as the user doesn't care if it's there or not + case enums_1.UnderscoreOptions.allow: { + if (hasSingleUnderscore()) { + return trimSingleUnderscore(); + } + return name; + } + case enums_1.UnderscoreOptions.allowDouble: { + if (hasDoubleUnderscore()) { + return trimDoubleUnderscore(); + } + return name; + } + case enums_1.UnderscoreOptions.allowSingleOrDouble: { + if (hasDoubleUnderscore()) { + return trimDoubleUnderscore(); + } + if (hasSingleUnderscore()) { + return trimSingleUnderscore(); + } + return name; + } + // FORBID + case enums_1.UnderscoreOptions.forbid: { + if (hasSingleUnderscore()) { + context.report({ + data: formatReportData({ + count: 'one', + originalName, + position, + }), + messageId: 'unexpectedUnderscore', + node, + }); + return null; + } + return name; + } + // REQUIRE + case enums_1.UnderscoreOptions.require: { + if (!hasSingleUnderscore()) { + context.report({ + data: formatReportData({ + count: 'one', + originalName, + position, + }), + messageId: 'missingUnderscore', + node, + }); + return null; + } + return trimSingleUnderscore(); + } + case enums_1.UnderscoreOptions.requireDouble: { + if (!hasDoubleUnderscore()) { + context.report({ + data: formatReportData({ + count: 'two', + originalName, + position, + }), + messageId: 'missingUnderscore', + node, + }); + return null; + } + return trimDoubleUnderscore(); + } + } + } + /** + * @returns the name with the affix removed, if it is valid according to the specified affix option, null otherwise + */ + function validateAffix(position, config, name, node, originalName) { + const affixes = config[position]; + if (!affixes || affixes.length === 0) { + return name; + } + for (const affix of affixes) { + const hasAffix = position === 'prefix' ? name.startsWith(affix) : name.endsWith(affix); + const trimAffix = position === 'prefix' + ? () => name.slice(affix.length) + : () => name.slice(0, -affix.length); + if (hasAffix) { + // matches, so trim it and return + return trimAffix(); + } + } + context.report({ + data: formatReportData({ + affixes, + originalName, + position, + }), + messageId: 'missingAffix', + node, + }); + return null; + } + /** + * @returns true if the name is valid according to the `regex` option, false otherwise + */ + function validateCustom(config, name, node, originalName) { + const custom = config.custom; + if (!custom) { + return true; + } + const result = custom.regex.test(name); + if (custom.match && result) { + return true; + } + if (!custom.match && !result) { + return true; + } + context.report({ + data: formatReportData({ + custom, + originalName, + }), + messageId: 'satisfyCustom', + node, + }); + return false; + } + /** + * @returns true if the name is valid according to the `format` option, false otherwise + */ + function validatePredefinedFormat(config, name, node, originalName, modifiers) { + const formats = config.format; + if (!formats?.length) { + return true; + } + if (!modifiers.has(enums_1.Modifiers.requiresQuotes)) { + for (const format of formats) { + const checker = format_1.PredefinedFormatToCheckFunction[format]; + if (checker(name)) { + return true; + } + } + } + context.report({ + data: formatReportData({ + formats, + originalName, + processedName: name, + }), + messageId: originalName === name + ? 'doesNotMatchFormat' + : 'doesNotMatchFormatTrimmed', + node, + }); + return false; + } +} +const SelectorsAllowedToHaveTypes = enums_1.Selectors.variable | + enums_1.Selectors.parameter | + enums_1.Selectors.classProperty | + enums_1.Selectors.objectLiteralProperty | + enums_1.Selectors.typeProperty | + enums_1.Selectors.parameterProperty | + enums_1.Selectors.classicAccessor; +function isCorrectType(node, config, context, selector) { + if (config.types == null) { + return true; + } + if ((SelectorsAllowedToHaveTypes & selector) === 0) { + return true; + } + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const type = services + .getTypeAtLocation(node) + // remove null and undefined from the type, as we don't care about it here + .getNonNullableType(); + for (const allowedType of config.types) { + switch (allowedType) { + case enums_1.TypeModifiers.array: + if (isAllTypesMatch(type, t => checker.isArrayType(t) || checker.isTupleType(t))) { + return true; + } + break; + case enums_1.TypeModifiers.function: + if (isAllTypesMatch(type, t => t.getCallSignatures().length > 0)) { + return true; + } + break; + case enums_1.TypeModifiers.boolean: + case enums_1.TypeModifiers.number: + case enums_1.TypeModifiers.string: { + const typeString = checker.typeToString( + // this will resolve things like true => boolean, 'a' => string and 1 => number + checker.getWidenedType(checker.getBaseTypeOfLiteralType(type))); + const allowedTypeString = enums_1.TypeModifiers[allowedType]; + if (typeString === allowedTypeString) { + return true; + } + break; + } + } + } + return false; +} +/** + * @returns `true` if the type (or all union types) in the given type return true for the callback + */ +function isAllTypesMatch(type, cb) { + if (type.isUnion()) { + return type.types.every(t => cb(t)); + } + return cb(type); +} +//# sourceMappingURL=validator.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.d.ts new file mode 100644 index 00000000..6c081ed4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.d.ts @@ -0,0 +1,8 @@ +import { TSESLint } from '@typescript-eslint/utils'; +import type { Selector } from './naming-convention-utils'; +export type MessageIds = 'doesNotMatchFormat' | 'doesNotMatchFormatTrimmed' | 'missingAffix' | 'missingUnderscore' | 'satisfyCustom' | 'unexpectedUnderscore'; +export type Options = Selector[]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.js new file mode 100644 index 00000000..3d835a7e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention.js @@ -0,0 +1,506 @@ +"use strict"; +// This rule was feature-frozen before we enabled no-property-in-node. +/* eslint-disable eslint-plugin/no-property-in-node */ +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const naming_convention_utils_1 = require("./naming-convention-utils"); +// This essentially mirrors ESLint's `camelcase` rule +// note that that rule ignores leading and trailing underscores and only checks those in the middle of a variable name +const defaultCamelCaseAllTheThingsConfig = [ + { + format: ['camelCase'], + leadingUnderscore: 'allow', + selector: 'default', + trailingUnderscore: 'allow', + }, + { + format: ['camelCase', 'PascalCase'], + selector: 'import', + }, + { + format: ['camelCase', 'UPPER_CASE'], + leadingUnderscore: 'allow', + selector: 'variable', + trailingUnderscore: 'allow', + }, + { + format: ['PascalCase'], + selector: 'typeLike', + }, +]; +exports.default = (0, util_1.createRule)({ + name: 'naming-convention', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce naming conventions for everything across a codebase', + // technically only requires type checking if the user uses "type" modifiers + frozen: true, + requiresTypeChecking: true, + }, + messages: { + doesNotMatchFormat: '{{type}} name `{{name}}` must match one of the following formats: {{formats}}', + doesNotMatchFormatTrimmed: '{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}', + missingAffix: '{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}', + missingUnderscore: '{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).', + satisfyCustom: '{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}', + unexpectedUnderscore: '{{type}} name `{{name}}` must not have a {{position}} underscore.', + }, + schema: naming_convention_utils_1.SCHEMA, + }, + defaultOptions: defaultCamelCaseAllTheThingsConfig, + create(contextWithoutDefaults) { + const context = contextWithoutDefaults.options.length > 0 + ? contextWithoutDefaults + : // only apply the defaults when the user provides no config + Object.setPrototypeOf({ + options: defaultCamelCaseAllTheThingsConfig, + }, contextWithoutDefaults); + const validators = (0, naming_convention_utils_1.parseOptions)(context); + const compilerOptions = (0, util_1.getParserServices)(context, true).program?.getCompilerOptions() ?? {}; + function handleMember(validator, node, modifiers) { + const key = node.key; + if (requiresQuoting(key, compilerOptions.target)) { + modifiers.add(naming_convention_utils_1.Modifiers.requiresQuotes); + } + validator(key, modifiers); + } + function getMemberModifiers(node) { + const modifiers = new Set(); + if ('key' in node && node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + modifiers.add(naming_convention_utils_1.Modifiers['#private']); + } + else if (node.accessibility) { + modifiers.add(naming_convention_utils_1.Modifiers[node.accessibility]); + } + else { + modifiers.add(naming_convention_utils_1.Modifiers.public); + } + if (node.static) { + modifiers.add(naming_convention_utils_1.Modifiers.static); + } + if ('readonly' in node && node.readonly) { + modifiers.add(naming_convention_utils_1.Modifiers.readonly); + } + if ('override' in node && node.override) { + modifiers.add(naming_convention_utils_1.Modifiers.override); + } + if (node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition || + node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition || + node.type === utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty) { + modifiers.add(naming_convention_utils_1.Modifiers.abstract); + } + return modifiers; + } + const { unusedVariables } = (0, util_1.collectVariables)(context); + function isUnused(name, initialScope) { + let variable = null; + let scope = initialScope; + while (scope) { + variable = scope.set.get(name) ?? null; + if (variable) { + break; + } + scope = scope.upper; + } + if (!variable) { + return false; + } + return unusedVariables.has(variable); + } + function isDestructured(id) { + return ( + // `const { x }` + // does not match `const { x: y }` + (id.parent.type === utils_1.AST_NODE_TYPES.Property && id.parent.shorthand) || + // `const { x = 2 }` + // does not match const `{ x: y = 2 }` + (id.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern && + id.parent.parent.type === utils_1.AST_NODE_TYPES.Property && + id.parent.parent.shorthand)); + } + function isAsyncMemberOrProperty(propertyOrMemberNode) { + return Boolean('value' in propertyOrMemberNode && + propertyOrMemberNode.value && + 'async' in propertyOrMemberNode.value && + propertyOrMemberNode.value.async); + } + function isAsyncVariableIdentifier(id) { + return Boolean(('async' in id.parent && id.parent.async) || + ('init' in id.parent && + id.parent.init && + 'async' in id.parent.init && + id.parent.init.async)); + } + const selectors = { + // #region import + 'FunctionDeclaration, TSDeclareFunction, FunctionExpression': { + handler: (node, validator) => { + if (node.id == null) { + return; + } + const modifiers = new Set(); + // functions create their own nested scope + const scope = context.sourceCode.getScope(node).upper; + if (isGlobal(scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.global); + } + if (isExported(node, node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + if (node.async) { + modifiers.add(naming_convention_utils_1.Modifiers.async); + } + validator(node.id, modifiers); + }, + validator: validators.function, + }, + // #endregion + // #region variable + 'ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier': { + handler: (node, validator) => { + const modifiers = new Set(); + switch (node.type) { + case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier: + modifiers.add(naming_convention_utils_1.Modifiers.default); + break; + case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier: + modifiers.add(naming_convention_utils_1.Modifiers.namespace); + break; + case utils_1.AST_NODE_TYPES.ImportSpecifier: + // Handle `import { default as Foo }` + if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier && + node.imported.name !== 'default') { + return; + } + modifiers.add(naming_convention_utils_1.Modifiers.default); + break; + } + validator(node.local, modifiers); + }, + validator: validators.import, + }, + // #endregion + // #region function + VariableDeclarator: { + handler: (node, validator) => { + const identifiers = getIdentifiersFromPattern(node.id); + const baseModifiers = new Set(); + const parent = node.parent; + if (parent.kind === 'const') { + baseModifiers.add(naming_convention_utils_1.Modifiers.const); + } + if (isGlobal(context.sourceCode.getScope(node))) { + baseModifiers.add(naming_convention_utils_1.Modifiers.global); + } + identifiers.forEach(id => { + const modifiers = new Set(baseModifiers); + if (isDestructured(id)) { + modifiers.add(naming_convention_utils_1.Modifiers.destructured); + } + const scope = context.sourceCode.getScope(id); + if (isExported(parent, id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + if (isAsyncVariableIdentifier(id)) { + modifiers.add(naming_convention_utils_1.Modifiers.async); + } + validator(id, modifiers); + }); + }, + validator: validators.variable, + }, + // #endregion function + // #region parameter + ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type != "ArrowFunctionExpression"][value.type != "FunctionExpression"][value.type != "TSEmptyBodyFunctionExpression"]': { + handler: (node, validator) => { + const modifiers = getMemberModifiers(node); + handleMember(validator, node, modifiers); + }, + validator: validators.classProperty, + }, + // #endregion parameter + // #region parameterProperty + ':not(ObjectPattern) > Property[computed = false][kind = "init"][value.type != "ArrowFunctionExpression"][value.type != "FunctionExpression"][value.type != "TSEmptyBodyFunctionExpression"]': { + handler: (node, validator) => { + const modifiers = new Set([naming_convention_utils_1.Modifiers.public]); + handleMember(validator, node, modifiers); + }, + validator: validators.objectLiteralProperty, + }, + // #endregion parameterProperty + // #region property + [[ + ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "ArrowFunctionExpression"]', + ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "FunctionExpression"]', + ':matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = "TSEmptyBodyFunctionExpression"]', + ':matches(MethodDefinition, TSAbstractMethodDefinition)[computed = false][kind = "method"]', + ].join(', ')]: { + handler: (node, validator) => { + const modifiers = getMemberModifiers(node); + if (isAsyncMemberOrProperty(node)) { + modifiers.add(naming_convention_utils_1.Modifiers.async); + } + handleMember(validator, node, modifiers); + }, + validator: validators.classMethod, + }, + [[ + 'MethodDefinition[computed = false]:matches([kind = "get"], [kind = "set"])', + 'TSAbstractMethodDefinition[computed = false]:matches([kind="get"], [kind="set"])', + ].join(', ')]: { + handler: (node, validator) => { + const modifiers = getMemberModifiers(node); + handleMember(validator, node, modifiers); + }, + validator: validators.classicAccessor, + }, + [[ + 'Property[computed = false][kind = "init"][value.type = "ArrowFunctionExpression"]', + 'Property[computed = false][kind = "init"][value.type = "FunctionExpression"]', + 'Property[computed = false][kind = "init"][value.type = "TSEmptyBodyFunctionExpression"]', + ].join(', ')]: { + handler: (node, validator) => { + const modifiers = new Set([naming_convention_utils_1.Modifiers.public]); + if (isAsyncMemberOrProperty(node)) { + modifiers.add(naming_convention_utils_1.Modifiers.async); + } + handleMember(validator, node, modifiers); + }, + validator: validators.objectLiteralMethod, + }, + // #endregion property + // #region method + [[ + 'TSMethodSignature[computed = false]', + 'TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type = "TSFunctionType"]', + ].join(', ')]: { + handler: (node, validator) => { + const modifiers = new Set([naming_convention_utils_1.Modifiers.public]); + handleMember(validator, node, modifiers); + }, + validator: validators.typeMethod, + }, + [[ + utils_1.AST_NODE_TYPES.AccessorProperty, + utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty, + ].join(', ')]: { + handler: (node, validator) => { + const modifiers = getMemberModifiers(node); + handleMember(validator, node, modifiers); + }, + validator: validators.autoAccessor, + }, + 'FunctionDeclaration, TSDeclareFunction, TSEmptyBodyFunctionExpression, FunctionExpression, ArrowFunctionExpression': { + handler: (node, validator) => { + node.params.forEach(param => { + if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) { + return; + } + const identifiers = getIdentifiersFromPattern(param); + identifiers.forEach(i => { + const modifiers = new Set(); + if (isDestructured(i)) { + modifiers.add(naming_convention_utils_1.Modifiers.destructured); + } + if (isUnused(i.name, context.sourceCode.getScope(i))) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(i, modifiers); + }); + }); + }, + validator: validators.parameter, + }, + // #endregion method + // #region accessor + 'Property[computed = false]:matches([kind = "get"], [kind = "set"])': { + handler: (node, validator) => { + const modifiers = new Set([naming_convention_utils_1.Modifiers.public]); + handleMember(validator, node, modifiers); + }, + validator: validators.classicAccessor, + }, + TSParameterProperty: { + handler: (node, validator) => { + const modifiers = getMemberModifiers(node); + const identifiers = getIdentifiersFromPattern(node.parameter); + identifiers.forEach(i => { + validator(i, modifiers); + }); + }, + validator: validators.parameterProperty, + }, + // #endregion accessor + // #region autoAccessor + 'TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != "TSFunctionType"]': { + handler: (node, validator) => { + const modifiers = new Set([naming_convention_utils_1.Modifiers.public]); + if (node.readonly) { + modifiers.add(naming_convention_utils_1.Modifiers.readonly); + } + handleMember(validator, node, modifiers); + }, + validator: validators.typeProperty, + }, + // #endregion autoAccessor + // #region enumMember + // computed is optional, so can't do [computed = false] + 'ClassDeclaration, ClassExpression': { + handler: (node, validator) => { + const id = node.id; + if (id == null) { + return; + } + const modifiers = new Set(); + // classes create their own nested scope + const scope = context.sourceCode.getScope(node).upper; + if (node.abstract) { + modifiers.add(naming_convention_utils_1.Modifiers.abstract); + } + if (isExported(node, id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(id, modifiers); + }, + validator: validators.class, + }, + // #endregion enumMember + // #region class + TSEnumDeclaration: { + handler: (node, validator) => { + const modifiers = new Set(); + // enums create their own nested scope + const scope = context.sourceCode.getScope(node).upper; + if (isExported(node, node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(node.id, modifiers); + }, + validator: validators.enum, + }, + // #endregion class + // #region interface + TSEnumMember: { + handler: (node, validator) => { + const id = node.id; + const modifiers = new Set(); + if (requiresQuoting(id, compilerOptions.target)) { + modifiers.add(naming_convention_utils_1.Modifiers.requiresQuotes); + } + validator(id, modifiers); + }, + validator: validators.enumMember, + }, + // #endregion interface + // #region typeAlias + TSInterfaceDeclaration: { + handler: (node, validator) => { + const modifiers = new Set(); + const scope = context.sourceCode.getScope(node); + if (isExported(node, node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(node.id, modifiers); + }, + validator: validators.interface, + }, + // #endregion typeAlias + // #region enum + TSTypeAliasDeclaration: { + handler: (node, validator) => { + const modifiers = new Set(); + const scope = context.sourceCode.getScope(node); + if (isExported(node, node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.exported); + } + if (isUnused(node.id.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(node.id, modifiers); + }, + validator: validators.typeAlias, + }, + // #endregion enum + // #region typeParameter + 'TSTypeParameterDeclaration > TSTypeParameter': { + handler: (node, validator) => { + const modifiers = new Set(); + const scope = context.sourceCode.getScope(node); + if (isUnused(node.name.name, scope)) { + modifiers.add(naming_convention_utils_1.Modifiers.unused); + } + validator(node.name, modifiers); + }, + validator: validators.typeParameter, + }, + // #endregion typeParameter + }; + return Object.fromEntries(Object.entries(selectors).map(([selector, { handler, validator }]) => { + return [ + selector, + (node) => { + handler(node, validator); + }, + ]; + })); + }, +}); +function getIdentifiersFromPattern(pattern) { + const identifiers = []; + const visitor = new scope_manager_1.PatternVisitor({}, pattern, id => identifiers.push(id)); + visitor.visit(pattern); + return identifiers; +} +function isExported(node, name, scope) { + if (node?.parent?.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration || + node?.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) { + return true; + } + if (scope == null) { + return false; + } + const variable = scope.set.get(name); + if (variable) { + for (const ref of variable.references) { + const refParent = ref.identifier.parent; + if (refParent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration || + refParent.type === utils_1.AST_NODE_TYPES.ExportSpecifier) { + return true; + } + } + } + return false; +} +function isGlobal(scope) { + if (scope == null) { + return false; + } + return (scope.type === utils_1.TSESLint.Scope.ScopeType.global || + scope.type === utils_1.TSESLint.Scope.ScopeType.module); +} +function requiresQuoting(node, target) { + const name = node.type === utils_1.AST_NODE_TYPES.Identifier || + node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier + ? node.name + : `${node.value}`; + return (0, util_1.requiresQuoting)(name, target); +} +//# sourceMappingURL=naming-convention.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.d.ts new file mode 100644 index 00000000..cbadb8fb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLiteral", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.js new file mode 100644 index 00000000..1aad8de0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-constructor.js @@ -0,0 +1,63 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ast_utils_1 = require("@typescript-eslint/utils/ast-utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-array-constructor', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow generic `Array` constructors', + extendsBaseRule: true, + recommended: 'recommended', + }, + fixable: 'code', + messages: { + useLiteral: 'The array literal notation [] is preferable.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const sourceCode = context.sourceCode; + function getArgumentsText(node) { + const lastToken = sourceCode.getLastToken(node); + if (lastToken == null || !(0, ast_utils_1.isClosingParenToken)(lastToken)) { + return ''; + } + let firstToken = node.callee; + do { + firstToken = sourceCode.getTokenAfter(firstToken); + if (!firstToken || firstToken === lastToken) { + return ''; + } + } while (!(0, ast_utils_1.isOpeningParenToken)(firstToken)); + return sourceCode.text.slice(firstToken.range[1], lastToken.range[0]); + } + /** + * Disallow construction of dense arrays using the Array constructor + * @param node node to evaluate + */ + function check(node) { + if (node.arguments.length !== 1 && + node.callee.type === utils_1.AST_NODE_TYPES.Identifier && + node.callee.name === 'Array' && + !node.typeArguments) { + context.report({ + node, + messageId: 'useLiteral', + fix(fixer) { + const argsText = getArgumentsText(node); + return fixer.replaceText(node, `[${argsText}]`); + }, + }); + } + } + return { + CallExpression: check, + NewExpression: check, + }; + }, +}); +//# sourceMappingURL=no-array-constructor.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.d.ts new file mode 100644 index 00000000..223f302d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageId = 'noArrayDelete' | 'useSplice'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.js new file mode 100644 index 00000000..03bad920 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-array-delete.js @@ -0,0 +1,81 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-array-delete', + meta: { + type: 'problem', + docs: { + description: 'Disallow using the `delete` operator on array values', + recommended: 'recommended', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + noArrayDelete: 'Using the `delete` operator with an array expression is unsafe.', + useSplice: 'Use `array.splice()` instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function isUnderlyingTypeArray(type) { + const predicate = (t) => checker.isArrayType(t) || checker.isTupleType(t); + if (type.isUnion()) { + return type.types.every(predicate); + } + if (type.isIntersection()) { + return type.types.some(predicate); + } + return predicate(type); + } + return { + 'UnaryExpression[operator="delete"]'(node) { + const { argument } = node; + if (argument.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return; + } + const type = (0, util_1.getConstrainedTypeAtLocation)(services, argument.object); + if (!isUnderlyingTypeArray(type)) { + return; + } + context.report({ + node, + messageId: 'noArrayDelete', + suggest: [ + { + messageId: 'useSplice', + fix(fixer) { + const { object, property } = argument; + const shouldHaveParentheses = property.type === utils_1.AST_NODE_TYPES.SequenceExpression; + const nodeMap = services.esTreeNodeToTSNodeMap; + const target = nodeMap.get(object).getText(); + const rawKey = nodeMap.get(property).getText(); + const key = shouldHaveParentheses ? `(${rawKey})` : rawKey; + let suggestion = `${target}.splice(${key}, 1)`; + const comments = context.sourceCode.getCommentsInside(node); + if (comments.length > 0) { + const indentationCount = node.loc.start.column; + const indentation = ' '.repeat(indentationCount); + const commentsText = comments + .map(comment => { + return comment.type === utils_1.AST_TOKEN_TYPES.Line + ? `//${comment.value}` + : `/*${comment.value}*/`; + }) + .join(`\n${indentation}`); + suggestion = `${commentsText}\n${indentation}${suggestion}`; + } + return fixer.replaceText(node, suggestion); + }, + }, + ], + }); + }, + }; + }, +}); +//# sourceMappingURL=no-array-delete.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.d.ts new file mode 100644 index 00000000..f1437c88 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + ignoredTypeNames?: string[]; + checkUnknown?: boolean; + } +]; +export type MessageIds = 'baseArrayJoin' | 'baseToString'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.js new file mode 100644 index 00000000..f9989286 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.js @@ -0,0 +1,323 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +var Usefulness; +(function (Usefulness) { + Usefulness["Always"] = "always"; + Usefulness["Never"] = "will"; + Usefulness["Sometimes"] = "may"; +})(Usefulness || (Usefulness = {})); +const canHaveTypeParameters = (declaration) => { + return (ts.isTypeAliasDeclaration(declaration) || + ts.isInterfaceDeclaration(declaration) || + ts.isClassDeclaration(declaration)); +}; +exports.default = (0, util_1.createRule)({ + name: 'no-base-to-string', + meta: { + type: 'suggestion', + docs: { + description: 'Require `.toString()` and `.toLocaleString()` to only be called on objects which provide useful information when stringified', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + baseArrayJoin: "Using `join()` for {{name}} {{certainty}} use Object's default stringification format ('[object Object]') when stringified.", + baseToString: "'{{name}}' {{certainty}} use Object's default stringification format ('[object Object]') when stringified.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + checkUnknown: { + type: 'boolean', + description: 'Whether to also check values of type `unknown`', + }, + ignoredTypeNames: { + type: 'array', + description: 'Stringified type names to ignore.', + items: { + type: 'string', + }, + }, + }, + }, + ], + }, + defaultOptions: [ + { + checkUnknown: false, + ignoredTypeNames: ['Error', 'RegExp', 'URL', 'URLSearchParams'], + }, + ], + create(context, [option]) { + const services = (0, util_1.getParserServices)(context); + const { program } = services; + const checker = program.getTypeChecker(); + const ignoredTypeNames = option.ignoredTypeNames ?? []; + function checkExpression(node, type) { + if (node.type === utils_1.AST_NODE_TYPES.Literal) { + return; + } + const certainty = collectToStringCertainty(type ?? services.getTypeAtLocation(node), new Set()); + if (certainty === Usefulness.Always) { + return; + } + context.report({ + node, + messageId: 'baseToString', + data: { + name: context.sourceCode.getText(node), + certainty, + }, + }); + } + function checkExpressionForArrayJoin(node, type) { + const certainty = collectJoinCertainty(type, new Set()); + if (certainty === Usefulness.Always) { + return; + } + context.report({ + node, + messageId: 'baseArrayJoin', + data: { + name: context.sourceCode.getText(node), + certainty, + }, + }); + } + function collectUnionTypeCertainty(type, collectSubTypeCertainty) { + const certainties = type.types.map(t => collectSubTypeCertainty(t)); + if (certainties.every(certainty => certainty === Usefulness.Never)) { + return Usefulness.Never; + } + if (certainties.every(certainty => certainty === Usefulness.Always)) { + return Usefulness.Always; + } + return Usefulness.Sometimes; + } + function collectIntersectionTypeCertainty(type, collectSubTypeCertainty) { + for (const subType of type.types) { + const subtypeUsefulness = collectSubTypeCertainty(subType); + if (subtypeUsefulness === Usefulness.Always) { + return Usefulness.Always; + } + } + return Usefulness.Never; + } + function collectTupleCertainty(type, visited) { + const typeArgs = checker.getTypeArguments(type); + const certainties = typeArgs.map(t => collectToStringCertainty(t, visited)); + if (certainties.some(certainty => certainty === Usefulness.Never)) { + return Usefulness.Never; + } + if (certainties.some(certainty => certainty === Usefulness.Sometimes)) { + return Usefulness.Sometimes; + } + return Usefulness.Always; + } + function collectArrayCertainty(type, visited) { + const elemType = (0, util_1.nullThrows)(type.getNumberIndexType(), 'array should have number index type'); + return collectToStringCertainty(elemType, visited); + } + function collectJoinCertainty(type, visited) { + if (tsutils.isUnionType(type)) { + return collectUnionTypeCertainty(type, t => collectJoinCertainty(t, visited)); + } + if (tsutils.isIntersectionType(type)) { + return collectIntersectionTypeCertainty(type, t => collectJoinCertainty(t, visited)); + } + if (checker.isTupleType(type)) { + return collectTupleCertainty(type, visited); + } + if (checker.isArrayType(type)) { + return collectArrayCertainty(type, visited); + } + return Usefulness.Always; + } + function collectToStringCertainty(type, visited) { + if (visited.has(type)) { + // don't report if this is a self referencing array or tuple type + return Usefulness.Always; + } + if (tsutils.isTypeParameter(type)) { + const constraint = type.getConstraint(); + if (constraint) { + return collectToStringCertainty(constraint, visited); + } + // unconstrained generic means `unknown` + return option.checkUnknown ? Usefulness.Sometimes : Usefulness.Always; + } + // the Boolean type definition missing toString() + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Boolean) || + tsutils.isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral)) { + return Usefulness.Always; + } + const symbol = type.aliasSymbol ?? type.getSymbol(); + const decl = symbol?.getDeclarations()?.[0]; + if (decl && + canHaveTypeParameters(decl) && + decl.typeParameters && + ignoredTypeNames.includes(symbol.name)) { + return Usefulness.Always; + } + if ((0, util_1.matchesTypeOrBaseType)(services, type => ignoredTypeNames.includes((0, util_1.getTypeName)(checker, type)), type)) { + return Usefulness.Always; + } + if (type.isIntersection()) { + return collectIntersectionTypeCertainty(type, t => collectToStringCertainty(t, visited)); + } + if (type.isUnion()) { + return collectUnionTypeCertainty(type, t => collectToStringCertainty(t, visited)); + } + if (checker.isTupleType(type)) { + return collectTupleCertainty(type, new Set([...visited, type])); + } + if (checker.isArrayType(type)) { + return collectArrayCertainty(type, new Set([...visited, type])); + } + switch (isToStringLikeFromObject(type)) { + case undefined: + // unknown + if (option.checkUnknown && type.flags === ts.TypeFlags.Unknown) { + return Usefulness.Sometimes; + } + // e.g. any + return Usefulness.Always; + case true: + return Usefulness.Never; + case false: + return Usefulness.Always; + } + } + function isBuiltInStringCall(node) { + if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + node.callee.name === 'String' && + node.arguments[0]) { + const scope = context.sourceCode.getScope(node); + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + const variable = utils_1.ASTUtils.findVariable(scope, 'String'); + return !variable?.defs.length; + } + return false; + } + function isSymbolToPrimitiveMethod(node) { + return (ts.isMethodSignature(node) && + ts.isComputedPropertyName(node.name) && + ts.isPropertyAccessExpression(node.name.expression) && + ts.isIdentifier(node.name.expression.expression) && + node.name.expression.expression.text === 'Symbol' && + ts.isIdentifier(node.name.expression.name) && + node.name.expression.name.text === 'toPrimitive' && + (0, util_1.isSymbolFromDefaultLibrary)(program, checker.getSymbolAtLocation(node.name.expression.expression))); + } + function isToStringLikeFromObject(type) { + // An explicit [Symbol.toPrimitive] declaration is always user-defined + if (type + .getProperties() + .some(property => property.valueDeclaration && + isSymbolToPrimitiveMethod(property.valueDeclaration))) { + return false; + } + // Otherwise, we check for known methods used in type coercion. + // We'll try to find one that's not declared on Object itself. + // Failing that, we'll fall back to one that is. + let foundFallbackOnObject = false; + for (const propertyName of ['toLocaleString', 'toString', 'valueOf']) { + const candidate = checker.getPropertyOfType(type, propertyName); + if (!candidate) { + continue; + } + const declarations = candidate.getDeclarations(); + if (!declarations?.length) { + continue; + } + // If any declaration is not from the Object interface, this is + // user-defined (e.g. overloaded toString on a class or module). + // see https://github.com/typescript-eslint/typescript-eslint/issues/8585 + // see https://github.com/typescript-eslint/typescript-eslint/issues/11945 + if (declarations.some(declaration => !(ts.isInterfaceDeclaration(declaration.parent) && + declaration.parent.name.text === 'Object'))) { + return false; + } + foundFallbackOnObject = true; + } + return foundFallbackOnObject ? true : undefined; + } + return { + 'AssignmentExpression[operator = "+="], BinaryExpression[operator = "+"]'(node) { + const leftType = services.getTypeAtLocation(node.left); + const rightType = services.getTypeAtLocation(node.right); + if ((0, util_1.getTypeName)(checker, leftType) === 'string') { + checkExpression(node.right, rightType); + } + else if (node.left.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier && + (0, util_1.getTypeName)(checker, rightType) === 'string') { + checkExpression(node.left, leftType); + } + }, + CallExpression(node) { + if (isBuiltInStringCall(node) && + node.arguments[0].type !== utils_1.AST_NODE_TYPES.SpreadElement) { + checkExpression(node.arguments[0]); + } + }, + 'CallExpression > MemberExpression.callee > Identifier[name = "join"].property'(node) { + const memberExpr = node.parent; + const type = (0, util_1.getConstrainedTypeAtLocation)(services, memberExpr.object); + checkExpressionForArrayJoin(memberExpr.object, type); + }, + 'CallExpression > MemberExpression.callee > Identifier[name = /^(toLocaleString|toString)$/].property'(node) { + const memberExpr = node.parent; + checkExpression(memberExpr.object); + }, + TemplateLiteral(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) { + return; + } + for (const expression of node.expressions) { + checkExpression(expression); + } + }, + }; + }, +}); +//# sourceMappingURL=no-base-to-string.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.d.ts new file mode 100644 index 00000000..6e48213c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageId = 'confusingAssign' | 'confusingEqual' | 'confusingOperator' | 'notNeedInAssign' | 'notNeedInEqualTest' | 'notNeedInOperator' | 'wrapUpLeft'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.js new file mode 100644 index 00000000..30f37149 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-non-null-assertion.js @@ -0,0 +1,143 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const confusingOperators = new Set([ + '=', + '==', + '===', + 'in', + 'instanceof', +]); +function isConfusingOperator(operator) { + return confusingOperators.has(operator); +} +exports.default = (0, util_1.createRule)({ + name: 'no-confusing-non-null-assertion', + meta: { + type: 'problem', + docs: { + description: 'Disallow non-null assertion in locations that may be confusing', + recommended: 'stylistic', + }, + hasSuggestions: true, + messages: { + confusingAssign: 'Confusing combination of non-null assertion and assignment like `a! = b`, which looks very similar to `a != b`.', + confusingEqual: 'Confusing combination of non-null assertion and equality test like `a! == b`, which looks very similar to `a !== b`.', + confusingOperator: 'Confusing combination of non-null assertion and `{{operator}}` operator like `a! {{operator}} b`, which might be misinterpreted as `!(a {{operator}} b)`.', + notNeedInAssign: 'Remove unnecessary non-null assertion (!) in assignment left-hand side.', + notNeedInEqualTest: 'Remove unnecessary non-null assertion (!) in equality test.', + notNeedInOperator: 'Remove possibly unnecessary non-null assertion (!) in the left operand of the `{{operator}}` operator.', + wrapUpLeft: 'Wrap the left-hand side in parentheses to avoid confusion with "{{operator}}" operator.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function confusingOperatorToMessageData(operator) { + switch (operator) { + case '=': + return { + messageId: 'confusingAssign', + }; + case '==': + case '===': + return { + messageId: 'confusingEqual', + }; + case 'in': + case 'instanceof': + return { + messageId: 'confusingOperator', + data: { operator }, + }; + // istanbul ignore next + default: + operator; + throw new Error(`Unexpected operator ${operator}`); + } + } + return { + 'BinaryExpression, AssignmentExpression'(node) { + const operator = node.operator; + if (isConfusingOperator(operator)) { + // Look for a non-null assertion as the last token on the left hand side. + // That way, we catch things like `1 + two! === 3`, even though the left + // hand side isn't a non-null assertion AST node. + const leftHandFinalToken = context.sourceCode.getLastToken(node.left); + const tokenAfterLeft = context.sourceCode.getTokenAfter(node.left); + if (leftHandFinalToken?.type === utils_1.AST_TOKEN_TYPES.Punctuator && + leftHandFinalToken.value === '!' && + tokenAfterLeft?.value !== ')') { + if (node.left.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) { + let suggestions; + switch (operator) { + case '=': + suggestions = [ + { + messageId: 'notNeedInAssign', + fix: (fixer) => fixer.remove(leftHandFinalToken), + }, + ]; + break; + case '==': + case '===': + suggestions = [ + { + messageId: 'notNeedInEqualTest', + fix: (fixer) => fixer.remove(leftHandFinalToken), + }, + ]; + break; + case 'in': + case 'instanceof': + suggestions = [ + { + messageId: 'notNeedInOperator', + data: { operator }, + fix: (fixer) => fixer.remove(leftHandFinalToken), + }, + { + messageId: 'wrapUpLeft', + data: { operator }, + fix: wrapUpLeftFixer(node), + }, + ]; + break; + // istanbul ignore next + default: + operator; + return; + } + context.report({ + node, + ...confusingOperatorToMessageData(operator), + suggest: suggestions, + }); + } + else { + context.report({ + node, + ...confusingOperatorToMessageData(operator), + suggest: [ + { + messageId: 'wrapUpLeft', + data: { operator }, + fix: wrapUpLeftFixer(node), + }, + ], + }); + } + } + } + }, + }; + }, +}); +function wrapUpLeftFixer(node) { + return (fixer) => [ + fixer.insertTextBefore(node.left, '('), + fixer.insertTextAfter(node.left, ')'), + ]; +} +//# sourceMappingURL=no-confusing-non-null-assertion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.d.ts new file mode 100644 index 00000000..1461f85f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.d.ts @@ -0,0 +1,13 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + ignoreArrowShorthand?: boolean; + ignoreVoidOperator?: boolean; + ignoreVoidReturningFunctions?: boolean; + } +]; +export type MessageId = 'invalidVoidExpr' | 'invalidVoidExprArrow' | 'invalidVoidExprArrowWrapVoid' | 'invalidVoidExprReturn' | 'invalidVoidExprReturnLast' | 'invalidVoidExprReturnWrapVoid' | 'invalidVoidExprWrapVoid' | 'voidExprWrapVoid'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.js new file mode 100644 index 00000000..01ebe1b9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.js @@ -0,0 +1,356 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getParentFunctionNode_1 = require("../util/getParentFunctionNode"); +exports.default = (0, util_1.createRule)({ + name: 'no-confusing-void-expression', + meta: { + type: 'problem', + docs: { + description: 'Require expressions of type void to appear in statement position', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + hasSuggestions: true, + messages: { + invalidVoidExpr: 'Placing a void expression inside another expression is forbidden. ' + + 'Move it to its own statement instead.', + invalidVoidExprArrow: 'Returning a void expression from an arrow function shorthand is forbidden. ' + + 'Please add braces to the arrow function.', + invalidVoidExprArrowWrapVoid: 'Void expressions returned from an arrow function shorthand ' + + 'must be marked explicitly with the `void` operator.', + invalidVoidExprReturn: 'Returning a void expression from a function is forbidden. ' + + 'Please move it before the `return` statement.', + invalidVoidExprReturnLast: 'Returning a void expression from a function is forbidden. ' + + 'Please remove the `return` statement.', + invalidVoidExprReturnWrapVoid: 'Void expressions returned from a function ' + + 'must be marked explicitly with the `void` operator.', + invalidVoidExprWrapVoid: 'Void expressions used inside another expression ' + + 'must be moved to its own statement ' + + 'or marked explicitly with the `void` operator.', + voidExprWrapVoid: 'Mark with an explicit `void` operator.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreArrowShorthand: { + type: 'boolean', + description: 'Whether to ignore "shorthand" `() =>` arrow functions: those without `{ ... }` braces.', + }, + ignoreVoidOperator: { + type: 'boolean', + description: 'Whether to ignore returns that start with the `void` operator.', + }, + ignoreVoidReturningFunctions: { + type: 'boolean', + description: 'Whether to ignore returns from functions with explicit `void` return types and functions with contextual `void` return types.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreArrowShorthand: false, + ignoreVoidOperator: false, + ignoreVoidReturningFunctions: false, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + return { + 'AwaitExpression, CallExpression, TaggedTemplateExpression'(node) { + const invalidAncestor = findInvalidAncestor(node); + if (invalidAncestor == null) { + // void expression is in valid position + return; + } + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) { + // not a void expression + return; + } + const wrapVoidFix = (fixer) => { + const nodeText = context.sourceCode.getText(node); + const newNodeText = `void ${nodeText}`; + return fixer.replaceText(node, newNodeText); + }; + if (invalidAncestor.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + // handle arrow function shorthand + if (options.ignoreVoidReturningFunctions) { + const returnsVoid = isVoidReturningFunctionNode(invalidAncestor); + if (returnsVoid) { + return; + } + } + if (options.ignoreVoidOperator) { + // handle wrapping with `void` + return context.report({ + node, + messageId: 'invalidVoidExprArrowWrapVoid', + fix: wrapVoidFix, + }); + } + // handle wrapping with braces + const arrowFunction = invalidAncestor; + return context.report({ + node, + messageId: 'invalidVoidExprArrow', + fix(fixer) { + if (!canFix(arrowFunction)) { + return null; + } + const arrowToken = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(arrowFunction.body, { + filter: token => token.value === '=>', + }), util_1.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body')); + return [ + fixer.replaceTextRange([arrowToken.range[1], arrowFunction.body.range[0]], ' { '), + fixer.replaceTextRange([arrowFunction.body.range[1], arrowFunction.range[1]], '; }'), + ]; + }, + }); + } + if (invalidAncestor.type === utils_1.AST_NODE_TYPES.ReturnStatement) { + // handle return statement + if (options.ignoreVoidReturningFunctions) { + const functionNode = (0, getParentFunctionNode_1.getParentFunctionNode)(invalidAncestor); + if (functionNode) { + const returnsVoid = isVoidReturningFunctionNode(functionNode); + if (returnsVoid) { + return; + } + } + } + if (options.ignoreVoidOperator) { + // handle wrapping with `void` + return context.report({ + node, + messageId: 'invalidVoidExprReturnWrapVoid', + fix: wrapVoidFix, + }); + } + if (isFinalReturn(invalidAncestor)) { + // remove the `return` keyword + return context.report({ + node, + messageId: 'invalidVoidExprReturnLast', + fix(fixer) { + if (!canFix(invalidAncestor)) { + return null; + } + const returnValue = invalidAncestor.argument; + const returnValueText = context.sourceCode.getText(returnValue); + let newReturnStmtText = `${returnValueText};`; + if (isPreventingASI(returnValue)) { + // put a semicolon at the beginning of the line + newReturnStmtText = `;${newReturnStmtText}`; + } + return fixer.replaceText(invalidAncestor, newReturnStmtText); + }, + }); + } + // move before the `return` keyword + return context.report({ + node, + messageId: 'invalidVoidExprReturn', + fix(fixer) { + const returnValue = invalidAncestor.argument; + const returnValueText = context.sourceCode.getText(returnValue); + let newReturnStmtText = `${returnValueText}; return;`; + if (isPreventingASI(returnValue)) { + // put a semicolon at the beginning of the line + newReturnStmtText = `;${newReturnStmtText}`; + } + if (invalidAncestor.parent.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + // e.g. `if (cond) return console.error();` + // add braces if not inside a block + newReturnStmtText = `{ ${newReturnStmtText} }`; + } + return fixer.replaceText(invalidAncestor, newReturnStmtText); + }, + }); + } + // handle generic case + if (options.ignoreVoidOperator) { + // this would be reported by this rule btw. such irony + return context.report({ + node, + messageId: 'invalidVoidExprWrapVoid', + suggest: [{ messageId: 'voidExprWrapVoid', fix: wrapVoidFix }], + }); + } + context.report({ + node, + messageId: 'invalidVoidExpr', + }); + }, + }; + /** + * Inspects the void expression's ancestors and finds closest invalid one. + * By default anything other than an ExpressionStatement is invalid. + * Parent expressions which can be used for their short-circuiting behavior + * are ignored and their parents are checked instead. + * @param node The void expression node to check. + * @returns Invalid ancestor node if it was found. `null` otherwise. + */ + function findInvalidAncestor(node) { + const parent = node.parent; + if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression && + node !== parent.expressions[parent.expressions.length - 1]) { + return null; + } + if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + // e.g. `{ console.log("foo"); }` + // this is always valid + return null; + } + if (parent.type === utils_1.AST_NODE_TYPES.LogicalExpression && + parent.right === node) { + // e.g. `x && console.log(x)` + // this is valid only if the next ancestor is valid + return findInvalidAncestor(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + (parent.consequent === node || parent.alternate === node)) { + // e.g. `cond ? console.log(true) : console.log(false)` + // this is valid only if the next ancestor is valid + return findInvalidAncestor(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + // e.g. `() => console.log("foo")` + // this is valid with an appropriate option + options.ignoreArrowShorthand) { + return null; + } + if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + parent.operator === 'void' && + // e.g. `void console.log("foo")` + // this is valid with an appropriate option + options.ignoreVoidOperator) { + return null; + } + if (parent.type === utils_1.AST_NODE_TYPES.ChainExpression) { + // e.g. `console?.log('foo')` + return findInvalidAncestor(parent); + } + // Any other parent is invalid. + // We can assume a return statement will have an argument. + return parent; + } + /** Checks whether the return statement is the last statement in a function body. */ + function isFinalReturn(node) { + // the parent must be a block + const block = node.parent; + if (block.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + // e.g. `if (cond) return;` (not in a block) + return false; + } + // the block's parent must be a function + const blockParent = block.parent; + if (![ + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.FunctionExpression, + ].includes(blockParent.type)) { + // e.g. `if (cond) { return; }` + // not in a top-level function block + return false; + } + // must be the last child of the block + if (block.body.indexOf(node) < block.body.length - 1) { + // not the last statement in the block + return false; + } + return true; + } + /** + * Checks whether the given node, if placed on its own line, + * would prevent automatic semicolon insertion on the line before. + * + * This happens if the line begins with `(`, `[` or `` ` `` + */ + function isPreventingASI(node) { + const startToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node), util_1.NullThrowsReasons.MissingToken('first token', node.type)); + return ['(', '[', '`'].includes(startToken.value); + } + function canFix(node) { + const targetNode = node.type === utils_1.AST_NODE_TYPES.ReturnStatement + ? node.argument + : node.body; + const type = (0, util_1.getConstrainedTypeAtLocation)(services, targetNode); + return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike); + } + function isFunctionReturnTypeIncludesVoid(functionType) { + const callSignatures = tsutils.getCallSignaturesOfType(functionType); + return callSignatures.some(signature => { + const returnType = signature.getReturnType(); + return tsutils + .unionConstituents(returnType) + .some(tsutils.isIntrinsicVoidType); + }); + } + function isVoidReturningFunctionNode(functionNode) { + // Game plan: + // - If the function node has a type annotation, check if it includes `void`. + // - If it does then the function is safe to return `void` expressions in. + // - Otherwise, check if the function is a function-expression or an arrow-function. + // - If it is, get its contextual type and bail if we cannot. + // - Return based on whether the contextual type includes `void` or not + if (functionNode.returnType) { + const returnType = services.getTypeFromTypeNode(functionNode.returnType.typeAnnotation); + return tsutils + .unionConstituents(returnType) + .some(tsutils.isIntrinsicVoidType); + } + if (functionNode.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration) { + const functionType = services.getContextualType(functionNode); + if (functionType) { + return tsutils + .unionConstituents(functionType) + .some(isFunctionReturnTypeIncludesVoid); + } + } + return false; + } + }, +}); +//# sourceMappingURL=no-confusing-void-expression.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.d.ts new file mode 100644 index 00000000..1e0ee706 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.d.ts @@ -0,0 +1,11 @@ +import type { TypeOrValueSpecifier } from '../util'; +type MessageIds = 'deprecated' | 'deprecatedWithReason'; +type Options = [ + { + allow?: TypeOrValueSpecifier[]; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.js new file mode 100644 index 00000000..e64363a6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.js @@ -0,0 +1,405 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-deprecated', + meta: { + type: 'problem', + docs: { + description: 'Disallow using code marked as `@deprecated`', + recommended: 'strict', + requiresTypeChecking: true, + }, + messages: { + deprecated: `\`{{name}}\` is deprecated.`, + deprecatedWithReason: `\`{{name}}\` is deprecated. {{reason}}`, + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + ...util_1.typeOrValueSpecifiersSchema, + description: 'Type specifiers that can be allowed.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + }, + ], + create(context, [options]) { + const { jsDocParsingMode } = context.languageOptions.parserOptions; + const allow = options.allow; + if (jsDocParsingMode === 'none' || jsDocParsingMode === 'type-info') { + throw new Error(`Cannot be used with jsDocParsingMode: '${jsDocParsingMode}'.`); + } + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + // Deprecated jsdoc tags can be added on some symbol alias, e.g. + // + // export { /** @deprecated */ foo } + // + // When we import foo, its symbol is an alias of the exported foo (the one + // with the deprecated tag), which is itself an alias of the original foo. + // Therefore, we carefully go through the chain of aliases and check each + // immediate alias for deprecated tags + function searchForDeprecationInAliasesChain(symbol, checkDeprecationsOfAliasedSymbol) { + if (!symbol || !tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)) { + return checkDeprecationsOfAliasedSymbol + ? getJsDocDeprecation(symbol) + : undefined; + } + const targetSymbol = checker.getAliasedSymbol(symbol); + while (tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)) { + const reason = getJsDocDeprecation(symbol); + if (reason != null) { + return reason; + } + const immediateAliasedSymbol = symbol.getDeclarations() && checker.getImmediateAliasedSymbol(symbol); + if (!immediateAliasedSymbol) { + break; + } + symbol = immediateAliasedSymbol; + if (checkDeprecationsOfAliasedSymbol && symbol === targetSymbol) { + return getJsDocDeprecation(symbol); + } + } + return undefined; + } + function isDeclaration(node) { + const { parent } = node; + switch (parent.type) { + case utils_1.AST_NODE_TYPES.ArrayPattern: + return parent.elements.includes(node); + case utils_1.AST_NODE_TYPES.ClassExpression: + case utils_1.AST_NODE_TYPES.ClassDeclaration: + case utils_1.AST_NODE_TYPES.VariableDeclarator: + case utils_1.AST_NODE_TYPES.TSEnumMember: + return parent.id === node; + case utils_1.AST_NODE_TYPES.MethodDefinition: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.AccessorProperty: + return parent.key === node; + case utils_1.AST_NODE_TYPES.Property: + // foo in "const { foo } = bar" will be processed twice, as parent.key + // and parent.value. The second is treated as a declaration. + if (parent.value === node) { + // const { foo: bar } = baz; -- bar IS a declaration. + // const baz = { foo: bar }; -- bar IS NOT a declaration. + return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern; + } + // const { foo: bar } = baz; -- foo IS NOT a declaration. + // const baz = { foo: bar }; -- foo IS a declaration. + return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression; + case utils_1.AST_NODE_TYPES.AssignmentPattern: + // foo in "const { foo = "" } = bar" will be processed twice, as parent.parent.key + // and parent.left. The second is treated as a declaration. + return parent.left === node; + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.TSDeclareFunction: + case utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression: + case utils_1.AST_NODE_TYPES.TSEnumDeclaration: + case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: + case utils_1.AST_NODE_TYPES.TSMethodSignature: + case utils_1.AST_NODE_TYPES.TSModuleDeclaration: + case utils_1.AST_NODE_TYPES.TSParameterProperty: + case utils_1.AST_NODE_TYPES.TSPropertySignature: + case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration: + case utils_1.AST_NODE_TYPES.TSTypeParameter: + return true; + // treat `export import Bar = Foo;` (and `import Foo = require('...')`) as declarations + case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration: + return parent.id === node; + default: + return false; + } + } + function isInsideImport(node) { + let current = node; + while (true) { + switch (current.type) { + case utils_1.AST_NODE_TYPES.ImportDeclaration: + return true; + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.ExportAllDeclaration: + case utils_1.AST_NODE_TYPES.ExportNamedDeclaration: + case utils_1.AST_NODE_TYPES.BlockStatement: + case utils_1.AST_NODE_TYPES.ClassDeclaration: + case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.Program: + case utils_1.AST_NODE_TYPES.TSUnionType: + case utils_1.AST_NODE_TYPES.VariableDeclarator: + return false; + default: + current = current.parent; + } + } + } + function getJsDocDeprecation(symbol) { + let jsDocTags; + try { + jsDocTags = symbol?.getJsDocTags(checker); + } + catch { + // workaround for https://github.com/microsoft/TypeScript/issues/60024 + return; + } + const tag = jsDocTags?.find(tag => tag.name === 'deprecated'); + if (!tag) { + return undefined; + } + const displayParts = tag.text; + return displayParts ? ts.displayPartsToString(displayParts) : ''; + } + function isNodeCalleeOfParent(node) { + switch (node.parent?.type) { + case utils_1.AST_NODE_TYPES.NewExpression: + case utils_1.AST_NODE_TYPES.CallExpression: + return node.parent.callee === node; + case utils_1.AST_NODE_TYPES.TaggedTemplateExpression: + return node.parent.tag === node; + case utils_1.AST_NODE_TYPES.JSXOpeningElement: + return node.parent.name === node; + default: + return false; + } + } + function getCallLikeNode(node) { + let callee = node; + while (callee.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression && + callee.parent.property === callee) { + callee = callee.parent; + } + return isNodeCalleeOfParent(callee) ? callee : undefined; + } + function getCallLikeDeprecation(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node.parent); + // If the node is a direct function call, we look for its signature. + const signature = (0, util_1.nullThrows)(checker.getResolvedSignature(tsNode), 'Expected call like node to have signature'); + const symbol = services.getSymbolAtLocation(node); + const aliasedSymbol = symbol != null && tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias) + ? checker.getAliasedSymbol(symbol) + : symbol; + const symbolDeclarationKind = aliasedSymbol?.declarations?.[0].kind; + // Properties with function-like types have "deprecated" jsdoc + // on their symbols, not on their signatures: + // + // interface Props { + // /** @deprecated */ + // property: () => 'foo' + // ^symbol^ ^signature^ + // } + if (symbolDeclarationKind !== ts.SyntaxKind.MethodDeclaration && + symbolDeclarationKind !== ts.SyntaxKind.FunctionDeclaration && + symbolDeclarationKind !== ts.SyntaxKind.MethodSignature) { + return (searchForDeprecationInAliasesChain(symbol, true) ?? + getJsDocDeprecation(signature) ?? + getJsDocDeprecation(aliasedSymbol)); + } + return (searchForDeprecationInAliasesChain(symbol, + // Here we're working with a function declaration or method. + // Both can have 1 or more overloads, each overload creates one + // ts.Declaration which is placed in symbol.declarations. + // + // Imagine the following code: + // + // function foo(): void + // /** @deprecated Some Reason */ + // function foo(arg: string): void + // function foo(arg?: string): void {} + // + // foo() // <- foo is our symbol + // + // If we call getJsDocDeprecation(checker.getAliasedSymbol(symbol)), + // we get 'Some Reason', but after all, we are calling foo with + // a signature that is not deprecated! + // It works this way because symbol.getJsDocTags returns tags from + // all symbol declarations combined into one array. And AFAIK there is + // no publicly exported TS function that can tell us if a particular + // declaration is deprecated or not. + // + // So, in case of function and method declarations, we don't check original + // aliased symbol, but rely on the getJsDocDeprecation(signature) call below. + false) ?? getJsDocDeprecation(signature)); + } + function getJSXAttributeDeprecation(openingElement, propertyName) { + const contextualType = (0, util_1.nullThrows)(services.getContextualType(openingElement.name), 'Expected JSX opening element name to have contextualType'); + const symbol = contextualType.getProperty(propertyName); + return getJsDocDeprecation(symbol); + } + function getDeprecationReason(node) { + const callLikeNode = getCallLikeNode(node); + if (callLikeNode) { + return getCallLikeDeprecation(callLikeNode); + } + if (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute && + node.type !== utils_1.AST_NODE_TYPES.Super) { + return getJSXAttributeDeprecation(node.parent.parent, node.name); + } + if (node.parent.type === utils_1.AST_NODE_TYPES.Property && + node.type !== utils_1.AST_NODE_TYPES.Super) { + const property = services + .getTypeAtLocation(node.parent.parent) + .getProperty(node.name); + const propertySymbol = services.getSymbolAtLocation(node); + const valueSymbol = checker.getShorthandAssignmentValueSymbol(propertySymbol?.valueDeclaration); + return (searchForDeprecationInAliasesChain(propertySymbol, true) ?? + getJsDocDeprecation(property) ?? + getJsDocDeprecation(propertySymbol) ?? + searchForDeprecationInAliasesChain(valueSymbol, true)); + } + return searchForDeprecationInAliasesChain(services.getSymbolAtLocation(node), true); + } + function checkIdentifier(node) { + if (isDeclaration(node) || isInsideImport(node)) { + return; + } + const reason = getDeprecationReason(node); + if (reason == null) { + return; + } + const type = services.getTypeAtLocation(node); + if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program) || + (0, util_1.valueMatchesSomeSpecifier)(node, allow, services.program, type)) { + return; + } + const name = getReportedNodeName(node); + context.report({ + ...(reason + ? { + messageId: 'deprecatedWithReason', + data: { name, reason }, + } + : { + messageId: 'deprecated', + data: { name }, + }), + node, + }); + } + function checkMemberExpression(node) { + if (!node.computed) { + return; + } + const propertyType = services.getTypeAtLocation(node.property); + if (propertyType.isLiteral()) { + const objectType = services.getTypeAtLocation(node.object); + const propertyName = propertyType.isStringLiteral() + ? propertyType.value + : // eslint-disable-next-line @typescript-eslint/no-base-to-string + String(propertyType.value); + const property = objectType.getProperty(propertyName); + const reason = getJsDocDeprecation(property); + if (reason == null) { + return; + } + if ((0, util_1.typeMatchesSomeSpecifier)(objectType, allow, services.program)) { + return; + } + context.report({ + ...(reason + ? { + messageId: 'deprecatedWithReason', + data: { name: propertyName, reason }, + } + : { + messageId: 'deprecated', + data: { name: propertyName }, + }), + node: node.property, + }); + } + } + return { + Identifier(node) { + const { parent } = node; + if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration || + parent.type === utils_1.AST_NODE_TYPES.ExportAllDeclaration) { + return; + } + // Computed identifier expressions are handled by checkMemberExpression + if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression && + parent.computed && + parent.property === node) { + return; + } + if (parent.type === utils_1.AST_NODE_TYPES.ExportSpecifier) { + // only deal with the alias (exported) side, not the local binding + if (parent.exported !== node) { + return; + } + const symbol = services.getSymbolAtLocation(node); + const aliasDeprecation = getJsDocDeprecation(symbol); + if (aliasDeprecation != null) { + return; + } + } + // whether it's a plain identifier or the exported alias + checkIdentifier(node); + }, + JSXIdentifier(node) { + if (node.parent.type !== utils_1.AST_NODE_TYPES.JSXClosingElement) { + checkIdentifier(node); + } + }, + MemberExpression: checkMemberExpression, + PrivateIdentifier: checkIdentifier, + Super: checkIdentifier, + }; + }, +}); +function getReportedNodeName(node) { + if (node.type === utils_1.AST_NODE_TYPES.Super) { + return 'super'; + } + if (node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return `#${node.name}`; + } + return node.name; +} +//# sourceMappingURL=no-deprecated.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.d.ts new file mode 100644 index 00000000..0a67d5da --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.d.ts @@ -0,0 +1,14 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], unknown, { + 'ClassBody:exit'(): void; + 'MethodDefinition, PropertyDefinition'(node: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): void; + ClassBody(): void; + Program(): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.js new file mode 100644 index 00000000..072edf0d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dupe-class-members.js @@ -0,0 +1,40 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-dupe-class-members'); +exports.default = (0, util_1.createRule)({ + name: 'no-dupe-class-members', + meta: { + type: 'problem', + // defaultOptions, -- base rule does not use defaultOptions + docs: { + description: 'Disallow duplicate class members', + extendsBaseRule: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions: [], + create(context) { + const rules = baseRule.create(context); + function wrapMemberDefinitionListener(coreListener) { + return (node) => { + if (node.computed) { + return; + } + if (node.value?.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + return; + } + return coreListener(node); + }; + } + return { + ...rules, + 'MethodDefinition, PropertyDefinition': wrapMemberDefinitionListener(rules['MethodDefinition, PropertyDefinition']), + }; + }, +}); +//# sourceMappingURL=no-dupe-class-members.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.d.ts new file mode 100644 index 00000000..060e0a5a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateValue", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.js new file mode 100644 index 00000000..374d2c13 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.js @@ -0,0 +1,84 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-duplicate-enum-values', + meta: { + type: 'problem', + docs: { + description: 'Disallow duplicate enum member values', + recommended: 'recommended', + }, + hasSuggestions: false, + messages: { + duplicateValue: 'Duplicate enum member value {{value}}.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function isStringLiteral(node) { + return (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string'); + } + function isNumberLiteral(node) { + return (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'number'); + } + function isSupportedUnary(node) { + return (node.type === utils_1.AST_NODE_TYPES.UnaryExpression && + ['-', '+'].includes(node.operator)); + } + function isStaticTemplateLiteral(node) { + return (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral && + node.expressions.length === 0 && + node.quasis.length === 1); + } + function getMemberValue(initializer) { + switch (true) { + case isStringLiteral(initializer): + case isNumberLiteral(initializer): + return initializer.value; + case isSupportedUnary(initializer): { + const inner = Number(getMemberValue(initializer.argument)); + if (Number.isNaN(inner)) { + return undefined; + } + return initializer.operator === '-' ? -inner : inner; + } + case isStaticTemplateLiteral(initializer): + return initializer.quasis[0].value.cooked ?? undefined; + default: + return undefined; + } + } + return { + TSEnumDeclaration(node) { + const enumMembers = node.body.members; + const seenValues = []; + enumMembers.forEach(member => { + if (member.initializer == null) { + return; + } + const value = getMemberValue(member.initializer); + if (value == null) { + return; + } + const isAlreadyPresent = seenValues.some(seenValue => Object.is(seenValue, value)); + if (isAlreadyPresent) { + context.report({ + node: member, + messageId: 'duplicateValue', + data: { + value, + }, + }); + } + else { + seenValues.push(value); + } + }); + }, + }; + }, +}); +//# sourceMappingURL=no-duplicate-enum-values.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.d.ts new file mode 100644 index 00000000..2c7e601d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + ignoreIntersections?: boolean; + ignoreUnions?: boolean; + } +]; +export type MessageIds = 'duplicate' | 'unnecessary'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.js new file mode 100644 index 00000000..324ae85f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-type-constituents.js @@ -0,0 +1,228 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const astIgnoreKeys = new Set(['loc', 'parent', 'range']); +const isSameAstNode = (actualNode, expectedNode) => { + if (actualNode === expectedNode) { + return true; + } + if (actualNode && + expectedNode && + typeof actualNode === 'object' && + typeof expectedNode === 'object') { + if (Array.isArray(actualNode) && Array.isArray(expectedNode)) { + if (actualNode.length !== expectedNode.length) { + return false; + } + return !actualNode.some((nodeEle, index) => !isSameAstNode(nodeEle, expectedNode[index])); + } + const actualNodeKeys = Object.keys(actualNode).filter(key => !astIgnoreKeys.has(key)); + const expectedNodeKeys = Object.keys(expectedNode).filter(key => !astIgnoreKeys.has(key)); + if (actualNodeKeys.length !== expectedNodeKeys.length) { + return false; + } + if (actualNodeKeys.some(actualNodeKey => !Object.hasOwn(expectedNode, actualNodeKey))) { + return false; + } + if (actualNodeKeys.some(actualNodeKey => !isSameAstNode(actualNode[actualNodeKey], expectedNode[actualNodeKey]))) { + return false; + } + return true; + } + return false; +}; +exports.default = (0, util_1.createRule)({ + name: 'no-duplicate-type-constituents', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow duplicate constituents of union or intersection types', + recommended: 'recommended', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + duplicate: '{{type}} type constituent is duplicated with {{previous}}.', + unnecessary: 'Explicit undefined is unnecessary on an optional parameter.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreIntersections: { + type: 'boolean', + description: 'Whether to ignore `&` intersections.', + }, + ignoreUnions: { + type: 'boolean', + description: 'Whether to ignore `|` unions.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreIntersections: false, + ignoreUnions: false, + }, + ], + create(context, [{ ignoreIntersections, ignoreUnions }]) { + const parserServices = (0, util_1.getParserServices)(context); + const { sourceCode } = context; + function report(messageId, constituentNode, data) { + const getUnionOrIntersectionToken = (where, at) => sourceCode[`getTokens${where}`](constituentNode, { + filter: token => ['&', '|'].includes(token.value) && + constituentNode.parent.range[0] <= token.range[0] && + token.range[1] <= constituentNode.parent.range[1], + }).at(at); + const beforeUnionOrIntersectionToken = getUnionOrIntersectionToken('Before', -1); + let afterUnionOrIntersectionToken; + let bracketBeforeTokens; + let bracketAfterTokens; + if (beforeUnionOrIntersectionToken) { + bracketBeforeTokens = sourceCode.getTokensBetween(beforeUnionOrIntersectionToken, constituentNode); + bracketAfterTokens = sourceCode.getTokensAfter(constituentNode, { + count: bracketBeforeTokens.length, + }); + } + else { + afterUnionOrIntersectionToken = (0, util_1.nullThrows)(getUnionOrIntersectionToken('After', 0), util_1.NullThrowsReasons.MissingToken('union or intersection token', 'duplicate type constituent')); + bracketAfterTokens = sourceCode.getTokensBetween(constituentNode, afterUnionOrIntersectionToken); + bracketBeforeTokens = sourceCode.getTokensBefore(constituentNode, { + count: bracketAfterTokens.length, + }); + } + context.report({ + loc: { + start: constituentNode.loc.start, + end: (bracketAfterTokens.at(-1) ?? constituentNode).loc.end, + }, + node: constituentNode, + messageId, + data, + fix: fixer => [ + beforeUnionOrIntersectionToken, + ...bracketBeforeTokens, + constituentNode, + ...bracketAfterTokens, + afterUnionOrIntersectionToken, + ].flatMap(token => (token ? fixer.remove(token) : [])), + }); + } + function checkDuplicateRecursively(unionOrIntersection, constituentNode, uniqueConstituents, cachedTypeMap, forEachNodeType) { + const reportDuplicate = (previous) => { + report('duplicate', constituentNode, { + type: unionOrIntersection, + previous: sourceCode.getText(previous), + }); + }; + // Check duplicates in the AST before type lookup for better performance. + let duplicatedPrevious = uniqueConstituents.find(ele => isSameAstNode(ele, constituentNode)); + if (duplicatedPrevious) { + reportDuplicate(duplicatedPrevious); + return; + } + const type = parserServices.getTypeAtLocation(constituentNode); + if (tsutils.isIntrinsicErrorType(type)) { + return; + } + duplicatedPrevious = cachedTypeMap.get(type); + if (duplicatedPrevious) { + reportDuplicate(duplicatedPrevious); + return; + } + forEachNodeType?.(type, constituentNode); + cachedTypeMap.set(type, constituentNode); + uniqueConstituents.push(constituentNode); + if ((unionOrIntersection === 'Union' && + constituentNode.type === utils_1.AST_NODE_TYPES.TSUnionType) || + (unionOrIntersection === 'Intersection' && + constituentNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType)) { + for (const constituent of constituentNode.types) { + checkDuplicateRecursively(unionOrIntersection, constituent, uniqueConstituents, cachedTypeMap, forEachNodeType); + } + } + } + function checkDuplicate(node, forEachNodeType) { + const cachedTypeMap = new Map(); + const uniqueConstituents = []; + const unionOrIntersection = node.type === utils_1.AST_NODE_TYPES.TSIntersectionType + ? 'Intersection' + : 'Union'; + for (const type of node.types) { + checkDuplicateRecursively(unionOrIntersection, type, uniqueConstituents, cachedTypeMap, forEachNodeType); + } + } + return { + ...(!ignoreIntersections && { + TSIntersectionType(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TSIntersectionType) { + return; + } + checkDuplicate(node); + }, + }), + ...(!ignoreUnions && { + TSUnionType: (node) => { + if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) { + return; + } + checkDuplicate(node, (constituentNodeType, constituentNode) => { + const maybeTypeAnnotation = node.parent; + if (maybeTypeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) { + const maybeIdentifier = maybeTypeAnnotation.parent; + if (maybeIdentifier.type === utils_1.AST_NODE_TYPES.Identifier && + maybeIdentifier.optional) { + const maybeFunction = maybeIdentifier.parent; + if ((0, util_1.isFunctionOrFunctionType)(maybeFunction) && + maybeFunction.params.includes(maybeIdentifier) && + tsutils.isTypeFlagSet(constituentNodeType, ts.TypeFlags.Undefined)) { + report('unnecessary', constituentNode); + } + } + } + }); + }, + }), + }; + }, +}); +//# sourceMappingURL=no-duplicate-type-constituents.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.d.ts new file mode 100644 index 00000000..832fb37e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.js new file mode 100644 index 00000000..ba41e2fc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-dynamic-delete.js @@ -0,0 +1,43 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-dynamic-delete', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow using the `delete` operator on computed key expressions', + recommended: 'strict', + }, + messages: { + dynamicDelete: 'Do not delete dynamically computed property keys.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + 'UnaryExpression[operator=delete]'(node) { + if (node.argument.type !== utils_1.AST_NODE_TYPES.MemberExpression || + !node.argument.computed || + isAcceptableIndexExpression(node.argument.property)) { + return; + } + context.report({ + node: node.argument.property, + messageId: 'dynamicDelete', + }); + }, + }; + }, +}); +function isAcceptableIndexExpression(property) { + return ((property.type === utils_1.AST_NODE_TYPES.Literal && + ['number', 'string'].includes(typeof property.value)) || + (property.type === utils_1.AST_NODE_TYPES.UnaryExpression && + property.operator === '-' && + property.argument.type === utils_1.AST_NODE_TYPES.Literal && + typeof property.argument.value === 'number')); +} +//# sourceMappingURL=no-dynamic-delete.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.d.ts new file mode 100644 index 00000000..99dff069 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.d.ts @@ -0,0 +1,16 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestComment" | "unexpected", [{ + allow?: string[]; +}], unknown, { + FunctionDeclaration(node: TSESTree.FunctionDeclaration): void; + FunctionExpression(node: TSESTree.FunctionExpression): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestComment" | "unexpected", [{ + allow?: string[]; +}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.js new file mode 100644 index 00000000..0a4a21d6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-function.js @@ -0,0 +1,135 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-empty-function'); +const defaultOptions = [ + { + allow: [], + }, +]; +const schema = (0, util_1.deepMerge)( +// eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- https://github.com/microsoft/TypeScript/issues/17002 +Array.isArray(baseRule.meta.schema) + ? baseRule.meta.schema[0] + : baseRule.meta.schema, { + properties: { + allow: { + description: 'Locations and kinds of functions that are allowed to be empty.', + items: { + type: 'string', + enum: [ + 'functions', + 'arrowFunctions', + 'generatorFunctions', + 'methods', + 'generatorMethods', + 'getters', + 'setters', + 'constructors', + 'private-constructors', + 'protected-constructors', + 'asyncFunctions', + 'asyncMethods', + 'decoratedFunctions', + 'overrideMethods', + ], + }, + }, + }, +}); +exports.default = (0, util_1.createRule)({ + name: 'no-empty-function', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Disallow empty functions', + extendsBaseRule: true, + recommended: 'stylistic', + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: [schema], + }, + defaultOptions, + create(context, [{ allow = [] }]) { + const rules = baseRule.create(context); + const isAllowedProtectedConstructors = allow.includes('protected-constructors'); + const isAllowedPrivateConstructors = allow.includes('private-constructors'); + const isAllowedDecoratedFunctions = allow.includes('decoratedFunctions'); + const isAllowedOverrideMethods = allow.includes('overrideMethods'); + /** + * Check if the method body is empty + * @param node the node to be validated + * @returns true if the body is empty + * @private + */ + function isBodyEmpty(node) { + return node.body.body.length === 0; + } + /** + * Check if method has parameter properties + * @param node the node to be validated + * @returns true if the body has parameter properties + * @private + */ + function hasParameterProperties(node) { + return node.params.some(param => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty); + } + /** + * @param node the node to be validated + * @returns true if the constructor is allowed to be empty + * @private + */ + function isAllowedEmptyConstructor(node) { + const parent = node.parent; + if (isBodyEmpty(node) && + parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + parent.kind === 'constructor') { + const { accessibility } = parent; + return ( + // allow protected constructors + (accessibility === 'protected' && isAllowedProtectedConstructors) || + // allow private constructors + (accessibility === 'private' && isAllowedPrivateConstructors) || + // allow constructors which have parameter properties + hasParameterProperties(node)); + } + return false; + } + /** + * @param node the node to be validated + * @returns true if a function has decorators + * @private + */ + function isAllowedEmptyDecoratedFunctions(node) { + if (isAllowedDecoratedFunctions && isBodyEmpty(node)) { + const decorators = node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition + ? node.parent.decorators + : undefined; + return !!decorators && !!decorators.length; + } + return false; + } + function isAllowedEmptyOverrideMethod(node) { + return (isAllowedOverrideMethods && + isBodyEmpty(node) && + node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.parent.override); + } + return { + ...rules, + FunctionExpression(node) { + if (isAllowedEmptyConstructor(node) || + isAllowedEmptyDecoratedFunctions(node) || + isAllowedEmptyOverrideMethod(node)) { + return; + } + rules.FunctionExpression(node); + }, + }; + }, +}); +//# sourceMappingURL=no-empty-function.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.d.ts new file mode 100644 index 00000000..a5424671 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.d.ts @@ -0,0 +1,11 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + allowSingleExtends?: boolean; + } +]; +export type MessageIds = 'noEmpty' | 'noEmptyWithSuper'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.js new file mode 100644 index 00000000..13e8b045 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.js @@ -0,0 +1,103 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-empty-interface', + meta: { + type: 'suggestion', + deprecated: { + deprecatedSince: '8.0.0', + replacedBy: [ + { + rule: { + name: '@typescript-eslint/no-empty-object-type', + url: 'https://typescript-eslint.io/rules/no-empty-object-type', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/8977', + }, + docs: { + description: 'Disallow the declaration of empty interfaces', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + noEmpty: 'An empty interface is equivalent to `{}`.', + noEmptyWithSuper: 'An interface declaring no members is equivalent to its supertype.', + }, + replacedBy: ['@typescript-eslint/no-empty-object-type'], + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowSingleExtends: { + type: 'boolean', + description: 'Whether to allow empty interfaces that extend a single other interface.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowSingleExtends: false, + }, + ], + create(context, [{ allowSingleExtends }]) { + return { + TSInterfaceDeclaration(node) { + if (node.body.body.length !== 0) { + // interface contains members --> Nothing to report + return; + } + const extend = node.extends; + if (extend.length === 0) { + context.report({ + node: node.id, + messageId: 'noEmpty', + }); + } + else if (extend.length === 1 && + // interface extends exactly 1 interface --> Report depending on rule setting + !allowSingleExtends) { + const fix = (fixer) => { + let typeParam = ''; + if (node.typeParameters) { + typeParam = context.sourceCode.getText(node.typeParameters); + } + return fixer.replaceText(node, `type ${context.sourceCode.getText(node.id)}${typeParam} = ${context.sourceCode.getText(extend[0])}`); + }; + const scope = context.sourceCode.getScope(node); + const mergedWithClassDeclaration = scope.set + .get(node.id.name) + ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration); + const isInAmbientDeclaration = (0, util_1.isDefinitionFile)(context.filename) && + scope.type === scope_manager_1.ScopeType.tsModule && + scope.block.declare; + const useAutoFix = !(isInAmbientDeclaration || mergedWithClassDeclaration); + context.report({ + node: node.id, + messageId: 'noEmptyWithSuper', + ...(useAutoFix + ? { fix } + : !mergedWithClassDeclaration + ? { + suggest: [ + { + messageId: 'noEmptyWithSuper', + fix, + }, + ], + } + : null), + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-empty-interface.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.d.ts new file mode 100644 index 00000000..7b02d101 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.d.ts @@ -0,0 +1,15 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type AllowInterfaces = 'always' | 'never' | 'with-single-extends'; +export type AllowObjectTypes = 'always' | 'never'; +export type Options = [ + { + allowInterfaces?: AllowInterfaces; + allowObjectTypes?: AllowObjectTypes; + allowWithName?: string; + } +]; +export type MessageIds = 'noEmptyInterface' | 'noEmptyInterfaceWithSuper' | 'noEmptyObject' | 'replaceEmptyInterface' | 'replaceEmptyInterfaceWithSuper' | 'replaceEmptyObjectType'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.js new file mode 100644 index 00000000..5e2c1400 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-object-type.js @@ -0,0 +1,148 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const noEmptyMessage = (emptyType) => [ + `${emptyType} allows any non-nullish value, including literals like \`0\` and \`""\`.`, + "- If that's what you want, disable this lint rule with an inline comment or configure the '{{ option }}' rule option.", + '- If you want a type meaning "any object", you probably want `object` instead.', + '- If you want a type meaning "any value", you probably want `unknown` instead.', +].join('\n'); +exports.default = (0, util_1.createRule)({ + name: 'no-empty-object-type', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow accidentally using the "empty object" type', + recommended: 'recommended', + }, + hasSuggestions: true, + messages: { + noEmptyInterface: noEmptyMessage('An empty interface declaration'), + noEmptyInterfaceWithSuper: 'An interface declaring no members is equivalent to its supertype.', + noEmptyObject: noEmptyMessage('The `{}` ("empty object") type'), + replaceEmptyInterface: 'Replace empty interface with `{{replacement}}`.', + replaceEmptyInterfaceWithSuper: 'Replace empty interface with a type alias.', + replaceEmptyObjectType: 'Replace `{}` with `{{replacement}}`.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowInterfaces: { + type: 'string', + description: 'Whether to allow empty interfaces.', + enum: ['always', 'never', 'with-single-extends'], + }, + allowObjectTypes: { + type: 'string', + description: 'Whether to allow empty object type literals.', + enum: ['always', 'never'], + }, + allowWithName: { + type: 'string', + description: 'A stringified regular expression to allow interfaces and object type aliases with the configured name.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowInterfaces: 'never', + allowObjectTypes: 'never', + }, + ], + create(context, [{ allowInterfaces, allowObjectTypes, allowWithName }]) { + const allowWithNameTester = allowWithName + ? new RegExp(allowWithName, 'u') + : undefined; + return { + ...(allowInterfaces !== 'always' && { + TSInterfaceDeclaration(node) { + if (allowWithNameTester?.test(node.id.name)) { + return; + } + const extend = node.extends; + if (node.body.body.length !== 0 || + (extend.length === 1 && + allowInterfaces === 'with-single-extends') || + extend.length > 1) { + return; + } + const scope = context.sourceCode.getScope(node); + const mergedWithOtherDeclaration = scope.set + .get(node.id.name) + ?.defs.some(def => def.node !== node && + (def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration || + def.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration)); + const isDefaultExport = node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration; + const shouldSuggest = !mergedWithOtherDeclaration && !isDefaultExport; + if (extend.length === 0) { + context.report({ + node: node.id, + messageId: 'noEmptyInterface', + data: { option: 'allowInterfaces' }, + ...(shouldSuggest && { + suggest: ['object', 'unknown'].map(replacement => ({ + messageId: 'replaceEmptyInterface', + data: { replacement }, + fix(fixer) { + const id = context.sourceCode.getText(node.id); + const typeParam = node.typeParameters + ? context.sourceCode.getText(node.typeParameters) + : ''; + return fixer.replaceText(node, `type ${id}${typeParam} = ${replacement}`); + }, + })), + }), + }); + return; + } + context.report({ + node: node.id, + messageId: 'noEmptyInterfaceWithSuper', + ...(shouldSuggest && { + suggest: [ + { + messageId: 'replaceEmptyInterfaceWithSuper', + fix(fixer) { + const extended = context.sourceCode.getText(extend[0]); + const id = context.sourceCode.getText(node.id); + const typeParam = node.typeParameters + ? context.sourceCode.getText(node.typeParameters) + : ''; + return fixer.replaceText(node, `type ${id}${typeParam} = ${extended}`); + }, + }, + ], + }), + }); + }, + }), + ...(allowObjectTypes !== 'always' && { + TSTypeLiteral(node) { + if (node.members.length || + node.parent.type === utils_1.AST_NODE_TYPES.TSIntersectionType || + (allowWithNameTester && + node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration && + allowWithNameTester.test(node.parent.id.name))) { + return; + } + context.report({ + node, + messageId: 'noEmptyObject', + data: { option: 'allowObjectTypes' }, + suggest: ['object', 'unknown'].map(replacement => ({ + messageId: 'replaceEmptyObjectType', + data: { replacement }, + fix: (fixer) => fixer.replaceText(node, replacement), + })), + }); + }, + }), + }; + }, +}); +//# sourceMappingURL=no-empty-object-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.d.ts new file mode 100644 index 00000000..f3ea2da2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.d.ts @@ -0,0 +1,12 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + fixToUnknown?: boolean; + ignoreRestArgs?: boolean; + } +]; +export type MessageIds = 'suggestNever' | 'suggestPropertyKey' | 'suggestUnknown' | 'unexpectedAny'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.js new file mode 100644 index 00000000..de154307 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-explicit-any.js @@ -0,0 +1,206 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-explicit-any', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow the `any` type', + recommended: 'recommended', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + suggestNever: "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of.", + suggestPropertyKey: 'Use `PropertyKey` instead, this is more explicit than `keyof any`.', + suggestUnknown: 'Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct.', + unexpectedAny: 'Unexpected any. Specify a different type.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + fixToUnknown: { + type: 'boolean', + description: 'Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.', + }, + ignoreRestArgs: { + type: 'boolean', + description: 'Whether to ignore rest parameter arrays.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + fixToUnknown: false, + ignoreRestArgs: false, + }, + ], + create(context, [{ fixToUnknown, ignoreRestArgs }]) { + /** + * Checks if the node is an arrow function, function/constructor declaration or function expression + * @param node the node to be validated. + * @returns true if the node is any kind of function declaration or expression + * @private + */ + function isNodeValidFunction(node) { + return [ + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, // const x = (...args: any[]) => {}; + utils_1.AST_NODE_TYPES.FunctionDeclaration, // function f(...args: any[]) {} + utils_1.AST_NODE_TYPES.FunctionExpression, // const x = function(...args: any[]) {}; + utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration, // type T = {(...args: any[]): unknown}; + utils_1.AST_NODE_TYPES.TSConstructorType, // type T = new (...args: any[]) => unknown + utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration, // type T = {new (...args: any[]): unknown}; + utils_1.AST_NODE_TYPES.TSDeclareFunction, // declare function _8(...args: any[]): unknown; + utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression, // declare class A { f(...args: any[]): unknown; } + utils_1.AST_NODE_TYPES.TSFunctionType, // type T = (...args: any[]) => unknown; + utils_1.AST_NODE_TYPES.TSMethodSignature, // type T = {f(...args: any[]): unknown}; + ].includes(node.type); + } + /** + * Checks if the node is a rest element child node of a function + * @param node the node to be validated. + * @returns true if the node is a rest element child node of a function + * @private + */ + function isNodeRestElementInFunction(node) { + return (node.type === utils_1.AST_NODE_TYPES.RestElement && + isNodeValidFunction(node.parent)); + } + /** + * Checks if the node is a TSTypeOperator node with a readonly operator + * @param node the node to be validated. + * @returns true if the node is a TSTypeOperator node with a readonly operator + * @private + */ + function isNodeReadonlyTSTypeOperator(node) { + return (node.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + node.operator === 'readonly'); + } + /** + * Checks if the node is a TSTypeReference node with an Array identifier + * @param node the node to be validated. + * @returns true if the node is a TSTypeReference node with an Array identifier + * @private + */ + function isNodeValidArrayTSTypeReference(node) { + return (node.type === utils_1.AST_NODE_TYPES.TSTypeReference && + node.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + ['Array', 'ReadonlyArray'].includes(node.typeName.name)); + } + /** + * Checks if the node is a valid TSTypeOperator or TSTypeReference node + * @param node the node to be validated. + * @returns true if the node is a valid TSTypeOperator or TSTypeReference node + * @private + */ + function isNodeValidTSType(node) { + return (isNodeReadonlyTSTypeOperator(node) || + isNodeValidArrayTSTypeReference(node)); + } + /** + * Checks if the great grand-parent node is a RestElement node in a function + * @param node the node to be validated. + * @returns true if the great grand-parent node is a RestElement node in a function + * @private + */ + function isGreatGrandparentRestElement(node) { + return (node.parent?.parent?.parent != null && + isNodeRestElementInFunction(node.parent.parent.parent)); + } + /** + * Checks if the great great grand-parent node is a valid RestElement node in a function + * @param node the node to be validated. + * @returns true if the great great grand-parent node is a valid RestElement node in a function + * @private + */ + function isGreatGreatGrandparentRestElement(node) { + return (node.parent?.parent?.parent?.parent != null && + isNodeValidTSType(node.parent.parent) && + isNodeRestElementInFunction(node.parent.parent.parent.parent)); + } + /** + * Checks if the great grand-parent or the great great grand-parent node is a RestElement node + * @param node the node to be validated. + * @returns true if the great grand-parent or the great great grand-parent node is a RestElement node + * @private + */ + function isNodeDescendantOfRestElementInFunction(node) { + return (isGreatGrandparentRestElement(node) || + isGreatGreatGrandparentRestElement(node)); + } + /** + * Checks if the node is within a keyof any expression + * @param node the node to be validated. + * @returns true if the node is within a keyof any expression, false otherwise + * @private + */ + function isNodeWithinKeyofAny(node) { + return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + node.parent.operator === 'keyof'); + } + /** + * Creates a fixer that replaces a keyof any with PropertyKey + * @param node the node to be fixed. + * @returns a function that will fix the node. + * @private + */ + function createPropertyKeyFixer(node) { + return (fixer) => { + return fixer.replaceText(node.parent, 'PropertyKey'); + }; + } + function createUnknownFixer(node) { + return (fixer) => { + return fixer.replaceText(node, node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation && + isNodeRestElementInFunction(node.parent.parent) + ? 'unknown[]' + : 'unknown'); + }; + } + return { + TSAnyKeyword(node) { + const isKeyofAny = isNodeWithinKeyofAny(node); + if (ignoreRestArgs && isNodeDescendantOfRestElementInFunction(node)) { + return; + } + const fixOrSuggest = { + fix: null, + suggest: isKeyofAny + ? [ + { + messageId: 'suggestPropertyKey', + fix: createPropertyKeyFixer(node), + }, + ] + : [ + { + messageId: 'suggestUnknown', + fix: createUnknownFixer(node), + }, + { + messageId: 'suggestNever', + fix: fixer => fixer.replaceText(node, 'never'), + }, + ], + }; + if (fixToUnknown) { + fixOrSuggest.fix = isKeyofAny + ? createPropertyKeyFixer(node) + : createUnknownFixer(node); + } + context.report({ + node, + messageId: 'unexpectedAny', + ...fixOrSuggest, + }); + }, + }; + }, +}); +//# sourceMappingURL=no-explicit-any.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.d.ts new file mode 100644 index 00000000..733adcbb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExtraNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.js new file mode 100644 index 00000000..e5281460 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extra-non-null-assertion.js @@ -0,0 +1,36 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-extra-non-null-assertion', + meta: { + type: 'problem', + docs: { + description: 'Disallow extra non-null assertions', + recommended: 'recommended', + }, + fixable: 'code', + messages: { + noExtraNonNullAssertion: 'Forbidden extra non-null assertion.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function checkExtraNonNullAssertion(node) { + context.report({ + node, + messageId: 'noExtraNonNullAssertion', + fix(fixer) { + return fixer.removeRange([node.range[1] - 1, node.range[1]]); + }, + }); + } + return { + 'CallExpression[optional = true] > TSNonNullExpression.callee': checkExtraNonNullAssertion, + 'MemberExpression[optional = true] > TSNonNullExpression.object': checkExtraNonNullAssertion, + 'TSNonNullExpression > TSNonNullExpression': checkExtraNonNullAssertion, + }; + }, +}); +//# sourceMappingURL=no-extra-non-null-assertion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.d.ts new file mode 100644 index 00000000..78ce6d6d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.d.ts @@ -0,0 +1,13 @@ +export type Options = [ + { + allowConstructorOnly?: boolean; + allowEmpty?: boolean; + allowStaticOnly?: boolean; + allowWithDecorator?: boolean; + } +]; +export type MessageIds = 'empty' | 'onlyConstructor' | 'onlyStatic'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.js new file mode 100644 index 00000000..c4f44444 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-extraneous-class.js @@ -0,0 +1,122 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-extraneous-class', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow classes used as namespaces', + recommended: 'strict', + }, + messages: { + empty: 'Unexpected empty class.', + onlyConstructor: 'Unexpected class with only a constructor.', + onlyStatic: 'Unexpected class with only static properties.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowConstructorOnly: { + type: 'boolean', + description: 'Whether to allow extraneous classes that contain only a constructor.', + }, + allowEmpty: { + type: 'boolean', + description: 'Whether to allow extraneous classes that have no body (i.e. are empty).', + }, + allowStaticOnly: { + type: 'boolean', + description: 'Whether to allow extraneous classes that only contain static members.', + }, + allowWithDecorator: { + type: 'boolean', + description: 'Whether to allow extraneous classes that include a decorator.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowConstructorOnly: false, + allowEmpty: false, + allowStaticOnly: false, + allowWithDecorator: false, + }, + ], + create(context, [{ allowConstructorOnly, allowEmpty, allowStaticOnly, allowWithDecorator }]) { + const isAllowWithDecorator = (node) => { + return !!(allowWithDecorator && + node?.decorators && + node.decorators.length !== 0); + }; + return { + ClassBody(node) { + const parent = node.parent; + if (parent.superClass || isAllowWithDecorator(parent)) { + return; + } + const reportNode = parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration && parent.id + ? parent.id + : parent; + if (node.body.length === 0) { + if (allowEmpty) { + return; + } + context.report({ + node: reportNode, + messageId: 'empty', + }); + return; + } + let onlyStatic = true; + let onlyConstructor = true; + for (const prop of node.body) { + if (prop.type === utils_1.AST_NODE_TYPES.MethodDefinition && + prop.kind === 'constructor') { + if (prop.value.params.some(param => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty)) { + onlyConstructor = false; + onlyStatic = false; + } + } + else { + onlyConstructor = false; + if (((prop.type === utils_1.AST_NODE_TYPES.PropertyDefinition || + prop.type === utils_1.AST_NODE_TYPES.MethodDefinition || + prop.type === utils_1.AST_NODE_TYPES.AccessorProperty) && + !prop.static) || + prop.type === utils_1.AST_NODE_TYPES.TSIndexSignature || + prop.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition || + prop.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition || // `static abstract` methods and properties are currently not supported. See: https://github.com/microsoft/TypeScript/issues/34516 + prop.type === utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty) { + onlyStatic = false; + } + } + if (!(onlyStatic || onlyConstructor)) { + break; + } + } + if (onlyConstructor) { + if (!allowConstructorOnly) { + context.report({ + node: reportNode, + messageId: 'onlyConstructor', + }); + } + return; + } + if (onlyStatic && !allowStaticOnly) { + context.report({ + node: reportNode, + messageId: 'onlyStatic', + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-extraneous-class.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.d.ts new file mode 100644 index 00000000..5a02e554 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.d.ts @@ -0,0 +1,16 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +import type { TypeOrValueSpecifier } from '../util'; +export type Options = [ + { + allowForKnownSafeCalls?: TypeOrValueSpecifier[]; + allowForKnownSafePromises?: TypeOrValueSpecifier[]; + checkThenables?: boolean; + ignoreIIFE?: boolean; + ignoreVoid?: boolean; + } +]; +export type MessageId = 'floating' | 'floatingFixAwait' | 'floatingFixVoid' | 'floatingPromiseArray' | 'floatingPromiseArrayVoid' | 'floatingUselessRejectionHandler' | 'floatingUselessRejectionHandlerVoid' | 'floatingVoid'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.js new file mode 100644 index 00000000..1205d250 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.js @@ -0,0 +1,386 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +const promiseUtils_1 = require("../util/promiseUtils"); +const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.'; +const messageBaseVoid = 'Promises must be awaited, end with a call to .catch, end with a call to .then with a rejection handler' + + ' or be explicitly marked as ignored with the `void` operator.'; +const messageRejectionHandler = 'A rejection handler that is not a function will be ignored.'; +const messagePromiseArray = "An array of Promises may be unintentional. Consider handling the promises' fulfillment or rejection with Promise.all or similar."; +const messagePromiseArrayVoid = "An array of Promises may be unintentional. Consider handling the promises' fulfillment or rejection with Promise.all or similar," + + ' or explicitly marking the expression as ignored with the `void` operator.'; +exports.default = (0, util_1.createRule)({ + name: 'no-floating-promises', + meta: { + type: 'problem', + docs: { + description: 'Require Promise-like statements to be handled appropriately', + recommended: 'recommended', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + floating: messageBase, + floatingFixAwait: 'Add await operator.', + floatingFixVoid: 'Add void operator to ignore.', + floatingPromiseArray: messagePromiseArray, + floatingPromiseArrayVoid: messagePromiseArrayVoid, + floatingUselessRejectionHandler: `${messageBase} ${messageRejectionHandler}`, + floatingUselessRejectionHandlerVoid: `${messageBaseVoid} ${messageRejectionHandler}`, + floatingVoid: messageBaseVoid, + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowForKnownSafeCalls: { + ...util_1.readonlynessOptionsSchema.properties.allow, + description: 'Type specifiers of functions whose calls are safe to float.', + }, + allowForKnownSafePromises: { + ...util_1.readonlynessOptionsSchema.properties.allow, + description: 'Type specifiers that are known to be safe to float.', + }, + checkThenables: { + type: 'boolean', + description: 'Whether to check all "Thenable"s, not just the built-in Promise type.', + }, + ignoreIIFE: { + type: 'boolean', + description: 'Whether to ignore async IIFEs (Immediately Invoked Function Expressions).', + }, + ignoreVoid: { + type: 'boolean', + description: 'Whether to ignore `void` expressions.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowForKnownSafeCalls: util_1.readonlynessOptionsDefaults.allow, + allowForKnownSafePromises: util_1.readonlynessOptionsDefaults.allow, + checkThenables: false, + ignoreIIFE: false, + ignoreVoid: true, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const { checkThenables } = options; + // TODO: #5439 + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + const allowForKnownSafePromises = options.allowForKnownSafePromises; + const allowForKnownSafeCalls = options.allowForKnownSafeCalls; + /* eslint-enable @typescript-eslint/no-non-null-assertion */ + return { + ArrowFunctionExpression(node) { + if (node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression) { + checkNode(node.body, node.body); + } + }, + ExpressionStatement(node) { + if (options.ignoreIIFE && isAsyncIife(node)) { + return; + } + const expression = (0, util_1.skipChainExpression)(node.expression); + checkNode(node, expression); + }, + }; + function checkNode(node, expression) { + if (isKnownSafePromiseCall(expression)) { + return; + } + const { isUnhandled, nonFunctionHandler, promiseArray } = isUnhandledPromise(checker, expression); + if (isUnhandled) { + if (promiseArray) { + context.report({ + node, + messageId: options.ignoreVoid + ? 'floatingPromiseArrayVoid' + : 'floatingPromiseArray', + }); + } + else if (options.ignoreVoid) { + context.report({ + node, + messageId: nonFunctionHandler + ? 'floatingUselessRejectionHandlerVoid' + : 'floatingVoid', + suggest: [ + { + messageId: 'floatingFixVoid', + fix(fixer) { + if ((0, util_1.isParenthesized)(expression, context.sourceCode) || + (0, util_1.getOperatorPrecedenceForNode)(expression) > + util_1.OperatorPrecedence.Unary) { + return fixer.insertTextBefore(node, 'void '); + } + return [ + fixer.insertTextBefore(node, 'void ('), + fixer.insertTextAfterRange([expression.range[1], expression.range[1]], ')'), + ]; + }, + }, + { + messageId: 'floatingFixAwait', + fix: (fixer) => addAwait(fixer, expression, node), + }, + ], + }); + } + else { + context.report({ + node, + messageId: nonFunctionHandler + ? 'floatingUselessRejectionHandler' + : 'floating', + suggest: [ + { + messageId: 'floatingFixAwait', + fix: (fixer) => addAwait(fixer, expression, node), + }, + ], + }); + } + } + } + function addAwait(fixer, expression, node) { + if (expression.type === utils_1.AST_NODE_TYPES.UnaryExpression && + expression.operator === 'void') { + return fixer.replaceTextRange([expression.range[0], expression.range[0] + 4], 'await'); + } + if ((0, util_1.isParenthesized)(expression, context.sourceCode) || + (0, util_1.getOperatorPrecedenceForNode)(expression) > util_1.OperatorPrecedence.Unary) { + return fixer.insertTextBefore(node, 'await '); + } + return [ + fixer.insertTextBefore(node, 'await ('), + fixer.insertTextAfterRange([expression.range[1], expression.range[1]], ')'), + ]; + } + function isKnownSafePromiseCall(node) { + if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) { + return false; + } + const type = services.getTypeAtLocation(node.callee); + if ((0, util_1.valueMatchesSomeSpecifier)(node.callee, allowForKnownSafeCalls, services.program, type)) { + return true; + } + return (0, util_1.typeMatchesSomeSpecifier)(type, allowForKnownSafeCalls, services.program); + } + function isAsyncIife(node) { + if (node.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) { + return false; + } + return (node.expression.callee.type === + utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + node.expression.callee.type === utils_1.AST_NODE_TYPES.FunctionExpression); + } + function isValidRejectionHandler(rejectionHandler) { + return (services.program + .getTypeChecker() + .getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(rejectionHandler)) + .getCallSignatures().length > 0); + } + function isUnhandledPromise(checker, node) { + if (node.type === utils_1.AST_NODE_TYPES.AssignmentExpression) { + return { isUnhandled: false }; + } + // First, check expressions whose resulting types may not be promise-like + if (node.type === utils_1.AST_NODE_TYPES.SequenceExpression) { + // Any child in a comma expression could return a potentially unhandled + // promise, so we check them all regardless of whether the final returned + // value is promise-like. + return (node.expressions + .map(item => isUnhandledPromise(checker, item)) + .find(result => result.isUnhandled) ?? { isUnhandled: false }); + } + if (!options.ignoreVoid && + node.type === utils_1.AST_NODE_TYPES.UnaryExpression && + node.operator === 'void') { + // Similarly, a `void` expression always returns undefined, so we need to + // see what's inside it without checking the type of the overall expression. + return isUnhandledPromise(checker, node.argument); + } + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + // Check the type. At this point it can't be unhandled if it isn't a promise + // or array thereof. + if (isPromiseArray(tsNode)) { + return { isUnhandled: true, promiseArray: true }; + } + // await expression addresses promises, but not promise arrays. + if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression) { + // you would think this wouldn't be strictly necessary, since we're + // anyway checking the type of the expression, but, unfortunately TS + // reports the result of `await (promise as Promise & number)` + // as `Promise & number` instead of `number`. + return { isUnhandled: false }; + } + if (!isPromiseLike(tsNode)) { + return { isUnhandled: false }; + } + if (node.type === utils_1.AST_NODE_TYPES.CallExpression) { + // If the outer expression is a call, a `.catch()` or `.then()` with + // rejection handler handles the promise. + const promiseHandlingMethodCall = (0, promiseUtils_1.parseCatchCall)(node, context) ?? (0, promiseUtils_1.parseThenCall)(node, context); + if (promiseHandlingMethodCall != null) { + const onRejected = promiseHandlingMethodCall.onRejected; + if (onRejected != null) { + if (isValidRejectionHandler(onRejected)) { + return { isUnhandled: false }; + } + return { isUnhandled: true, nonFunctionHandler: true }; + } + return { isUnhandled: true }; + } + const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context); + if (promiseFinallyCall != null) { + return isUnhandledPromise(checker, promiseFinallyCall.object); + } + // All other cases are unhandled. + return { isUnhandled: true }; + } + if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) { + // We must be getting the promise-like value from one of the branches of the + // ternary. Check them directly. + const alternateResult = isUnhandledPromise(checker, node.alternate); + if (alternateResult.isUnhandled) { + return alternateResult; + } + return isUnhandledPromise(checker, node.consequent); + } + if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + const leftResult = isUnhandledPromise(checker, node.left); + if (leftResult.isUnhandled) { + return leftResult; + } + return isUnhandledPromise(checker, node.right); + } + // Anything else is unhandled. + return { isUnhandled: true }; + } + function isPromiseArray(node) { + const type = getTypeAtLocation(checker, node); + if (type == null) { + return false; + } + for (const ty of tsutils + .unionConstituents(type) + .map(t => checker.getApparentType(t))) { + if (checker.isArrayType(ty)) { + const arrayType = checker.getTypeArguments(ty)[0]; + if (isPromiseLike(node, arrayType)) { + return true; + } + } + if (checker.isTupleType(ty)) { + for (const tupleElementType of checker.getTypeArguments(ty)) { + if (isPromiseLike(node, tupleElementType)) { + return true; + } + } + } + } + return false; + } + function isPromiseLike(node, type) { + type ??= checker.getTypeAtLocation(node); + // The highest priority is to allow anything allowlisted + if ((0, util_1.typeMatchesSomeSpecifier)(type, allowForKnownSafePromises, services.program)) { + return false; + } + // Otherwise, we always consider the built-in Promise to be Promise-like... + const typeParts = tsutils.unionConstituents(checker.getApparentType(type)); + if (typeParts.some(typePart => (0, util_1.isBuiltinSymbolLike)(services.program, typePart, 'Promise'))) { + return true; + } + // ...and only check all Thenables if explicitly told to + if (!checkThenables) { + return false; + } + // Modified from tsutils.isThenable() to only consider thenables which can be + // rejected/caught via a second parameter. Original source (MIT licensed): + // + // https://github.com/ajafff/tsutils/blob/49d0d31050b44b81e918eae4fbaf1dfe7b7286af/util/type.ts#L95-L125 + for (const ty of typeParts) { + const then = ty.getProperty('then'); + if (then == null) { + continue; + } + const thenType = checker.getTypeOfSymbolAtLocation(then, node); + if (hasMatchingSignature(thenType, signature => signature.parameters.length >= 2 && + isFunctionParam(checker, signature.parameters[0], node) && + isFunctionParam(checker, signature.parameters[1], node))) { + return true; + } + } + return false; + } + }, +}); +function hasMatchingSignature(type, matcher) { + for (const t of tsutils.unionConstituents(type)) { + if (t.getCallSignatures().some(matcher)) { + return true; + } + } + return false; +} +function isFunctionParam(checker, param, node) { + const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node)); + for (const t of tsutils.unionConstituents(type)) { + if (t.getCallSignatures().length !== 0) { + return true; + } + } + return false; +} +function getTypeAtLocation(checker, node) { + try { + return checker.getTypeAtLocation(node); + } + catch { + // Workaround for https://github.com/typescript-eslint/typescript-eslint/issues/11947 + return null; + } +} +//# sourceMappingURL=no-floating-promises.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.d.ts new file mode 100644 index 00000000..765fa86f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.js new file mode 100644 index 00000000..4c50f36d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-for-in-array.js @@ -0,0 +1,87 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getForStatementHeadLoc_1 = require("../util/getForStatementHeadLoc"); +exports.default = (0, util_1.createRule)({ + name: 'no-for-in-array', + meta: { + type: 'problem', + docs: { + description: 'Disallow iterating over an array with a for-in loop', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + forInViolation: 'For-in loops over arrays skips holes, returns indices as strings, and may visit the prototype chain or other enumerable properties. Use a more robust iteration method such as for-of or array.forEach instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + ForInStatement(node) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.right); + if (isArrayLike(checker, type)) { + context.report({ + loc: (0, getForStatementHeadLoc_1.getForStatementHeadLoc)(context.sourceCode, node), + messageId: 'forInViolation', + }); + } + }, + }; + }, +}); +function isArrayLike(checker, type) { + return isTypeRecurser(type, t => t.getNumberIndexType() != null && hasArrayishLength(checker, t)); +} +function hasArrayishLength(checker, type) { + const lengthProperty = type.getProperty('length'); + if (lengthProperty == null) { + return false; + } + return tsutils.isTypeFlagSet(checker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike); +} +function isTypeRecurser(type, predicate) { + if (type.isUnionOrIntersection()) { + return type.types.some(t => isTypeRecurser(t, predicate)); + } + return predicate(type); +} +//# sourceMappingURL=no-for-in-array.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.d.ts new file mode 100644 index 00000000..51c2ac7f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noGeneratedEmptyObjectType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.js new file mode 100644 index 00000000..9bf74939 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-generated-empty-object-type.js @@ -0,0 +1,96 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-generated-empty-object-type', + meta: { + type: 'problem', + docs: { + description: 'Disallow type operations that resolve to the "empty object" type', + recommended: 'strict', + requiresTypeChecking: true, + }, + messages: { + noGeneratedEmptyObjectType: 'This type resolves to `{}`, the empty object type. This was likely not intentional.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function isEmptyObjectType(type) { + return (tsutils.isObjectType(type) && + !tsutils.isObjectFlagSet(type, ts.ObjectFlags.Class | ts.ObjectFlags.Interface) && + checker.getPropertiesOfType(type).length === 0 && + checker.getIndexInfosOfType(type).length === 0 && + type.getCallSignatures().length === 0 && + type.getConstructSignatures().length === 0 && + // Types still awaiting type arguments, such as `Record` + // inside a generic declaration, also have no members yet. Every + // primitive is assignable to `{}`, so probing with more than one of + // them rules those out: a mapped type whose keys are not resolved yet, + // such as `{ [K in Keys]: K }`, accepts `number` but not `string`. + checker.isTypeAssignableTo(checker.getNumberType(), type) && + checker.isTypeAssignableTo(checker.getStringType(), type)); + } + function containsEmptyObjectType(type) { + return (isEmptyObjectType(type) || + (type.isUnion() && type.types.some(isEmptyObjectType))); + } + function checkNode(node) { + if (containsEmptyObjectType(services.getTypeAtLocation(node))) { + context.report({ + node, + messageId: 'noGeneratedEmptyObjectType', + }); + } + } + return { + TSIntersectionType: checkNode, + TSTypeReference(node) { + if (node.typeArguments && + node.parent.type !== utils_1.AST_NODE_TYPES.TSIntersectionType) { + checkNode(node); + } + }, + }; + }, +}); +//# sourceMappingURL=no-generated-empty-object-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.d.ts new file mode 100644 index 00000000..7c7d5b75 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.js new file mode 100644 index 00000000..2bd389ae --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-implied-eval.js @@ -0,0 +1,153 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const FUNCTION_CONSTRUCTOR = 'Function'; +const GLOBAL_CANDIDATES = new Set(['global', 'globalThis', 'window']); +const EVAL_LIKE_FUNCTIONS = new Set([ + 'execScript', + 'setImmediate', + 'setInterval', + 'setTimeout', +]); +exports.default = (0, util_1.createRule)({ + name: 'no-implied-eval', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow the use of `eval()`-like functions', + extendsBaseRule: true, + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + noFunctionConstructor: 'Implied eval. Do not use the Function constructor to create functions.', + noImpliedEvalError: 'Implied eval. Consider passing a function.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function getCalleeName(node) { + if (node.type === utils_1.AST_NODE_TYPES.Identifier) { + return node.name; + } + if (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.object.type === utils_1.AST_NODE_TYPES.Identifier && + GLOBAL_CANDIDATES.has(node.object.name)) { + if (node.property.type === utils_1.AST_NODE_TYPES.Identifier) { + return node.property.name; + } + if (node.property.type === utils_1.AST_NODE_TYPES.Literal && + typeof node.property.value === 'string') { + return node.property.value; + } + } + return null; + } + function isFunctionType(node) { + const type = services.getTypeAtLocation(node); + const symbol = type.getSymbol(); + if (symbol && + tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Function | ts.SymbolFlags.Method)) { + return true; + } + if ((0, util_1.isBuiltinSymbolLike)(services.program, type, FUNCTION_CONSTRUCTOR)) { + return true; + } + const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call); + return signatures.length > 0; + } + function isBind(node) { + return node.type === utils_1.AST_NODE_TYPES.MemberExpression + ? isBind(node.property) + : node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'bind'; + } + function isFunction(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + case utils_1.AST_NODE_TYPES.FunctionExpression: + return true; + case utils_1.AST_NODE_TYPES.Literal: + case utils_1.AST_NODE_TYPES.TemplateLiteral: + return false; + case utils_1.AST_NODE_TYPES.CallExpression: + return isBind(node.callee) || isFunctionType(node); + default: + return isFunctionType(node); + } + } + function checkImpliedEval(node) { + const calleeName = getCalleeName(node.callee); + if (calleeName == null) { + return; + } + if (calleeName === FUNCTION_CONSTRUCTOR) { + const type = services.getTypeAtLocation(node.callee); + const symbol = type.getSymbol(); + if (symbol) { + if ((0, util_1.isBuiltinSymbolLike)(services.program, type, 'FunctionConstructor')) { + context.report({ node, messageId: 'noFunctionConstructor' }); + return; + } + } + else { + context.report({ node, messageId: 'noFunctionConstructor' }); + return; + } + } + if (node.arguments.length === 0) { + return; + } + const [handler] = node.arguments; + if (EVAL_LIKE_FUNCTIONS.has(calleeName) && + !isFunction(handler) && + (0, util_1.isReferenceToGlobalFunction)(calleeName, node, context.sourceCode)) { + context.report({ node: handler, messageId: 'noImpliedEvalError' }); + } + } + return { + CallExpression: checkImpliedEval, + NewExpression: checkImpliedEval, + }; + }, +}); +//# sourceMappingURL=no-implied-eval.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.d.ts new file mode 100644 index 00000000..b2070563 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.d.ts @@ -0,0 +1,7 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = []; +export type MessageIds = 'useTopLevelQualifier'; +declare const _default: TSESLint.RuleModule<"useTopLevelQualifier", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.js new file mode 100644 index 00000000..b6d6724a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-import-type-side-effects.js @@ -0,0 +1,54 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-import-type-side-effects', + meta: { + type: 'problem', + docs: { + description: 'Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers', + }, + fixable: 'code', + messages: { + useTopLevelQualifier: 'TypeScript will only remove the inline type specifiers which will leave behind a side effect import at runtime. Convert this to a top-level type qualifier to properly remove the entire import.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + 'ImportDeclaration[importKind!="type"]'(node) { + if (node.specifiers.length === 0) { + return; + } + const specifiers = []; + for (const specifier of node.specifiers) { + if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier || + specifier.importKind !== 'type') { + return; + } + specifiers.push(specifier); + } + context.report({ + node, + messageId: 'useTopLevelQualifier', + fix(fixer) { + const fixes = []; + for (const specifier of specifiers) { + const qualifier = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(specifier, util_1.isTypeKeyword), util_1.NullThrowsReasons.MissingToken('type keyword', 'import specifier')); + fixes.push(fixer.removeRange([ + qualifier.range[0], + specifier.imported.range[0], + ])); + } + const importKeyword = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node, util_1.isImportKeyword), util_1.NullThrowsReasons.MissingToken('import keyword', 'import')); + fixes.push(fixer.insertTextAfter(importKeyword, ' type')); + return fixes; + }, + }); + }, + }; + }, +}); +//# sourceMappingURL=no-import-type-side-effects.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.d.ts new file mode 100644 index 00000000..1fda422f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + ignoreParameters?: boolean; + ignoreProperties?: boolean; + } +]; +export type MessageIds = 'noInferrableType'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.js new file mode 100644 index 00000000..ee541146 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.js @@ -0,0 +1,183 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-inferrable-types', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + noInferrableType: 'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreParameters: { + type: 'boolean', + description: 'Whether to ignore function parameters.', + }, + ignoreProperties: { + type: 'boolean', + description: 'Whether to ignore class properties.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreParameters: false, + ignoreProperties: false, + }, + ], + create(context, [{ ignoreParameters, ignoreProperties }]) { + function isFunctionCall(init, callName) { + const node = (0, util_1.skipChainExpression)(init); + return (node.type === utils_1.AST_NODE_TYPES.CallExpression && + node.callee.type === utils_1.AST_NODE_TYPES.Identifier && + node.callee.name === callName); + } + function isLiteral(init, typeName) { + return (init.type === utils_1.AST_NODE_TYPES.Literal && typeof init.value === typeName); + } + function isIdentifier(init, ...names) { + return (init.type === utils_1.AST_NODE_TYPES.Identifier && names.includes(init.name)); + } + function hasUnaryPrefix(init, ...operators) { + return (init.type === utils_1.AST_NODE_TYPES.UnaryExpression && + operators.includes(init.operator)); + } + const keywordMap = { + [utils_1.AST_NODE_TYPES.TSBigIntKeyword]: 'bigint', + [utils_1.AST_NODE_TYPES.TSBooleanKeyword]: 'boolean', + [utils_1.AST_NODE_TYPES.TSNullKeyword]: 'null', + [utils_1.AST_NODE_TYPES.TSNumberKeyword]: 'number', + [utils_1.AST_NODE_TYPES.TSStringKeyword]: 'string', + [utils_1.AST_NODE_TYPES.TSSymbolKeyword]: 'symbol', + [utils_1.AST_NODE_TYPES.TSUndefinedKeyword]: 'undefined', + }; + /** + * Returns whether a node has an inferrable value or not + */ + function isInferrable(annotation, init) { + switch (annotation.type) { + case utils_1.AST_NODE_TYPES.TSBigIntKeyword: { + // note that bigint cannot have + prefixed to it + const unwrappedInit = hasUnaryPrefix(init, '-') + ? init.argument + : init; + return (isFunctionCall(unwrappedInit, 'BigInt') || + unwrappedInit.type === utils_1.AST_NODE_TYPES.Literal); + } + case utils_1.AST_NODE_TYPES.TSBooleanKeyword: + return (hasUnaryPrefix(init, '!') || + isFunctionCall(init, 'Boolean') || + isLiteral(init, 'boolean')); + case utils_1.AST_NODE_TYPES.TSNumberKeyword: { + const unwrappedInit = hasUnaryPrefix(init, '+', '-') + ? init.argument + : init; + return (isIdentifier(unwrappedInit, 'Infinity', 'NaN') || + isFunctionCall(unwrappedInit, 'Number') || + isLiteral(unwrappedInit, 'number')); + } + case utils_1.AST_NODE_TYPES.TSNullKeyword: + return init.type === utils_1.AST_NODE_TYPES.Literal && init.value == null; + case utils_1.AST_NODE_TYPES.TSStringKeyword: + return (isFunctionCall(init, 'String') || + isLiteral(init, 'string') || + init.type === utils_1.AST_NODE_TYPES.TemplateLiteral); + case utils_1.AST_NODE_TYPES.TSSymbolKeyword: + return isFunctionCall(init, 'Symbol'); + case utils_1.AST_NODE_TYPES.TSTypeReference: { + if (annotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + annotation.typeName.name === 'RegExp') { + const isRegExpLiteral = init.type === utils_1.AST_NODE_TYPES.Literal && + init.value instanceof RegExp; + const isRegExpNewCall = init.type === utils_1.AST_NODE_TYPES.NewExpression && + init.callee.type === utils_1.AST_NODE_TYPES.Identifier && + init.callee.name === 'RegExp'; + const isRegExpCall = isFunctionCall(init, 'RegExp'); + return isRegExpLiteral || isRegExpCall || isRegExpNewCall; + } + return false; + } + case utils_1.AST_NODE_TYPES.TSUndefinedKeyword: + return (hasUnaryPrefix(init, 'void') || isIdentifier(init, 'undefined')); + } + return false; + } + /** + * Reports an inferrable type declaration, if any + */ + function reportInferrableType(node, typeNode, initNode) { + if (!typeNode || !initNode) { + return; + } + if (!isInferrable(typeNode.typeAnnotation, initNode)) { + return; + } + const type = typeNode.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference + ? // TODO - if we add more references + 'RegExp' + : keywordMap[typeNode.typeAnnotation.type]; + context.report({ + node, + messageId: 'noInferrableType', + data: { + type, + }, + *fix(fixer) { + if ((node.type === utils_1.AST_NODE_TYPES.AssignmentPattern && + node.left.optional) || + (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition && node.definite)) { + yield fixer.remove((0, util_1.nullThrows)(context.sourceCode.getTokenBefore(typeNode), util_1.NullThrowsReasons.MissingToken('token before', 'type node'))); + } + yield fixer.remove(typeNode); + }, + }); + } + function inferrableVariableVisitor(node) { + reportInferrableType(node, node.id.typeAnnotation, node.init); + } + function inferrableParameterVisitor(node) { + if (ignoreParameters) { + return; + } + node.params.forEach(param => { + if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) { + param = param.parameter; + } + if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + reportInferrableType(param, param.left.typeAnnotation, param.right); + } + }); + } + function inferrablePropertyVisitor(node) { + // We ignore `readonly` because of Microsoft/TypeScript#14416 + // Essentially a readonly property without a type + // will result in its value being the type, leading to + // compile errors if the type is stripped. + if (ignoreProperties || node.readonly || node.optional) { + return; + } + reportInferrableType(node, node.typeAnnotation, node.value); + } + return { + AccessorProperty: inferrablePropertyVisitor, + ArrowFunctionExpression: inferrableParameterVisitor, + FunctionDeclaration: inferrableParameterVisitor, + FunctionExpression: inferrableParameterVisitor, + PropertyDefinition: inferrablePropertyVisitor, + VariableDeclarator: inferrableVariableVisitor, + }; + }, +}); +//# sourceMappingURL=no-inferrable-types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.d.ts new file mode 100644 index 00000000..4defcf8c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.d.ts @@ -0,0 +1,15 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({ + capIsConstructor?: boolean; +} | undefined)?], unknown, { + ThisExpression(node: TSESTree.ThisExpression): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({ + capIsConstructor?: boolean; +} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.js new file mode 100644 index 00000000..63938771 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.js @@ -0,0 +1,76 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-invalid-this'); +const defaultOptions = [{ capIsConstructor: true }]; +exports.default = (0, util_1.createRule)({ + name: 'no-invalid-this', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Disallow `this` keywords outside of classes or class-like objects', + extendsBaseRule: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions, + create(context) { + const rules = baseRule.create(context); + /** + * Since function definitions can be nested we use a stack storing if "this" is valid in the current context. + * + * Example: + * + * function a(this: number) { // valid "this" + * function b() { + * console.log(this); // invalid "this" + * } + * } + * + * When parsing the function declaration of "a" the stack will be: [true] + * When parsing the function declaration of "b" the stack will be: [true, false] + */ + const thisIsValidStack = []; + return { + ...rules, + AccessorProperty() { + thisIsValidStack.push(true); + }, + 'AccessorProperty:exit'() { + thisIsValidStack.pop(); + }, + FunctionDeclaration(node) { + thisIsValidStack.push(node.params.some(param => param.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this')); + }, + 'FunctionDeclaration:exit'() { + thisIsValidStack.pop(); + }, + FunctionExpression(node) { + thisIsValidStack.push(node.params.some(param => param.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this')); + }, + 'FunctionExpression:exit'() { + thisIsValidStack.pop(); + }, + PropertyDefinition() { + thisIsValidStack.push(true); + }, + 'PropertyDefinition:exit'() { + thisIsValidStack.pop(); + }, + ThisExpression(node) { + const thisIsValidHere = thisIsValidStack[thisIsValidStack.length - 1]; + if (thisIsValidHere) { + return; + } + // baseRule's work + rules.ThisExpression(node); + }, + }; + }, +}); +//# sourceMappingURL=no-invalid-this.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.d.ts new file mode 100644 index 00000000..71aba5a1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.d.ts @@ -0,0 +1,9 @@ +export interface Options { + allowAsThisParameter?: boolean; + allowInGenericTypeArguments?: boolean | [string, ...string[]]; +} +export type MessageIds = 'invalidVoidForGeneric' | 'invalidVoidNotReturn' | 'invalidVoidNotReturnOrGeneric' | 'invalidVoidNotReturnOrThisParam' | 'invalidVoidNotReturnOrThisParamOrGeneric' | 'invalidVoidUnionConstituent'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.js new file mode 100644 index 00000000..ea6f48d7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.js @@ -0,0 +1,211 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-invalid-void-type', + meta: { + type: 'problem', + docs: { + description: 'Disallow `void` type outside of generic or return types', + recommended: 'strict', + }, + messages: { + invalidVoidForGeneric: '{{ generic }} may not have void as a type argument.', + invalidVoidNotReturn: 'void is only valid as a return type.', + invalidVoidNotReturnOrGeneric: 'void is only valid as a return type or generic type argument.', + invalidVoidNotReturnOrThisParam: 'void is only valid as return type or type of `this` parameter.', + invalidVoidNotReturnOrThisParamOrGeneric: 'void is only valid as a return type or generic type argument or the type of a `this` parameter.', + invalidVoidUnionConstituent: 'void is not valid as a constituent in a union type', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowAsThisParameter: { + type: 'boolean', + description: 'Whether a `this` parameter of a function may be `void`.', + }, + allowInGenericTypeArguments: { + description: 'Whether `void` can be used as a valid value for generic type parameters.', + oneOf: [ + { + type: 'boolean', + description: 'Whether `void` can be used as a valid value for all generic type parameters.', + }, + { + type: 'array', + description: 'Allowlist of types that may accept `void` as a generic type parameter.', + items: { type: 'string' }, + minItems: 1, + }, + ], + }, + }, + }, + ], + }, + defaultOptions: [ + { allowAsThisParameter: false, allowInGenericTypeArguments: true }, + ], + create(context, [{ allowAsThisParameter, allowInGenericTypeArguments }]) { + const validParents = [ + utils_1.AST_NODE_TYPES.TSTypeAnnotation, // + ]; + const invalidGrandParents = [ + utils_1.AST_NODE_TYPES.TSPropertySignature, + utils_1.AST_NODE_TYPES.CallExpression, + utils_1.AST_NODE_TYPES.PropertyDefinition, + utils_1.AST_NODE_TYPES.AccessorProperty, + utils_1.AST_NODE_TYPES.Identifier, + ]; + const validUnionMembers = [ + utils_1.AST_NODE_TYPES.TSVoidKeyword, + utils_1.AST_NODE_TYPES.TSNeverKeyword, + ]; + if (allowInGenericTypeArguments === true) { + validParents.push(utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation); + } + /** + * @brief check if the given void keyword is used as a valid generic type + * + * reports if the type parametrized by void is not in the allowlist, or + * allowInGenericTypeArguments is false. + * no-op if the given void keyword is not used as generic type + */ + function checkGenericTypeArgument(node) { + // only matches T<..., void, ...> + // extra check for precaution + /* istanbul ignore next */ + if (node.parent.type !== utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation || + node.parent.parent.type !== utils_1.AST_NODE_TYPES.TSTypeReference) { + return; + } + // check allowlist + if (Array.isArray(allowInGenericTypeArguments)) { + const fullyQualifiedName = context.sourceCode + .getText(node.parent.parent.typeName) + .replaceAll(' ', ''); + if (!allowInGenericTypeArguments + .map(s => s.replaceAll(' ', '')) + .includes(fullyQualifiedName)) { + context.report({ + node, + messageId: 'invalidVoidForGeneric', + data: { generic: fullyQualifiedName }, + }); + } + return; + } + if (!allowInGenericTypeArguments) { + context.report({ + node, + messageId: allowAsThisParameter + ? 'invalidVoidNotReturnOrThisParam' + : 'invalidVoidNotReturn', + }); + } + } + /** + * @brief checks if the generic type parameter defaults to void + */ + function checkDefaultVoid(node, parentNode) { + if (parentNode.default !== node) { + context.report({ + node, + messageId: getNotReturnOrGenericMessageId(node), + }); + } + } + /** + * @brief checks that a union containing void is valid + * @return true if every member of the union is specified as a valid type in + * validUnionMembers, or is a valid generic type parametrized by void + */ + function isValidUnionType(node) { + return node.types.every(member => validUnionMembers.includes(member.type) || + // allows any T<..., void, ...> here, checked by checkGenericTypeArgument + (member.type === utils_1.AST_NODE_TYPES.TSTypeReference && + member.typeArguments?.type === + utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation && + member.typeArguments.params + .map(param => param.type) + .includes(utils_1.AST_NODE_TYPES.TSVoidKeyword))); + } + return { + TSVoidKeyword(node) { + // checks T<..., void, ...> against specification of allowInGenericArguments option + if (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation && + node.parent.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference) { + checkGenericTypeArgument(node); + return; + } + // allow if allowInGenericTypeArguments is specified, and report if the generic type parameter extends void + if (allowInGenericTypeArguments && + node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameter && + node.parent.default?.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) { + checkDefaultVoid(node, node.parent); + return; + } + // union w/ void must contain types from validUnionMembers, or a valid generic void type + if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType && + isValidUnionType(node.parent)) { + return; + } + // using `void` as part of the return type of function overloading implementation + if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) { + const declaringFunction = getParentFunctionDeclarationNode(node.parent); + if (declaringFunction && + (0, util_1.hasOverloadSignatures)(declaringFunction, context)) { + return; + } + } + // this parameter is ok to be void. + if (allowAsThisParameter && + node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation && + node.parent.parent.type === utils_1.AST_NODE_TYPES.Identifier && + node.parent.parent.name === 'this') { + return; + } + // default cases + if (validParents.includes(node.parent.type) && + // https://github.com/typescript-eslint/typescript-eslint/issues/6225 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + !invalidGrandParents.includes(node.parent.parent.type)) { + return; + } + context.report({ + node, + messageId: allowInGenericTypeArguments && allowAsThisParameter + ? 'invalidVoidNotReturnOrThisParamOrGeneric' + : allowInGenericTypeArguments + ? getNotReturnOrGenericMessageId(node) + : allowAsThisParameter + ? 'invalidVoidNotReturnOrThisParam' + : 'invalidVoidNotReturn', + }); + }, + }; + }, +}); +function getNotReturnOrGenericMessageId(node) { + return node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType + ? 'invalidVoidUnionConstituent' + : 'invalidVoidNotReturnOrGeneric'; +} +function getParentFunctionDeclarationNode(node) { + let current = node.parent; + while (current) { + if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) { + return current; + } + if (current.type === utils_1.AST_NODE_TYPES.MethodDefinition && + current.value.body != null) { + return current; + } + current = current.parent; + } + return null; +} +//# sourceMappingURL=no-invalid-void-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.d.ts new file mode 100644 index 00000000..684e2e45 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.d.ts @@ -0,0 +1,13 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: TSESLint.RuleModule<"unsafeRefs", [], unknown, { + ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void; + FunctionDeclaration(node: TSESTree.FunctionDeclaration): void; + FunctionExpression(node: TSESTree.FunctionExpression): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: TSESLint.RuleModule<"unsafeRefs", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.js new file mode 100644 index 00000000..9f8663b1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.js @@ -0,0 +1,202 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-loop-func'); +const CONSTANT_BINDINGS = new Set(['await using', 'const', 'using']); +exports.default = (0, util_1.createRule)({ + name: 'no-loop-func', + meta: { + type: 'suggestion', + // defaultOptions, -- base rule does not use defaultOptions + deprecated: { + deprecatedSince: '8.64.0', + replacedBy: [ + { + rule: { + name: 'no-loop-func', + url: 'https://eslint.org/docs/latest/rules/no-loop-func', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/issues/12496', + }, + docs: { + description: 'Disallow function declarations that contain unsafe references inside loop statements', + extendsBaseRule: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: [], + }, + defaultOptions: [], + create(context) { + const SKIPPED_IIFE_NODES = new Set(); + /** + * Gets the containing loop node of a specified node. + * + * We don't need to check nested functions, so this ignores those. + * `Scope.through` contains references of nested functions. + * + * @param node An AST node to get. + * @returns The containing loop node of the specified node, or `null`. + */ + function getContainingLoopNode(node) { + for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) { + const parent = currentNode.parent; + switch (parent.type) { + case utils_1.AST_NODE_TYPES.WhileStatement: + case utils_1.AST_NODE_TYPES.DoWhileStatement: + return parent; + case utils_1.AST_NODE_TYPES.ForStatement: + // `init` is outside of the loop. + if (parent.init !== currentNode) { + return parent; + } + break; + case utils_1.AST_NODE_TYPES.ForInStatement: + case utils_1.AST_NODE_TYPES.ForOfStatement: + // `right` is outside of the loop. + if (parent.right !== currentNode) { + return parent; + } + break; + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + // We don't need to check nested functions. + // We need to check nested functions only in case of IIFE. + if (SKIPPED_IIFE_NODES.has(parent)) { + break; + } + return null; + default: + break; + } + } + return null; + } + /** + * Gets the containing loop node of a given node. + * If the loop was nested, this returns the most outer loop. + * @param node A node to get. This is a loop node. + * @param excludedNode A node that the result node should not include. + * @returns The most outer loop node. + */ + function getTopLoopNode(node, excludedNode) { + const border = excludedNode ? excludedNode.range[1] : 0; + let retv = node; + let containingLoopNode = node; + while (containingLoopNode && containingLoopNode.range[0] >= border) { + retv = containingLoopNode; + containingLoopNode = getContainingLoopNode(containingLoopNode); + } + return retv; + } + /** + * Checks whether a given reference which refers to an upper scope's variable is + * safe or not. + * @param loopNode A containing loop node. + * @param reference A reference to check. + * @returns `true` if the reference is safe or not. + */ + function isSafe(loopNode, reference) { + const variable = reference.resolved; + const definition = variable?.defs[0]; + const declaration = definition?.parent; + const kind = declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration + ? declaration.kind + : ''; + // type references are all safe + // this only really matters for global types that haven't been configured + if (reference.isTypeReference) { + return true; + } + // Variables which are declared by `const`, `using`, or `await using` are + // safe. They can't be reassigned, so each iteration captures a fresh one. + if (CONSTANT_BINDINGS.has(kind)) { + return true; + } + /* + * Variables which are declared by `let` in the loop is safe. + * It's a different instance from the next loop step's. + */ + if (kind === 'let' && + declaration && + declaration.range[0] > loopNode.range[0] && + declaration.range[1] < loopNode.range[1]) { + return true; + } + /* + * WriteReferences which exist after this border are unsafe because those + * can modify the variable. + */ + const border = getTopLoopNode(loopNode, kind === 'let' ? declaration : null).range[0]; + /** + * Checks whether a given reference is safe or not. + * The reference is every reference of the upper scope's variable we are + * looking now. + * + * It's safe if the reference matches one of the following condition. + * - is readonly. + * - doesn't exist inside a local function and after the border. + * + * @param upperRef A reference to check. + * @returns `true` if the reference is safe. + */ + function isSafeReference(upperRef) { + const id = upperRef.identifier; + return (!upperRef.isWrite() || + (variable?.scope.variableScope === upperRef.from.variableScope && + id.range[0] < border)); + } + return variable?.references.every(isSafeReference) ?? false; + } + /** + * Reports functions which match the following condition: + * - has a loop node in ancestors. + * - has any references which refers to an unsafe variable. + * + * @param node The AST node to check. + */ + function checkForLoops(node) { + const loopNode = getContainingLoopNode(node); + if (!loopNode) { + return; + } + const references = context.sourceCode.getScope(node).through; + if (!(node.async || node.generator) && isIIFE(node)) { + const isFunctionExpression = node.type === utils_1.AST_NODE_TYPES.FunctionExpression; + // Check if the function is referenced elsewhere in the code + const isFunctionReferenced = isFunctionExpression && node.id + ? references.some(r => r.identifier.name === node.id?.name) + : false; + if (!isFunctionReferenced) { + SKIPPED_IIFE_NODES.add(node); + return; + } + } + const unsafeRefs = references + .filter(r => r.resolved && !isSafe(loopNode, r)) + .map(r => r.identifier.name); + if (unsafeRefs.length > 0) { + context.report({ + node, + messageId: 'unsafeRefs', + data: { varNames: `'${unsafeRefs.join("', '")}'` }, + }); + } + } + return { + ArrowFunctionExpression: checkForLoops, + FunctionDeclaration: checkForLoops, + FunctionExpression: checkForLoops, + }; + }, +}); +function isIIFE(node) { + return (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression && + node.parent.callee === node); +} +//# sourceMappingURL=no-loop-func.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.d.ts new file mode 100644 index 00000000..68625b4a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.d.ts @@ -0,0 +1,9 @@ +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +import { getESLintCoreRule } from '../util/getESLintCoreRule'; +declare const baseRule: ReturnType; +export type Options = InferOptionsTypeFromRule>; +export type MessageIds = InferMessageIdsTypeFromRule>; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.js new file mode 100644 index 00000000..51bc846d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.js @@ -0,0 +1,36 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-loss-of-precision'); +exports.default = (0, util_1.createRule)({ + name: 'no-loss-of-precision', + meta: { + type: 'problem', + // defaultOptions, -- base rule does not use defaultOptions + deprecated: { + deprecatedSince: '8.0.0', + replacedBy: [ + { + rule: { + name: 'no-loss-of-precision', + url: 'https://eslint.org/docs/latest/rules/no-loss-of-precision', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/8832', + }, + docs: { + description: 'Disallow literal numbers that lose precision', + extendsBaseRule: true, + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: [], + }, + defaultOptions: [], + create(context) { + return baseRule.create(context); + }, +}); +//# sourceMappingURL=no-loss-of-precision.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.d.ts new file mode 100644 index 00000000..4296ba0d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.d.ts @@ -0,0 +1,29 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{ + detectObjects?: boolean; + enforceConst?: boolean; + ignore?: (number | string)[]; + ignoreArrayIndexes?: boolean; + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; + ignoreTypeIndexes?: boolean; +}], unknown, { + Literal(node: TSESTree.Literal): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{ + detectObjects?: boolean; + enforceConst?: boolean; + ignore?: (number | string)[]; + ignoreArrayIndexes?: boolean; + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; + ignoreTypeIndexes?: boolean; +}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.js new file mode 100644 index 00000000..c13f1f0c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.js @@ -0,0 +1,250 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-magic-numbers'); +// Extend base schema with additional property to ignore TS numeric literal types +const schema = (0, util_1.deepMerge)( +// eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- https://github.com/microsoft/TypeScript/issues/17002 +Array.isArray(baseRule.meta.schema) + ? baseRule.meta.schema[0] + : baseRule.meta.schema, { + properties: { + ignoreEnums: { + type: 'boolean', + description: 'Whether enums used in TypeScript are considered okay.', + }, + ignoreNumericLiteralTypes: { + type: 'boolean', + description: 'Whether numbers used in TypeScript numeric literal types are considered okay.', + }, + ignoreReadonlyClassProperties: { + type: 'boolean', + description: 'Whether `readonly` class properties are considered okay.', + }, + ignoreTypeIndexes: { + type: 'boolean', + description: 'Whether numbers used to index types are okay.', + }, + }, +}); +const defaultOptions = [ + { + detectObjects: false, + enforceConst: false, + ignore: [], + ignoreArrayIndexes: false, + ignoreEnums: false, + ignoreNumericLiteralTypes: false, + ignoreReadonlyClassProperties: false, + ignoreTypeIndexes: false, + }, +]; +exports.default = (0, util_1.createRule)({ + name: 'no-magic-numbers', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Disallow magic numbers', + extendsBaseRule: true, + frozen: true, + }, + messages: baseRule.meta.messages, + schema: [schema], + }, + defaultOptions, + create(context, [options]) { + const rules = baseRule.create(context); + const ignored = new Set((options.ignore ?? []).map(normalizeIgnoreValue)); + return { + Literal(node) { + // If it’s not a numeric literal we’re not interested + if (typeof node.value !== 'number' && typeof node.value !== 'bigint') { + return; + } + // This will be `true` if we’re configured to ignore this case (eg. it’s + // an enum and `ignoreEnums` is `true`). It will be `false` if we’re not + // configured to ignore this case. It will remain `undefined` if this is + // not one of our exception cases, and we’ll fall back to the base rule. + let isAllowed; + // Check if the node is ignored + if (ignored.has(normalizeLiteralValue(node, node.value))) { + isAllowed = true; + } + // Check if the node is a TypeScript enum declaration + else if (isParentTSEnumDeclaration(node)) { + isAllowed = options.ignoreEnums === true; + } + // Check TypeScript specific nodes for Numeric Literal + else if (isTSNumericLiteralType(node)) { + isAllowed = options.ignoreNumericLiteralTypes === true; + } + // Check if the node is a type index + else if (isAncestorTSIndexedAccessType(node)) { + isAllowed = options.ignoreTypeIndexes === true; + } + // Check if the node is a readonly class property + else if (isParentTSReadonlyPropertyDefinition(node)) { + isAllowed = options.ignoreReadonlyClassProperties === true; + } + // If we’ve hit a case where the ignore option is true we can return now + if (isAllowed === true) { + return; + } + // If the ignore option is *not* set we can report it now + if (isAllowed === false) { + let fullNumberNode = node; + let raw = node.raw; + if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + // the base rule only shows the operator for negative numbers + // https://github.com/eslint/eslint/blob/9dfc8501fb1956c90dc11e6377b4cb38a6bea65d/lib/rules/no-magic-numbers.js#L126 + node.parent.operator === '-') { + fullNumberNode = node.parent; + raw = `${node.parent.operator}${node.raw}`; + } + context.report({ + node: fullNumberNode, + messageId: 'noMagic', + data: { raw }, + }); + return; + } + // Let the base rule deal with the rest + rules.Literal(node); + }, + }; + }, +}); +/** + * Convert the value to bigint if it's a string. Otherwise, return the value as-is. + * @param value The value to normalize. + * @returns The normalized value. + */ +function normalizeIgnoreValue(value) { + if (typeof value === 'string') { + return BigInt(value.slice(0, -1)); + } + return value; +} +/** + * Converts the node to its numeric value, handling prefixed numbers (-1 / +1) + * @param node the node to normalize. + * @param value the node's value. + */ +function normalizeLiteralValue(node, value) { + if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + ['-', '+'].includes(node.parent.operator) && + node.parent.operator === '-') { + return -value; + } + return value; +} +/** + * Gets the true parent of the literal, handling prefixed numbers (-1 / +1) + */ +function getLiteralParent(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + ['-', '+'].includes(node.parent.operator)) { + return node.parent.parent; + } + return node.parent; +} +/** + * Checks if the node grandparent is a Typescript type alias declaration + * @param node the node to be validated. + * @returns true if the node grandparent is a Typescript type alias declaration + * @private + */ +function isGrandparentTSTypeAliasDeclaration(node) { + return node.parent?.parent?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration; +} +/** + * Checks if the node grandparent is a Typescript union type and its parent is a type alias declaration + * @param node the node to be validated. + * @returns true if the node grandparent is a Typescript union type and its parent is a type alias declaration + * @private + */ +function isGrandparentTSUnionType(node) { + if (node.parent?.parent?.type === utils_1.AST_NODE_TYPES.TSUnionType) { + return isGrandparentTSTypeAliasDeclaration(node.parent); + } + return false; +} +/** + * Checks if the node parent is a Typescript enum member + * @param node the node to be validated. + * @returns true if the node parent is a Typescript enum member + * @private + */ +function isParentTSEnumDeclaration(node) { + const parent = getLiteralParent(node); + return parent?.type === utils_1.AST_NODE_TYPES.TSEnumMember; +} +/** + * Checks if the node parent is a Typescript literal type + * @param node the node to be validated. + * @returns true if the node parent is a Typescript literal type + * @private + */ +function isParentTSLiteralType(node) { + return node.parent?.type === utils_1.AST_NODE_TYPES.TSLiteralType; +} +/** + * Checks if the node is a valid TypeScript numeric literal type. + * @param node the node to be validated. + * @returns true if the node is a TypeScript numeric literal type. + * @private + */ +function isTSNumericLiteralType(node) { + // For negative numbers, use the parent node + if (node.parent?.type === utils_1.AST_NODE_TYPES.UnaryExpression && + node.parent.operator === '-') { + node = node.parent; + } + // If the parent node is not a TSLiteralType, early return + if (!isParentTSLiteralType(node)) { + return false; + } + // If the grandparent is a TSTypeAliasDeclaration, ignore + if (isGrandparentTSTypeAliasDeclaration(node)) { + return true; + } + // If the grandparent is a TSUnionType and it's parent is a TSTypeAliasDeclaration, ignore + if (isGrandparentTSUnionType(node)) { + return true; + } + return false; +} +/** + * Checks if the node parent is a readonly class property + * @param node the node to be validated. + * @returns true if the node parent is a readonly class property + * @private + */ +function isParentTSReadonlyPropertyDefinition(node) { + const parent = getLiteralParent(node); + if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition && parent.readonly) { + return true; + } + return false; +} +/** + * Checks if the node is part of a type indexed access (eg. Foo[4]) + * @param node the node to be validated. + * @returns true if the node is part of an indexed access + * @private + */ +function isAncestorTSIndexedAccessType(node) { + // Handle unary expressions (eg. -4) + let ancestor = getLiteralParent(node); + // Go up another level while we’re part of a type union (eg. 1 | 2) or + // intersection (eg. 1 & 2) + while (ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSUnionType || + ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSIntersectionType) { + ancestor = ancestor.parent; + } + return ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSIndexedAccessType; +} +//# sourceMappingURL=no-magic-numbers.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.d.ts new file mode 100644 index 00000000..0fa93a43 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.d.ts @@ -0,0 +1,10 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + checkNever: boolean; + } +]; +declare const _default: TSESLint.RuleModule<"meaninglessVoidOnNonCall" | "meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js new file mode 100644 index 00000000..0d3f2b5b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js @@ -0,0 +1,149 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-meaningless-void-operator', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow the `void` operator except when used to discard a value', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + hasSuggestions: true, + messages: { + meaninglessVoidOnNonCall: "void operator is useless here; it should only discard a call's return value", + meaninglessVoidOperator: "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored", + removeVoid: "Remove 'void'", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + checkNever: { + type: 'boolean', + description: "Whether to suggest removing `void` when a call's return type is `never`.", + }, + }, + }, + ], + }, + defaultOptions: [{ checkNever: false }], + create(context, [{ checkNever }]) { + const services = utils_1.ESLintUtils.getParserServices(context); + const checker = services.program.getTypeChecker(); + return { + 'UnaryExpression[operator="void"]'(node) { + const fix = (fixer) => { + return fixer.removeRange([ + context.sourceCode.getTokens(node)[0].range[0], + context.sourceCode.getTokens(node)[1].range[0], + ]); + }; + const inner = unwrapVoidArgument(node.argument); + if (inner.type !== utils_1.AST_NODE_TYPES.CallExpression) { + // `void 0` is a common undefined idiom, not a discarded call. + if (inner.type === utils_1.AST_NODE_TYPES.Literal && inner.value === 0) { + return; + } + // `void (x = value)` discards the assignment result so the + // expression evaluates to undefined (e.g. `() => void (x = 1)`). + if (inner.type === utils_1.AST_NODE_TYPES.AssignmentExpression) { + return; + } + const tsArgument = services.esTreeNodeToTSNodeMap.get(node.argument); + const argType = services.getTypeAtLocation(node.argument); + // Allow `void promiseValue` so this rule does not fight no-floating-promises. + if (tsutils.isThenableType(checker, tsArgument, argType)) { + return; + } + context.report({ + node, + messageId: 'meaninglessVoidOnNonCall', + fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement + ? fix + : undefined, + }); + return; + } + const argType = services.getTypeAtLocation(node.argument); + const unionParts = tsutils.unionConstituents(argType); + if (unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined))) { + context.report({ + node, + messageId: 'meaninglessVoidOperator', + data: { type: checker.typeToString(argType) }, + fix, + }); + } + else if (checkNever && + unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never))) { + context.report({ + node, + messageId: 'meaninglessVoidOperator', + data: { type: checker.typeToString(argType) }, + suggest: [{ messageId: 'removeVoid', fix }], + }); + } + }, + }; + }, +}); +function unwrapVoidArgument(node) { + let current = node; + while (true) { + switch (current.type) { + case utils_1.AST_NODE_TYPES.ChainExpression: + case utils_1.AST_NODE_TYPES.TSAsExpression: + case utils_1.AST_NODE_TYPES.TSNonNullExpression: + case utils_1.AST_NODE_TYPES.TSSatisfiesExpression: + case utils_1.AST_NODE_TYPES.TSTypeAssertion: + current = current.expression; + continue; + case utils_1.AST_NODE_TYPES.SequenceExpression: + current = (0, util_1.nullThrows)(current.expressions.at(-1), 'Expected SequenceExpression to have at least one expression'); + continue; + default: + return current; + } + } +} +//# sourceMappingURL=no-meaningless-void-operator.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.d.ts new file mode 100644 index 00000000..541f8bf2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.js new file mode 100644 index 00000000..2249331c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.js @@ -0,0 +1,82 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-misused-new', + meta: { + type: 'problem', + docs: { + description: 'Enforce valid definition of `new` and `constructor`', + recommended: 'recommended', + }, + messages: { + errorMessageClass: 'Class cannot have method named `new`.', + errorMessageInterface: 'Interfaces cannot be constructed, only classes.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + /** + * @param node type to be inspected. + * @returns name of simple type or null + */ + function getTypeReferenceName(node) { + if (node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSTypeAnnotation: + return getTypeReferenceName(node.typeAnnotation); + case utils_1.AST_NODE_TYPES.TSTypeReference: + return getTypeReferenceName(node.typeName); + case utils_1.AST_NODE_TYPES.Identifier: + return node.name; + default: + break; + } + } + return null; + } + /** + * @param parent parent node. + * @param returnType type to be compared + */ + function isMatchingParentType(parent, returnType) { + if (parent && + (parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration || + parent.type === utils_1.AST_NODE_TYPES.ClassExpression || + parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) && + parent.id) { + return getTypeReferenceName(returnType) === parent.id.name; + } + return false; + } + return { + "ClassBody > MethodDefinition[key.name='new']"(node) { + if (node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression && + isMatchingParentType(node.parent.parent, node.value.returnType)) { + context.report({ + node, + messageId: 'errorMessageClass', + }); + } + }, + 'TSInterfaceBody > TSConstructSignatureDeclaration'(node) { + if (isMatchingParentType(node.parent.parent, node.returnType)) { + // constructor + context.report({ + node, + messageId: 'errorMessageInterface', + }); + } + }, + "TSMethodSignature[key.name='constructor']"(node) { + context.report({ + node, + messageId: 'errorMessageInterface', + }); + }, + }; + }, +}); +//# sourceMappingURL=no-misused-new.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.d.ts new file mode 100644 index 00000000..f07cc923 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.d.ts @@ -0,0 +1,25 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + checksConditionals?: boolean | ChecksConditionalsOptions; + checksSpreads?: boolean; + checksVoidReturn?: boolean | ChecksVoidReturnOptions; + } +]; +export type FlagUnionsOptions = 'all' | 'none' | 'strict'; +export interface ChecksConditionalsOptions { + flagUnions?: FlagUnionsOptions; +} +export interface ChecksVoidReturnOptions { + arguments?: boolean; + attributes?: boolean; + inheritedMethods?: boolean; + properties?: boolean; + returns?: boolean; + variables?: boolean; +} +export type MessageId = 'conditional' | 'predicate' | 'spread' | 'voidReturnArgument' | 'voidReturnAttribute' | 'voidReturnInheritedMethod' | 'voidReturnProperty' | 'voidReturnReturnValue' | 'voidReturnVariable'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js new file mode 100644 index 00000000..6f967be6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js @@ -0,0 +1,868 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const promiseUtils_1 = require("../util/promiseUtils"); +function parseChecksVoidReturn(checksVoidReturn) { + switch (checksVoidReturn) { + case false: + return false; + case true: + case undefined: + return { + arguments: true, + attributes: true, + inheritedMethods: true, + properties: true, + returns: true, + variables: true, + }; + default: + return { + arguments: checksVoidReturn.arguments ?? true, + attributes: checksVoidReturn.attributes ?? true, + inheritedMethods: checksVoidReturn.inheritedMethods ?? true, + properties: checksVoidReturn.properties ?? true, + returns: checksVoidReturn.returns ?? true, + variables: checksVoidReturn.variables ?? true, + }; + } +} +exports.default = (0, util_1.createRule)({ + name: 'no-misused-promises', + meta: { + type: 'problem', + docs: { + description: 'Disallow Promises in places not designed to handle them', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + conditional: 'Expected non-Promise value in a boolean conditional.', + predicate: 'Expected a non-Promise value to be returned.', + spread: 'Expected a non-Promise value to be spread in an object.', + voidReturnArgument: 'Promise returned in function argument where a void return was expected.', + voidReturnAttribute: 'Promise-returning function provided to attribute where a void return was expected.', + voidReturnInheritedMethod: "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.", + voidReturnProperty: 'Promise-returning function provided to property where a void return was expected.', + voidReturnReturnValue: 'Promise-returning function provided to return value where a void return was expected.', + voidReturnVariable: 'Promise-returning function provided to variable where a void return was expected.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + checksConditionals: { + description: 'Whether to warn when a Promise is provided to conditional statements.', + oneOf: [ + { + type: 'boolean', + description: 'Whether to check conditionals.', + }, + { + type: 'object', + additionalProperties: false, + description: 'Detailed settings for conditional inspection.', + properties: { + flagUnions: { + type: 'string', + description: 'Configures how union types containing Promise-like types are checked.', + enum: ['all', 'strict', 'none'], + }, + }, + }, + ], + }, + checksSpreads: { + type: 'boolean', + description: 'Whether to warn when `...` spreading a `Promise`.', + }, + checksVoidReturn: { + description: 'Whether to warn when a Promise is returned from a function typed as returning `void`.', + oneOf: [ + { + type: 'boolean', + description: 'Whether to disable checking all asynchronous functions.', + }, + { + type: 'object', + additionalProperties: false, + description: 'Which forms of functions may have checking disabled.', + properties: { + arguments: { + type: 'boolean', + description: 'Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns `void`.', + }, + attributes: { + type: 'boolean', + description: 'Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns `void`.', + }, + inheritedMethods: { + type: 'boolean', + description: 'Disables checking an asynchronous method in a type that extends or implements another type expecting that method to return `void`.', + }, + properties: { + type: 'boolean', + description: 'Disables checking an asynchronous function passed as an object property expected to be a function that returns `void`.', + }, + returns: { + type: 'boolean', + description: 'Disables checking an asynchronous function returned in a function whose return type is a function that returns `void`.', + }, + variables: { + type: 'boolean', + description: 'Disables checking an asynchronous function used as a variable whose return type is a function that returns `void`.', + }, + }, + }, + ], + }, + }, + }, + ], + }, + defaultOptions: [ + { + checksConditionals: true, + checksSpreads: true, + checksVoidReturn: true, + }, + ], + create(context, [{ checksConditionals, checksSpreads, checksVoidReturn }]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const checkedNodes = new Set(); + const flagUnionsOption = normalizeFlagUnionsOption(checksConditionals); + const conditionalChecks = { + 'CallExpression > MemberExpression': checkArrayPredicates, + ConditionalExpression: checkTestConditional, + DoWhileStatement: checkTestConditional, + ForStatement: checkTestConditional, + IfStatement: checkTestConditional, + LogicalExpression: checkConditional, + 'UnaryExpression[operator="!"]'(node) { + checkConditional(node.argument, true); + }, + WhileStatement: checkTestConditional, + }; + checksVoidReturn = parseChecksVoidReturn(checksVoidReturn); + const voidReturnChecks = checksVoidReturn + ? { + ...(checksVoidReturn.arguments && { + CallExpression: checkArguments, + NewExpression: checkArguments, + }), + ...(checksVoidReturn.attributes && { + JSXAttribute: checkJSXAttribute, + }), + ...(checksVoidReturn.inheritedMethods && { + ClassDeclaration: checkClassLikeOrInterfaceNode, + ClassExpression: checkClassLikeOrInterfaceNode, + TSInterfaceDeclaration: checkClassLikeOrInterfaceNode, + }), + ...(checksVoidReturn.properties && { + Property: checkProperty, + }), + ...(checksVoidReturn.returns && { + ReturnStatement: checkReturnStatement, + }), + ...(checksVoidReturn.variables && { + AssignmentExpression: checkAssignment, + VariableDeclarator: checkVariableDeclaration, + }), + } + : {}; + const spreadChecks = { + SpreadElement: checkSpread, + }; + /** + * A syntactic check to see if an annotated type is maybe a function type. + * This is a perf optimization to help avoid requesting types where possible + */ + function isPossiblyFunctionType(node) { + switch (node.typeAnnotation.type) { + case utils_1.AST_NODE_TYPES.TSConditionalType: + case utils_1.AST_NODE_TYPES.TSConstructorType: + case utils_1.AST_NODE_TYPES.TSFunctionType: + case utils_1.AST_NODE_TYPES.TSImportType: + case utils_1.AST_NODE_TYPES.TSIndexedAccessType: + case utils_1.AST_NODE_TYPES.TSInferType: + case utils_1.AST_NODE_TYPES.TSIntersectionType: + case utils_1.AST_NODE_TYPES.TSQualifiedName: + case utils_1.AST_NODE_TYPES.TSThisType: + case utils_1.AST_NODE_TYPES.TSTypeOperator: + case utils_1.AST_NODE_TYPES.TSTypeQuery: + case utils_1.AST_NODE_TYPES.TSTypeReference: + case utils_1.AST_NODE_TYPES.TSUnionType: + return true; + case utils_1.AST_NODE_TYPES.TSTypeLiteral: + return node.typeAnnotation.members.some(member => member.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration || + member.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration); + case utils_1.AST_NODE_TYPES.TSAbstractKeyword: + case utils_1.AST_NODE_TYPES.TSAnyKeyword: + case utils_1.AST_NODE_TYPES.TSArrayType: + case utils_1.AST_NODE_TYPES.TSAsyncKeyword: + case utils_1.AST_NODE_TYPES.TSBigIntKeyword: + case utils_1.AST_NODE_TYPES.TSBooleanKeyword: + case utils_1.AST_NODE_TYPES.TSDeclareKeyword: + case utils_1.AST_NODE_TYPES.TSExportKeyword: + case utils_1.AST_NODE_TYPES.TSIntrinsicKeyword: + case utils_1.AST_NODE_TYPES.TSLiteralType: + case utils_1.AST_NODE_TYPES.TSMappedType: + case utils_1.AST_NODE_TYPES.TSNamedTupleMember: + case utils_1.AST_NODE_TYPES.TSNeverKeyword: + case utils_1.AST_NODE_TYPES.TSNullKeyword: + case utils_1.AST_NODE_TYPES.TSNumberKeyword: + case utils_1.AST_NODE_TYPES.TSObjectKeyword: + case utils_1.AST_NODE_TYPES.TSOptionalType: + case utils_1.AST_NODE_TYPES.TSPrivateKeyword: + case utils_1.AST_NODE_TYPES.TSProtectedKeyword: + case utils_1.AST_NODE_TYPES.TSPublicKeyword: + case utils_1.AST_NODE_TYPES.TSReadonlyKeyword: + case utils_1.AST_NODE_TYPES.TSRestType: + case utils_1.AST_NODE_TYPES.TSStaticKeyword: + case utils_1.AST_NODE_TYPES.TSStringKeyword: + case utils_1.AST_NODE_TYPES.TSSymbolKeyword: + case utils_1.AST_NODE_TYPES.TSTemplateLiteralType: + case utils_1.AST_NODE_TYPES.TSTupleType: + case utils_1.AST_NODE_TYPES.TSTypePredicate: + case utils_1.AST_NODE_TYPES.TSUndefinedKeyword: + case utils_1.AST_NODE_TYPES.TSUnknownKeyword: + case utils_1.AST_NODE_TYPES.TSVoidKeyword: + return false; + } + } + function checkTestConditional(node) { + if (node.test) { + checkConditional(node.test, true); + } + } + /** + * This function analyzes the type of a node and checks if it is a Promise in a boolean conditional. + * It uses recursion when checking nested logical operators. + * @param node The AST node to check. + * @param isTestExpr Whether the node is a descendant of a test expression. + */ + function checkConditional(node, isTestExpr = false) { + // prevent checking the same node multiple times + if (checkedNodes.has(node)) { + return; + } + checkedNodes.add(node); + if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + // ignore the left operand for nullish coalescing expressions not in a context of a test expression + if (node.operator !== '??' || isTestExpr) { + checkConditional(node.left, isTestExpr); + } + // we ignore the right operand when not in a context of a test expression + if (isTestExpr) { + checkConditional(node.right, isTestExpr); + } + return; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (isAlwaysThenable(checker, tsNode)) { + context.report({ + node, + messageId: 'conditional', + }); + return; + } + if ( + // none -> Report `Promise` but not `Promise | ...` + (flagUnionsOption === 'none' && isAlwaysThenable(checker, tsNode)) || + // + // all -> Report `Promise` and `Promise | ...` + (flagUnionsOption === 'all' && isSometimesThenable(checker, tsNode)) || + // + // strict -> Report `Promise | T` but not `Promise | NotT` + (flagUnionsOption === 'strict' && + hasMatchingPromiseTypeArgument(checker, tsNode))) { + context.report({ + node, + messageId: 'conditional', + }); + } + } + function checkArrayPredicates(node) { + const parent = node.parent; + if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) { + const callback = parent.arguments.at(0); + if (callback && + (0, util_1.isArrayMethodCallWithPredicate)(context, services, parent)) { + const type = services.esTreeNodeToTSNodeMap.get(callback); + if (returnsThenable(checker, type)) { + context.report({ + node: callback, + messageId: 'predicate', + }); + } + } + } + } + function checkArguments(node) { + if (node.type === utils_1.AST_NODE_TYPES.CallExpression && + isPromiseFinallyMethod(node)) { + return; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + const voidArgs = voidFunctionArguments(checker, tsNode); + if (voidArgs.size === 0) { + return; + } + for (const [index, argument] of node.arguments.entries()) { + if (!voidArgs.has(index)) { + continue; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(argument); + if (returnsThenable(checker, tsNode)) { + context.report({ + node: argument, + messageId: 'voidReturnArgument', + }); + } + } + } + function checkAssignment(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + const varType = services.getTypeAtLocation(node.left); + if (!isVoidReturningFunctionType(checker, tsNode.left, varType)) { + return; + } + if (returnsThenable(checker, tsNode.right)) { + context.report({ + node: node.right, + messageId: 'voidReturnVariable', + }); + } + } + function checkVariableDeclaration(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (tsNode.initializer == null || node.init == null) { + return; + } + if (node.parent.kind === 'using' && + hasWellKnownSymbolWithThenableReturn(checker, tsNode.initializer, checker.getTypeAtLocation(tsNode.initializer), 'dispose')) { + context.report({ + node: node.init, + messageId: 'voidReturnVariable', + }); + } + if (node.id.typeAnnotation == null) { + return; + } + const variableType = services.getTypeAtLocation(node.id); + if (hasWellKnownSymbolWithVoidReturn(checker, tsNode.name, variableType, 'dispose') && + hasWellKnownSymbolWithThenableReturn(checker, tsNode.initializer, checker.getTypeAtLocation(tsNode.initializer), 'dispose')) { + context.report({ + node: node.init, + messageId: 'voidReturnVariable', + }); + } + // syntactically ignore some known-good cases to avoid touching type info + if (!isPossiblyFunctionType(node.id.typeAnnotation)) { + return; + } + const varType = services.getTypeAtLocation(node.id); + if (!isVoidReturningFunctionType(checker, tsNode.initializer, varType)) { + return; + } + if (returnsThenable(checker, tsNode.initializer)) { + context.report({ + node: node.init, + messageId: 'voidReturnVariable', + }); + } + } + function checkProperty(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (ts.isPropertyAssignment(tsNode)) { + const contextualType = checker.getContextualType(tsNode.initializer); + if (contextualType != null && + isVoidReturningFunctionType(checker, tsNode.initializer, contextualType) && + returnsThenable(checker, tsNode.initializer)) { + if ((0, util_1.isFunction)(node.value)) { + const functionNode = node.value; + if (functionNode.returnType) { + context.report({ + node: functionNode.returnType.typeAnnotation, + messageId: 'voidReturnProperty', + }); + } + else { + context.report({ + loc: (0, util_1.getFunctionHeadLoc)(functionNode, context.sourceCode), + messageId: 'voidReturnProperty', + }); + } + } + else { + context.report({ + node: node.value, + messageId: 'voidReturnProperty', + }); + } + } + } + else if (ts.isShorthandPropertyAssignment(tsNode)) { + const contextualType = checker.getContextualType(tsNode.name); + if (contextualType != null && + isVoidReturningFunctionType(checker, tsNode.name, contextualType) && + returnsThenable(checker, tsNode.name)) { + context.report({ + node: node.value, + messageId: 'voidReturnProperty', + }); + } + } + else if (ts.isMethodDeclaration(tsNode)) { + if (ts.isComputedPropertyName(tsNode.name)) { + return; + } + const obj = tsNode.parent; + // Below condition isn't satisfied unless something goes wrong, + // but is needed for type checking. + // 'node' does not include class method declaration so 'obj' is + // always an object literal expression, but after converting 'node' + // to TypeScript AST, its type includes MethodDeclaration which + // does include the case of class method declaration. + if (!ts.isObjectLiteralExpression(obj)) { + return; + } + if (!returnsThenable(checker, tsNode)) { + return; + } + const objType = checker.getContextualType(obj); + if (objType == null) { + return; + } + const propertySymbol = tsutils + .unionConstituents(objType) + .map(t => checker.getPropertyOfType(t, tsNode.name.getText())) + .find(p => p); + if (propertySymbol == null) { + return; + } + const contextualType = checker.getTypeOfSymbolAtLocation(propertySymbol, tsNode.name); + if (isVoidReturningFunctionType(checker, tsNode.name, contextualType)) { + const functionNode = node.value; + if (functionNode.returnType) { + context.report({ + node: functionNode.returnType.typeAnnotation, + messageId: 'voidReturnProperty', + }); + } + else { + context.report({ + loc: (0, util_1.getFunctionHeadLoc)(functionNode, context.sourceCode), + messageId: 'voidReturnProperty', + }); + } + } + return; + } + } + function checkReturnStatement(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (tsNode.expression == null || node.argument == null) { + return; + } + // syntactically ignore some known-good cases to avoid touching type info + const functionNode = (() => { + let current = node.parent; + while (current && !(0, util_1.isFunction)(current)) { + current = current.parent; + } + return (0, util_1.nullThrows)(current, util_1.NullThrowsReasons.MissingParent); + })(); + if (functionNode.returnType && + !isPossiblyFunctionType(functionNode.returnType)) { + return; + } + const contextualType = checker.getContextualType(tsNode.expression); + if (contextualType != null && + isVoidReturningFunctionType(checker, tsNode.expression, contextualType) && + returnsThenable(checker, tsNode.expression)) { + context.report({ + node: node.argument, + messageId: 'voidReturnReturnValue', + }); + } + } + function isPromiseFinallyMethod(node) { + const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context); + return (promiseFinallyCall != null && + (0, util_1.isPromiseLike)(services.program, (0, util_1.getConstrainedTypeAtLocation)(services, promiseFinallyCall.object))); + } + function checkClassLikeOrInterfaceNode(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + const heritageTypes = getHeritageTypes(checker, tsNode); + if (!heritageTypes?.length) { + return; + } + for (const nodeMember of tsNode.members) { + const memberName = nodeMember.name?.getText(); + if (memberName == null) { + // Call/construct/index signatures don't have names. TS allows call signatures to mismatch, + // and construct signatures can't be async. + // TODO - Once we're able to use `checker.isTypeAssignableTo` (v8), we can check an index + // signature here against its compatible index signatures in `heritageTypes` + continue; + } + if (!returnsThenable(checker, nodeMember)) { + continue; + } + const node = services.tsNodeToESTreeNodeMap.get(nodeMember); + if (isStaticMember(node)) { + continue; + } + for (const heritageType of heritageTypes) { + checkHeritageTypeForMemberReturningVoid(nodeMember, heritageType, memberName); + } + } + } + /** + * Checks `heritageType` for a member named `memberName` that returns void; reports the + * 'voidReturnInheritedMethod' message if found. + * @param nodeMember Node member that returns a Promise + * @param heritageType Heritage type to check against + * @param memberName Name of the member to check for + */ + function checkHeritageTypeForMemberReturningVoid(nodeMember, heritageType, memberName) { + const heritageMember = getMemberIfExists(heritageType, memberName); + if (heritageMember == null) { + return; + } + const memberType = checker.getTypeOfSymbolAtLocation(heritageMember, nodeMember); + if (!isVoidReturningFunctionType(checker, nodeMember, memberType)) { + return; + } + context.report({ + node: services.tsNodeToESTreeNodeMap.get(nodeMember), + messageId: 'voidReturnInheritedMethod', + data: { heritageTypeName: checker.typeToString(heritageType) }, + }); + } + function checkJSXAttribute(node) { + if (node.value?.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) { + return; + } + const expressionContainer = services.esTreeNodeToTSNodeMap.get(node.value); + const expression = services.esTreeNodeToTSNodeMap.get(node.value.expression); + const contextualType = checker.getContextualType(expressionContainer); + if (contextualType != null && + isVoidReturningFunctionType(checker, expressionContainer, contextualType) && + returnsThenable(checker, expression)) { + context.report({ + node: node.value, + messageId: 'voidReturnAttribute', + }); + } + } + function checkSpread(node) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (isSometimesThenable(checker, tsNode.expression)) { + context.report({ + node: node.argument, + messageId: 'spread', + }); + } + } + return { + ...(checksConditionals ? conditionalChecks : {}), + ...(checksVoidReturn ? voidReturnChecks : {}), + ...(checksSpreads ? spreadChecks : {}), + }; + }, +}); +function isSometimesThenable(checker, node) { + const type = checker.getTypeAtLocation(node); + for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) { + if (tsutils.isThenableType(checker, node, subType)) { + return true; + } + } + return false; +} +// Variation on the thenable check which requires all forms of the type (read: +// alternates in a union) to be thenable. Otherwise, you might be trying to +// check if something is defined or undefined and get caught because one of the +// branches is thenable. +function isAlwaysThenable(checker, node) { + const type = checker.getTypeAtLocation(node); + for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) { + const thenProp = subType.getProperty('then'); + // If one of the alternates has no then property, it is not thenable in all + // cases. + if (thenProp == null) { + return false; + } + // We walk through each variation of the then property. Since we know it + // exists at this point, we just need at least one of the alternates to + // be of the right form to consider it thenable. + const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node); + let hasThenableSignature = false; + for (const subType of tsutils.unionConstituents(thenType)) { + for (const signature of subType.getCallSignatures()) { + if (signature.parameters.length !== 0 && + isFunctionParam(checker, signature.parameters[0], node)) { + hasThenableSignature = true; + break; + } + } + // We only need to find one variant of the then property that has a + // function signature for it to be thenable. + if (hasThenableSignature) { + break; + } + } + // If no flavors of the then property are thenable, we don't consider the + // overall type to be thenable + if (!hasThenableSignature) { + return false; + } + } + // If all variants are considered thenable (i.e. haven't returned false), we + // consider the overall type thenable + return true; +} +function isFunctionParam(checker, param, node) { + const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node)); + for (const subType of tsutils.unionConstituents(type)) { + if (subType.getCallSignatures().length !== 0) { + return true; + } + } + return false; +} +function checkThenableOrVoidArgument(checker, node, type, index, thenableReturnIndices, voidReturnIndices) { + if (isThenableReturningFunctionType(checker, node.expression, type)) { + thenableReturnIndices.add(index); + } + else if (isVoidReturningFunctionType(checker, node.expression, type) && + // If a certain argument accepts both thenable and void returns, + // a promise-returning function is valid + !thenableReturnIndices.has(index)) { + voidReturnIndices.add(index); + } + const contextualType = checker.getContextualTypeForArgumentAtIndex(node, index); + if (contextualType !== type) { + checkThenableOrVoidArgument(checker, node, contextualType, index, thenableReturnIndices, voidReturnIndices); + } +} +// Get the positions of arguments which are void functions (and not also +// thenable functions). These are the candidates for the void-return check at +// the current call site. +// If the function parameters end with a 'rest' parameter, then we consider +// the array type parameter (e.g. '...args:Array') when determining +// if trailing arguments are candidates. +function voidFunctionArguments(checker, node) { + // 'new' can be used without any arguments, as in 'let b = new Object;' + // In this case, there are no argument positions to check, so return early. + if (!node.arguments) { + return new Set(); + } + const thenableReturnIndices = new Set(); + const voidReturnIndices = new Set(); + const type = checker.getTypeAtLocation(node.expression); + // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise' + // See https://github.com/microsoft/TypeScript/issues/48077 + for (const subType of tsutils.unionConstituents(type)) { + // Standard function calls and `new` have two different types of signatures + const signatures = ts.isCallExpression(node) + ? subType.getCallSignatures() + : subType.getConstructSignatures(); + for (const signature of signatures) { + for (const [index, parameter] of signature.parameters.entries()) { + const decl = parameter.valueDeclaration; + let type = checker.getTypeOfSymbolAtLocation(parameter, node.expression); + // If this is a array 'rest' parameter, check all of the argument indices + // from the current argument to the end. + if (decl && (0, util_1.isRestParameterDeclaration)(decl)) { + if (checker.isArrayType(type)) { + // Unwrap 'Array' to 'MaybeVoidFunction', + // so that we'll handle it in the same way as a non-rest + // 'param: MaybeVoidFunction' + type = checker.getTypeArguments(type)[0]; + for (let i = index; i < node.arguments.length; i++) { + checkThenableOrVoidArgument(checker, node, type, i, thenableReturnIndices, voidReturnIndices); + } + } + else if (checker.isTupleType(type)) { + // Check each type in the tuple - for example, [boolean, () => void] would + // add the index of the second tuple parameter to 'voidReturnIndices' + const typeArgs = checker.getTypeArguments(type); + for (let i = index; i < node.arguments.length && i - index < typeArgs.length; i++) { + checkThenableOrVoidArgument(checker, node, typeArgs[i - index], i, thenableReturnIndices, voidReturnIndices); + } + } + } + else { + checkThenableOrVoidArgument(checker, node, type, index, thenableReturnIndices, voidReturnIndices); + } + } + } + } + for (const index of thenableReturnIndices) { + voidReturnIndices.delete(index); + } + return voidReturnIndices; +} +/** + * @returns Whether any call signature of the type has a thenable return type. + */ +function anySignatureIsThenableType(checker, node, type) { + for (const signature of type.getCallSignatures()) { + const returnType = signature.getReturnType(); + if (tsutils.isThenableType(checker, node, returnType)) { + return true; + } + } + return false; +} +/** + * @returns Whether type is a thenable-returning function. + */ +function isThenableReturningFunctionType(checker, node, type) { + for (const subType of tsutils.unionConstituents(type)) { + if (anySignatureIsThenableType(checker, node, subType)) { + return true; + } + } + return false; +} +/** + * @returns Whether type is a void-returning function. + */ +function isVoidReturningFunctionType(checker, node, type) { + let hadVoidReturn = false; + for (const subType of tsutils.unionConstituents(type)) { + for (const signature of subType.getCallSignatures()) { + const returnType = signature.getReturnType(); + // If a certain positional argument accepts both thenable and void returns, + // a promise-returning function is valid + if (tsutils.isThenableType(checker, node, returnType)) { + return false; + } + hadVoidReturn ||= tsutils.isTypeFlagSet(returnType, ts.TypeFlags.Void); + } + } + return hadVoidReturn; +} +/** + * @returns Whether expression is a function that returns a thenable. + */ +function returnsThenable(checker, node) { + const type = checker.getApparentType(checker.getTypeAtLocation(node)); + return tsutils + .unionConstituents(type) + .some(t => anySignatureIsThenableType(checker, node, t)); +} +function getHeritageTypes(checker, tsNode) { + return tsNode.heritageClauses + ?.flatMap(clause => clause.types) + .map(typeExpression => checker.getTypeAtLocation(typeExpression)); +} +/** + * @returns The member with the given name in `type`, if it exists. + */ +function getMemberIfExists(type, memberName) { + const escapedMemberName = ts.escapeLeadingUnderscores(memberName); + const symbolMemberMatch = type.getSymbol()?.members?.get(escapedMemberName); + return (symbolMemberMatch ?? tsutils.getPropertyOfType(type, escapedMemberName)); +} +function isStaticMember(node) { + return ((node.type === utils_1.AST_NODE_TYPES.MethodDefinition || + node.type === utils_1.AST_NODE_TYPES.PropertyDefinition || + node.type === utils_1.AST_NODE_TYPES.AccessorProperty) && + node.static); +} +function hasWellKnownSymbolWithThenableReturn(checker, node, type, symbolName) { + return tsutils + .unionConstituents(checker.getApparentType(type)) + .some(typePart => { + const symbol = tsutils.getWellKnownSymbolPropertyOfType(typePart, symbolName, checker); + if (symbol == null) { + return false; + } + return isThenableReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node)); + }); +} +function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) { + return tsutils + .unionConstituents(checker.getApparentType(type)) + .some(typePart => { + const symbol = tsutils.getWellKnownSymbolPropertyOfType(typePart, symbolName, checker); + if (symbol == null) { + return false; + } + return isVoidReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node)); + }); +} +/** + * Check that the Promise argument is the same as the rest of the type when it is a Union that contains Promise. + */ +function hasMatchingPromiseTypeArgument(checker, node) { + const type = checker.getTypeAtLocation(node); + const unionConstituents = tsutils.unionConstituents(checker.getApparentType(type)); + const promiseTypes = unionConstituents.filter(type => tsutils.isThenableType(checker, node, type)); + if (promiseTypes.length === 0) { + return false; + } + const nonPromiseUnionConstituents = unionConstituents.filter(type => !promiseTypes.includes(type)); + const awaitedTypeConstituents = []; + for (const promiseType of promiseTypes) { + const awaitedType = checker.getAwaitedType(promiseType); + if (!awaitedType) { + return false; + } + awaitedTypeConstituents.push(...tsutils.unionConstituents(awaitedType)); + } + const typesAreEquivalent = (left, right) => checker.isTypeAssignableTo(left, right) && + checker.isTypeAssignableTo(right, left); + return (nonPromiseUnionConstituents.every(type => awaitedTypeConstituents.some(awaited => typesAreEquivalent(type, awaited))) && + awaitedTypeConstituents.every(awaited => nonPromiseUnionConstituents.some(type => typesAreEquivalent(type, awaited)))); +} +function normalizeFlagUnionsOption(checksConditionals) { + if (!checksConditionals || checksConditionals === true) { + return 'none'; + } + return checksConditionals.flagUnions ?? 'none'; +} +//# sourceMappingURL=no-misused-promises.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.d.ts new file mode 100644 index 00000000..6b963466 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.d.ts @@ -0,0 +1,12 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +import type { TypeOrValueSpecifier } from '../util'; +type Options = [ + { + allow?: TypeOrValueSpecifier[]; + } +]; +type MessageIds = 'addAwait' | 'noArraySpreadInObject' | 'noClassDeclarationSpreadInObject' | 'noClassInstanceSpreadInObject' | 'noFunctionSpreadInObject' | 'noIterableSpreadInObject' | 'noMapSpreadInObject' | 'noPromiseSpreadInObject' | 'noStringSpread' | 'replaceMapSpreadInObject'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js new file mode 100644 index 00000000..b5f5760e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js @@ -0,0 +1,264 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-misused-spread', + meta: { + type: 'problem', + docs: { + description: 'Disallow using the spread operator when it might cause unexpected behavior', + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + addAwait: 'Add await operator.', + noArraySpreadInObject: 'Using the spread operator on an array in an object will result in a list of indices.', + noClassDeclarationSpreadInObject: 'Using the spread operator on class declarations will spread only their static properties, and will lose their class prototype.', + noClassInstanceSpreadInObject: 'Using the spread operator on class instances will lose their class prototype.', + noFunctionSpreadInObject: 'Using the spread operator on a function without additional properties can cause unexpected behavior. Did you forget to call the function?', + noIterableSpreadInObject: 'Using the spread operator on an Iterable in an object can cause unexpected behavior.', + noMapSpreadInObject: 'Using the spread operator on a Map in an object will result in an empty object. Did you mean to use `Object.fromEntries(map)` instead?', + noPromiseSpreadInObject: 'Using the spread operator on Promise in an object can cause unexpected behavior. Did you forget to await the promise?', + noStringSpread: [ + 'Using the spread operator on a string can mishandle special characters, as can `.split("")`.', + '- `...` produces Unicode code points, which will decompose complex emojis into individual emojis', + '- .split("") produces UTF-16 code units, which breaks rich characters in many languages', + 'Consider using `Intl.Segmenter` for locale-aware string decomposition.', + "Otherwise, if you don't need to preserve emojis or other non-Ascii characters, disable this lint rule on this line or configure the 'allow' rule option.", + ].join('\n'), + replaceMapSpreadInObject: 'Replace map spread in object with `Object.fromEntries()`', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + ...util_1.readonlynessOptionsSchema.properties.allow, + description: 'An array of type specifiers that are known to be safe to spread.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function checkArrayOrCallSpread(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.argument); + if (!(0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program) && + isString(type)) { + context.report({ + node, + messageId: 'noStringSpread', + }); + } + } + function getMapSpreadSuggestions(node, type) { + const types = tsutils.unionConstituents(type); + if (types.some(t => !isIterableMap(services.program, t))) { + return null; + } + if (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression && + node.parent.properties.length === 1) { + return [ + { + messageId: 'replaceMapSpreadInObject', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node.argument, + sourceCode: context.sourceCode, + wrap: code => `Object.fromEntries(${code})`, + }), + }, + ]; + } + return [ + { + messageId: 'replaceMapSpreadInObject', + fix: (0, util_1.getWrappingFixer)({ + node: node.argument, + sourceCode: context.sourceCode, + wrap: code => `Object.fromEntries(${code})`, + }), + }, + ]; + } + function getPromiseSpreadSuggestions(node) { + const isHighPrecedence = (0, util_1.isHigherPrecedenceThanAwait)(services.esTreeNodeToTSNodeMap.get(node)); + return [ + { + messageId: 'addAwait', + fix: fixer => isHighPrecedence + ? fixer.insertTextBefore(node, 'await ') + : [ + fixer.insertTextBefore(node, 'await ('), + fixer.insertTextAfter(node, ')'), + ], + }, + ]; + } + function checkObjectSpread(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.argument); + if ((0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program)) { + return; + } + if (isPromise(services.program, type)) { + context.report({ + node, + messageId: 'noPromiseSpreadInObject', + suggest: getPromiseSpreadSuggestions(node.argument), + }); + return; + } + if (isFunctionWithoutProps(type)) { + context.report({ + node, + messageId: 'noFunctionSpreadInObject', + }); + return; + } + if (isMap(services.program, type)) { + context.report({ + node, + messageId: 'noMapSpreadInObject', + suggest: getMapSpreadSuggestions(node, type), + }); + return; + } + if (isArray(checker, type)) { + context.report({ + node, + messageId: 'noArraySpreadInObject', + }); + return; + } + if (isIterable(type, checker) && + // Don't report when the type is string, since TS will flag it already + !isString(type)) { + context.report({ + node, + messageId: 'noIterableSpreadInObject', + }); + return; + } + if (isClassInstance(checker, type)) { + context.report({ + node, + messageId: 'noClassInstanceSpreadInObject', + }); + return; + } + if (isClassDeclaration(type)) { + context.report({ + node, + messageId: 'noClassDeclarationSpreadInObject', + }); + } + } + return { + 'ArrayExpression > SpreadElement': checkArrayOrCallSpread, + 'CallExpression > SpreadElement': checkArrayOrCallSpread, + JSXSpreadAttribute: checkObjectSpread, + 'ObjectExpression > SpreadElement': checkObjectSpread, + }; + }, +}); +function isIterable(type, checker) { + return tsutils + .typeConstituents(type) + .some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker)); +} +function isArray(checker, type) { + return isTypeRecurser(type, t => checker.isArrayType(t) || checker.isTupleType(t)); +} +function isString(type) { + return isTypeRecurser(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.StringLike)); +} +function isFunctionWithoutProps(type) { + return isTypeRecurser(type, t => t.getCallSignatures().length > 0 && t.getProperties().length === 0); +} +function isPromise(program, type) { + return isTypeRecurser(type, t => (0, util_1.isPromiseLike)(program, t)); +} +function isClassInstance(checker, type) { + return isTypeRecurser(type, t => { + // If the type itself has a construct signature, it's a class(-like) + if (t.getConstructSignatures().length) { + return false; + } + const symbol = t.getSymbol(); + // If the type's symbol has a construct signature, the type is an instance + return !!symbol + ?.getDeclarations() + ?.some(declaration => checker + .getTypeOfSymbolAtLocation(symbol, declaration) + .getConstructSignatures().length); + }); +} +function isClassDeclaration(type) { + return isTypeRecurser(type, t => { + if (tsutils.isObjectType(t) && + tsutils.isObjectFlagSet(t, ts.ObjectFlags.InstantiationExpressionType)) { + return true; + } + const kind = t.getSymbol()?.valueDeclaration?.kind; + return (kind === ts.SyntaxKind.ClassDeclaration || + kind === ts.SyntaxKind.ClassExpression); + }); +} +function isMap(program, type) { + return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap', 'WeakMap'])); +} +function isIterableMap(program, type) { + return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap'])); +} +function isTypeRecurser(type, predicate) { + if (type.isUnionOrIntersection()) { + return type.types.some(t => isTypeRecurser(t, predicate)); + } + return predicate(type); +} +//# sourceMappingURL=no-misused-spread.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.d.ts new file mode 100644 index 00000000..1695393b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.js new file mode 100644 index 00000000..87c9dfc1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.js @@ -0,0 +1,211 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +var AllowedType; +(function (AllowedType) { + AllowedType[AllowedType["Number"] = 0] = "Number"; + AllowedType[AllowedType["String"] = 1] = "String"; + AllowedType[AllowedType["Unknown"] = 2] = "Unknown"; +})(AllowedType || (AllowedType = {})); +exports.default = (0, util_1.createRule)({ + name: 'no-mixed-enums', + meta: { + type: 'problem', + docs: { + description: 'Disallow enums from having both number and string members', + recommended: 'strict', + requiresTypeChecking: true, + }, + messages: { + mixed: `Mixing number and string enums can be confusing.`, + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const parserServices = (0, util_1.getParserServices)(context); + const typeChecker = parserServices.program.getTypeChecker(); + function getModuleName(id) { + if (id.type === utils_1.AST_NODE_TYPES.Literal) { + return JSON.stringify(id.value); + } + let qualifiers = ''; + let current = id; + while (current.type === utils_1.AST_NODE_TYPES.TSQualifiedName) { + qualifiers = `.${current.right.name}${qualifiers}`; + current = current.left; + } + return context.sourceCode.getText(current) + qualifiers; + } + function getMergedScopes(scope) { + const { block } = scope; + if (block.type !== utils_1.AST_NODE_TYPES.TSModuleDeclaration) { + return [scope]; + } + const name = getModuleName(block.id); + return getEnclosingScopes(block).flatMap(enclosing => enclosing.childScopes.filter(childScope => childScope.block.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration && + getModuleName(childScope.block.id) === name)); + } + function getEnclosingScopes(node) { + const enclosing = (0, util_1.nullThrows)(context.sourceCode.getScope(node).upper, util_1.NullThrowsReasons.MissingParent); + return node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration + ? getMergedScopes(enclosing) + : [enclosing]; + } + function collectNodeDefinitions(node) { + const { name } = node.id; + const found = { + imports: [], + previousSibling: undefined, + }; + for (const definition of getEnclosingScopes(node).flatMap(enclosing => enclosing.set.get(name)?.defs ?? [])) { + if (definition.node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration && + definition.node.range[0] < node.range[0] && + definition.node.body.members.length > 0) { + found.previousSibling = definition.node; + break; + } + } + let scope = context.sourceCode.getScope(node); + while (scope) { + scope.set.get(name)?.defs.forEach(definition => { + if (definition.type === scope_manager_1.DefinitionType.ImportBinding) { + found.imports.push(definition.node); + } + }); + scope = scope.upper; + } + return found; + } + function getAllowedTypeForNode(node) { + return tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(node), ts.TypeFlags.StringLike) + ? AllowedType.String + : AllowedType.Number; + } + function getTypeFromImported(imported) { + const type = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(imported)); + const valueDeclaration = type.getSymbol()?.valueDeclaration; + if (!valueDeclaration || + !ts.isEnumDeclaration(valueDeclaration) || + valueDeclaration.members.length === 0) { + return undefined; + } + return getAllowedTypeForNode(valueDeclaration.members[0]); + } + function getMemberType(member) { + if (!member.initializer) { + return AllowedType.Number; + } + switch (member.initializer.type) { + case utils_1.AST_NODE_TYPES.Literal: + switch (typeof member.initializer.value) { + case 'number': + return AllowedType.Number; + case 'string': + return AllowedType.String; + default: + return AllowedType.Unknown; + } + case utils_1.AST_NODE_TYPES.TemplateLiteral: + return AllowedType.String; + default: + return getAllowedTypeForNode(parserServices.esTreeNodeToTSNodeMap.get(member.initializer)); + } + } + function getDesiredTypeForDefinition(node) { + const { imports, previousSibling } = collectNodeDefinitions(node); + // Case: Merged ambiently via module augmentation + // import { MyEnum } from 'other-module'; + // declare module 'other-module' { + // enum MyEnum { A } + // } + for (const imported of imports) { + const typeFromImported = getTypeFromImported(imported); + if (typeFromImported != null) { + return typeFromImported; + } + } + // Case: Multiple enum declarations in the same file + // enum MyEnum { A } + // enum MyEnum { B } + // + // ...including ones merged across namespace declarations + // namespace MyNamespace { + // export enum MyEnum { A } + // } + // namespace MyNamespace { + // export enum MyEnum { B } + // } + if (previousSibling) { + return getMemberType(previousSibling.body.members[0]); + } + // Finally, we default to the type of the first enum member + return getMemberType(node.body.members[0]); + } + return { + TSEnumDeclaration(node) { + if (!node.body.members.length) { + return; + } + let desiredType = getDesiredTypeForDefinition(node); + if (desiredType === ts.TypeFlags.Unknown) { + return; + } + for (const member of node.body.members) { + const currentType = getMemberType(member); + if (currentType === AllowedType.Unknown) { + return; + } + if (currentType === AllowedType.Number) { + desiredType ??= currentType; + } + if (currentType !== desiredType) { + context.report({ + node: member.initializer ?? member, + messageId: 'mixed', + }); + return; + } + } + }, + }; + }, +}); +//# sourceMappingURL=no-mixed-enums.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.d.ts new file mode 100644 index 00000000..d85a5842 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + allowDeclarations?: boolean; + allowDefinitionFiles?: boolean; + } +]; +export type MessageIds = 'moduleSyntaxIsPreferred'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.js new file mode 100644 index 00000000..8fe10290 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.js @@ -0,0 +1,61 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-namespace', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow TypeScript namespaces', + recommended: 'recommended', + }, + messages: { + moduleSyntaxIsPreferred: 'ES2015 module syntax is preferred over namespaces.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowDeclarations: { + type: 'boolean', + description: 'Whether to allow `declare` with custom TypeScript namespaces.', + }, + allowDefinitionFiles: { + type: 'boolean', + description: 'Whether to allow `declare` with custom TypeScript namespaces inside definition files.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowDeclarations: false, + allowDefinitionFiles: true, + }, + ], + create(context, [{ allowDeclarations, allowDefinitionFiles }]) { + function isDeclaration(node) { + if (node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration && node.declare) { + return true; + } + return node.parent != null && isDeclaration(node.parent); + } + return { + "TSModuleDeclaration[global!=true][id.type!='Literal']"(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration || + (allowDefinitionFiles && (0, util_1.isDefinitionFile)(context.filename)) || + (allowDeclarations && isDeclaration(node))) { + return; + } + context.report({ + node, + messageId: 'moduleSyntaxIsPreferred', + }); + }, + }; + }, +}); +//# sourceMappingURL=no-namespace.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.d.ts new file mode 100644 index 00000000..951ca072 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.js new file mode 100644 index 00000000..d09a327e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.js @@ -0,0 +1,74 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +function hasAssignmentBeforeNode(variable, node) { + return (variable.references.some(ref => ref.isWrite() && ref.identifier.range[1] < node.range[1]) || + variable.defs.some(def => isDefinitionWithAssignment(def) && def.node.range[1] < node.range[1])); +} +function isDefinitionWithAssignment(definition) { + if (definition.type !== scope_manager_1.DefinitionType.Variable) { + return false; + } + const variableDeclarator = definition.node; + return variableDeclarator.definite || variableDeclarator.init != null; +} +exports.default = (0, util_1.createRule)({ + name: 'no-non-null-asserted-nullish-coalescing', + meta: { + type: 'problem', + docs: { + description: 'Disallow non-null assertions in the left operand of a nullish coalescing operator', + recommended: 'strict', + }, + hasSuggestions: true, + messages: { + noNonNullAssertedNullishCoalescing: 'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.', + suggestRemovingNonNull: 'Remove the non-null assertion.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + 'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(node) { + if (node.expression.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier) { + const scope = context.sourceCode.getScope(node); + const identifier = node.expression; + const variable = utils_1.ASTUtils.findVariable(scope, identifier.name); + if (variable && !hasAssignmentBeforeNode(variable, node)) { + return; + } + } + context.report({ + node, + messageId: 'noNonNullAssertedNullishCoalescing', + /* + Use a suggestion instead of a fixer, because this can break type checks. + The resulting type of the nullish coalesce is only influenced by the right operand if the left operand can be `null` or `undefined`. + After removing the non-null assertion the type of the left operand might contain `null` or `undefined` and then the type of the right operand + might change the resulting type of the nullish coalesce. + See the following example: + + function test(x?: string): string { + const bar = x! ?? false; // type analysis reports `bar` has type `string` + // x ?? false; // type analysis reports `bar` has type `string | false` + return bar; + } + */ + suggest: [ + { + messageId: 'suggestRemovingNonNull', + fix(fixer) { + const exclamationMark = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node, utils_1.ASTUtils.isNonNullAssertionPunctuator), util_1.NullThrowsReasons.MissingToken('!', 'Non-null Assertion')); + return fixer.remove(exclamationMark); + }, + }, + ], + }); + }, + }; + }, +}); +//# sourceMappingURL=no-non-null-asserted-nullish-coalescing.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.d.ts new file mode 100644 index 00000000..31c7a856 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"noNonNullOptionalChain" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.js new file mode 100644 index 00000000..36975d71 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.js @@ -0,0 +1,66 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-non-null-asserted-optional-chain', + meta: { + type: 'problem', + docs: { + description: 'Disallow non-null assertions after an optional chain expression', + recommended: 'recommended', + }, + hasSuggestions: true, + messages: { + noNonNullOptionalChain: 'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.', + suggestRemovingNonNull: 'You should remove the non-null assertion.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + // non-nulling a wrapped chain will scrub all nulls introduced by the chain + // (x?.y)! + // (x?.())! + 'TSNonNullExpression > ChainExpression'(node) { + // selector guarantees this assertion + const parent = node.parent; + context.report({ + node, + messageId: 'noNonNullOptionalChain', + // use a suggestion instead of a fixer, because this can obviously break type checks + suggest: [ + { + messageId: 'suggestRemovingNonNull', + fix(fixer) { + return fixer.removeRange([ + parent.range[1] - 1, + parent.range[1], + ]); + }, + }, + ], + }); + }, + // non-nulling at the end of a chain will scrub all nulls introduced by the chain + // x?.y! + // x?.()! + 'ChainExpression > TSNonNullExpression'(node) { + context.report({ + node, + messageId: 'noNonNullOptionalChain', + // use a suggestion instead of a fixer, because this can obviously break type checks + suggest: [ + { + messageId: 'suggestRemovingNonNull', + fix(fixer) { + return fixer.removeRange([node.range[1] - 1, node.range[1]]); + }, + }, + ], + }); + }, + }; + }, +}); +//# sourceMappingURL=no-non-null-asserted-optional-chain.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.d.ts new file mode 100644 index 00000000..5667a19e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'noNonNull' | 'suggestOptionalChain'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.js new file mode 100644 index 00000000..04e1094e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.js @@ -0,0 +1,94 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-non-null-assertion', + meta: { + type: 'problem', + docs: { + description: 'Disallow non-null assertions using the `!` postfix operator', + recommended: 'strict', + }, + hasSuggestions: true, + messages: { + noNonNull: 'Forbidden non-null assertion.', + suggestOptionalChain: 'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + TSNonNullExpression(node) { + const suggest = []; + // it always exists in non-null assertion + const nonNullOperator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, util_1.isNonNullAssertionPunctuator), util_1.NullThrowsReasons.MissingToken('!', 'expression')); + function replaceTokenWithOptional() { + return fixer => fixer.replaceText(nonNullOperator, '?.'); + } + function removeToken() { + return fixer => fixer.remove(nonNullOperator); + } + if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.parent.object === node && + !(0, util_1.isAssignee)(node.parent)) { + if (!node.parent.optional) { + if (node.parent.computed) { + // it is x![y]?.z + suggest.push({ + messageId: 'suggestOptionalChain', + fix: replaceTokenWithOptional(), + }); + } + else { + // it is x!.y?.z + suggest.push({ + messageId: 'suggestOptionalChain', + fix(fixer) { + // x!.y?.z + // ^ punctuator + const punctuator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(nonNullOperator), util_1.NullThrowsReasons.MissingToken('.', '!')); + return [ + fixer.remove(nonNullOperator), + fixer.insertTextBefore(punctuator, '?'), + ]; + }, + }); + } + } + else { + // it is x!?.[y].z or x!?.y.z + suggest.push({ + messageId: 'suggestOptionalChain', + fix: removeToken(), + }); + } + } + else if (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression && + node.parent.callee === node) { + if (!node.parent.optional) { + // it is x.y?.z!() + suggest.push({ + messageId: 'suggestOptionalChain', + fix: replaceTokenWithOptional(), + }); + } + else { + // it is x.y.z!?.() + suggest.push({ + messageId: 'suggestOptionalChain', + fix: removeToken(), + }); + } + } + context.report({ + node, + messageId: 'noNonNull', + suggest, + }); + }, + }; + }, +}); +//# sourceMappingURL=no-non-null-assertion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.d.ts new file mode 100644 index 00000000..0d9c7adf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.d.ts @@ -0,0 +1,12 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'redeclared' | 'redeclaredAsBuiltin' | 'redeclaredBySyntax'; +export type Options = [ + { + builtinGlobals?: boolean; + ignoreDeclarationMerge?: boolean; + } +]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.js new file mode 100644 index 00000000..7b9f420e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.js @@ -0,0 +1,200 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-redeclare', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow variable redeclaration', + extendsBaseRule: true, + }, + messages: { + redeclared: "'{{id}}' is already defined.", + redeclaredAsBuiltin: "'{{id}}' is already defined as a built-in global variable.", + redeclaredBySyntax: "'{{id}}' is already defined by a variable declaration.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + builtinGlobals: { + type: 'boolean', + description: 'Whether to report shadowing of built-in global variables.', + }, + ignoreDeclarationMerge: { + type: 'boolean', + description: 'Whether to ignore declaration merges between certain TypeScript declaration types.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + builtinGlobals: true, + ignoreDeclarationMerge: true, + }, + ], + create(context, [options]) { + const CLASS_DECLARATION_MERGE_NODES = new Set([ + utils_1.AST_NODE_TYPES.ClassDeclaration, + utils_1.AST_NODE_TYPES.TSInterfaceDeclaration, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + ]); + const FUNCTION_DECLARATION_MERGE_NODES = new Set([ + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + ]); + const ENUM_DECLARATION_MERGE_NODES = new Set([ + utils_1.AST_NODE_TYPES.TSEnumDeclaration, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + ]); + function* iterateDeclarations(variable) { + if (options.builtinGlobals && + 'eslintImplicitGlobalSetting' in variable && + (variable.eslintImplicitGlobalSetting === 'readonly' || + variable.eslintImplicitGlobalSetting === 'writable')) { + yield { type: 'builtin' }; + } + if ('eslintExplicitGlobalComments' in variable && + variable.eslintExplicitGlobalComments) { + for (const comment of variable.eslintExplicitGlobalComments) { + yield { + loc: (0, util_1.getNameLocationInGlobalDirectiveComment)(context.sourceCode, comment, variable.name), + node: comment, + type: 'comment', + }; + } + } + const identifiers = variable.identifiers + .map(id => ({ + identifier: id, + parent: id.parent, + })) + // ignore function declarations because TS will treat them as an overload + .filter(({ parent }) => parent.type !== utils_1.AST_NODE_TYPES.TSDeclareFunction); + if (options.ignoreDeclarationMerge && identifiers.length > 1) { + if ( + // interfaces merging + identifiers.every(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration)) { + return; + } + if ( + // namespace/module merging + identifiers.every(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration)) { + return; + } + if ( + // class + interface/namespace merging + identifiers.every(({ parent }) => CLASS_DECLARATION_MERGE_NODES.has(parent.type))) { + const classDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration); + if (classDecls.length === 1) { + // safe declaration merging + return; + } + // there's more than one class declaration, which needs to be reported + for (const { identifier } of classDecls) { + yield { loc: identifier.loc, node: identifier, type: 'syntax' }; + } + return; + } + if ( + // class + interface/namespace merging + identifiers.every(({ parent }) => FUNCTION_DECLARATION_MERGE_NODES.has(parent.type))) { + const functionDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration); + if (functionDecls.length === 1) { + // safe declaration merging + return; + } + // there's more than one function declaration, which needs to be reported + for (const { identifier } of functionDecls) { + yield { loc: identifier.loc, node: identifier, type: 'syntax' }; + } + return; + } + if ( + // enum + namespace merging + identifiers.every(({ parent }) => ENUM_DECLARATION_MERGE_NODES.has(parent.type))) { + const enumDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration); + if (enumDecls.length === 1) { + // safe declaration merging + return; + } + // there's more than one enum declaration, which needs to be reported + for (const { identifier } of enumDecls) { + yield { loc: identifier.loc, node: identifier, type: 'syntax' }; + } + return; + } + } + for (const { identifier } of identifiers) { + yield { loc: identifier.loc, node: identifier, type: 'syntax' }; + } + } + function findVariablesInScope(scope) { + for (const variable of scope.variables) { + const [declaration, ...extraDeclarations] = iterateDeclarations(variable); + if (extraDeclarations.length === 0) { + continue; + } + /* + * If the type of a declaration is different from the type of + * the first declaration, it shows the location of the first + * declaration. + */ + const detailMessageId = declaration.type === 'builtin' + ? 'redeclaredAsBuiltin' + : 'redeclaredBySyntax'; + const data = { id: variable.name }; + // Report extra declarations. + for (const { loc, node, type } of extraDeclarations) { + const messageId = type === declaration.type ? 'redeclared' : detailMessageId; + if (node) { + context.report({ loc, node, messageId, data }); + } + else if (loc) { + context.report({ loc, messageId, data }); + } + } + } + } + /** + * Find variables in the current scope. + */ + function checkForBlock(node) { + const scope = context.sourceCode.getScope(node); + /* + * In ES5, some node type such as `BlockStatement` doesn't have that scope. + * `scope.block` is a different node in such a case. + */ + if (scope.block === node) { + findVariablesInScope(scope); + } + } + return { + ArrowFunctionExpression: checkForBlock, + BlockStatement: checkForBlock, + ForInStatement: checkForBlock, + ForOfStatement: checkForBlock, + ForStatement: checkForBlock, + FunctionDeclaration: checkForBlock, + FunctionExpression: checkForBlock, + Program(node) { + const scope = context.sourceCode.getScope(node); + findVariablesInScope(scope); + // Node.js or ES modules has a special scope. + if (scope.type === scope_manager_1.ScopeType.global && + // The special scope's block is the Program node. + scope.block === scope.childScopes[0]?.block) { + findVariablesInScope(scope.childScopes[0]); + } + }, + SwitchStatement: checkForBlock, + }; + }, +}); +//# sourceMappingURL=no-redeclare.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.d.ts new file mode 100644 index 00000000..4eea4f0d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js new file mode 100644 index 00000000..3780ee0f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js @@ -0,0 +1,432 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const literalToPrimitiveTypeFlags = { + [ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt, + [ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean, + [ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number, + [ts.TypeFlags.StringLiteral]: ts.TypeFlags.String, + [ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String, +}; +const literalTypeFlags = [ + ts.TypeFlags.BigIntLiteral, + ts.TypeFlags.BooleanLiteral, + ts.TypeFlags.NumberLiteral, + ts.TypeFlags.StringLiteral, + ts.TypeFlags.TemplateLiteral, +]; +const primitiveTypeFlags = [ + ts.TypeFlags.BigInt, + ts.TypeFlags.Boolean, + ts.TypeFlags.Number, + ts.TypeFlags.String, +]; +const primitiveTypeFlagNames = { + [ts.TypeFlags.BigInt]: 'bigint', + [ts.TypeFlags.Boolean]: 'boolean', + [ts.TypeFlags.Number]: 'number', + [ts.TypeFlags.String]: 'string', +}; +const primitiveTypeFlagTypes = { + bigint: ts.TypeFlags.BigIntLiteral, + boolean: ts.TypeFlags.BooleanLiteral, + number: ts.TypeFlags.NumberLiteral, + string: ts.TypeFlags.StringLiteral, +}; +const keywordNodeTypesToTsTypes = new Map([ + [utils_1.TSESTree.AST_NODE_TYPES.TSAnyKeyword, ts.TypeFlags.Any], + [utils_1.TSESTree.AST_NODE_TYPES.TSBigIntKeyword, ts.TypeFlags.BigInt], + [utils_1.TSESTree.AST_NODE_TYPES.TSBooleanKeyword, ts.TypeFlags.Boolean], + [utils_1.TSESTree.AST_NODE_TYPES.TSNeverKeyword, ts.TypeFlags.Never], + [utils_1.TSESTree.AST_NODE_TYPES.TSNumberKeyword, ts.TypeFlags.Number], + [utils_1.TSESTree.AST_NODE_TYPES.TSStringKeyword, ts.TypeFlags.String], + [utils_1.TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown], +]); +function addToMapGroup(map, key, value) { + const existing = map.get(key); + if (existing) { + existing.push(value); + } + else { + map.set(key, [value]); + } +} +function describeLiteralType(type) { + if (type.isStringLiteral()) { + return JSON.stringify(type.value); + } + if ((0, util_1.isTypeBigIntLiteralType)(type)) { + return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`; + } + if (type.isLiteral()) { + // eslint-disable-next-line @typescript-eslint/no-base-to-string + return type.value.toString(); + } + if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) { + return type.aliasSymbol.escapedName.toString(); + } + if ((0, util_1.isTypeAnyType)(type)) { + return 'any'; + } + if ((0, util_1.isTypeNeverType)(type)) { + return 'never'; + } + if ((0, util_1.isTypeUnknownType)(type)) { + return 'unknown'; + } + if ((0, util_1.isTypeTemplateLiteralType)(type)) { + return 'template literal type'; + } + if ((0, util_1.isTypeBigIntLiteralType)(type)) { + return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`; + } + if (tsutils.isTrueLiteralType(type)) { + return 'true'; + } + if (tsutils.isFalseLiteralType(type)) { + return 'false'; + } + return 'literal type'; +} +function describeLiteralTypeNode(typeNode) { + switch (typeNode.type) { + case utils_1.AST_NODE_TYPES.TSAnyKeyword: + return 'any'; + case utils_1.AST_NODE_TYPES.TSBooleanKeyword: + return 'boolean'; + case utils_1.AST_NODE_TYPES.TSNeverKeyword: + return 'never'; + case utils_1.AST_NODE_TYPES.TSNumberKeyword: + return 'number'; + case utils_1.AST_NODE_TYPES.TSStringKeyword: + return 'string'; + case utils_1.AST_NODE_TYPES.TSUnknownKeyword: + return 'unknown'; + case utils_1.AST_NODE_TYPES.TSLiteralType: + switch (typeNode.literal.type) { + case utils_1.TSESTree.AST_NODE_TYPES.Literal: + switch (typeof typeNode.literal.value) { + case 'bigint': + return `${typeNode.literal.value < 0 ? '-' : ''}${typeNode.literal.value}n`; + case 'string': + return JSON.stringify(typeNode.literal.value); + default: + return `${typeNode.literal.value}`; + } + case utils_1.TSESTree.AST_NODE_TYPES.TemplateLiteral: + return 'template literal type'; + } + } + return 'literal type'; +} +function isNodeInsideReturnType(node) { + return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation && + (0, util_1.isFunctionOrFunctionType)(node.parent.parent)); +} +/** + * @remarks TypeScript stores boolean types as the union false | true, always. + */ +function unionTypePartsUnlessBoolean(type) { + return type.isUnion() && + type.types.length === 2 && + tsutils.isFalseLiteralType(type.types[0]) && + tsutils.isTrueLiteralType(type.types[1]) + ? [type] + : tsutils.unionConstituents(type); +} +exports.default = (0, util_1.createRule)({ + name: 'no-redundant-type-constituents', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow members of unions and intersections that do nothing or override type information', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`, + literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`, + overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`, + overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`, + primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`, + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const typesCache = new Map(); + function getTypeNodeTypePartFlags(typeNode) { + const keywordTypeFlags = keywordNodeTypesToTsTypes.get(typeNode.type); + if (keywordTypeFlags) { + return [ + { + typeFlags: keywordTypeFlags, + typeName: describeLiteralTypeNode(typeNode), + }, + ]; + } + if (typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType && + typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal) { + return [ + { + typeFlags: primitiveTypeFlagTypes[typeof typeNode.literal + .value], + typeName: describeLiteralTypeNode(typeNode), + }, + ]; + } + if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) { + return typeNode.types.flatMap(getTypeNodeTypePartFlags); + } + const nodeType = services.getTypeAtLocation(typeNode); + const typeParts = unionTypePartsUnlessBoolean(nodeType); + return typeParts.map(typePart => ({ + typeFlags: typePart.flags, + typeName: describeLiteralType(typePart), + })); + } + function getTypeNodeTypePartFlagsCached(typeNode) { + const existing = typesCache.get(typeNode); + if (existing) { + return existing; + } + const created = getTypeNodeTypePartFlags(typeNode); + typesCache.set(typeNode, created); + return created; + } + return { + 'TSIntersectionType:exit'(node) { + const seenLiteralTypes = new Map(); + const seenPrimitiveTypes = new Map(); + const seenUnionTypes = new Map(); + function checkIntersectionBottomAndTopTypes({ typeFlags, typeName }, typeNode) { + for (const [messageId, checkFlag] of [ + ['overrides', ts.TypeFlags.Any], + ['overrides', ts.TypeFlags.Never], + ['overridden', ts.TypeFlags.Unknown], + ]) { + if (typeFlags === checkFlag) { + context.report({ + node: typeNode, + messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any' + ? 'errorTypeOverrides' + : messageId, + data: { + container: 'intersection', + typeName, + }, + }); + return true; + } + } + return false; + } + for (const typeNode of node.types) { + const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode); + for (const typePart of typePartFlags) { + if (checkIntersectionBottomAndTopTypes(typePart, typeNode)) { + continue; + } + for (const literalTypeFlag of literalTypeFlags) { + if (typePart.typeFlags === literalTypeFlag) { + addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], typePart.typeName); + break; + } + } + for (const primitiveTypeFlag of primitiveTypeFlags) { + if (typePart.typeFlags === primitiveTypeFlag) { + addToMapGroup(seenPrimitiveTypes, primitiveTypeFlag, typeNode); + } + } + } + // if any typeNode is TSTypeReference and typePartFlags have more than 1 element, than the referenced type is definitely a union. + if (typePartFlags.length >= 2) { + seenUnionTypes.set(typeNode, typePartFlags); + } + } + /** + * @example + * ```ts + * type F = "a"|2|"b"; + * type I = F & string; + * ``` + * This function checks if all the union members of `F` are assignable to the other member of `I`. If every member is assignable, then its reported else not. + */ + const checkIfUnionsAreAssignable = () => { + for (const [typeRef, typeValues] of seenUnionTypes) { + let primitive = undefined; + for (const { typeFlags } of typeValues) { + if (seenPrimitiveTypes.has(literalToPrimitiveTypeFlags[typeFlags])) { + primitive = + literalToPrimitiveTypeFlags[typeFlags]; + } + else { + primitive = undefined; + break; + } + } + if (Number.isInteger(primitive)) { + context.report({ + node: typeRef, + messageId: 'primitiveOverridden', + data: { + literal: typeValues.map(name => name.typeName).join(' | '), + primitive: primitiveTypeFlagNames[primitive], + }, + }); + } + } + }; + if (seenUnionTypes.size > 0) { + checkIfUnionsAreAssignable(); + return; + } + // For each primitive type of all the seen primitive types, + // if there was a literal type seen that overrides it, + // report each of the primitive type's type nodes + for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) { + const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag); + if (matchedLiteralTypes) { + for (const typeNode of typeNodes) { + context.report({ + node: typeNode, + messageId: 'primitiveOverridden', + data: { + literal: matchedLiteralTypes.join(' | '), + primitive: primitiveTypeFlagNames[primitiveTypeFlag], + }, + }); + } + } + } + }, + 'TSUnionType:exit'(node) { + const seenLiteralTypes = new Map(); + const seenPrimitiveTypes = new Set(); + function checkUnionBottomAndTopTypes({ typeFlags, typeName }, typeNode) { + for (const checkFlag of [ + ts.TypeFlags.Any, + ts.TypeFlags.Unknown, + ]) { + if (typeFlags === checkFlag) { + context.report({ + node: typeNode, + messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any' + ? 'errorTypeOverrides' + : 'overrides', + data: { + container: 'union', + typeName, + }, + }); + return true; + } + } + if (typeFlags === ts.TypeFlags.Never && + !isNodeInsideReturnType(node)) { + context.report({ + node: typeNode, + messageId: 'overridden', + data: { + container: 'union', + typeName: 'never', + }, + }); + return true; + } + return false; + } + for (const typeNode of node.types) { + const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode); + for (const typePart of typePartFlags) { + if (checkUnionBottomAndTopTypes(typePart, typeNode)) { + continue; + } + for (const literalTypeFlag of literalTypeFlags) { + if (typePart.typeFlags === literalTypeFlag) { + addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], { + literalValue: typePart.typeName, + typeNode, + }); + break; + } + } + for (const primitiveTypeFlag of primitiveTypeFlags) { + if ((typePart.typeFlags & primitiveTypeFlag) !== 0) { + seenPrimitiveTypes.add(primitiveTypeFlag); + } + } + } + } + const overriddenTypeNodes = new Map(); + // For each primitive type of all the seen literal types, + // if there was a primitive type seen that overrides it, + // upsert the literal text and primitive type under the backing type node + for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) { + if (seenPrimitiveTypes.has(primitiveTypeFlag)) { + for (const { literalValue, typeNode } of typeNodesWithText) { + addToMapGroup(overriddenTypeNodes, typeNode, { + literalValue, + primitiveTypeFlag, + }); + } + } + } + // For each type node that had at least one overridden literal, + // group those literals by their primitive type, + // then report each primitive type with all its literals + for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) { + const grouped = (0, util_1.arrayGroupByToMap)(typeFlagsWithText, pair => pair.primitiveTypeFlag); + for (const [primitiveTypeFlag, pairs] of grouped) { + context.report({ + node: typeNode, + messageId: 'literalOverridden', + data: { + literal: pairs.map(pair => pair.literalValue).join(' | '), + primitive: primitiveTypeFlagNames[primitiveTypeFlag], + }, + }); + } + } + }, + }; + }, +}); +//# sourceMappingURL=no-redundant-type-constituents.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.d.ts new file mode 100644 index 00000000..9207b5a1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + allow?: string[]; + allowAsImport?: boolean; + } +]; +export type MessageIds = 'noRequireImports'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.js new file mode 100644 index 00000000..181ab0a1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.js @@ -0,0 +1,116 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util = __importStar(require("../util")); +exports.default = util.createRule({ + name: 'no-require-imports', + meta: { + type: 'problem', + docs: { + description: 'Disallow invocation of `require()`', + recommended: 'recommended', + }, + messages: { + noRequireImports: 'A `require()` style import is forbidden.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + type: 'array', + description: 'Patterns of import paths to allow requiring from.', + items: { type: 'string' }, + }, + allowAsImport: { + type: 'boolean', + description: 'Allows `require` statements in import declarations.', + }, + }, + }, + ], + }, + defaultOptions: [{ allow: [], allowAsImport: false }], + create(context, options) { + const allowAsImport = options[0].allowAsImport; + const allowPatterns = options[0].allow?.map(pattern => new RegExp(pattern, 'u')); + function isImportPathAllowed(importPath) { + return allowPatterns?.some(pattern => importPath.match(pattern)); + } + function isStringOrTemplateLiteral(node) { + return ((node.type === utils_1.AST_NODE_TYPES.Literal && + typeof node.value === 'string') || + node.type === utils_1.AST_NODE_TYPES.TemplateLiteral); + } + return { + 'CallExpression[callee.name="require"]'(node) { + if (node.arguments[0] && isStringOrTemplateLiteral(node.arguments[0])) { + const argValue = util.getStaticStringValue(node.arguments[0]); + if (typeof argValue === 'string' && isImportPathAllowed(argValue)) { + return; + } + } + const variable = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(node), 'require'); + // ignore non-global require usage as it's something user-land custom instead + // of the commonjs standard + if (!variable?.identifiers.length) { + context.report({ + node, + messageId: 'noRequireImports', + }); + } + }, + TSExternalModuleReference(node) { + if (isStringOrTemplateLiteral(node.expression)) { + const argValue = util.getStaticStringValue(node.expression); + if (typeof argValue === 'string' && isImportPathAllowed(argValue)) { + return; + } + } + if (allowAsImport && + node.parent.type === utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration) { + return; + } + context.report({ + node, + messageId: 'noRequireImports', + }); + }, + }; + }, +}); +//# sourceMappingURL=no-require-imports.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.d.ts new file mode 100644 index 00000000..5863fda6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.d.ts @@ -0,0 +1,9 @@ +import type { ArrayOfStringOrObject, RuleListener } from 'eslint/lib/rules/no-restricted-imports'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], unknown, RuleListener>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.js new file mode 100644 index 00000000..efb246e0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.js @@ -0,0 +1,256 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ignore_1 = __importDefault(require("ignore")); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-restricted-imports'); +// In some versions of eslint, the base rule has a completely incompatible schema +// This helper function is to safely try to get parts of the schema. If it's not +// possible, we'll fallback to less strict checks. +const tryAccess = (getter, fallback) => { + try { + return getter(); + } + catch { + return fallback; + } +}; +const baseSchema = baseRule.meta.schema; +const allowTypeImportsOptionSchema = { + allowTypeImports: { + type: 'boolean', + description: 'Whether to allow type-only imports for a path.', + }, +}; +const arrayOfStringsOrObjects = { + type: 'array', + items: { + anyOf: [ + { type: 'string' }, + { + type: 'object', + additionalProperties: false, + properties: { + ...tryAccess(() => baseSchema.anyOf[1].items[0].properties.paths.items.anyOf[1] + .properties, undefined), + ...allowTypeImportsOptionSchema, + }, + required: tryAccess(() => baseSchema.anyOf[1].items[0].properties.paths.items.anyOf[1] + .required, undefined), + }, + ], + }, + uniqueItems: true, +}; +const arrayOfStringsOrObjectPatterns = { + anyOf: [ + { + type: 'array', + items: { + type: 'string', + }, + uniqueItems: true, + }, + { + type: 'array', + items: { + type: 'object', + additionalProperties: false, + properties: { + ...tryAccess(() => baseSchema.anyOf[1].items[0].properties.patterns.anyOf[1].items + .properties, undefined), + ...allowTypeImportsOptionSchema, + }, + required: tryAccess(() => baseSchema.anyOf[1].items[0].properties.patterns.anyOf[1].items + .required, []), + }, + uniqueItems: true, + }, + ], +}; +const schema = { + anyOf: [ + arrayOfStringsOrObjects, + { + type: 'array', + additionalItems: false, + items: [ + { + type: 'object', + additionalProperties: false, + properties: { + paths: arrayOfStringsOrObjects, + patterns: arrayOfStringsOrObjectPatterns, + }, + }, + ], + }, + ], +}; +function isObjectOfPaths(obj) { + return !!obj && Object.hasOwn(obj, 'paths'); +} +function isObjectOfPatterns(obj) { + return !!obj && Object.hasOwn(obj, 'patterns'); +} +function isOptionsArrayOfStringOrObject(options) { + if (isObjectOfPaths(options[0])) { + return false; + } + if (isObjectOfPatterns(options[0])) { + return false; + } + return true; +} +function getRestrictedPaths(options) { + if (isOptionsArrayOfStringOrObject(options)) { + return options; + } + if (isObjectOfPaths(options[0])) { + return options[0].paths; + } + return []; +} +function getRestrictedPatterns(options) { + if (isObjectOfPatterns(options[0])) { + return options[0].patterns; + } + return []; +} +function shouldCreateRule(baseRules, options) { + if (Object.keys(baseRules).length === 0 || options.length === 0) { + return false; + } + if (!isOptionsArrayOfStringOrObject(options)) { + return !!(options[0].paths?.length || options[0].patterns?.length); + } + return true; +} +exports.default = (0, util_1.createRule)({ + name: 'no-restricted-imports', + meta: { + type: 'suggestion', + // defaultOptions, -- base rule does not use defaultOptions + deprecated: { + deprecatedSince: '8.64.0', + replacedBy: [ + { + rule: { + name: 'no-restricted-imports', + url: 'https://eslint.org/docs/latest/rules/no-restricted-imports', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/12527', + }, + docs: { + description: 'Disallow specified modules when loaded by `import`', + extendsBaseRule: true, + }, + fixable: baseRule.meta.fixable, + messages: baseRule.meta.messages, + schema, + }, + defaultOptions: [], + create(context) { + const rules = baseRule.create(context); + const { options } = context; + if (!shouldCreateRule(rules, options)) { + return {}; + } + const restrictedPaths = getRestrictedPaths(options); + const allowedTypeImportPathNameSet = new Set(); + for (const restrictedPath of restrictedPaths) { + if (typeof restrictedPath === 'object' && + restrictedPath.allowTypeImports) { + allowedTypeImportPathNameSet.add(restrictedPath.name); + } + } + function isAllowedTypeImportPath(importSource) { + return allowedTypeImportPathNameSet.has(importSource); + } + const restrictedPatterns = getRestrictedPatterns(options); + const allowedImportTypeMatchers = []; + const allowedImportTypeRegexMatchers = []; + for (const restrictedPattern of restrictedPatterns) { + if (typeof restrictedPattern === 'object' && + restrictedPattern.allowTypeImports) { + // Following how ignore is configured in the base rule + if (restrictedPattern.group) { + allowedImportTypeMatchers.push((0, ignore_1.default)({ + allowRelativePaths: true, + ignoreCase: !restrictedPattern.caseSensitive, + }).add(restrictedPattern.group)); + } + if (restrictedPattern.regex) { + allowedImportTypeRegexMatchers.push(new RegExp(restrictedPattern.regex, restrictedPattern.caseSensitive ? 'u' : 'iu')); + } + } + } + function isAllowedTypeImportPattern(importSource) { + return ( + // As long as there's one matching pattern that allows type import + allowedImportTypeMatchers.some(matcher => matcher.ignores(importSource)) || + allowedImportTypeRegexMatchers.some(regex => regex.test(importSource))); + } + function checkImportNode(node) { + if (node.importKind === 'type' || + (node.specifiers.length > 0 && + node.specifiers.every(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier && + specifier.importKind === 'type'))) { + const importSource = node.source.value.trim(); + if (!isAllowedTypeImportPath(importSource) && + !isAllowedTypeImportPattern(importSource)) { + return rules.ImportDeclaration(node); + } + } + else { + return rules.ImportDeclaration(node); + } + } + return { + ExportAllDeclaration: rules.ExportAllDeclaration, + 'ExportNamedDeclaration[source]'(node) { + if (node.exportKind === 'type' || + (node.specifiers.length > 0 && + node.specifiers.every(specifier => specifier.exportKind === 'type'))) { + const importSource = node.source.value.trim(); + if (!isAllowedTypeImportPath(importSource) && + !isAllowedTypeImportPattern(importSource)) { + return rules.ExportNamedDeclaration(node); + } + } + else { + return rules.ExportNamedDeclaration(node); + } + }, + ImportDeclaration: checkImportNode, + TSImportEqualsDeclaration(node) { + if (node.moduleReference.type === utils_1.AST_NODE_TYPES.TSExternalModuleReference) { + const synthesizedImport = { + ...node, + type: utils_1.AST_NODE_TYPES.ImportDeclaration, + assertions: [], + attributes: [], + source: node.moduleReference.expression, + specifiers: [ + { + ...node.id, + type: utils_1.AST_NODE_TYPES.ImportDefaultSpecifier, + local: node.id, + // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension + parent: node.id.parent, + }, + ], + }; + return checkImportNode(synthesizedImport); + } + }, + }; + }, +}); +//# sourceMappingURL=no-restricted-imports.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.d.ts new file mode 100644 index 00000000..63e9b40c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.d.ts @@ -0,0 +1,16 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +type Types = Record; +export type Options = [ + { + types?: Types; + } +]; +export type MessageIds = 'bannedTypeMessage' | 'bannedTypeReplacement'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.js new file mode 100644 index 00000000..1c125d75 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.js @@ -0,0 +1,172 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +function removeSpaces(str) { + return str.replaceAll(/\s/g, ''); +} +function stringifyNode(node, sourceCode) { + return removeSpaces(sourceCode.getText(node)); +} +function getCustomMessage(bannedType) { + if (!bannedType || bannedType === true) { + return ''; + } + if (typeof bannedType === 'string') { + return ` ${bannedType}`; + } + if (bannedType.message) { + return ` ${bannedType.message}`; + } + return ''; +} +const TYPE_KEYWORDS = { + bigint: utils_1.AST_NODE_TYPES.TSBigIntKeyword, + boolean: utils_1.AST_NODE_TYPES.TSBooleanKeyword, + never: utils_1.AST_NODE_TYPES.TSNeverKeyword, + null: utils_1.AST_NODE_TYPES.TSNullKeyword, + number: utils_1.AST_NODE_TYPES.TSNumberKeyword, + object: utils_1.AST_NODE_TYPES.TSObjectKeyword, + string: utils_1.AST_NODE_TYPES.TSStringKeyword, + symbol: utils_1.AST_NODE_TYPES.TSSymbolKeyword, + undefined: utils_1.AST_NODE_TYPES.TSUndefinedKeyword, + unknown: utils_1.AST_NODE_TYPES.TSUnknownKeyword, + void: utils_1.AST_NODE_TYPES.TSVoidKeyword, +}; +exports.default = (0, util_1.createRule)({ + name: 'no-restricted-types', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow certain types', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}", + bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.', + }, + schema: [ + { + type: 'object', + $defs: { + banConfig: { + oneOf: [ + { + type: 'boolean', + description: 'Bans the type with the default message.', + enum: [true], + }, + { + type: 'string', + description: 'Bans the type with a custom message.', + }, + { + type: 'object', + additionalProperties: false, + description: 'Bans a type.', + properties: { + fixWith: { + type: 'string', + description: 'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.', + }, + message: { + type: 'string', + description: 'Custom error message.', + }, + suggest: { + type: 'array', + description: 'Types to suggest replacing with.', + items: { type: 'string' }, + }, + }, + }, + ], + }, + }, + additionalProperties: false, + properties: { + types: { + type: 'object', + additionalProperties: { + $ref: '#/items/0/$defs/banConfig', + }, + description: 'An object whose keys are the types you want to ban, and the values are error messages.', + }, + }, + }, + ], + }, + defaultOptions: [{}], + create(context, [{ types = {} }]) { + const bannedTypes = new Map(Object.entries(types).map(([type, data]) => [removeSpaces(type), data])); + function checkBannedTypes(typeNode, name = stringifyNode(typeNode, context.sourceCode)) { + const bannedType = bannedTypes.get(name); + if (bannedType == null || bannedType === false) { + return; + } + const customMessage = getCustomMessage(bannedType); + const fixWith = bannedType && typeof bannedType === 'object' && bannedType.fixWith; + const suggest = bannedType && typeof bannedType === 'object' + ? bannedType.suggest + : undefined; + context.report({ + node: typeNode, + messageId: 'bannedTypeMessage', + data: { + name, + customMessage, + }, + fix: fixWith + ? (fixer) => fixer.replaceText(typeNode, fixWith) + : null, + suggest: suggest?.map(replacement => ({ + messageId: 'bannedTypeReplacement', + data: { + name, + replacement, + }, + fix: (fixer) => fixer.replaceText(typeNode, replacement), + })), + }); + } + const keywordSelectors = (0, util_1.objectReduceKey)(TYPE_KEYWORDS, (acc, keyword) => { + if (bannedTypes.has(keyword)) { + acc[TYPE_KEYWORDS[keyword]] = (node) => checkBannedTypes(node, keyword); + } + return acc; + }, {}); + return { + ...keywordSelectors, + TSClassImplements(node) { + checkBannedTypes(node.expression); + if (node.typeArguments) { + checkBannedTypes(node); + } + }, + TSInterfaceHeritage(node) { + checkBannedTypes(node.expression); + if (node.typeArguments) { + checkBannedTypes(node); + } + }, + TSTupleType(node) { + if (!node.elementTypes.length) { + checkBannedTypes(node); + } + }, + TSTypeLiteral(node) { + if (!node.members.length) { + checkBannedTypes(node); + } + }, + TSTypeReference(node) { + checkBannedTypes(node.typeName); + if (node.typeArguments) { + checkBannedTypes(node); + } + }, + }; + }, +}); +//# sourceMappingURL=no-restricted-types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.d.ts new file mode 100644 index 00000000..35e5aef7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.d.ts @@ -0,0 +1,16 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'noEnumShadow' | 'noShadow' | 'noShadowGlobal'; +export type Options = [ + { + allow?: string[]; + builtinGlobals?: boolean; + hoist?: 'all' | 'functions' | 'functions-and-types' | 'never' | 'types'; + ignoreFunctionTypeParameterNameValueShadow?: boolean; + ignoreOnInitialization?: boolean; + ignoreTypeValueShadow?: boolean; + } +]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.js new file mode 100644 index 00000000..263413f2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.js @@ -0,0 +1,553 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const isTypeImport_1 = require("../util/isTypeImport"); +const allowedFunctionVariableDefTypes = new Set([ + utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration, + utils_1.AST_NODE_TYPES.TSFunctionType, + utils_1.AST_NODE_TYPES.TSMethodSignature, + utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression, + utils_1.AST_NODE_TYPES.TSDeclareFunction, + utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration, + utils_1.AST_NODE_TYPES.TSConstructorType, +]); +const functionsHoistedNodes = new Set([utils_1.AST_NODE_TYPES.FunctionDeclaration]); +const typesHoistedNodes = new Set([ + utils_1.AST_NODE_TYPES.TSInterfaceDeclaration, + utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration, +]); +exports.default = (0, util_1.createRule)({ + name: 'no-shadow', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow variable declarations from shadowing variables declared in the outer scope', + extendsBaseRule: true, + }, + messages: { + noEnumShadow: "Enum members are added to the enum scope, so references to '{{name}}' in enum member initializers resolve to this member instead of the declaration in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.", + noShadow: "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.", + noShadowGlobal: "'{{name}}' is already a global variable.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + type: 'array', + description: 'Identifier names for which shadowing is allowed.', + items: { + type: 'string', + }, + }, + builtinGlobals: { + type: 'boolean', + description: 'Whether to report shadowing of built-in global variables.', + }, + hoist: { + type: 'string', + description: 'Whether to report shadowing before outer functions or variables are defined.', + enum: ['all', 'functions', 'functions-and-types', 'never', 'types'], + }, + ignoreFunctionTypeParameterNameValueShadow: { + type: 'boolean', + description: 'Whether to ignore function parameters named the same as a variable.', + }, + ignoreOnInitialization: { + type: 'boolean', + description: 'Whether to ignore the variable initializers when the shadowed variable is presumably still uninitialized.', + }, + ignoreTypeValueShadow: { + type: 'boolean', + description: 'Whether to ignore types named the same as a variable.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + builtinGlobals: false, + hoist: 'functions-and-types', + ignoreFunctionTypeParameterNameValueShadow: true, + ignoreOnInitialization: false, + ignoreTypeValueShadow: true, + }, + ], + create(context, [options]) { + /** + * Check if a scope is a TypeScript module augmenting the global namespace. + */ + function isGlobalAugmentation(scope) { + return ((scope.type === scope_manager_1.ScopeType.tsModule && scope.block.kind === 'global') || + (!!scope.upper && isGlobalAugmentation(scope.upper))); + } + /** + * Check if variable is a `this` parameter. + */ + function isThisParam(variable) { + return (variable.defs[0].type === scope_manager_1.DefinitionType.Parameter && + variable.name === 'this'); + } + function isTypeValueShadow(variable, shadowed) { + if (options.ignoreTypeValueShadow !== true) { + return false; + } + if (!('isValueVariable' in variable)) { + // this shouldn't happen... + return false; + } + const firstDefinition = shadowed.defs.at(0); + const isShadowedValue = !('isValueVariable' in shadowed) || + !firstDefinition || + (!(0, isTypeImport_1.isTypeImport)(firstDefinition) && shadowed.isValueVariable); + return variable.isValueVariable !== isShadowedValue; + } + function isFunctionTypeParameterNameValueShadow(variable, shadowed) { + if (options.ignoreFunctionTypeParameterNameValueShadow !== true) { + return false; + } + if (!('isValueVariable' in variable)) { + // this shouldn't happen... + return false; + } + const isShadowedValue = 'isValueVariable' in shadowed ? shadowed.isValueVariable : true; + if (!isShadowedValue) { + return false; + } + return variable.defs.every(def => allowedFunctionVariableDefTypes.has(def.node.type)); + } + function isGenericOfStaticMethod(variable) { + if (!('isTypeVariable' in variable)) { + // this shouldn't happen... + return false; + } + if (!variable.isTypeVariable) { + return false; + } + if (variable.identifiers.length === 0) { + return false; + } + const typeParameter = variable.identifiers[0].parent; + if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) { + return false; + } + const typeParameterDecl = typeParameter.parent; + if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) { + return false; + } + const functionExpr = typeParameterDecl.parent; + if (functionExpr.type !== utils_1.AST_NODE_TYPES.FunctionExpression && + functionExpr.type !== utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + return false; + } + const methodDefinition = functionExpr.parent; + if (methodDefinition.type !== utils_1.AST_NODE_TYPES.MethodDefinition) { + return false; + } + return methodDefinition.static; + } + function isGenericOfClass(variable) { + if (!('isTypeVariable' in variable)) { + // this shouldn't happen... + return false; + } + if (!variable.isTypeVariable) { + return false; + } + if (variable.identifiers.length === 0) { + return false; + } + const typeParameter = variable.identifiers[0].parent; + if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) { + return false; + } + const typeParameterDecl = typeParameter.parent; + if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) { + return false; + } + const classDecl = typeParameterDecl.parent; + return (classDecl.type === utils_1.AST_NODE_TYPES.ClassDeclaration || + classDecl.type === utils_1.AST_NODE_TYPES.ClassExpression); + } + function isGenericOfAStaticMethodShadow(variable, shadowed) { + return isGenericOfStaticMethod(variable) && isGenericOfClass(shadowed); + } + function isImportDeclaration(definition) { + return definition.type === utils_1.AST_NODE_TYPES.ImportDeclaration; + } + function isExternalModuleDeclarationWithName(scope, name) { + return (scope.type === scope_manager_1.ScopeType.tsModule && + scope.block.id.type === utils_1.AST_NODE_TYPES.Literal && + scope.block.id.value === name); + } + function isExternalDeclarationMerging(scope, variable, shadowed) { + const [firstDefinition] = shadowed.defs; + const [secondDefinition] = variable.defs; + return ((0, isTypeImport_1.isTypeImport)(firstDefinition) && + isImportDeclaration(firstDefinition.parent) && + isExternalModuleDeclarationWithName(scope, firstDefinition.parent.source.value) && + (secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration || + secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration)); + } + /** + * Check if variable name is allowed. + * @param variable The variable to check. + * @returns Whether or not the variable name is allowed. + */ + function isAllowed(variable) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + return options.allow.includes(variable.name); + } + /** + * Checks if a variable of the class name in the class scope of ClassDeclaration. + * + * ClassDeclaration creates two variables of its name into its outer scope and its class scope. + * So we should ignore the variable in the class scope. + * @param variable The variable to check. + * @returns Whether or not the variable of the class name in the class scope of ClassDeclaration. + */ + function isDuplicatedClassNameVariable(variable) { + const block = variable.scope.block; + return (block.type === utils_1.AST_NODE_TYPES.ClassDeclaration && + block.id === variable.identifiers[0]); + } + /** + * Checks if a variable of the class name in the class scope of TSEnumDeclaration. + * + * TSEnumDeclaration creates two variables of its name into its outer scope and its class scope. + * So we should ignore the variable in the class scope. + * @param variable The variable to check. + * @returns Whether or not the variable of the class name in the class scope of TSEnumDeclaration. + */ + function isDuplicatedEnumNameVariable(variable) { + const block = variable.scope.block; + return (block.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration && + block.id === variable.identifiers[0]); + } + /** + * Checks whether or not a given location is inside of the range of a given node. + * @param node An node to check. + * @param location A location to check. + * @returns `true` if the location is inside of the range of the node. + */ + function isInRange(node, location) { + return node && node.range[0] <= location && location <= node.range[1]; + } + /** + * Searches from the current node through its ancestry to find a matching node. + * @param node a node to get. + * @param match a callback that checks whether or not the node verifies its condition or not. + * @returns the matching node. + */ + function findSelfOrAncestor(node, match) { + let currentNode = node; + while (currentNode && !match(currentNode)) { + currentNode = currentNode.parent; + } + return currentNode; + } + /** + * Finds function's outer scope. + * @param scope Function's own scope. + * @returns Function's outer scope. + */ + function getOuterScope(scope) { + const upper = scope.upper; + if (upper?.type === scope_manager_1.ScopeType.functionExpressionName) { + return upper.upper; + } + return upper; + } + /** + * Checks if a variable and a shadowedVariable have the same init pattern ancestor. + * @param variable a variable to check. + * @param shadowedVariable a shadowedVariable to check. + * @returns Whether or not the variable and the shadowedVariable have the same init pattern ancestor. + */ + function isInitPatternNode(variable, shadowedVariable) { + const outerDef = shadowedVariable.defs.at(0); + if (!outerDef) { + return false; + } + const { variableScope } = variable.scope; + if (!((variableScope.block.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + variableScope.block.type === utils_1.AST_NODE_TYPES.FunctionExpression) && + getOuterScope(variableScope) === shadowedVariable.scope)) { + return false; + } + const fun = variableScope.block; + const { parent } = fun; + const callExpression = findSelfOrAncestor(parent, node => node.type === utils_1.AST_NODE_TYPES.CallExpression); + if (!callExpression) { + return false; + } + let node = outerDef.name; + const location = callExpression.range[1]; + while (node) { + if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) { + if (isInRange(node.init, location)) { + return true; + } + if ((node.parent.parent.type === utils_1.AST_NODE_TYPES.ForInStatement || + node.parent.parent.type === utils_1.AST_NODE_TYPES.ForOfStatement) && + isInRange(node.parent.parent.right, location)) { + return true; + } + break; + } + else if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + if (isInRange(node.right, location)) { + return true; + } + } + else if ([ + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, + utils_1.AST_NODE_TYPES.CatchClause, + utils_1.AST_NODE_TYPES.ClassDeclaration, + utils_1.AST_NODE_TYPES.ClassExpression, + utils_1.AST_NODE_TYPES.ExportNamedDeclaration, + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.FunctionExpression, + utils_1.AST_NODE_TYPES.ImportDeclaration, + ].includes(node.type)) { + break; + } + node = node.parent; + } + return false; + } + /** + * Finds the uppermost expression node that can evaluate to the given one, + * unwrapping through LogicalExpression and non-test ConditionalExpression branches. + * @param node The node to unwrap. + * @returns The topmost unwrapped node. + */ + function unwrapExpression(node) { + const { parent } = node; + if (parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression || + (parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + parent.test !== node)) { + return unwrapExpression(parent); + } + return node; + } + /** + * Checks if a variable is the name of a function or class expression that is + * directly assigned (or transparently through `||`/`?:`) as the initializer + * of scopeVar. + * + * Allows `var a = function a() {}` but reports `var a = wrap(function a() {})`. + * @param variable The variable to check. + * @param scopeVar The scope variable to look for. + * @returns Whether or not the variable is the direct initializer name of scopeVar. + */ + function isOnInitializer(variable, scopeVar) { + const outerDef = scopeVar.defs.at(0); + const innerDef = variable.defs.at(0); + if (!outerDef || !innerDef) { + return false; + } + if (!((innerDef.type === scope_manager_1.DefinitionType.FunctionName && + innerDef.node.type === utils_1.AST_NODE_TYPES.FunctionExpression) || + (innerDef.type === scope_manager_1.DefinitionType.ClassName && + innerDef.node.type === utils_1.AST_NODE_TYPES.ClassExpression))) { + return false; + } + const outerIdentifier = outerDef.name; + let initializerNode; + if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) { + initializerNode = outerIdentifier.parent.init; + } + else if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + initializerNode = outerIdentifier.parent.right; + } + if (!initializerNode) { + return false; + } + const nodeToCheck = innerDef.node; + if (!(initializerNode.range[0] <= nodeToCheck.range[0] && + nodeToCheck.range[1] <= initializerNode.range[1])) { + return false; + } + return initializerNode === unwrapExpression(nodeToCheck); + } + /** + * Get a range of a variable's identifier node. + * @param variable The variable to get. + * @returns The range of the variable's identifier node. + */ + function getNameRange(variable) { + const def = variable.defs.at(0); + return def?.name.range; + } + /** + * Checks if a variable is in TDZ of scopeVar. + * @param variable The variable to check. + * @param scopeVar The variable of TDZ. + * @returns Whether or not the variable is in TDZ of scopeVar. + */ + function isInTdz(variable, scopeVar) { + const outerDef = scopeVar.defs.at(0); + const inner = getNameRange(variable); + const outer = getNameRange(scopeVar); + if (!inner || !outer || inner[1] >= outer[0]) { + return false; + } + if (!outerDef) { + return true; + } + if (options.hoist === 'functions') { + return !functionsHoistedNodes.has(outerDef.node.type); + } + if (options.hoist === 'types') { + return !typesHoistedNodes.has(outerDef.node.type); + } + if (options.hoist === 'functions-and-types') { + return (!functionsHoistedNodes.has(outerDef.node.type) && + !typesHoistedNodes.has(outerDef.node.type)); + } + return true; + } + /** + * Get declared line and column of a variable. + * @param variable The variable to get. + * @returns The declared line and column of the variable. + */ + function getDeclaredLocation(variable) { + const identifier = variable.identifiers.at(0); + if (identifier) { + return { + column: identifier.loc.start.column + 1, + global: false, + line: identifier.loc.start.line, + }; + } + return { + global: true, + }; + } + /** + * Checks if the initialization of a variable has the declare modifier in a + * definition file. + */ + function isDeclareInDTSFile(variable) { + const fileName = context.filename; + if (!(0, util_1.isDefinitionFile)(fileName)) { + return false; + } + return variable.defs.some(def => { + return ((def.type === scope_manager_1.DefinitionType.Variable && def.parent.declare) || + (def.type === scope_manager_1.DefinitionType.ClassName && def.node.declare) || + (def.type === scope_manager_1.DefinitionType.TSEnumName && def.node.declare) || + (def.type === scope_manager_1.DefinitionType.TSModuleName && def.node.declare)); + }); + } + /** + * Checks the current context for shadowed variables. + * @param scope Fixme + */ + function checkForShadows(scope) { + // ignore global augmentation + if (isGlobalAugmentation(scope)) { + return; + } + const variables = scope.variables; + for (const variable of variables) { + // ignore "arguments" + if (variable.identifiers.length === 0) { + continue; + } + // this params are pseudo-params that cannot be shadowed + if (isThisParam(variable)) { + continue; + } + // ignore variables of a class name in the class scope of ClassDeclaration + if (isDuplicatedClassNameVariable(variable)) { + continue; + } + // ignore variables of a class name in the class scope of ClassDeclaration + if (isDuplicatedEnumNameVariable(variable)) { + continue; + } + // ignore configured allowed names + if (isAllowed(variable)) { + continue; + } + // ignore variables with the declare keyword in .d.ts files + if (isDeclareInDTSFile(variable)) { + continue; + } + // Gets shadowed variable. + const shadowed = scope.upper + ? utils_1.ASTUtils.findVariable(scope.upper, variable.name) + : null; + if (!shadowed) { + continue; + } + // ignore type value variable shadowing if configured + if (isTypeValueShadow(variable, shadowed)) { + continue; + } + // ignore function type parameter name shadowing if configured + if (isFunctionTypeParameterNameValueShadow(variable, shadowed)) { + continue; + } + // ignore static class method generic shadowing class generic + // this is impossible for the scope analyser to understand + // so we have to handle this manually in this rule + if (isGenericOfAStaticMethodShadow(variable, shadowed)) { + continue; + } + if (isExternalDeclarationMerging(scope, variable, shadowed)) { + continue; + } + const isESLintGlobal = 'writeable' in shadowed; + if ((shadowed.identifiers.length > 0 || + (options.builtinGlobals && isESLintGlobal)) && + !isOnInitializer(variable, shadowed) && + !(options.ignoreOnInitialization && + isInitPatternNode(variable, shadowed)) && + !(options.hoist !== 'all' && isInTdz(variable, shadowed))) { + const location = getDeclaredLocation(shadowed); + const isEnumDeclaration = shadowed.defs.some(def => def.type === scope_manager_1.DefinitionType.TSEnumName); + context.report({ + node: variable.identifiers[0], + ...(location.global + ? { + messageId: 'noShadowGlobal', + data: { + name: variable.name, + }, + } + : { + messageId: isEnumDeclaration ? 'noEnumShadow' : 'noShadow', + data: { + name: variable.name, + shadowedColumn: location.column, + shadowedLine: location.line, + }, + }), + }); + } + } + } + return { + 'Program:exit'(node) { + const globalScope = context.sourceCode.getScope(node); + const stack = [...globalScope.childScopes]; + while (stack.length) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const scope = stack.pop(); + stack.push(...scope.childScopes); + checkForShadows(scope); + } + }, + }; + }, +}); +//# sourceMappingURL=no-shadow.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.d.ts new file mode 100644 index 00000000..b583e528 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + allowDestructuring?: boolean; + allowedNames?: string[]; + } +]; +export type MessageIds = 'thisAssignment' | 'thisDestructure'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.js new file mode 100644 index 00000000..c0f6a57c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.js @@ -0,0 +1,67 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-this-alias', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow aliasing `this`', + recommended: 'recommended', + }, + messages: { + thisAssignment: "Unexpected aliasing of 'this' to local variable.", + thisDestructure: "Unexpected aliasing of members of 'this' to local variables.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowDestructuring: { + type: 'boolean', + description: 'Whether to ignore destructuring, such as `const { props, state } = this`.', + }, + allowedNames: { + type: 'array', + description: 'Names to ignore, such as ["self"] for `const self = this;`.', + items: { + type: 'string', + }, + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowDestructuring: true, + allowedNames: [], + }, + ], + create(context, [{ allowDestructuring, allowedNames }]) { + return { + "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(node) { + const id = node.type === utils_1.AST_NODE_TYPES.VariableDeclarator ? node.id : node.left; + if (allowDestructuring && id.type !== utils_1.AST_NODE_TYPES.Identifier) { + return; + } + const hasAllowedName = id.type === utils_1.AST_NODE_TYPES.Identifier + ? // https://github.com/typescript-eslint/typescript-eslint/issues/5439 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + allowedNames.includes(id.name) + : false; + if (!hasAllowedName) { + context.report({ + node: id, + messageId: id.type === utils_1.AST_NODE_TYPES.Identifier + ? 'thisAssignment' + : 'thisDestructure', + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-this-alias.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.d.ts new file mode 100644 index 00000000..bed9f0e2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.d.ts @@ -0,0 +1,18 @@ +type Values = 'always' | 'in-intersections' | 'in-unions' | 'in-unions-and-intersections' | 'never'; +export type Options = [ + { + allowAliases?: Values; + allowCallbacks?: 'always' | 'never'; + allowConditionalTypes?: 'always' | 'never'; + allowConstructors?: 'always' | 'never'; + allowGenerics?: 'always' | 'never'; + allowLiterals?: Values; + allowMappedTypes?: Values; + allowTupleTypes?: Values; + } +]; +export type MessageIds = 'noCompositionAlias' | 'noTypeAlias'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.js new file mode 100644 index 00000000..60af47fa --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.js @@ -0,0 +1,269 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-type-alias', + meta: { + type: 'suggestion', + deprecated: { + deprecatedSince: '6.0.0', + replacedBy: [ + { + rule: { + name: '@typescript-eslint/consistent-type-definitions', + url: 'https://typescript-eslint.io/rules/consistent-type-definitions', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/6229', + }, + docs: { + description: 'Disallow type aliases', + // too opinionated to be recommended + }, + messages: { + noCompositionAlias: '{{typeName}} in {{compositionType}} types are not allowed.', + noTypeAlias: 'Type {{alias}} are not allowed.', + }, + schema: [ + { + type: 'object', + $defs: { + expandedOptions: { + type: 'string', + enum: [ + 'always', + 'never', + 'in-unions', + 'in-intersections', + 'in-unions-and-intersections', + ], + }, + simpleOptions: { + type: 'string', + enum: ['always', 'never'], + }, + }, + additionalProperties: false, + properties: { + allowAliases: { + $ref: '#/items/0/$defs/expandedOptions', + description: 'Whether to allow direct one-to-one type aliases.', + }, + allowCallbacks: { + $ref: '#/items/0/$defs/simpleOptions', + description: 'Whether to allow type aliases for callbacks.', + }, + allowConditionalTypes: { + $ref: '#/items/0/$defs/simpleOptions', + description: 'Whether to allow type aliases for conditional types.', + }, + allowConstructors: { + $ref: '#/items/0/$defs/simpleOptions', + description: 'Whether to allow type aliases with constructors.', + }, + allowGenerics: { + $ref: '#/items/0/$defs/simpleOptions', + description: 'Whether to allow type aliases with generic types.', + }, + allowLiterals: { + $ref: '#/items/0/$defs/expandedOptions', + description: 'Whether to allow type aliases with object literal types.', + }, + allowMappedTypes: { + $ref: '#/items/0/$defs/expandedOptions', + description: 'Whether to allow type aliases with mapped types.', + }, + allowTupleTypes: { + $ref: '#/items/0/$defs/expandedOptions', + description: 'Whether to allow type aliases with tuple types.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowAliases: 'never', + allowCallbacks: 'never', + allowConditionalTypes: 'never', + allowConstructors: 'never', + allowGenerics: 'never', + allowLiterals: 'never', + allowMappedTypes: 'never', + allowTupleTypes: 'never', + }, + ], + create(context, [{ allowAliases, allowCallbacks, allowConditionalTypes, allowConstructors, allowGenerics, allowLiterals, allowMappedTypes, allowTupleTypes, },]) { + const unions = ['always', 'in-unions', 'in-unions-and-intersections']; + const intersections = [ + 'always', + 'in-intersections', + 'in-unions-and-intersections', + ]; + const compositions = [ + 'in-unions', + 'in-intersections', + 'in-unions-and-intersections', + ]; + const aliasTypes = new Set([ + utils_1.AST_NODE_TYPES.TSArrayType, + utils_1.AST_NODE_TYPES.TSImportType, + utils_1.AST_NODE_TYPES.TSIndexedAccessType, + utils_1.AST_NODE_TYPES.TSLiteralType, + utils_1.AST_NODE_TYPES.TSTemplateLiteralType, + utils_1.AST_NODE_TYPES.TSTypeQuery, + utils_1.AST_NODE_TYPES.TSTypeReference, + ]); + /** + * Determines if the composition type is supported by the allowed flags. + * @param isTopLevel a flag indicating this is the top level node. + * @param compositionType the composition type (either TSUnionType or TSIntersectionType) + * @param allowed the currently allowed flags. + */ + function isSupportedComposition(isTopLevel, compositionType, allowed) { + return (!compositions.includes(allowed) || + (!isTopLevel && + ((compositionType === utils_1.AST_NODE_TYPES.TSUnionType && + unions.includes(allowed)) || + (compositionType === utils_1.AST_NODE_TYPES.TSIntersectionType && + intersections.includes(allowed))))); + } + /** + * Gets the message to be displayed based on the node type and whether the node is a top level declaration. + * @param node the location + * @param compositionType the type of composition this alias is part of (undefined if not + * part of a composition) + * @param isRoot a flag indicating we are dealing with the top level declaration. + * @param type the kind of type alias being validated. + */ + function reportError(node, compositionType, isRoot, type) { + if (isRoot) { + return context.report({ + node, + messageId: 'noTypeAlias', + data: { + alias: type.toLowerCase(), + }, + }); + } + return context.report({ + node, + messageId: 'noCompositionAlias', + data: { + compositionType: compositionType === utils_1.AST_NODE_TYPES.TSUnionType + ? 'union' + : 'intersection', + typeName: type, + }, + }); + } + const isValidTupleType = (type) => { + if (type.node.type === utils_1.AST_NODE_TYPES.TSTupleType) { + return true; + } + if (type.node.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + ['keyof', 'readonly'].includes(type.node.operator) && + type.node.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTupleType) { + return true; + } + return false; + }; + const isValidGeneric = (type) => { + return (type.node.type === utils_1.AST_NODE_TYPES.TSTypeReference && + type.node.typeArguments != null); + }; + const checkAndReport = (optionValue, isTopLevel, type, label) => { + if (optionValue === 'never' || + !isSupportedComposition(isTopLevel, type.compositionType, optionValue)) { + reportError(type.node, type.compositionType, isTopLevel, label); + } + }; + /** + * Validates the node looking for aliases, callbacks and literals. + * @param type the type of composition this alias is part of (null if not + * part of a composition) + * @param isTopLevel a flag indicating this is the top level node. + */ + function validateTypeAliases(type, isTopLevel = false) { + // https://github.com/typescript-eslint/typescript-eslint/issues/5439 + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + if (type.node.type === utils_1.AST_NODE_TYPES.TSFunctionType) { + // callback + if (allowCallbacks === 'never') { + reportError(type.node, type.compositionType, isTopLevel, 'Callbacks'); + } + } + else if (type.node.type === utils_1.AST_NODE_TYPES.TSConditionalType) { + // conditional type + if (allowConditionalTypes === 'never') { + reportError(type.node, type.compositionType, isTopLevel, 'Conditional types'); + } + } + else if (type.node.type === utils_1.AST_NODE_TYPES.TSConstructorType) { + if (allowConstructors === 'never') { + reportError(type.node, type.compositionType, isTopLevel, 'Constructors'); + } + } + else if (type.node.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) { + // literal object type + checkAndReport(allowLiterals, isTopLevel, type, 'Literals'); + } + else if (type.node.type === utils_1.AST_NODE_TYPES.TSMappedType) { + // mapped type + checkAndReport(allowMappedTypes, isTopLevel, type, 'Mapped types'); + } + else if (isValidTupleType(type)) { + // tuple types + checkAndReport(allowTupleTypes, isTopLevel, type, 'Tuple Types'); + } + else if (isValidGeneric(type)) { + if (allowGenerics === 'never') { + reportError(type.node, type.compositionType, isTopLevel, 'Generics'); + } + } + else if (type.node.type.endsWith(utils_1.AST_TOKEN_TYPES.Keyword) || + aliasTypes.has(type.node.type) || + (type.node.type === utils_1.AST_NODE_TYPES.TSTypeOperator && + (type.node.operator === 'keyof' || + (type.node.operator === 'readonly' && + type.node.typeAnnotation && + aliasTypes.has(type.node.typeAnnotation.type))))) { + // alias / keyword + checkAndReport(allowAliases, isTopLevel, type, 'Aliases'); + } + else { + // unhandled type - shouldn't happen + reportError(type.node, type.compositionType, isTopLevel, 'Unhandled'); + } + /* eslint-enable @typescript-eslint/no-non-null-assertion */ + } + /** + * Flatten the given type into an array of its dependencies + */ + function getTypes(node, compositionType = null) { + if (node.type === utils_1.AST_NODE_TYPES.TSUnionType || + node.type === utils_1.AST_NODE_TYPES.TSIntersectionType) { + return node.types.flatMap(type => getTypes(type, node.type)); + } + return [{ node, compositionType }]; + } + return { + TSTypeAliasDeclaration(node) { + const types = getTypes(node.typeAnnotation); + if (types.length === 1) { + // is a top level type annotation + validateTypeAliases(types[0], true); + } + else { + // is a composition type + types.forEach(type => { + validateTypeAliases(type); + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-type-alias.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.d.ts new file mode 100644 index 00000000..2ea3109a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.d.ts @@ -0,0 +1,12 @@ +export type MessageIds = 'comparingNullableToFalse' | 'comparingNullableToTrueDirect' | 'comparingNullableToTrueNegated' | 'direct' | 'negated' | 'noStrictNullCheck'; +export type Options = [ + { + allowComparingNullableBooleansToFalse?: boolean; + allowComparingNullableBooleansToTrue?: boolean; + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.js new file mode 100644 index 00000000..57a00884 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.js @@ -0,0 +1,286 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-boolean-literal-compare', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow unnecessary equality comparisons against boolean literals', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + comparingNullableToFalse: 'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.', + comparingNullableToTrueDirect: 'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.', + comparingNullableToTrueNegated: 'This expression unnecessarily compares a nullable boolean value to true instead of negating it.', + direct: 'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.', + negated: 'This expression unnecessarily compares a boolean value to a boolean instead of negating it.', + noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowComparingNullableBooleansToFalse: { + type: 'boolean', + description: 'Whether to allow comparisons between nullable boolean variables and `false`.', + }, + allowComparingNullableBooleansToTrue: { + type: 'boolean', + description: 'Whether to allow comparisons between nullable boolean variables and `true`.', + }, + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: { + type: 'boolean', + description: 'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowComparingNullableBooleansToFalse: true, + allowComparingNullableBooleansToTrue: true, + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks'); + if (!isStrictNullChecks && + options.allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) { + context.report({ + loc: { + start: { column: 0, line: 0 }, + end: { column: 0, line: 0 }, + }, + messageId: 'noStrictNullCheck', + }); + } + function getBooleanComparison(node) { + const comparison = deconstructComparison(node); + if (!comparison) { + return undefined; + } + const { constraintType, isTypeParameter } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(comparison.expression)); + if (isTypeParameter && constraintType == null) { + return undefined; + } + if (isBooleanType(constraintType)) { + return { + ...comparison, + expressionIsNullableBoolean: false, + }; + } + if (isNullableBoolean(constraintType)) { + return { + ...comparison, + expressionIsNullableBoolean: true, + }; + } + return undefined; + } + function isBooleanType(expressionType) { + return tsutils.isTypeFlagSet(expressionType, ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral); + } + /** + * checks if the expressionType is a union that + * 1) contains at least one nullish type (null or undefined) + * 2) contains at least once boolean type (true or false or boolean) + * 3) does not contain any types besides nullish and boolean types + */ + function isNullableBoolean(expressionType) { + if (!expressionType.isUnion()) { + return false; + } + const { types } = expressionType; + const nonNullishTypes = types.filter(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Undefined | ts.TypeFlags.Null)); + const hasNonNullishType = nonNullishTypes.length > 0; + if (!hasNonNullishType) { + return false; + } + const hasNullableType = nonNullishTypes.length < types.length; + if (!hasNullableType) { + return false; + } + const allNonNullishTypesAreBoolean = nonNullishTypes.every(isBooleanType); + if (!allNonNullishTypesAreBoolean) { + return false; + } + return true; + } + function deconstructComparison(node) { + const comparisonType = getEqualsKind(node.operator); + if (!comparisonType) { + return undefined; + } + for (const [against, expression] of [ + [node.right, node.left], + [node.left, node.right], + ]) { + if (against.type !== utils_1.AST_NODE_TYPES.Literal || + typeof against.value !== 'boolean') { + continue; + } + const booleanLiteral = against.value ? 'true' : 'false'; + const negated = !comparisonType.isPositive; + return { + booleanLiteral, + expression, + negated, + }; + } + return undefined; + } + function nodeIsUnaryNegation(node) { + return (node.type === utils_1.AST_NODE_TYPES.UnaryExpression && node.operator === '!'); + } + return { + BinaryExpression(node) { + const comparison = getBooleanComparison(node); + if (comparison == null) { + return; + } + if (comparison.expressionIsNullableBoolean) { + if (comparison.booleanLiteral === 'true' && + options.allowComparingNullableBooleansToTrue) { + return; + } + if (comparison.booleanLiteral === 'false' && + options.allowComparingNullableBooleansToFalse) { + return; + } + } + context.report({ + node, + messageId: comparison.expressionIsNullableBoolean + ? comparison.booleanLiteral === 'true' + ? comparison.negated + ? 'comparingNullableToTrueNegated' + : 'comparingNullableToTrueDirect' + : 'comparingNullableToFalse' + : comparison.negated + ? 'negated' + : 'direct', + fix(fixer) { + const isWrappedInUnaryNegation = nodeIsUnaryNegation(node.parent); + const mutatedNode = isWrappedInUnaryNegation ? node.parent : node; + // Whether the truth table of the overall expression being replaced + // is negated, _ignoring the nullish cases_. + const isOverallNegated = booleanXor(isWrappedInUnaryNegation, comparison.negated, comparison.booleanLiteral === 'false'); + // we'll build up the replacement text from the compared expression outwards. + let replacementText = context.sourceCode.getText(comparison.expression); + let mayNeedParentheses = !(0, util_1.isStrongPrecedenceNode)(comparison.expression); + const fixWouldReturnExpressionDirectly = !isOverallNegated && comparison.expressionIsNullableBoolean; + if (fixWouldReturnExpressionDirectly && + !(0, util_1.isConditionalTest)(mutatedNode)) { + if (mayNeedParentheses) { + replacementText = parenthesize(replacementText); + } + replacementText = `${replacementText} ?? false`; + mayNeedParentheses = true; + } + else { + // In maybeNullish === false, nullish values have the same truth table + // as `true`. + if (comparison.expressionIsNullableBoolean && + comparison.booleanLiteral === 'false') { + if (mayNeedParentheses) { + replacementText = parenthesize(replacementText); + } + replacementText = `${replacementText} ?? true`; + mayNeedParentheses = true; + } + if (isOverallNegated) { + if (mayNeedParentheses) { + replacementText = parenthesize(replacementText); + } + replacementText = `!${replacementText}`; + mayNeedParentheses = false; + } + } + if (mayNeedParentheses && (0, util_1.isWeakPrecedenceParent)(mutatedNode)) { + replacementText = parenthesize(replacementText); + } + return fixer.replaceText(mutatedNode, replacementText); + }, + }); + }, + }; + }, +}); +function getEqualsKind(operator) { + switch (operator) { + case '!=': + return { + isPositive: false, + isStrict: false, + }; + case '!==': + return { + isPositive: false, + isStrict: true, + }; + case '==': + return { + isPositive: true, + isStrict: false, + }; + case '===': + return { + isPositive: true, + isStrict: true, + }; + default: + return undefined; + } +} +function booleanXor(arg0, ...args) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion + return args.reduce((acc, curr) => acc !== Boolean(curr), Boolean(arg0)); +} +function parenthesize(text) { + return `(${text})`; +} +//# sourceMappingURL=no-unnecessary-boolean-literal-compare.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.d.ts new file mode 100644 index 00000000..925abd15 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.d.ts @@ -0,0 +1,14 @@ +type LegacyAllowConstantLoopConditions = boolean; +type AllowConstantLoopConditions = 'always' | 'never' | 'only-allowed-literals'; +export type Options = [ + { + allowConstantLoopConditions?: AllowConstantLoopConditions | LegacyAllowConstantLoopConditions; + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + checkTypePredicates?: boolean; + } +]; +export type MessageId = 'alwaysFalsy' | 'alwaysFalsyFunc' | 'alwaysNullish' | 'alwaysTruthy' | 'alwaysTruthyFunc' | 'comparisonBetweenLiteralTypes' | 'never' | 'neverNullish' | 'neverOptionalChain' | 'noOverlapBooleanExpression' | 'noStrictNullCheck' | 'suggestRemoveOptionalChain' | 'typeGuardAlreadyIsType'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js new file mode 100644 index 00000000..387d6c88 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js @@ -0,0 +1,760 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const assertionFunctionUtils_1 = require("../util/assertionFunctionUtils"); +// #region +const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null; +function isNullishType(type) { + return tsutils.isTypeFlagSet(type, nullishFlag); +} +function isAlwaysNullish(type) { + return tsutils.unionConstituents(type).every(isNullishType); +} +/** + * Note that this differs from {@link isNullableType} in that it doesn't consider + * `any` or `unknown` to be nullable. + */ +function isPossiblyNullish(type) { + return tsutils + .unionConstituents(type) + .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void)); +} +/** + * Note that this differs from {@link isNullableType} in that it doesn't consider + * `any` or `unknown` to be nullable. + */ +function isPossiblyNonNullish(type) { + return tsutils + .unionConstituents(type) + .some(t => !isNullishType(t) && !(0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void)); +} +function toStaticValue(type) { + // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches. + if (tsutils.isBooleanLiteralType(type)) { + return { value: tsutils.isTrueLiteralType(type) }; + } + if (type.flags === ts.TypeFlags.Undefined) { + return { value: undefined }; + } + if (type.flags === ts.TypeFlags.Null) { + return { value: null }; + } + if (type.isLiteral()) { + return { value: (0, util_1.getValueOfLiteralType)(type) }; + } + return undefined; +} +const BOOL_OPERATORS = new Set([ + '<', + '>', + '<=', + '>=', + '==', + '===', + '!=', + '!==', +]); +function isBoolOperator(operator) { + return BOOL_OPERATORS.has(operator); +} +function booleanComparison(left, operator, right) { + switch (operator) { + case '!=': + // eslint-disable-next-line eqeqeq -- intentionally comparing with loose equality + return left != right; + case '!==': + return left !== right; + case '<': + // @ts-expect-error: we don't care if the comparison seems unintentional. + return left < right; + case '<=': + // @ts-expect-error: we don't care if the comparison seems unintentional. + return left <= right; + case '==': + // eslint-disable-next-line eqeqeq -- intentionally comparing with loose equality + return left == right; + case '===': + return left === right; + case '>': + // @ts-expect-error: we don't care if the comparison seems unintentional. + return left > right; + case '>=': + // @ts-expect-error: we don't care if the comparison seems unintentional. + return left >= right; + } +} +function isOnlyUsedForTruthiness(node) { + const parent = node.parent; + switch (parent.type) { + case utils_1.AST_NODE_TYPES.ConditionalExpression: + case utils_1.AST_NODE_TYPES.DoWhileStatement: + case utils_1.AST_NODE_TYPES.ForStatement: + case utils_1.AST_NODE_TYPES.IfStatement: + case utils_1.AST_NODE_TYPES.WhileStatement: + return parent.test === node; + case utils_1.AST_NODE_TYPES.LogicalExpression: + return ((parent.operator === '&&' && parent.left === node) || + isOnlyUsedForTruthiness(parent)); + case utils_1.AST_NODE_TYPES.UnaryExpression: + return parent.operator === '!'; + default: + return false; + } +} +const constantLoopConditionsAllowedLiterals = new Set([ + true, + false, + 1, + 0, +]); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-condition', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow conditionals where the type is always truthy or always falsy', + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + alwaysFalsy: 'Unnecessary conditional, value is always falsy.', + alwaysFalsyFunc: 'This callback should return a conditional, but return is always falsy.', + alwaysNullish: 'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.', + alwaysTruthy: 'Unnecessary conditional, value is always truthy.', + alwaysTruthyFunc: 'This callback should return a conditional, but return is always truthy.', + comparisonBetweenLiteralTypes: 'Unnecessary conditional, comparison is always {{trueOrFalse}}, since `{{left}} {{operator}} {{right}}` is {{trueOrFalse}}.', + never: 'Unnecessary conditional, value is `never`.', + neverNullish: 'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.', + neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.', + noOverlapBooleanExpression: 'Unnecessary conditional, the types have no overlap.', + noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.', + suggestRemoveOptionalChain: 'Remove unnecessary optional chain', + typeGuardAlreadyIsType: 'Unnecessary conditional, expression already has the type being checked by the {{typeGuardOrAssertionFunction}}.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowConstantLoopConditions: { + description: 'Whether to ignore constant loop conditions, such as `while (true)`.', + oneOf: [ + { + type: 'boolean', + description: 'Always ignore or not ignore the loop conditions', + }, + { + type: 'string', + description: 'Which situations to ignore constant conditions in.', + enum: ['always', 'never', 'only-allowed-literals'], + }, + ], + }, + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: { + type: 'boolean', + description: 'Whether to not error when running with a tsconfig that has strictNullChecks turned.', + }, + checkTypePredicates: { + type: 'boolean', + description: 'Whether to check the asserted argument of a type predicate function for unnecessary conditions', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowConstantLoopConditions: 'never', + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false, + checkTypePredicates: false, + }, + ], + create(context, [{ allowConstantLoopConditions, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, checkTypePredicates, },]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks'); + const isNoUncheckedIndexedAccess = tsutils.isCompilerOptionEnabled(compilerOptions, 'noUncheckedIndexedAccess'); + const allowConstantLoopConditionsOption = normalizeAllowConstantLoopConditions( + // https://github.com/typescript-eslint/typescript-eslint/issues/5439 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + allowConstantLoopConditions); + if (!isStrictNullChecks && + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) { + context.report({ + loc: { + start: { column: 0, line: 0 }, + end: { column: 0, line: 0 }, + }, + messageId: 'noStrictNullCheck', + }); + } + function nodeIsArrayType(node) { + const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node); + return tsutils + .unionConstituents(nodeType) + .some(part => checker.isArrayType(part)); + } + function nodeIsTupleType(node) { + const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node); + return tsutils + .unionConstituents(nodeType) + .some(part => checker.isTupleType(part)); + } + function isArrayIndexExpression(node) { + return ( + // Is an index signature + node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.computed && + // ...into an array type + (nodeIsArrayType(node.object) || + // ... or a tuple type + (nodeIsTupleType(node.object) && + // Exception: literal index into a tuple - will have a sound type + node.property.type !== utils_1.AST_NODE_TYPES.Literal))); + } + // Conditional is always necessary if it involves: + // `any` or `unknown` or a naked type variable + function isConditionalAlwaysNecessary(type) { + return tsutils + .unionConstituents(type) + .some(part => (0, util_1.isTypeAnyType)(part) || + (0, util_1.isTypeUnknownType)(part) || + (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable)); + } + function isNullableMemberExpression(node) { + const objectType = services.getTypeAtLocation(node.object); + if (node.computed) { + const propertyType = services.getTypeAtLocation(node.property); + return isNullablePropertyType(objectType, propertyType); + } + const property = node.property; + // Get the actual property name, to account for private properties (this.#prop). + const propertyName = context.sourceCode.getText(property); + const propertyType = objectType + .getProperties() + .find(prop => prop.name === propertyName); + return (propertyType != null && + tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)); + } + /** + * Obtains the property types of the computed member expression + * @param node The member expression + * @returns The property types, unless the node isn't computed. + */ + function getComputedMemberPropertyTypes(node) { + if (!node.computed) { + return undefined; + } + const objectType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object); + const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property); + const propertyTypes = []; + for (const keyType of tsutils.unionConstituents(propertyType)) { + if (!keyType.isStringLiteral() && !keyType.isNumberLiteral()) { + return undefined; + } + const selectedType = (0, util_1.getTypeOfPropertyOfName)(checker, objectType, String(keyType.value)); + if (!selectedType) { + return undefined; + } + propertyTypes.push(selectedType); + } + return propertyTypes; + } + /** + * Verify if the node may have non-nullish properties + * @param node The node to verify + * @returns If it may have non-nullish properties, unless the node isn't a + * MemberExpression + */ + function hasPossiblyNonNullishComputedMemberProperty(node) { + if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return false; + } + const propertyTypes = getComputedMemberPropertyTypes(node); + if (propertyTypes == null) { + return false; + } + return propertyTypes.some(isPossiblyNonNullish); + } + /** + * Checks if a conditional node is necessary: + * if the type of the node is always true or always false, it's not necessary. + */ + function checkNode(expression, isUnaryNotArgument = false, node = expression) { + // Check if the node is Unary Negation expression and handle it + if (expression.type === utils_1.AST_NODE_TYPES.UnaryExpression && + expression.operator === '!') { + return checkNode(expression.argument, !isUnaryNotArgument, node); + } + // Since typescript array index signature types don't represent the + // possibility of out-of-bounds access, if we're indexing into an array + // just skip the check, to avoid false positives + if (!isNoUncheckedIndexedAccess && isArrayIndexExpression(expression)) { + return; + } + // Only check the right side when the logical expression is used for + // truthiness, as the left side has already been checked by + // checkLogicalExpressionForUnnecessaryConditionals. + // + // Unless the node is nullish coalescing, as it's common to use patterns like + // `nullBool ?? true` to perform strict boolean checks. If we inspect the right + // here, it'll usually be a constant condition on purpose. + // In this case it's better to inspect the type of the expression as a whole. + if (expression.type === utils_1.AST_NODE_TYPES.LogicalExpression && + expression.operator !== '??') { + if (isOnlyUsedForTruthiness(expression)) { + checkNode(expression.right); + } + return; + } + const type = (0, util_1.getConstrainedTypeAtLocation)(services, expression); + if (isConditionalAlwaysNecessary(type)) { + return; + } + let messageId = null; + if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) { + messageId = 'never'; + } + else if (!(0, util_1.isPossiblyTruthy)(type)) { + messageId = !isUnaryNotArgument ? 'alwaysFalsy' : 'alwaysTruthy'; + } + else if (!(0, util_1.isPossiblyFalsy)(type)) { + messageId = !isUnaryNotArgument ? 'alwaysTruthy' : 'alwaysFalsy'; + } + if (messageId) { + context.report({ node, messageId }); + } + } + function checkNodeForNullish(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + // Conditional is always necessary if it involves `any`, `unknown` or a naked type parameter + if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Any | + ts.TypeFlags.Unknown | + ts.TypeFlags.TypeParameter | + ts.TypeFlags.TypeVariable)) { + return; + } + let messageId = null; + if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) { + messageId = 'never'; + } + else if (!isPossiblyNullish(type) && + !(node.type === utils_1.AST_NODE_TYPES.MemberExpression && + isNullableMemberExpression(node))) { + // Since typescript array index signature types don't represent the + // possibility of out-of-bounds access, if we're indexing into an array + // just skip the check, to avoid false positives + if (isNoUncheckedIndexedAccess || + (!isArrayIndexExpression(node) && + !(node.type === utils_1.AST_NODE_TYPES.ChainExpression && + node.expression.type !== utils_1.AST_NODE_TYPES.TSNonNullExpression && + optionChainContainsOptionArrayIndex(node.expression)))) { + messageId = 'neverNullish'; + } + } + else if (isAlwaysNullish(type) && + !hasPossiblyNonNullishComputedMemberProperty(node)) { + messageId = 'alwaysNullish'; + } + if (messageId) { + context.report({ node, messageId }); + } + } + /** + * Checks that a binary expression is necessarily conditional, reports otherwise. + * If both sides of the binary expression are literal values, it's not a necessary condition. + * + * NOTE: It's also unnecessary if the types that don't overlap at all + * but that case is handled by the Typescript compiler itself. + * Known exceptions: + * - https://github.com/microsoft/TypeScript/issues/32627 + * - https://github.com/microsoft/TypeScript/issues/37160 (handled) + */ + function checkIfBoolExpressionIsNecessaryConditional(node, left, right, operator) { + const leftType = (0, util_1.getConstrainedTypeAtLocation)(services, left); + const rightType = (0, util_1.getConstrainedTypeAtLocation)(services, right); + const leftStaticValue = toStaticValue(leftType); + const rightStaticValue = toStaticValue(rightType); + if (leftStaticValue != null && rightStaticValue != null) { + const conditionIsTrue = booleanComparison(leftStaticValue.value, operator, rightStaticValue.value); + context.report({ + node, + messageId: 'comparisonBetweenLiteralTypes', + data: { + left: checker.typeToString(leftType), + operator, + right: checker.typeToString(rightType), + trueOrFalse: conditionIsTrue ? 'true' : 'false', + }, + }); + return; + } + // Workaround for https://github.com/microsoft/TypeScript/issues/37160 + if (isStrictNullChecks) { + const UNDEFINED = ts.TypeFlags.Undefined; + const NULL = ts.TypeFlags.Null; + const VOID = ts.TypeFlags.Void; + const isComparable = (type, flag) => { + // Allow comparison to `any`, `unknown` or a naked type parameter. + flag |= + ts.TypeFlags.Any | + ts.TypeFlags.Unknown | + ts.TypeFlags.TypeParameter | + ts.TypeFlags.TypeVariable; + // Allow loose comparison to nullish values. + if (operator === '==' || operator === '!=') { + flag |= NULL | UNDEFINED | VOID; + } + return (0, util_1.isTypeFlagSet)(type, flag); + }; + if ((leftType.flags === UNDEFINED && + !isComparable(rightType, UNDEFINED | VOID)) || + (rightType.flags === UNDEFINED && + !isComparable(leftType, UNDEFINED | VOID)) || + (leftType.flags === NULL && !isComparable(rightType, NULL)) || + (rightType.flags === NULL && !isComparable(leftType, NULL))) { + context.report({ node, messageId: 'noOverlapBooleanExpression' }); + return; + } + } + } + /** + * Checks that a logical expression contains a boolean, reports otherwise. + */ + function checkLogicalExpressionForUnnecessaryConditionals(node) { + if (node.operator === '??') { + checkNodeForNullish(node.left); + return; + } + // Only checks the left side, since the right side might not be "conditional" at all. + // The right side will be checked if the LogicalExpression is used in a conditional context + checkNode(node.left); + } + /** + * Checks that a testable expression of a loop is necessarily conditional, reports otherwise. + */ + function checkIfLoopIsNecessaryConditional(node) { + if (node.test == null) { + // e.g. `for(;;)` + return; + } + if (allowConstantLoopConditionsOption === 'only-allowed-literals' && + node.test.type === utils_1.AST_NODE_TYPES.Literal && + constantLoopConditionsAllowedLiterals.has(node.test.value)) { + return; + } + if (allowConstantLoopConditionsOption === 'always' && + tsutils.isTrueLiteralType((0, util_1.getConstrainedTypeAtLocation)(services, node.test))) { + return; + } + checkNode(node.test); + } + function checkCallExpression(node) { + if (checkTypePredicates) { + const truthinessAssertedArgument = (0, assertionFunctionUtils_1.findTruthinessAssertedArgument)(services, node); + if (truthinessAssertedArgument != null) { + checkNode(truthinessAssertedArgument); + } + const typeGuardAssertedArgument = (0, assertionFunctionUtils_1.findTypeGuardAssertedArgument)(services, node); + if (typeGuardAssertedArgument != null) { + const typeOfArgument = (0, util_1.getConstrainedTypeAtLocation)(services, typeGuardAssertedArgument.argument); + if ( + // Skip `any` — it is assignable to everything, producing + // false positives for meaningful runtime type guards. + !tsutils.isTypeFlagSet(typeOfArgument, ts.TypeFlags.Any | ts.TypeFlags.Unknown) && + checker.isTypeAssignableTo(typeOfArgument, typeGuardAssertedArgument.type) && + // Only flag if the types are mutually assignable (i.e. equivalent, + // like Narrower ↔ Wider with optional props) or the predicate type + // is a union that the argument is a strict subtype of. This avoids + // false positives with structural subtypes whose extra members are + // all optional in the *predicate* type (e.g. custom MappedType + // interfaces extending ts.Type). + (checker.isTypeAssignableTo(typeGuardAssertedArgument.type, typeOfArgument) || + typeGuardAssertedArgument.type.isUnion())) { + context.report({ + node: typeGuardAssertedArgument.argument, + messageId: 'typeGuardAlreadyIsType', + data: { + typeGuardOrAssertionFunction: typeGuardAssertedArgument.asserts + ? 'assertion function' + : 'type guard', + }, + }); + } + } + } + // If this is something like arr.filter(x => /*condition*/), check `condition` + if ((0, util_1.isArrayMethodCallWithPredicate)(context, services, node) && + node.arguments.length) { + const callback = node.arguments[0]; + // Inline defined functions + if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) { + // Two special cases, where we can directly check the node that's returned: + // () => something + if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + return checkNode(callback.body); + } + // () => { return something; } + const callbackBody = callback.body.body; + if (callbackBody.length === 1 && + callbackBody[0].type === utils_1.AST_NODE_TYPES.ReturnStatement && + callbackBody[0].argument) { + return checkNode(callbackBody[0].argument); + } + // Potential enhancement: could use code-path analysis to check + // any function with a single return statement + // (Value to complexity ratio is dubious however) + } + // Otherwise just do type analysis on the function as a whole. + const returnTypes = tsutils + .getCallSignaturesOfType((0, util_1.getConstrainedTypeAtLocation)(services, callback)) + .map(sig => sig.getReturnType()); + if (returnTypes.length === 0) { + // Not a callable function, e.g. `any` + return; + } + let hasFalsyReturnTypes = false; + let hasTruthyReturnTypes = false; + for (const type of returnTypes) { + const { constraintType } = (0, util_1.getConstraintInfo)(checker, type); + // Predicate is always necessary if it involves `any` or `unknown` + if (!constraintType || + (0, util_1.isTypeAnyType)(constraintType) || + (0, util_1.isTypeUnknownType)(constraintType)) { + return; + } + if ((0, util_1.isPossiblyFalsy)(constraintType)) { + hasFalsyReturnTypes = true; + } + if ((0, util_1.isPossiblyTruthy)(constraintType)) { + hasTruthyReturnTypes = true; + } + // bail early if both a possibly-truthy and a possibly-falsy have been detected + if (hasFalsyReturnTypes && hasTruthyReturnTypes) { + return; + } + } + if (!hasFalsyReturnTypes) { + return context.report({ + node: callback, + messageId: 'alwaysTruthyFunc', + }); + } + if (!hasTruthyReturnTypes) { + return context.report({ + node: callback, + messageId: 'alwaysFalsyFunc', + }); + } + } + } + // Recursively searches an optional chain for an array index expression + // Has to search the entire chain, because an array index will "infect" the rest of the types + // Example: + // ``` + // [{x: {y: "z"} }][n] // type is {x: {y: "z"}} + // ?.x // type is {y: "z"} + // ?.y // This access is considered "unnecessary" according to the types + // ``` + function optionChainContainsOptionArrayIndex(node) { + const lhsNode = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object; + if (node.optional && isArrayIndexExpression(lhsNode)) { + return true; + } + if (lhsNode.type === utils_1.AST_NODE_TYPES.MemberExpression || + lhsNode.type === utils_1.AST_NODE_TYPES.CallExpression) { + return optionChainContainsOptionArrayIndex(lhsNode); + } + return false; + } + function isNullablePropertyType(objType, propertyType) { + if (propertyType.isUnion()) { + return propertyType.types.some(type => isNullablePropertyType(objType, type)); + } + if (propertyType.isNumberLiteral() || propertyType.isStringLiteral()) { + const propType = (0, util_1.getTypeOfPropertyOfName)(checker, objType, propertyType.value.toString()); + if (propType) { + return (0, util_1.isNullableType)(propType); + } + } + const typeName = (0, util_1.getTypeName)(checker, propertyType); + return checker + .getIndexInfosOfType(objType) + .some(info => (0, util_1.getTypeName)(checker, info.keyType) === typeName); + } + // Checks whether a member expression is nullable or not regardless of it's previous node. + // Example: + // ``` + // // 'bar' is nullable if 'foo' is null. + // // but this function checks regardless of 'foo' type, so returns 'true'. + // declare const foo: { bar : { baz: string } } | null + // foo?.bar; + // ``` + function isMemberExpressionNullableOriginFromObject(node) { + const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object); + const property = node.property; + if (prevType.isUnion() && (0, util_1.isIdentifier)(property)) { + const isOwnNullable = prevType.types.some(type => { + if (node.computed) { + const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property); + return isNullablePropertyType(type, propertyType); + } + const propType = (0, util_1.getTypeOfPropertyOfName)(checker, type, property.name); + if (propType) { + return (0, util_1.isNullableType)(propType); + } + const indexInfo = checker.getIndexInfosOfType(type); + return indexInfo.some(info => { + const isStringTypeName = (0, util_1.getTypeName)(checker, info.keyType) === 'string'; + return (isStringTypeName && + (isNoUncheckedIndexedAccess || (0, util_1.isNullableType)(info.type))); + }); + }); + return !isOwnNullable && (0, util_1.isNullableType)(prevType); + } + return false; + } + function isCallExpressionNullableOriginFromCallee(node) { + const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.callee); + if (prevType.isUnion()) { + const isOwnNullable = prevType.types.some(type => { + const signatures = type.getCallSignatures(); + return signatures.some(sig => (0, util_1.isNullableType)(sig.getReturnType())); + }); + return !isOwnNullable && (0, util_1.isNullableType)(prevType); + } + return false; + } + function isOptionableExpression(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + const isOwnNullable = node.type === utils_1.AST_NODE_TYPES.MemberExpression + ? !isMemberExpressionNullableOriginFromObject(node) + : node.type === utils_1.AST_NODE_TYPES.CallExpression + ? !isCallExpressionNullableOriginFromCallee(node) + : true; + return (isConditionalAlwaysNecessary(type) || + (isOwnNullable && (0, util_1.isNullableType)(type))); + } + function checkOptionalChain(node, beforeOperator, fix) { + // We only care if this step in the chain is optional. If just descend + // from an optional chain, then that's fine. + if (!node.optional) { + return; + } + // Since typescript array index signature types don't represent the + // possibility of out-of-bounds access, if we're indexing into an array + // just skip the check, to avoid false positives + if (!isNoUncheckedIndexedAccess && + optionChainContainsOptionArrayIndex(node)) { + return; + } + const nodeToCheck = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object; + if (isOptionableExpression(nodeToCheck)) { + return; + } + const questionDotOperator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(beforeOperator, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '?.'), util_1.NullThrowsReasons.MissingToken('operator', node.type)); + context.report({ + loc: questionDotOperator.loc, + node, + messageId: 'neverOptionalChain', + suggest: [ + { + messageId: 'suggestRemoveOptionalChain', + fix(fixer) { + return fixer.replaceText(questionDotOperator, fix); + }, + }, + ], + }); + } + function checkOptionalMemberExpression(node) { + checkOptionalChain(node, node.object, node.computed ? '' : '.'); + } + function checkOptionalCallExpression(node) { + checkOptionalChain(node, node.callee, ''); + } + function checkAssignmentExpression(node) { + // Similar to checkLogicalExpressionForUnnecessaryConditionals, since + // a ||= b is equivalent to a || (a = b) + if (['&&=', '||='].includes(node.operator)) { + checkNode(node.left); + } + else if (node.operator === '??=') { + checkNodeForNullish(node.left); + } + } + return { + AssignmentExpression: checkAssignmentExpression, + BinaryExpression(node) { + const { operator } = node; + if (isBoolOperator(operator)) { + checkIfBoolExpressionIsNecessaryConditional(node, node.left, node.right, operator); + } + }, + CallExpression: checkCallExpression, + 'CallExpression[optional = true]': checkOptionalCallExpression, + ConditionalExpression: (node) => checkNode(node.test), + DoWhileStatement: checkIfLoopIsNecessaryConditional, + ForStatement: checkIfLoopIsNecessaryConditional, + IfStatement: (node) => checkNode(node.test), + LogicalExpression: checkLogicalExpressionForUnnecessaryConditionals, + 'MemberExpression[optional = true]': checkOptionalMemberExpression, + SwitchCase({ parent, test }) { + // only check `case ...:`, not `default:` + if (test) { + checkIfBoolExpressionIsNecessaryConditional(test, parent.discriminant, test, '==='); + } + }, + WhileStatement: checkIfLoopIsNecessaryConditional, + }; + }, +}); +function normalizeAllowConstantLoopConditions(allowConstantLoopConditions) { + if (allowConstantLoopConditions === true) { + return 'always'; + } + if (allowConstantLoopConditions === false) { + return 'never'; + } + return allowConstantLoopConditions; +} +//# sourceMappingURL=no-unnecessary-condition.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.d.ts new file mode 100644 index 00000000..1d5d8231 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryAssign", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.js new file mode 100644 index 00000000..20f78899 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.js @@ -0,0 +1,157 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const UNNECESSARY_OPERATORS = new Set(['??=', '&&=', '=', '||=']); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-parameter-property-assignment', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow unnecessary assignment of constructor property parameter', + }, + messages: { + unnecessaryAssign: 'This assignment is unnecessary since it is already assigned by a parameter property.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const reportInfoStack = []; + function isThisMemberExpression(node) { + return (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.object.type === utils_1.AST_NODE_TYPES.ThisExpression); + } + function getPropertyName(node) { + if (!isThisMemberExpression(node)) { + return null; + } + if (!node.computed && node.property.type === utils_1.AST_NODE_TYPES.Identifier) { + return node.property.name; + } + if (node.computed) { + return (0, util_1.getStaticStringValue)(node.property); + } + return null; + } + function findParentFunction(node) { + if (!node || + node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration || + node.type === utils_1.AST_NODE_TYPES.FunctionExpression || + node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + return node; + } + return findParentFunction(node.parent); + } + function findParentPropertyDefinition(node) { + if (!node || node.type === utils_1.AST_NODE_TYPES.PropertyDefinition) { + return node; + } + return findParentPropertyDefinition(node.parent); + } + function isConstructorFunctionExpression(node) { + return (node?.type === utils_1.AST_NODE_TYPES.FunctionExpression && + utils_1.ASTUtils.isConstructor(node.parent)); + } + function isReferenceFromParameter(node) { + const scope = context.sourceCode.getScope(node); + const rightRef = scope.references.find(ref => ref.identifier.name === node.name); + return rightRef?.resolved?.defs.at(0)?.type === scope_manager_1.DefinitionType.Parameter; + } + function isParameterPropertyWithName(node, name) { + return (node.type === utils_1.AST_NODE_TYPES.TSParameterProperty && + ((node.parameter.type === utils_1.AST_NODE_TYPES.Identifier && // constructor (public foo) {} + node.parameter.name === name) || + (node.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern && // constructor (public foo = 1) {} + node.parameter.left.name === name))); + } + function getIdentifier(node) { + if (node.type === utils_1.AST_NODE_TYPES.Identifier) { + return node; + } + if (node.type === utils_1.AST_NODE_TYPES.TSAsExpression || + node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) { + return getIdentifier(node.expression); + } + return null; + } + function isArrowIIFE(node) { + return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + node.parent.type === utils_1.AST_NODE_TYPES.CallExpression); + } + return { + ClassBody() { + reportInfoStack.push({ + assignedBeforeConstructor: new Set(), + assignedBeforeUnnecessary: new Set(), + unnecessaryAssignments: [], + }); + }, + 'ClassBody:exit'() { + const { assignedBeforeConstructor, unnecessaryAssignments } = (0, util_1.nullThrows)(reportInfoStack.pop(), 'The top stack should exist'); + unnecessaryAssignments.forEach(({ name, node }) => { + if (assignedBeforeConstructor.has(name)) { + return; + } + context.report({ + node, + messageId: 'unnecessaryAssign', + }); + }); + }, + "MethodDefinition[kind='constructor'] > FunctionExpression AssignmentExpression"(node) { + let functionNode = findParentFunction(node); + if (functionNode && isArrowIIFE(functionNode)) { + functionNode = findParentFunction(functionNode.parent); + } + if (!isConstructorFunctionExpression(functionNode)) { + return; + } + const { assignedBeforeUnnecessary, unnecessaryAssignments } = (0, util_1.nullThrows)(reportInfoStack.at(reportInfoStack.length - 1), 'The top of stack should exist'); + // A prior write to the parameter binding means a later `this.x = x` + // may copy a different value than the parameter property initialized. + if (node.left.type === utils_1.AST_NODE_TYPES.Identifier) { + if (isReferenceFromParameter(node.left)) { + assignedBeforeUnnecessary.add(node.left.name); + } + return; + } + const leftName = getPropertyName(node.left); + if (!leftName) { + return; + } + if (!UNNECESSARY_OPERATORS.has(node.operator)) { + assignedBeforeUnnecessary.add(leftName); + return; + } + const rightId = getIdentifier(node.right); + if (leftName !== rightId?.name || !isReferenceFromParameter(rightId)) { + return; + } + const hasParameterProperty = functionNode.params.some(param => isParameterPropertyWithName(param, rightId.name)); + if (hasParameterProperty && !assignedBeforeUnnecessary.has(leftName)) { + unnecessaryAssignments.push({ + name: leftName, + node, + }); + } + }, + 'PropertyDefinition AssignmentExpression'(node) { + const name = getPropertyName(node.left); + if (!name) { + return; + } + const functionNode = findParentFunction(node); + if (functionNode && + !(isArrowIIFE(functionNode) && + findParentPropertyDefinition(node)?.value === functionNode.parent)) { + return; + } + const { assignedBeforeConstructor } = (0, util_1.nullThrows)(reportInfoStack.at(-1), 'The top stack should exist'); + assignedBeforeConstructor.add(name); + }, + }; + }, +}); +//# sourceMappingURL=no-unnecessary-parameter-property-assignment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.d.ts new file mode 100644 index 00000000..fc69e907 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.js new file mode 100644 index 00000000..ee6a7a1c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-qualifier.js @@ -0,0 +1,157 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-qualifier', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow unnecessary namespace qualifiers', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + unnecessaryQualifier: "Qualifier is unnecessary since '{{ name }}' is in scope.", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const namespacesInScope = []; + let currentFailedNamespaceExpression = null; + const services = (0, util_1.getParserServices)(context); + const esTreeNodeToTSNodeMap = services.esTreeNodeToTSNodeMap; + const checker = services.program.getTypeChecker(); + function tryGetAliasedSymbol(symbol, checker) { + return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias) + ? checker.getAliasedSymbol(symbol) + : null; + } + function symbolIsNamespaceInScope(symbol) { + const symbolDeclarations = symbol.getDeclarations() ?? []; + if (symbolDeclarations.some(decl => namespacesInScope.some(ns => ns === decl))) { + return true; + } + const alias = tryGetAliasedSymbol(symbol, checker); + return alias != null && symbolIsNamespaceInScope(alias); + } + function getSymbolInScope(node, flags, name) { + const scope = checker.getSymbolsInScope(node, flags); + return scope.find(scopeSymbol => scopeSymbol.name === name); + } + function symbolsAreEqual(accessed, inScope) { + return accessed === checker.getExportSymbolOfSymbol(inScope); + } + function qualifierIsUnnecessary(qualifier, name) { + const namespaceSymbol = services.getSymbolAtLocation(qualifier); + if (namespaceSymbol == null || + !symbolIsNamespaceInScope(namespaceSymbol)) { + return false; + } + const accessedSymbol = services.getSymbolAtLocation(name); + if (accessedSymbol == null) { + return false; + } + // If the symbol in scope is different, the qualifier is necessary. + const tsQualifier = esTreeNodeToTSNodeMap.get(qualifier); + const fromScope = getSymbolInScope(tsQualifier, accessedSymbol.flags, context.sourceCode.getText(name)); + return !!fromScope && symbolsAreEqual(accessedSymbol, fromScope); + } + function visitNamespaceAccess(node, qualifier, name) { + // Only look for nested qualifier errors if we didn't already fail on the outer qualifier. + if (!currentFailedNamespaceExpression && + qualifierIsUnnecessary(qualifier, name)) { + currentFailedNamespaceExpression = node; + context.report({ + node: qualifier, + messageId: 'unnecessaryQualifier', + data: { + name: context.sourceCode.getText(name), + }, + fix(fixer) { + return fixer.removeRange([qualifier.range[0], name.range[0]]); + }, + }); + } + } + function enterDeclaration(node) { + namespacesInScope.push(esTreeNodeToTSNodeMap.get(node)); + } + function exitDeclaration() { + namespacesInScope.pop(); + } + function resetCurrentNamespaceExpression(node) { + if (node === currentFailedNamespaceExpression) { + currentFailedNamespaceExpression = null; + } + } + function isPropertyAccessExpression(node) { + return node.type === utils_1.AST_NODE_TYPES.MemberExpression && !node.computed; + } + function isEntityNameExpression(node) { + return (node.type === utils_1.AST_NODE_TYPES.Identifier || + (isPropertyAccessExpression(node) && + isEntityNameExpression(node.object))); + } + return { + 'ExportNamedDeclaration[declaration.type="TSEnumDeclaration"]': enterDeclaration, + 'ExportNamedDeclaration[declaration.type="TSEnumDeclaration"]:exit': exitDeclaration, + 'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]': enterDeclaration, + 'ExportNamedDeclaration[declaration.type="TSModuleDeclaration"]:exit': exitDeclaration, + 'MemberExpression:exit': resetCurrentNamespaceExpression, + 'MemberExpression[computed=false]'(node) { + const property = node.property; + if (isEntityNameExpression(node.object)) { + visitNamespaceAccess(node, node.object, property); + } + }, + TSEnumDeclaration: enterDeclaration, + 'TSEnumDeclaration:exit': exitDeclaration, + 'TSModuleDeclaration:exit': exitDeclaration, + 'TSModuleDeclaration > TSModuleBlock'(node) { + enterDeclaration(node.parent); + }, + TSQualifiedName(node) { + visitNamespaceAccess(node, node.left, node.right); + }, + 'TSQualifiedName:exit': resetCurrentNamespaceExpression, + }; + }, +}); +//# sourceMappingURL=no-unnecessary-qualifier.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.d.ts new file mode 100644 index 00000000..cacc7549 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageId = 'noUnnecessaryTemplateExpression'; +declare const _default: TSESLint.RuleModule<"noUnnecessaryTemplateExpression", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js new file mode 100644 index 00000000..ee686eb5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js @@ -0,0 +1,350 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const rangeToLoc_1 = require("../util/rangeToLoc"); +const evenNumOfBackslashesRegExp = /(? { + const symbol = t.getSymbol(); + return !!(symbol?.valueDeclaration && ts.isEnumMember(symbol.valueDeclaration)); + }); + } + const isLiteral = (0, util_1.isNodeOfType)(utils_1.TSESTree.AST_NODE_TYPES.Literal); + function isTemplateLiteral(node) { + return node.type === utils_1.AST_NODE_TYPES.TemplateLiteral; + } + function isInfinityIdentifier(node) { + return (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'Infinity'); + } + function isNaNIdentifier(node) { + return node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'NaN'; + } + function isFixableIdentifier(node) { + return ((0, util_1.isUndefinedIdentifier)(node) || + isInfinityIdentifier(node) || + isNaNIdentifier(node)); + } + function hasCommentsBetweenQuasi(startQuasi, endQuasi) { + const startToken = (0, util_1.nullThrows)(context.sourceCode.getTokenByRangeStart(startQuasi.range[0]), util_1.NullThrowsReasons.MissingToken('`${', 'opening template literal')); + const endToken = (0, util_1.nullThrows)(context.sourceCode.getTokenByRangeStart(endQuasi.range[0]), util_1.NullThrowsReasons.MissingToken('}', 'closing template literal')); + return context.sourceCode.commentsExistBetween(startToken, endToken); + } + function isTrivialInterpolation(node) { + return (node.quasis.length === 2 && + node.quasis[0].value.raw === '' && + node.quasis[1].value.raw === ''); + } + function getInterpolations(node) { + if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) { + return node.expressions; + } + return node.types; + } + function getInterpolationInfos(node) { + return getInterpolations(node).map((interpolation, index) => ({ + interpolation, + nextQuasi: node.quasis[index + 1], + prevQuasi: node.quasis[index], + })); + } + function getLiteral(node) { + const maybeLiteral = node.type === utils_1.AST_NODE_TYPES.TSLiteralType ? node.literal : node; + return isLiteral(maybeLiteral) ? maybeLiteral : null; + } + function getTemplateLiteral(node) { + const maybeTemplateLiteral = node.type === utils_1.AST_NODE_TYPES.TSLiteralType ? node.literal : node; + return isTemplateLiteral(maybeTemplateLiteral) + ? maybeTemplateLiteral + : null; + } + function reportSingleInterpolation(node) { + const interpolations = getInterpolations(node); + context.report({ + loc: (0, rangeToLoc_1.rangeToLoc)(context.sourceCode, [ + interpolations[0].range[0] - 2, + interpolations[0].range[1] + 1, + ]), + messageId: 'noUnnecessaryTemplateExpression', + fix(fixer) { + const wrappingCode = (0, util_1.getMovedNodeCode)({ + destinationNode: node, + nodeToMove: interpolations[0], + sourceCode: context.sourceCode, + }); + return fixer.replaceText(node, wrappingCode); + }, + }); + } + function isUnnecessaryValueInterpolation({ interpolation, nextQuasi, prevQuasi, }) { + if (hasCommentsBetweenQuasi(prevQuasi, nextQuasi)) { + return false; + } + if (isFixableIdentifier(interpolation)) { + return true; + } + if (isLiteral(interpolation)) { + // allow trailing whitespace literal + if (startsWithNewLine(nextQuasi.value.raw)) { + return !(typeof interpolation.value === 'string' && + isWhitespace(interpolation.value)); + } + return true; + } + if (isTemplateLiteral(interpolation)) { + // allow trailing whitespace literal + if (startsWithNewLine(nextQuasi.value.raw)) { + return !(interpolation.quasis.length === 1 && + isWhitespace(interpolation.quasis[0].value.raw)); + } + return true; + } + return false; + } + function isUnnecessaryTypeInterpolation({ interpolation, nextQuasi, prevQuasi, }) { + if (hasCommentsBetweenQuasi(prevQuasi, nextQuasi)) { + return false; + } + const literal = getLiteral(interpolation); + if (literal) { + // allow trailing whitespace literal + if (startsWithNewLine(nextQuasi.value.raw)) { + return !(typeof literal.value === 'string' && isWhitespace(literal.value)); + } + return true; + } + if (interpolation.type === utils_1.AST_NODE_TYPES.TSNullKeyword || + interpolation.type === utils_1.AST_NODE_TYPES.TSUndefinedKeyword) { + return true; + } + const templateLiteral = getTemplateLiteral(interpolation); + if (templateLiteral) { + // allow trailing whitespace literal + if (startsWithNewLine(nextQuasi.value.raw)) { + return !(templateLiteral.quasis.length === 1 && + isWhitespace(templateLiteral.quasis[0].value.raw)); + } + return true; + } + return false; + } + function getReportDescriptors(infos) { + let nextCharacterIsOpeningCurlyBrace = false; + const reportDescriptors = []; + const reversedInfos = [...infos].reverse(); + for (const { interpolation, nextQuasi, prevQuasi } of reversedInfos) { + const fixers = []; + if (nextQuasi.value.raw !== '') { + nextCharacterIsOpeningCurlyBrace = + nextQuasi.value.raw.startsWith('{'); + } + const literal = getLiteral(interpolation); + const templateLiteral = getTemplateLiteral(interpolation); + if (literal) { + let escapedValue = (typeof literal.value === 'string' + ? // The value is already a string, so we're removing quotes: + // "'va`lue'" -> "va`lue" + literal.raw.slice(1, -1) + : // The value may be one of number | bigint | boolean | RegExp | null. + // In regular expressions, we escape every backslash + String(literal.value).replaceAll('\\', '\\\\')) + // The string or RegExp may contain ` or ${. + // We want both of these to be escaped in the final template expression. + // + // A pair of backslashes means "escaped backslash", so backslashes + // from this pair won't escape ` or ${. Therefore, to escape these + // sequences in the resulting template expression, we need to escape + // all sequences that are preceded by an even number of backslashes. + // + // This RegExp does the following transformations: + // \` -> \` + // \\` -> \\\` + // \${ -> \${ + // \\${ -> \\\${ + .replaceAll(new RegExp(`${evenNumOfBackslashesRegExp.source}(\`|\\\${)`, 'g'), '\\$1'); + // `...${'...$'}{...` + // ^^^^ + if (nextCharacterIsOpeningCurlyBrace && + endsWithUnescapedDollarSign(escapedValue)) { + escapedValue = escapedValue.replaceAll(/\$$/g, '\\$'); + } + if (escapedValue.length !== 0) { + nextCharacterIsOpeningCurlyBrace = escapedValue.startsWith('{'); + } + fixers.push(fixer => [fixer.replaceText(literal, escapedValue)]); + } + else if (templateLiteral) { + // Since we iterate from the last expression to the first, + // a subsequent expression can tell the current expression + // that it starts with {. + // + // `... ${`... $`}${'{...'} ...` + // ^ ^ subsequent expression starts with { + // current expression ends with a dollar sign, + // so '$' + '{' === '${' (bad news for us). + // Let's escape the dollar sign at the end. + if (nextCharacterIsOpeningCurlyBrace && + endsWithUnescapedDollarSign(templateLiteral.quasis[templateLiteral.quasis.length - 1].value + .raw)) { + fixers.push(fixer => [ + fixer.replaceTextRange([templateLiteral.range[1] - 2, templateLiteral.range[1] - 2], '\\'), + ]); + } + if (templateLiteral.quasis.length === 1 && + templateLiteral.quasis[0].value.raw.length !== 0) { + nextCharacterIsOpeningCurlyBrace = + templateLiteral.quasis[0].value.raw.startsWith('{'); + } + // Remove the beginning and trailing backtick characters. + fixers.push(fixer => [ + fixer.removeRange([ + templateLiteral.range[0], + templateLiteral.range[0] + 1, + ]), + fixer.removeRange([ + templateLiteral.range[1] - 1, + templateLiteral.range[1], + ]), + ]); + } + else { + nextCharacterIsOpeningCurlyBrace = false; + } + // `... $${'{...'} ...` + // ^^^^^ + if (nextCharacterIsOpeningCurlyBrace && + endsWithUnescapedDollarSign(prevQuasi.value.raw)) { + fixers.push(fixer => [ + fixer.replaceTextRange([prevQuasi.range[1] - 3, prevQuasi.range[1] - 2], '\\$'), + ]); + } + const warnLocStart = prevQuasi.range[1] - 2; + const warnLocEnd = nextQuasi.range[0] + 1; + reportDescriptors.push({ + loc: (0, rangeToLoc_1.rangeToLoc)(context.sourceCode, [warnLocStart, warnLocEnd]), + messageId: 'noUnnecessaryTemplateExpression', + fix(fixer) { + return [ + // Remove the quasis' parts that are related to the current expression. + fixer.removeRange([warnLocStart, interpolation.range[0]]), + fixer.removeRange([interpolation.range[1], warnLocEnd]), + ...fixers.flatMap(cb => cb(fixer)), + ]; + }, + }); + } + return reportDescriptors; + } + return { + TemplateLiteral(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) { + return; + } + if (isTrivialInterpolation(node) && + !hasCommentsBetweenQuasi(node.quasis[0], node.quasis[1])) { + const { constraintType } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.expressions[0])); + if (constraintType && (0, util_1.isStringLike)(constraintType)) { + reportSingleInterpolation(node); + return; + } + } + const infos = getInterpolationInfos(node).filter(isUnnecessaryValueInterpolation); + for (const reportDescriptor of getReportDescriptors(infos)) { + context.report(reportDescriptor); + } + }, + TSTemplateLiteralType(node) { + if (isTrivialInterpolation(node) && + !hasCommentsBetweenQuasi(node.quasis[0], node.quasis[1])) { + const { constraintType, isTypeParameter } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.types[0])); + if (constraintType && + !isTypeParameter && + (0, util_1.isStringLike)(constraintType) && + !isEnumMemberType(constraintType)) { + reportSingleInterpolation(node); + return; + } + } + const infos = getInterpolationInfos(node).filter(isUnnecessaryTypeInterpolation); + for (const reportDescriptor of getReportDescriptors(infos)) { + context.report(reportDescriptor); + } + }, + }; + }, +}); +function isWhitespace(x) { + // allow empty string too since we went to allow + // ` ${''} + // `; + // + // in addition to + // `${' '} + // `; + // + return /^\s*$/.test(x); +} +function startsWithNewLine(x) { + return utils_1.ASTUtils.LINEBREAK_MATCHER.exec(x)?.index === 0; +} +//# sourceMappingURL=no-unnecessary-template-expression.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.d.ts new file mode 100644 index 00000000..9cca9e4c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.d.ts @@ -0,0 +1,5 @@ +export type MessageIds = 'unnecessaryTypeParameter'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.js new file mode 100644 index 00000000..dbd331d8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-arguments.js @@ -0,0 +1,203 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-type-arguments', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow type arguments that are equal to the default', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + unnecessaryTypeParameter: 'This is the default value for this type parameter, so it can be omitted.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function getTypeForComparison(type) { + if ((0, util_1.isTypeReferenceType)(type)) { + return { + type: type.target, + typeArguments: checker.getTypeArguments(type), + }; + } + return { + type, + typeArguments: [], + }; + } + function checkTSArgsAndParameters(esParameters, typeParameters) { + // Just check the last one. Must specify previous type parameters if the last one is specified. + const i = esParameters.params.length - 1; + const arg = esParameters.params[i]; + const param = typeParameters.at(i); + if (!param?.default) { + return; + } + // TODO: would like checker.areTypesEquivalent. https://github.com/Microsoft/TypeScript/issues/13502 + const defaultType = checker.getTypeAtLocation(param.default); + const argType = services.getTypeAtLocation(arg); + // this check should handle some of the most simple cases of like strings, numbers, etc + if (defaultType !== argType) { + // For more complex types (like aliases to generic object types) - TS won't always create a + // global shared type object for the type - so we need to resort to manually comparing the + // reference type and the passed type arguments. + // Also - in case there are aliases - we need to resolve them before we do checks + const defaultTypeResolved = getTypeForComparison(defaultType); + const argTypeResolved = getTypeForComparison(argType); + if ( + // ensure the resolved type AND all the parameters are the same + defaultTypeResolved.type !== argTypeResolved.type || + defaultTypeResolved.typeArguments.length !== + argTypeResolved.typeArguments.length || + defaultTypeResolved.typeArguments.some((t, i) => t !== argTypeResolved.typeArguments[i])) { + return; + } + } + context.report({ + node: arg, + messageId: 'unnecessaryTypeParameter', + fix: fixer => fixer.removeRange(i === 0 + ? esParameters.range + : [esParameters.params[i - 1].range[1], arg.range[1]]), + }); + } + return { + TSTypeParameterInstantiation(node) { + // TypeScript does not apply default type parameters in instantiation + // expressions, so explicit type args here are always meaningful. + if (node.parent.type === utils_1.AST_NODE_TYPES.TSInstantiationExpression) { + return; + } + const expression = services.esTreeNodeToTSNodeMap.get(node); + const typeParameters = getTypeParametersFromNode(node, expression, checker); + if (typeParameters) { + checkTSArgsAndParameters(node, typeParameters); + } + }, + }; + }, +}); +function getTypeParametersFromNode(node, tsNode, checker) { + if (ts.isExpressionWithTypeArguments(tsNode)) { + return getTypeParametersFromType(node, tsNode.expression, checker); + } + if (ts.isTypeReferenceNode(tsNode)) { + return getTypeParametersFromType(node, tsNode.typeName, checker); + } + if (ts.isCallExpression(tsNode) || + ts.isNewExpression(tsNode) || + ts.isTaggedTemplateExpression(tsNode) || + ts.isJsxOpeningElement(tsNode) || + ts.isJsxSelfClosingElement(tsNode)) { + return getTypeParametersFromCall(node, tsNode, checker); + } + return undefined; +} +function getTypeParametersFromType(node, type, checker) { + const symAtLocation = checker.getSymbolAtLocation(type); + if (!symAtLocation) { + return undefined; + } + const sym = getAliasedSymbol(symAtLocation, checker); + const declarations = sym.getDeclarations(); + if (!declarations) { + return undefined; + } + const sortedDeclarations = sortDeclarationsByTypeValueContext(node, declarations); + return (0, util_1.findFirstResult)(sortedDeclarations, decl => { + if (ts.isTypeAliasDeclaration(decl) || + ts.isInterfaceDeclaration(decl) || + ts.isClassLike(decl)) { + return decl.typeParameters; + } + if (ts.isVariableDeclaration(decl)) { + return getConstructSignatureDeclaration(symAtLocation, checker) + ?.typeParameters; + } + return undefined; + }); +} +function getTypeParametersFromCall(node, tsNode, checker) { + const sig = checker.getResolvedSignature(tsNode); + const sigDecl = sig?.getDeclaration(); + if (!sigDecl) { + return ts.isNewExpression(tsNode) + ? getTypeParametersFromType(node, tsNode.expression, checker) + : undefined; + } + return sigDecl.typeParameters; +} +function getAliasedSymbol(symbol, checker) { + return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias) + ? checker.getAliasedSymbol(symbol) + : symbol; +} +function isInTypeContext(node) { + return (node.parent.type === utils_1.AST_NODE_TYPES.TSInterfaceHeritage || + node.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference || + node.parent.type === utils_1.AST_NODE_TYPES.TSClassImplements); +} +function isTypeContextDeclaration(decl) { + return ts.isTypeAliasDeclaration(decl) || ts.isInterfaceDeclaration(decl); +} +function typeFirstCompare(declA, declB) { + const aIsType = isTypeContextDeclaration(declA); + const bIsType = isTypeContextDeclaration(declB); + return Number(bIsType) - Number(aIsType); +} +function sortDeclarationsByTypeValueContext(node, declarations) { + const sorted = [...declarations].sort(typeFirstCompare); + if (isInTypeContext(node)) { + return sorted; + } + return sorted.reverse(); +} +function getConstructSignatureDeclaration(symbol, checker) { + const type = checker.getTypeOfSymbol(symbol); + const sig = type.getConstructSignatures(); + return sig.at(0)?.getDeclaration(); +} +//# sourceMappingURL=no-unnecessary-type-arguments.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.d.ts new file mode 100644 index 00000000..d627f721 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.d.ts @@ -0,0 +1,11 @@ +export type Options = [ + { + checkLiteralConstAssertions?: boolean; + typesToIgnore?: string[]; + } +]; +export type MessageIds = 'contextuallyUnnecessary' | 'unnecessaryAssertion'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js new file mode 100644 index 00000000..f3f84cea --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js @@ -0,0 +1,786 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-type-assertion', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow type assertions that do not change the type of an expression', + recommended: 'recommended', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + contextuallyUnnecessary: 'This assertion is unnecessary since the receiver accepts the original type of the expression.', + unnecessaryAssertion: 'This assertion is unnecessary since it does not change the type of the expression.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + checkLiteralConstAssertions: { + type: 'boolean', + description: 'Whether to check literal const assertions.', + }, + typesToIgnore: { + type: 'array', + description: 'A list of type names to ignore.', + items: { + type: 'string', + }, + }, + }, + }, + ], + }, + defaultOptions: [{}], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + /** + * Returns true if there's a chance the variable has been used before a value has been assigned to it + */ + function isPossiblyUsedBeforeAssigned(node) { + const declaration = (0, util_1.getDeclaration)(services, node); + if (!declaration) { + // don't know what the declaration is for some reason, so just assume the worst + return true; + } + if ( + // non-strict mode doesn't care about used before assigned errors + tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks') && + // ignore class properties as they are compile time guarded + // also ignore function arguments as they can't be used before defined + ts.isVariableDeclaration(declaration)) { + // For var declarations, we need to check whether the node + // is actually in a descendant of its declaration or not. If not, + // it may be used before defined. + // eg + // if (Math.random() < 0.5) { + // var x: number = 2; + // } else { + // x!.toFixed(); + // } + if (ts.isVariableDeclarationList(declaration.parent) && + // var + declaration.parent.flags === ts.NodeFlags.None && + // If they are not in the same file it will not exist. + // This situation must not occur using before defined. + services.tsNodeToESTreeNodeMap.has(declaration)) { + const declaratorNode = services.tsNodeToESTreeNodeMap.get(declaration); + const scope = context.sourceCode.getScope(node); + const declaratorScope = context.sourceCode.getScope(declaratorNode); + let parentScope = declaratorScope; + while ((parentScope = parentScope.upper)) { + if (parentScope === scope) { + return true; + } + } + } + if ( + // is it `const x!: number` + declaration.initializer == null && + declaration.exclamationToken == null && + declaration.type != null) { + // check if the defined variable type has changed since assignment + const declarationType = checker.getTypeFromTypeNode(declaration.type); + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + if (declarationType === type && + // `declare`s are never narrowed, so never skip them + !(ts.isVariableDeclarationList(declaration.parent) && + ts.isVariableStatement(declaration.parent.parent) && + tsutils.includesModifier((0, util_1.getModifiers)(declaration.parent.parent), ts.SyntaxKind.DeclareKeyword))) { + // possibly used before assigned, so just skip it + // better to false negative and skip it, than false positive and fix to compile erroring code + // + // no better way to figure this out right now + // https://github.com/Microsoft/TypeScript/issues/31124 + return true; + } + } + } + return false; + } + function isConstAssertion(node) { + return (node.type === utils_1.AST_NODE_TYPES.TSTypeReference && + node.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + node.typeName.name === 'const'); + } + function isTemplateLiteralWithExpressions(expression) { + return (expression.type === utils_1.AST_NODE_TYPES.TemplateLiteral && + expression.expressions.length !== 0); + } + function isImplicitlyNarrowedLiteralDeclaration({ expression, parent, }) { + /** + * Even on `const` variable declarations, template literals with expressions can sometimes be widened without a type assertion. + * @see https://github.com/typescript-eslint/typescript-eslint/issues/8737 + */ + if (isTemplateLiteralWithExpressions(expression)) { + return false; + } + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const maybeDeclarationNode = parent.parent; + return ((maybeDeclarationNode.type === utils_1.AST_NODE_TYPES.VariableDeclaration && + maybeDeclarationNode.kind === 'const') || + (parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition && parent.readonly)); + } + function isTypeUnchanged(node, expression, uncast, cast) { + if (uncast === cast) { + return true; + } + if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType && + containsTypeVariable(cast)) { + return false; + } + if ((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.Undefined) && + (0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) && + tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) { + return areUnionPartsEquivalentIgnoringUndefined(uncast, cast); + } + if (((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.NonPrimitive) && + !(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.NonPrimitive)) || + hasIndexSignature(uncast) !== hasIndexSignature(cast) || + containsAny(uncast) || + containsAny(cast) || + (containsTypeVariable(cast) && !containsTypeVariable(uncast))) { + return false; + } + if (isConceptuallyLiteral(expression) && + (expression.type !== utils_1.AST_NODE_TYPES.ObjectExpression || + expression.properties.length === 0 || + cast + .getProperties() + .some(p => isTypeLiteral(checker.getTypeOfSymbol(p))))) { + return false; + } + if (cast.isIntersection() && !uncast.isIntersection()) { + const castParts = cast.types; + const otherPart = castParts.find(part => part !== uncast); + if (tsutils.isTypeParameter(uncast) && + castParts.length === 2 && + castParts.some(part => part === uncast) && + otherPart != null && + isEmptyObjectType(otherPart) && + !containsTypeVariable(otherPart)) { + const constraint = checker.getBaseConstraintOfType(uncast); + if (constraint && !(0, util_1.isNullableType)(constraint)) { + return true; + } + } + return false; + } + if (!hasSameProperties(uncast, cast) || + !haveSameTypeArguments(uncast, cast)) { + return false; + } + return areMutuallyAssignable(uncast, cast); + } + function isTypeLiteral(type) { + return type.isLiteral() || tsutils.isBooleanLiteralType(type); + } + function hasIndexSignature(type) { + return tsutils + .unionConstituents(type) + .some(part => checker.getIndexInfosOfType(part).length > 0); + } + function getTypeArguments(type) { + return (type.aliasTypeArguments ?? + (tsutils.isTypeReference(type) ? checker.getTypeArguments(type) : [])); + } + function typeContains(type, predicate, seen = new Set()) { + if (seen.has(type)) { + return false; + } + seen.add(type); + if (predicate(type)) { + return true; + } + if (type.isUnionOrIntersection()) { + return type.types.some(t => typeContains(t, predicate, seen)); + } + const nestedTypes = [ + ...getTypeArguments(type), + ...type + .getCallSignatures() + .flatMap(sig => [ + sig.getReturnType(), + ...sig.getParameters().map(p => checker.getTypeOfSymbol(p)), + ]), + ]; + return nestedTypes.some(t => typeContains(t, predicate, seen)); + } + function containsAny(type) { + try { + return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Any)); + } + catch (error) { + // Workaround for https://github.com/typescript-eslint/typescript-eslint/issues/12705 + if (error instanceof RangeError && + error.message === 'Maximum call stack size exceeded') { + return false; + } + throw error; + } + } + function containsTypeVariable(type) { + return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.TypeVariable | ts.TypeFlags.Index)); + } + function hasPhantomTypeArguments(type) { + return isEmptyObjectType(type) && getTypeArguments(type).length > 0; + } + function hasTypeParams(sig) { + return (sig.getTypeParameters()?.length ?? 0) > 0; + } + function genericsMismatch(uncast, contextual) { + return contextual.getProperties().some(prop => { + const contextualSigs = checker.getSignaturesOfType(checker.getTypeOfSymbol(prop), ts.SignatureKind.Call); + if (!contextualSigs.some(hasTypeParams)) { + return false; + } + const uncastProp = uncast.getProperty(prop.getEscapedName()); + if (!uncastProp) { + return true; + } + return !checker + .getSignaturesOfType(checker.getTypeOfSymbol(uncastProp), ts.SignatureKind.Call) + .some(hasTypeParams); + }); + } + function hasSameProperties(uncast, cast) { + const uncastProps = uncast.getProperties(); + const castProps = cast.getProperties(); + if (uncastProps.length !== castProps.length) { + return false; + } + const castPropNames = new Set(castProps.map(p => p.getEscapedName())); + return uncastProps.every(prop => { + const name = prop.getEscapedName(); + return (castPropNames.has(name) && + tsutils.isPropertyReadonlyInType(uncast, name, checker) === + tsutils.isPropertyReadonlyInType(cast, name, checker)); + }); + } + function haveSameTypeArguments(uncast, cast) { + const uncastArgs = getTypeArguments(uncast); + const castArgs = getTypeArguments(cast); + return (uncastArgs.length === castArgs.length && + uncastArgs.every((arg, i) => arg === castArgs[i])); + } + function areMutuallyAssignable(a, b) { + return (checker.isTypeAssignableTo(a, b) && checker.isTypeAssignableTo(b, a)); + } + function areUnionPartsEquivalentIgnoringUndefined(uncast, cast) { + const filterUndefined = (part) => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined); + const uncastParts = tsutils + .unionConstituents(uncast) + .filter(filterUndefined); + const castParts = tsutils.unionConstituents(cast).filter(filterUndefined); + if (uncastParts.length !== castParts.length) { + return false; + } + const uncastPartsSet = new Set(uncastParts); + return castParts.every(part => uncastPartsSet.has(part)); + } + function getOriginalExpression(node) { + let current = node.expression; + while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression || + current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) { + current = current.expression; + } + return current; + } + function isDoubleAssertionUnnecessary(node, contextualType) { + const innerExpression = node.expression; + if (innerExpression.type !== utils_1.AST_NODE_TYPES.TSAsExpression && + innerExpression.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) { + return false; + } + const originalExpr = getOriginalExpression(node); + const originalType = services.getTypeAtLocation(originalExpr); + const castType = services.getTypeAtLocation(node); + if (isTypeUnchanged(node, innerExpression, originalType, castType) && + !(0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any)) { + return 'unnecessaryAssertion'; + } + if (contextualType) { + const intermediateType = services.getTypeAtLocation(innerExpression); + if (((0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Any) || + (0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Unknown)) && + checker.isTypeAssignableTo(originalType, contextualType)) { + return 'contextuallyUnnecessary'; + } + } + return false; + } + const CONCEPTUALLY_LITERAL_TYPES = new Set([ + utils_1.AST_NODE_TYPES.Literal, + utils_1.AST_NODE_TYPES.ArrayExpression, + utils_1.AST_NODE_TYPES.ObjectExpression, + utils_1.AST_NODE_TYPES.TemplateLiteral, + utils_1.AST_NODE_TYPES.ClassExpression, + utils_1.AST_NODE_TYPES.FunctionExpression, + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, + utils_1.AST_NODE_TYPES.JSXElement, + utils_1.AST_NODE_TYPES.JSXFragment, + ]); + function isConceptuallyLiteral(node) { + return CONCEPTUALLY_LITERAL_TYPES.has(node.type); + } + function isIIFE(expression) { + return (expression.type === utils_1.AST_NODE_TYPES.CallExpression && + (expression.callee.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + expression.callee.type === utils_1.AST_NODE_TYPES.FunctionExpression)); + } + function isEmptyObjectType(type) { + return ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.NonPrimitive) || + (type.getProperties().length === 0 && + !type.getCallSignatures().length && + !type.getConstructSignatures().length && + !type.getStringIndexType() && + !type.getNumberIndexType())); + } + function hasGenericCallSignature(type) { + return type.getCallSignatures().some(hasTypeParams); + } + function isArgumentToOverloadedFunction(node) { + const { parent } = node; + if ((parent.type !== utils_1.AST_NODE_TYPES.CallExpression && + parent.type !== utils_1.AST_NODE_TYPES.NewExpression) || + !parent.arguments.includes(node)) { + return false; + } + // An optional-chained callee (`foo?.bar(...)`) types as ` | undefined`, + // and a union exposes no call signatures — strip the nullability first. + const calleeType = services + .getTypeAtLocation(parent.callee) + .getNonNullableType(); + const signatures = calleeType.getCallSignatures(); + if (signatures.length <= 1) { + return false; + } + const argIndex = parent.arguments.indexOf(node); + const paramTypes = signatures.map(sig => { + const params = sig.getParameters(); + if (argIndex >= params.length) { + return undefined; + } + const param = params[argIndex]; + let paramType = checker.getTypeOfSymbol(param); + if (param.valueDeclaration && + ts.isParameter(param.valueDeclaration) && + param.valueDeclaration.dotDotDotToken) { + const typeArgs = getTypeArguments(paramType); + if (typeArgs.length > 0) { + paramType = typeArgs[0]; + } + } + return paramType; + }); + if (paramTypes.some(type => type == null)) { + return true; + } + const definedParamTypes = paramTypes; + const firstParamType = definedParamTypes[0]; + if (definedParamTypes.every(type => type === firstParamType)) { + return false; + } + const uncastType = services.getTypeAtLocation(node.expression); + return !definedParamTypes.every(type => checker.isTypeAssignableTo(uncastType, type)); + } + function isInDestructuringDeclaration(node) { + const { parent } = node; + return (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && + parent.init === node && + (parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern || + parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern)); + } + function isPropertyInProblematicContext(node) { + const { parent } = node; + if (parent.type !== utils_1.AST_NODE_TYPES.Property || parent.value !== node) { + return false; + } + const objectExpr = parent.parent; + if (objectExpr.type !== utils_1.AST_NODE_TYPES.ObjectExpression) { + return false; + } + const objectTsNode = services.esTreeNodeToTSNodeMap.get(objectExpr); + if (checker.getContextualType(objectTsNode)?.isUnion()) { + const nodeTsNode = services.esTreeNodeToTSNodeMap.get(node); + const propContextualType = checker.getContextualType(nodeTsNode); + if (propContextualType == null) { + return true; + } + const nonNullableContextualType = checker.getNonNullableType(propContextualType); + if (nonNullableContextualType.isUnion()) { + return true; + } + const uncastType = services.getTypeAtLocation(node.expression); + return !checker.isTypeAssignableTo(uncastType, nonNullableContextualType); + } + const objectParent = objectExpr.parent; + return (objectParent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression || + (objectParent.type === utils_1.AST_NODE_TYPES.CallExpression && + objectParent.parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression)); + } + function isAssignmentInNonStatementContext(node) { + const { parent } = node; + if (parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression || + parent.right !== node) { + return false; + } + const assignmentParent = parent.parent; + return assignmentParent.type !== utils_1.AST_NODE_TYPES.ExpressionStatement; + } + function isRightHandSideOfLogicalAssignment(node) { + const { parent } = node; + return (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + parent.right === node && + (parent.operator === '&&=' || + parent.operator === '||=' || + parent.operator === '??=')); + } + function isInGenericContext(node) { + let seenFunction = false; + for (let current = node.parent; current; current = current.parent) { + if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) { + return false; + } + if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression || + current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + if (current.body.type === utils_1.AST_NODE_TYPES.BlockStatement) { + return false; + } + if (seenFunction) { + return false; + } + seenFunction = true; + } + if (current.type === utils_1.AST_NODE_TYPES.CallExpression || + current.type === utils_1.AST_NODE_TYPES.NewExpression) { + if (current.typeArguments != null) { + continue; + } + if (current.type === utils_1.AST_NODE_TYPES.CallExpression && + current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression && + current.arguments.includes(node)) { + continue; + } + const calleeType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(current.callee)); + if (hasGenericCallSignature(calleeType)) { + return true; + } + } + } + return false; + } + function hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) { + return (isInGenericContext(node) && + (hasPhantomTypeArguments(uncastType) || + hasPhantomTypeArguments(contextualType)) && + !haveSameTypeArguments(uncastType, contextualType)); + } + const SKIP_PARENT_TYPES = new Set([ + utils_1.AST_NODE_TYPES.TSAsExpression, + utils_1.AST_NODE_TYPES.TSTypeAssertion, + utils_1.AST_NODE_TYPES.SpreadElement, + utils_1.AST_NODE_TYPES.TSSatisfiesExpression, + ]); + function shouldSkipContextualTypeFallback(node, castIsAny) { + if (castIsAny) { + return (node.parent.type === utils_1.AST_NODE_TYPES.LogicalExpression || + isInGenericContext(node)); + } + /** + * Interpolated template literals can be widened to `string` while contextual + * typing still accepts them, so the assertion may be required. + * @see https://github.com/typescript-eslint/typescript-eslint/issues/12276 + */ + if (isTemplateLiteralWithExpressions(node.expression)) { + return true; + } + if (SKIP_PARENT_TYPES.has(node.parent.type) || + node.expression.type === utils_1.AST_NODE_TYPES.ArrayExpression || + isInDestructuringDeclaration(node) || + isPropertyInProblematicContext(node) || + isAssignmentInNonStatementContext(node) || + isRightHandSideOfLogicalAssignment(node) || + isArgumentToOverloadedFunction(node)) { + return true; + } + if (isInGenericContext(node)) { + const originalExpr = getOriginalExpression(node); + return (!isConceptuallyLiteral(originalExpr) && + node.parent.type !== utils_1.AST_NODE_TYPES.Property); + } + return false; + } + function getUncastType(node) { + // Special handling for IIFE: extract the function's return type + if (isIIFE(node.expression)) { + const callee = node.expression.callee; + const functionType = services.getTypeAtLocation(callee); + const signatures = functionType.getCallSignatures(); + if (signatures.length > 0) { + const returnType = checker.getReturnTypeOfSignature(signatures[0]); + // If the function has no explicit return type annotation and returns undefined, + // treat it as void (TypeScript infers () => {} as () => undefined, but it should be void) + if (callee.returnType == null && + (0, util_1.isTypeFlagSet)(returnType, ts.TypeFlags.Undefined)) { + return checker.getVoidType(); + } + return returnType; + } + } + return services.getTypeAtLocation(node.expression); + } + function createAssertionFixer(node) { + return fixer => { + if (node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) { + const openingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation')); + const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation')); + // Removing the angle brackets leaves the asserted operand at the + // assertion's position, so its first token leads whatever the + // assertion led. A leading `{`/`function`/`class` at the start of an + // expression statement is parsed as a block / function or class + // declaration, and a leading `{` at the start of a concise arrow body + // is parsed as a block body. In those positions the operand must be + // wrapped in parentheses to stay an expression. + const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(closingAngleBracket), util_1.NullThrowsReasons.MissingToken('operand', 'type assertion')); + const needsParens = (0, util_1.isStartOfExpressionStatementNeedingParentheses)(node, firstOperandToken) || + (0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode); + const fixes = []; + if (needsParens) { + fixes.push(fixer.insertTextBefore(node, '(')); + } + fixes.push(fixer.removeRange([ + openingAngleBracket.range[0], + closingAngleBracket.range[1], + ])); + if (needsParens) { + fixes.push(fixer.insertTextAfter(node, ')')); + } + return fixes; + } + const asToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'as'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation')); + const tokenBeforeAs = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(asToken, { + includeComments: true, + }), util_1.NullThrowsReasons.MissingToken('comment', 'as')); + return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]); + }; + } + function reportDoubleAssertionIfUnnecessary(node, contextualType) { + const doubleAssertionResult = isDoubleAssertionUnnecessary(node, contextualType); + if (doubleAssertionResult) { + context.report({ + node, + messageId: doubleAssertionResult, + fix(fixer) { + const originalExpr = getOriginalExpression(node); + let text = context.sourceCode.getText(originalExpr); + if (originalExpr.type === utils_1.AST_NODE_TYPES.ObjectExpression && + node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + node.parent.body === node) { + text = `(${text})`; + } + return fixer.replaceText(node, text); + }, + }); + } + } + return { + 'TSAsExpression, TSTypeAssertion'(node) { + if (options.typesToIgnore?.includes(context.sourceCode.getText(node.typeAnnotation))) { + return; + } + const castType = services.getTypeAtLocation(node); + const castTypeIsLiteral = isTypeLiteral(castType); + const typeAnnotationIsConstAssertion = isConstAssertion(node.typeAnnotation); + if (!options.checkLiteralConstAssertions && + castTypeIsLiteral && + typeAnnotationIsConstAssertion) { + return; + } + const uncastType = getUncastType(node); + const typeIsUnchanged = isTypeUnchanged(node, node.expression, uncastType, castType); + const wouldSameTypeBeInferred = castTypeIsLiteral + ? isImplicitlyNarrowedLiteralDeclaration(node) + : !typeAnnotationIsConstAssertion; + if (typeIsUnchanged && wouldSameTypeBeInferred) { + context.report({ + node, + messageId: 'unnecessaryAssertion', + fix: createAssertionFixer(node), + }); + return; + } + const originalNode = services.esTreeNodeToTSNodeMap.get(node); + const castIsAny = (0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any) && + !SKIP_PARENT_TYPES.has(node.parent.type); + const contextualType = shouldSkipContextualTypeFallback(node, castIsAny) + ? undefined + : checker.getContextualType(originalNode); + if (contextualType) { + const contextualTypeIsAny = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Any); + const isCallArgument = (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression || + node.parent.type === utils_1.AST_NODE_TYPES.NewExpression) && + node.parent.arguments.includes(node); + const anyInvolvedInContextualCheck = contextualTypeIsAny + ? isCallArgument && !containsAny(castType) + : !containsAny(contextualType); + const isNullishLiteralToUnion = castType.isUnion() && + ((node.expression.type === utils_1.AST_NODE_TYPES.Literal && + node.expression.value == null) || + (node.expression.type === utils_1.AST_NODE_TYPES.Identifier && + node.expression.name === 'undefined')); + const isContextuallyUnnecessary = !typeAnnotationIsConstAssertion && + !containsAny(uncastType) && + anyInvolvedInContextualCheck && + !hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) && + (castIsAny || !genericsMismatch(uncastType, contextualType)) && + (contextualTypeIsAny || + checker.isTypeAssignableTo(uncastType, contextualType)) && + !isNullishLiteralToUnion; + if (isContextuallyUnnecessary) { + context.report({ + node, + messageId: 'contextuallyUnnecessary', + fix: createAssertionFixer(node), + }); + return; + } + } + reportDoubleAssertionIfUnnecessary(node, contextualType); + }, + TSNonNullExpression(node) { + const removeExclamationFix = fixer => { + const exclamationToken = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node, token => token.value === '!'), util_1.NullThrowsReasons.MissingToken('exclamation mark', 'non-null assertion')); + return fixer.removeRange(exclamationToken.range); + }; + if (node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + node.parent.operator === '=') { + if (node.parent.left === node) { + context.report({ + node, + messageId: 'contextuallyUnnecessary', + fix: removeExclamationFix, + }); + } + // for all other = assignments we ignore non-null checks + // this is because non-null assertions can change the type-flow of the code + // so whilst they might be unnecessary for the assignment - they are necessary + // for following code + return; + } + const originalNode = services.esTreeNodeToTSNodeMap.get(node); + const constrainedType = (0, util_1.getConstrainedTypeAtLocation)(services, node.expression); + const actualType = services.getTypeAtLocation(node.expression); + // Check both the constrained type and the actual type. + // If either is nullable, we should not report the assertion as unnecessary. + // This handles cases like generic constraints with `any` where the + // constrained type is `any` (nullable) but the actual type might be + // a type parameter that TypeScript treats nominally. + // See: https://github.com/typescript-eslint/typescript-eslint/issues/11559 + const constrainedTypeIsNullable = (0, util_1.isNullableType)(constrainedType); + const actualTypeIsNullable = (0, util_1.isNullableType)(actualType); + if (!constrainedTypeIsNullable && !actualTypeIsNullable) { + if (node.expression.type === utils_1.AST_NODE_TYPES.Identifier && + isPossiblyUsedBeforeAssigned(node.expression)) { + return; + } + context.report({ + node, + messageId: 'unnecessaryAssertion', + fix: removeExclamationFix, + }); + } + else { + // we know it's a nullable type + // so figure out if the variable is used in a place that accepts nullable types + // If the constrained type differs from the actual type (e.g., when dealing + // with unresolved generic type parameters), we should not report the assertion + // as contextually unnecessary. TypeScript may still require the assertion + // even if the constraint is nullable (like `any`). + // See: https://github.com/typescript-eslint/typescript-eslint/issues/11559 + if (constrainedType !== actualType) { + return; + } + const contextualType = (0, util_1.getContextualType)(checker, originalNode); + if (contextualType) { + if ((0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Unknown) && + !(0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Unknown)) { + return; + } + // in strict mode you can't assign null to undefined, so we have to make sure that + // the two types share a nullable type + const typeIncludesUndefined = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Undefined); + const typeIncludesNull = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Null); + const typeIncludesVoid = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Void); + const contextualTypeIncludesUndefined = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Undefined); + const contextualTypeIncludesNull = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Null); + const contextualTypeIncludesVoid = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Void); + // make sure that the parent accepts the same types + // i.e. assigning `string | null | undefined` to `string | undefined` is invalid + const isValidUndefined = typeIncludesUndefined + ? contextualTypeIncludesUndefined + : true; + const isValidNull = typeIncludesNull + ? contextualTypeIncludesNull + : true; + const isValidVoid = typeIncludesVoid + ? contextualTypeIncludesVoid + : true; + if (isValidUndefined && isValidNull && isValidVoid) { + context.report({ + node, + messageId: 'contextuallyUnnecessary', + fix: removeExclamationFix, + }); + } + } + } + }, + }; + }, +}); +//# sourceMappingURL=no-unnecessary-type-assertion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.d.ts new file mode 100644 index 00000000..10948287 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.js new file mode 100644 index 00000000..7449f10e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-constraint.js @@ -0,0 +1,120 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const node_path_1 = require("node:path"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-type-constraint', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow unnecessary constraints on generic types', + recommended: 'recommended', + }, + hasSuggestions: true, + messages: { + removeUnnecessaryConstraint: 'Remove the unnecessary `{{constraint}}` constraint.', + unnecessaryConstraint: 'Constraining the generic type `{{name}}` to `{{constraint}}` does nothing and is unnecessary.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + // In theory, we could use the type checker for more advanced constraint types... + // ...but in practice, these types are rare, and likely not worth requiring type info. + // https://github.com/typescript-eslint/typescript-eslint/pull/2516#discussion_r495731858 + const unnecessaryConstraints = new Map([ + [utils_1.AST_NODE_TYPES.TSAnyKeyword, 'any'], + [utils_1.AST_NODE_TYPES.TSUnknownKeyword, 'unknown'], + ]); + function checkRequiresGenericDeclarationDisambiguation(filename) { + const pathExt = (0, node_path_1.extname)(filename).toLocaleLowerCase(); + switch (pathExt) { + case ts.Extension.Cts: + case ts.Extension.Mts: + case ts.Extension.Tsx: + return true; + default: + return false; + } + } + const requiresGenericDeclarationDisambiguation = checkRequiresGenericDeclarationDisambiguation(context.filename); + const checkNode = (node, inArrowFunction) => { + const constraint = unnecessaryConstraints.get(node.constraint.type); + function shouldAddTrailingComma() { + if (!inArrowFunction || !requiresGenericDeclarationDisambiguation) { + return false; + } + // Only () => {} would need trailing comma + return (node.parent.params.length === + 1 && + context.sourceCode.getTokensAfter(node)[0].value !== ',' && + !node.default); + } + if (constraint) { + context.report({ + node, + messageId: 'unnecessaryConstraint', + data: { + name: node.name.name, + constraint, + }, + suggest: [ + { + messageId: 'removeUnnecessaryConstraint', + data: { + constraint, + }, + fix(fixer) { + return fixer.replaceTextRange([node.name.range[1], node.constraint.range[1]], shouldAddTrailingComma() ? ',' : ''); + }, + }, + ], + }); + } + }; + return { + ':not(ArrowFunctionExpression) > TSTypeParameterDeclaration > TSTypeParameter[constraint]'(node) { + checkNode(node, false); + }, + 'ArrowFunctionExpression > TSTypeParameterDeclaration > TSTypeParameter[constraint]'(node) { + checkNode(node, true); + }, + }; + }, +}); +//# sourceMappingURL=no-unnecessary-type-constraint.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts new file mode 100644 index 00000000..39920c84 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts @@ -0,0 +1,5 @@ +type MessageIds = 'suggestRemove' | 'suggestSatisfies' | 'unnecessaryTypeConversion'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.js new file mode 100644 index 00000000..a92f5306 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.js @@ -0,0 +1,357 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +function isEnumType(type) { + return (type.getFlags() & ts.TypeFlags.EnumLike) !== 0; +} +function isEnumMemberType(type) { + const symbol = type.getSymbol(); + if (!symbol) { + return false; + } + return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.EnumMember); +} +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-type-conversion', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow conversion idioms when they do not change the type or value of the expression', + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + suggestRemove: 'Remove the type conversion.', + suggestSatisfies: 'Instead, assert that the value satisfies the {{type}} type.', + unnecessaryTypeConversion: '{{violation}} does not change the type or value of the {{type}}.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function doesUnderlyingTypeMatchFlag(type, typeFlag) { + return tsutils + .unionConstituents(type) + .every(t => (0, util_1.isTypeFlagSet)(t, typeFlag)); + } + const services = (0, util_1.getParserServices)(context); + function handleUnaryOperator(node, typeFlag, typeString, violation, isDoubleOperator) { + const outerNode = isDoubleOperator ? node.parent : node; + const type = services.getTypeAtLocation(node.argument); + if (doesUnderlyingTypeMatchFlag(type, typeFlag)) { + const wrappingFixerParams = { + node: outerNode, + innerNode: [node.argument], + sourceCode: context.sourceCode, + }; + context.report({ + loc: { + start: outerNode.loc.start, + end: { + column: node.loc.start.column + 1, + line: node.loc.start.line, + }, + }, + messageId: 'unnecessaryTypeConversion', + data: { type: typeString, violation }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: typeString }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies ${typeString}`, + }), + }, + ], + }); + } + } + return { + 'AssignmentExpression[operator = "+="]'(node) { + if (node.right.type === utils_1.AST_NODE_TYPES.Literal && + node.right.value === '' && + doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) { + const wrappingFixerParams = { + node, + innerNode: [node.left], + sourceCode: context.sourceCode, + }; + context.report({ + node, + messageId: 'unnecessaryTypeConversion', + data: { + type: 'string', + violation: "Concatenating a string with ''", + }, + suggest: [ + { + messageId: 'suggestRemove', + fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement + ? (fixer) => [ + fixer.removeRange([ + node.parent.range[0], + node.parent.range[1], + ]), + ] + : (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: 'string' }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies string`, + }), + }, + ], + }); + } + }, + 'BinaryExpression[operator = "+"]'(node) { + if (node.right.type === utils_1.AST_NODE_TYPES.Literal && + node.right.value === '' && + doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) { + const wrappingFixerParams = { + node, + innerNode: [node.left], + sourceCode: context.sourceCode, + }; + context.report({ + loc: { + start: node.left.loc.end, + end: node.loc.end, + }, + messageId: 'unnecessaryTypeConversion', + data: { + type: 'string', + violation: "Concatenating a string with ''", + }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: 'string' }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies string`, + }), + }, + ], + }); + } + else if (node.left.type === utils_1.AST_NODE_TYPES.Literal && + node.left.value === '' && + doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.right), ts.TypeFlags.StringLike)) { + const wrappingFixerParams = { + node, + innerNode: [node.right], + sourceCode: context.sourceCode, + }; + context.report({ + loc: { + start: node.loc.start, + end: node.right.loc.start, + }, + messageId: 'unnecessaryTypeConversion', + data: { + type: 'string', + violation: "Concatenating '' with a string", + }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: 'string' }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies string`, + }), + }, + ], + }); + } + }, + CallExpression(node) { + const nodeCallee = node.callee; + const builtInTypeFlags = { + BigInt: ts.TypeFlags.BigIntLike, + Boolean: ts.TypeFlags.BooleanLike, + Number: ts.TypeFlags.NumberLike, + String: ts.TypeFlags.StringLike, + }; + if (nodeCallee.type !== utils_1.AST_NODE_TYPES.Identifier || + !(nodeCallee.name in builtInTypeFlags)) { + return; + } + const typeFlag = builtInTypeFlags[nodeCallee.name]; + const scope = context.sourceCode.getScope(node); + const variable = utils_1.ASTUtils.findVariable(scope, nodeCallee.name); + if (!!variable?.defs.length || + !doesUnderlyingTypeMatchFlag((0, util_1.getConstrainedTypeAtLocation)(services, node.arguments[0]), typeFlag)) { + return; + } + const wrappingFixerParams = { + node, + innerNode: [node.arguments[0]], + sourceCode: context.sourceCode, + }; + const typeString = nodeCallee.name.toLowerCase(); + context.report({ + node: nodeCallee, + messageId: 'unnecessaryTypeConversion', + data: { + type: nodeCallee.name.toLowerCase(), + violation: `Passing a ${typeString} to ${nodeCallee.name}()`, + }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: typeString }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies ${typeString}`, + }), + }, + ], + }); + }, + 'CallExpression > MemberExpression.callee > Identifier[name = "toString"].property'(node) { + const memberExpr = node.parent; + const type = (0, util_1.getConstrainedTypeAtLocation)(services, memberExpr.object); + if (isEnumType(type) || isEnumMemberType(type)) { + return; + } + if (doesUnderlyingTypeMatchFlag(type, ts.TypeFlags.StringLike)) { + const wrappingFixerParams = { + node: memberExpr.parent, + innerNode: [memberExpr.object], + sourceCode: context.sourceCode, + }; + context.report({ + loc: { + start: memberExpr.property.loc.start, + end: memberExpr.parent.loc.end, + }, + messageId: 'unnecessaryTypeConversion', + data: { + type: 'string', + violation: "Calling a string's .toString() method", + }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: 'string' }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies string`, + }), + }, + ], + }); + } + }, + 'UnaryExpression[operator = "!"] > UnaryExpression[operator = "!"]'(node) { + handleUnaryOperator(node, ts.TypeFlags.BooleanLike, 'boolean', 'Using !! on a boolean', true); + }, + 'UnaryExpression[operator = "+"]'(node) { + handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using the unary + operator on a number', false); + }, + 'UnaryExpression[operator = "~"] > UnaryExpression[operator = "~"]'(node) { + const outerNode = node.parent; + const type = services.getTypeAtLocation(node.argument); + if (tsutils.unionConstituents(type).every(t => { + return ((0, util_1.isTypeFlagSet)(t, ts.TypeFlags.NumberLiteral) && + Number.isInteger(t.value)); + })) { + const wrappingFixerParams = { + node: outerNode, + innerNode: [node.argument], + sourceCode: context.sourceCode, + }; + context.report({ + loc: { + start: outerNode.loc.start, + end: { + column: node.loc.start.column + 1, + line: node.loc.start.line, + }, + }, + messageId: 'unnecessaryTypeConversion', + data: { type: 'number', violation: 'Using ~~ on an integer' }, + suggest: [ + { + messageId: 'suggestRemove', + fix: (0, util_1.getWrappingFixer)(wrappingFixerParams), + }, + { + messageId: 'suggestSatisfies', + data: { type: 'number' }, + fix: (0, util_1.getWrappingFixer)({ + ...wrappingFixerParams, + wrap: expr => `${expr} satisfies number`, + }), + }, + ], + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-unnecessary-type-conversion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.d.ts new file mode 100644 index 00000000..938c91eb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.js new file mode 100644 index 00000000..d96ae53a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.js @@ -0,0 +1,426 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unnecessary-type-parameters', + meta: { + type: 'problem', + docs: { + description: "Disallow type parameters that aren't used multiple times", + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + replaceUsagesWithConstraint: 'Replace all usages of type parameter with its constraint.', + sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const parserServices = (0, util_1.getParserServices)(context); + function checkNode(node, descriptor) { + const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node); + const checker = parserServices.program.getTypeChecker(); + let counts; + // Get the scope in which the type parameters are declared. + const scope = context.sourceCode.getScope(node); + for (const typeParameter of tsNode.typeParameters) { + const esTypeParameter = parserServices.tsNodeToESTreeNodeMap.get(typeParameter); + const smTypeParameterVariable = (0, util_1.nullThrows)((() => { + const variable = scope.set.get(esTypeParameter.name.name); + return variable?.isTypeVariable ? variable : undefined; + })(), "Type parameter should be present in scope's variables."); + // Quick path: if the type parameter is used multiple times in the AST, + // we don't need to dip into types to know it's repeated. + if (isTypeParameterRepeatedInAST(esTypeParameter, smTypeParameterVariable.references, node.body?.range[0] ?? node.returnType?.range[1])) { + continue; + } + // For any inferred types, we have to dip into type checking. + counts ??= countTypeParameterUsage(checker, tsNode); + const identifierCounts = counts.get(typeParameter.name); + if (!identifierCounts || identifierCounts > 2) { + continue; + } + context.report({ + node: esTypeParameter, + messageId: 'sole', + data: { + name: typeParameter.name.text, + descriptor, + uses: identifierCounts === 1 ? 'never used' : 'used only once', + }, + suggest: [ + { + messageId: 'replaceUsagesWithConstraint', + *fix(fixer) { + // Replace all the usages of the type parameter with the constraint... + const constraint = esTypeParameter.constraint; + // special case - a constraint of 'any' actually acts like 'unknown' + const constraintText = constraint != null && + constraint.type !== utils_1.AST_NODE_TYPES.TSAnyKeyword + ? context.sourceCode.getText(constraint) + : 'unknown'; + for (const reference of smTypeParameterVariable.references) { + if (reference.isTypeReference) { + const referenceNode = reference.identifier; + const isWeakPrecedenceConstraint = constraint?.type === utils_1.AST_NODE_TYPES.TSUnionType || + constraint?.type === utils_1.AST_NODE_TYPES.TSIntersectionType || + constraint?.type === utils_1.AST_NODE_TYPES.TSConditionalType || + constraint?.type === utils_1.AST_NODE_TYPES.TSTypeOperator || + constraint?.type === utils_1.AST_NODE_TYPES.TSFunctionType || + constraint?.type === utils_1.AST_NODE_TYPES.TSConstructorType; + const grandparent = (0, util_1.nullThrows)(referenceNode.parent.parent, util_1.NullThrowsReasons.MissingParent); + const isWeakPrecedenceTypeParent = grandparent.type === utils_1.AST_NODE_TYPES.TSArrayType || + grandparent.type === utils_1.AST_NODE_TYPES.TSIndexedAccessType || + grandparent.type === utils_1.AST_NODE_TYPES.TSIntersectionType || + grandparent.type === utils_1.AST_NODE_TYPES.TSUnionType || + grandparent.type === utils_1.AST_NODE_TYPES.TSConditionalType || + grandparent.type === utils_1.AST_NODE_TYPES.TSTypeOperator; + if (isWeakPrecedenceConstraint && + isWeakPrecedenceTypeParent) { + yield fixer.replaceText(referenceNode.parent, `(${constraintText})`); + } + else { + yield fixer.replaceText(referenceNode.parent, constraintText); + } + } + } + // ...and remove the type parameter itself from the declaration. + const typeParamsNode = (0, util_1.nullThrows)(node.typeParameters, 'node should have type parameters'); + // We are assuming at this point that the reported type parameter + // is present in the inspected node's type parameters. + if (typeParamsNode.params.length === 1) { + // Remove the whole generic syntax if we're removing the only type parameter in the list. + yield fixer.remove(typeParamsNode); + } + else { + const index = typeParamsNode.params.indexOf(esTypeParameter); + if (index === 0) { + const commaAfter = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(esTypeParameter, token => token.value === ','), util_1.NullThrowsReasons.MissingToken('comma', 'type parameter list')); + const tokenAfterComma = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(commaAfter, { + includeComments: true, + }), util_1.NullThrowsReasons.MissingToken('token', 'type parameter list')); + yield fixer.removeRange([ + esTypeParameter.range[0], + tokenAfterComma.range[0], + ]); + } + else { + const commaBefore = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(esTypeParameter, token => token.value === ','), util_1.NullThrowsReasons.MissingToken('comma', 'type parameter list')); + yield fixer.removeRange([ + commaBefore.range[0], + esTypeParameter.range[1], + ]); + } + } + }, + }, + ], + }); + } + } + return { + [[ + 'ArrowFunctionExpression[typeParameters]', + 'FunctionDeclaration[typeParameters]', + 'FunctionExpression[typeParameters]', + 'TSCallSignatureDeclaration[typeParameters]', + 'TSConstructorType[typeParameters]', + 'TSDeclareFunction[typeParameters]', + 'TSEmptyBodyFunctionExpression[typeParameters]', + 'TSFunctionType[typeParameters]', + 'TSMethodSignature[typeParameters]', + ].join(', ')](node) { + checkNode(node, 'function'); + }, + [[ + 'ClassDeclaration[typeParameters]', + 'ClassExpression[typeParameters]', + ].join(', ')](node) { + checkNode(node, 'class'); + }, + }; + }, +}); +function isTypeParameterRepeatedInAST(node, references, startOfBody = Infinity) { + let total = 0; + for (const reference of references) { + // References inside the type parameter's definition don't count... + if (reference.identifier.range[0] < node.range[1] && + reference.identifier.range[1] > node.range[0]) { + continue; + } + // ...nor references that are outside the declaring signature. + if (reference.identifier.range[0] > startOfBody) { + continue; + } + // Neither do references that aren't to the same type parameter, + // namely value-land (non-type) identifiers of the type parameter's type, + // and references to different type parameters or values. + if (!reference.isTypeReference || + reference.identifier.name !== node.name.name) { + continue; + } + // If the type parameter is being used as a type argument, then we + // know the type parameter is being reused and can't be reported. + if (reference.identifier.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference) { + const grandparent = skipConstituentsUpward(reference.identifier.parent.parent); + if (grandparent.type === utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation && + grandparent.params.includes(reference.identifier.parent) && + // Array and ReadonlyArray must be handled carefully + // let's defer the check to the type-aware phase + !(grandparent.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference && + grandparent.parent.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + ['Array', 'ReadonlyArray'].includes(grandparent.parent.typeName.name))) { + return true; + } + } + total += 1; + if (total >= 2) { + return true; + } + } + return false; +} +function skipConstituentsUpward(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSIntersectionType: + case utils_1.AST_NODE_TYPES.TSUnionType: + return skipConstituentsUpward(node.parent); + default: + return node; + } +} +/** + * Count uses of type parameters in inferred return types. + * We need to resolve and analyze the inferred return type of a function + * to see whether it contains additional references to the type parameters. + * For classes, we need to do this for all their methods. + */ +function countTypeParameterUsage(checker, node) { + const counts = new Map(); + if (ts.isClassLike(node)) { + for (const typeParameter of node.typeParameters) { + collectTypeParameterUsageCounts(checker, typeParameter, counts, true); + } + for (const member of node.members) { + collectTypeParameterUsageCounts(checker, member, counts, true); + } + } + else { + collectTypeParameterUsageCounts(checker, node, counts, false); + } + return counts; +} +/** + * Populates {@link foundIdentifierUsages} by the number of times each type parameter + * appears in the given type by checking its uses through its type references. + * This is essentially a limited subset of the scope manager, but for types. + */ +function collectTypeParameterUsageCounts(checker, node, foundIdentifierUsages, fromClass) { + const visitedSymbolLists = new Set(); + const type = checker.getTypeAtLocation(node); + const typeUsages = new Map(); + const visitedConstraints = new Set(); + let functionLikeType = false; + let visitedDefault = false; + if (ts.isCallSignatureDeclaration(node) || + ts.isConstructorDeclaration(node)) { + functionLikeType = true; + visitSignature(checker.getSignatureFromDeclaration(node)); + } + if (!functionLikeType) { + visitType(type, false); + } + function visitType(type, assumeMultipleUses, isReturnType = false) { + // Seeing the same type > (threshold=3 ** 2) times indicates a likely + // recursive type, like `type T = { [P in keyof T]: T }`. + // If it's not recursive, then heck, we've seen it enough times that any + // referenced types have been counted enough to qualify as used. + if (!type || incrementTypeUsages(type) > 9) { + return; + } + if (tsutils.isTypeParameter(type)) { + const declaration = type.getSymbol()?.getDeclarations()?.[0]; + if (declaration) { + incrementIdentifierCount(declaration.name, assumeMultipleUses); + // Visiting the type of a constrained type parameter will recurse into + // the constraint. We avoid infinite loops by visiting each only once. + if (declaration.constraint && + !visitedConstraints.has(declaration.constraint)) { + visitedConstraints.add(declaration.constraint); + visitType(checker.getTypeAtLocation(declaration.constraint), false); + } + if (declaration.default && !visitedDefault) { + visitedDefault = true; + visitType(checker.getTypeAtLocation(declaration.default), false); + } + } + } + // Catch-all: generic type references like `Exclude` + else if (type.aliasTypeArguments) { + // We don't descend into the definition of the type alias, so we don't + // know whether it's used multiple times. It's safest to assume it is. + visitTypesList(type.aliasTypeArguments, true); + } + // Intersections and unions like `0 | 1` + else if (tsutils.isUnionOrIntersectionType(type)) { + visitTypesList(type.types, assumeMultipleUses); + } + // Index access types like `T[K]` + else if (tsutils.isIndexedAccessType(type)) { + visitType(type.objectType, assumeMultipleUses); + visitType(type.indexType, assumeMultipleUses); + } + // Tuple types like `[K, V]` + // Generic type references like `Map` + else if (tsutils.isTypeReference(type)) { + for (const typeArgument of type.typeArguments ?? []) { + // currently, if we are in a "class context", everything is accepted + let thisAssumeMultipleUses = fromClass || assumeMultipleUses; + // special cases - readonly arrays/tuples are considered only to use the + // type parameter once. Mutable arrays/tuples are considered to use the + // type parameter multiple times if and only if they are returned. + // other kind of type references always count as multiple uses + thisAssumeMultipleUses ||= tsutils.isTupleType(type.target) + ? isReturnType && !type.target.readonly + : checker.isArrayType(type.target) + ? isReturnType && + type.symbol?.getName() === 'Array' + : true; + visitType(typeArgument, thisAssumeMultipleUses, isReturnType); + } + } + // Template literals like `a${T}b` + else if (tsutils.isTemplateLiteralType(type)) { + for (const subType of type.types) { + visitType(subType, assumeMultipleUses); + } + } + // Conditional types like `T extends string ? T : never` + else if (tsutils.isConditionalType(type)) { + visitType(type.checkType, assumeMultipleUses); + visitType(type.extendsType, assumeMultipleUses); + } + // Catch-all: inferred object types like `{ K: V }`. + // These catch-alls should be _after_ more specific checks like + // `isTypeReference` to avoid descending into all the properties of a + // generic interface/class, e.g. `Map`. + else if (tsutils.isObjectType(type)) { + const properties = type.getProperties(); + visitSymbolsListOnce(properties, false); + if (isMappedType(type)) { + visitType(type.typeParameter, false); + if (properties.length === 0) { + // TS treats mapped types like `{[k in "a"]: T}` like `{a: T}`. + // They have properties, so we need to avoid double-counting. + visitType(type.templateType ?? type.constraintType, false); + } + // TS doesn't count mapped types key remapping (`{[K in 'a' as T]: K}`) + // but handles this under `MappedType.nameType`, so we need to visit that too. + if (type.nameType) { + visitType(type.nameType, false); + } + } + visitType(type.getNumberIndexType(), true); + visitType(type.getStringIndexType(), true); + type.getCallSignatures().forEach(signature => { + functionLikeType = true; + visitSignature(signature); + }); + type.getConstructSignatures().forEach(signature => { + functionLikeType = true; + visitSignature(signature); + }); + } + // Catch-all: operator types like `keyof T` + else if (isOperatorType(type)) { + visitType(type.type, assumeMultipleUses); + } + } + function incrementIdentifierCount(id, assumeMultipleUses) { + const identifierCount = foundIdentifierUsages.get(id) ?? 0; + const value = assumeMultipleUses ? 2 : 1; + foundIdentifierUsages.set(id, identifierCount + value); + } + function incrementTypeUsages(type) { + const count = (typeUsages.get(type) ?? 0) + 1; + typeUsages.set(type, count); + return count; + } + function visitSignature(signature) { + if (!signature) { + return; + } + if (signature.thisParameter) { + visitType(checker.getTypeOfSymbol(signature.thisParameter), false); + } + for (const parameter of signature.parameters) { + visitType(checker.getTypeOfSymbol(parameter), false); + } + for (const typeParameter of signature.getTypeParameters() ?? []) { + visitType(typeParameter, false); + } + visitType(checker.getTypePredicateOfSignature(signature)?.type ?? + signature.getReturnType(), false, true); + } + function visitSymbolsListOnce(symbols, assumeMultipleUses) { + if (visitedSymbolLists.has(symbols)) { + return; + } + visitedSymbolLists.add(symbols); + for (const symbol of symbols) { + visitType(checker.getTypeOfSymbol(symbol), assumeMultipleUses); + } + } + function visitTypesList(types, assumeMultipleUses) { + for (const type of types) { + visitType(type, assumeMultipleUses); + } + } +} +function isMappedType(type) { + return 'typeParameter' in type; +} +function isOperatorType(type) { + return 'type' in type && !!type.type; +} +//# sourceMappingURL=no-unnecessary-type-parameters.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.d.ts new file mode 100644 index 00000000..fdc979f1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.d.ts @@ -0,0 +1,5 @@ +export type MessageIds = 'unsafeArgument' | 'unsafeArraySpread' | 'unsafeSpread' | 'unsafeTupleSpread'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.js new file mode 100644 index 00000000..0245b6d9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-argument.js @@ -0,0 +1,183 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-argument', + meta: { + type: 'problem', + docs: { + description: 'Disallow calling a function with a value with type `any`', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + unsafeArgument: 'Unsafe argument of type {{sender}} assigned to a parameter of type {{receiver}}.', + unsafeArraySpread: 'Unsafe spread of an {{sender}} array type.', + unsafeSpread: 'Unsafe spread of an {{sender}} type.', + unsafeTupleSpread: 'Unsafe spread of a tuple type. The argument is {{sender}} and is assigned to a parameter of type {{receiver}}.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function describeType(type) { + if (tsutils.isIntrinsicErrorType(type)) { + return 'error typed'; + } + return `\`${checker.typeToString(type)}\``; + } + function describeTypeForSpread(type) { + if (checker.isArrayType(type) && + tsutils.isIntrinsicErrorType(checker.getTypeArguments(type)[0])) { + return 'error'; + } + return describeType(type); + } + function describeTypeForTuple(type) { + if (tsutils.isIntrinsicErrorType(type)) { + return 'error typed'; + } + return `of type \`${checker.typeToString(type)}\``; + } + function checkUnsafeArguments(args, callee, node) { + if (args.length === 0) { + return; + } + // ignore any-typed calls as these are caught by no-unsafe-call + if ((0, util_1.isTypeAnyType)(services.getTypeAtLocation(callee))) { + return; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + const signature = util_1.FunctionSignature.create(checker, tsNode); + if (node.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) { + // Consumes the first parameter (TemplateStringsArray) of the function called with TaggedTemplateExpression. + signature.getNextParameterType(); + } + for (const argument of args) { + switch (argument.type) { + // spreads consume + case utils_1.AST_NODE_TYPES.SpreadElement: { + const spreadArgType = services.getTypeAtLocation(argument.argument); + if ((0, util_1.isTypeAnyType)(spreadArgType)) { + // foo(...any) + context.report({ + node: argument, + messageId: 'unsafeSpread', + data: { sender: describeType(spreadArgType) }, + }); + } + else if ((0, util_1.isTypeAnyArrayType)(spreadArgType, checker)) { + // foo(...any[]) + // TODO - we could break down the spread and compare the array type against each argument + context.report({ + node: argument, + messageId: 'unsafeArraySpread', + data: { sender: describeTypeForSpread(spreadArgType) }, + }); + } + else if (checker.isTupleType(spreadArgType)) { + // foo(...[tuple1, tuple2]) + const spreadTypeArguments = checker.getTypeArguments(spreadArgType); + for (const tupleType of spreadTypeArguments) { + const parameterType = signature.getNextParameterType(); + if (parameterType == null) { + continue; + } + const result = (0, util_1.isUnsafeAssignment)(tupleType, parameterType, checker, + // we can't pass the individual tuple members in here as this will most likely be a spread variable + // not a spread array + null); + if (result) { + context.report({ + node: argument, + messageId: 'unsafeTupleSpread', + data: { + receiver: describeType(parameterType), + sender: describeTypeForTuple(tupleType), + }, + }); + } + } + if (spreadArgType.target.combinedFlags & ts.ElementFlags.Variable) { + // the last element was a rest - so all remaining defined arguments can be considered "consumed" + // all remaining arguments should be compared against the rest type (if one exists) + signature.consumeRemainingArguments(); + } + } + else { + // something that's iterable + // handling this will be pretty complex - so we ignore it for now + // TODO - handle generic iterable case + } + break; + } + default: { + const parameterType = signature.getNextParameterType(); + if (parameterType == null) { + continue; + } + const argumentType = services.getTypeAtLocation(argument); + const result = (0, util_1.isUnsafeAssignment)(argumentType, parameterType, checker, argument); + if (result) { + context.report({ + node: argument, + messageId: 'unsafeArgument', + data: { + receiver: describeType(parameterType), + sender: describeType(argumentType), + }, + }); + } + } + } + } + } + return { + 'CallExpression, NewExpression'(node) { + checkUnsafeArguments(node.arguments, node.callee, node); + }, + TaggedTemplateExpression(node) { + checkUnsafeArguments(node.quasi.expressions, node.tag, node); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-argument.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.d.ts new file mode 100644 index 00000000..8013ad4c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeObjectPattern", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.js new file mode 100644 index 00000000..c9aa7c0b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.js @@ -0,0 +1,323 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +var ComparisonType; +(function (ComparisonType) { + /** Do no assignment comparison */ + ComparisonType[ComparisonType["None"] = 0] = "None"; + /** Use the receiver's type for comparison */ + ComparisonType[ComparisonType["Basic"] = 1] = "Basic"; + /** Use the sender's contextual type for comparison */ + ComparisonType[ComparisonType["Contextual"] = 2] = "Contextual"; +})(ComparisonType || (ComparisonType = {})); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-assignment', + meta: { + type: 'problem', + docs: { + description: 'Disallow assigning a value with type `any` to variables and properties', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + anyAssignment: 'Unsafe assignment of an {{sender}} value.', + anyAssignmentThis: [ + 'Unsafe assignment of an {{sender}} value. `this` is typed as `any`.', + 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.', + ].join('\n'), + unsafeArrayPattern: 'Unsafe array destructuring of an {{sender}} array value.', + unsafeArrayPatternFromTuple: 'Unsafe array destructuring of a tuple element with an {{sender}} value.', + unsafeArraySpread: 'Unsafe spread of an {{sender}} value in an array.', + unsafeAssignment: 'Unsafe assignment of type {{sender}} to a variable of type {{receiver}}.', + unsafeObjectPattern: 'Unsafe object destructuring of a property with an {{sender}} value.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis'); + // returns true if the assignment reported + function checkArrayDestructureHelper(receiverNode, senderNode) { + if (receiverNode.type !== utils_1.AST_NODE_TYPES.ArrayPattern) { + return false; + } + const senderTsNode = services.esTreeNodeToTSNodeMap.get(senderNode); + const senderType = services.getTypeAtLocation(senderNode); + return checkArrayDestructure(receiverNode, senderType, senderTsNode); + } + // returns true if the assignment reported + function checkArrayDestructure(receiverNode, senderType, senderNode) { + // any array + // const [x] = ([] as any[]); + if ((0, util_1.isTypeAnyArrayType)(senderType, checker)) { + context.report({ + node: receiverNode, + messageId: 'unsafeArrayPattern', + data: createData(senderType), + }); + return false; + } + if (!checker.isTupleType(senderType)) { + return true; + } + const tupleElements = checker.getTypeArguments(senderType); + // tuple with any + // const [x] = [1 as any]; + let didReport = false; + for (let receiverIndex = 0; receiverIndex < receiverNode.elements.length; receiverIndex += 1) { + const receiverElement = receiverNode.elements[receiverIndex]; + if (!receiverElement) { + continue; + } + if (receiverElement.type === utils_1.AST_NODE_TYPES.RestElement) { + // don't handle rests as they're not a 1:1 assignment + continue; + } + const senderType = tupleElements[receiverIndex]; + if (!senderType) { + continue; + } + // check for the any type first so we can handle [[[x]]] = [any] + if ((0, util_1.isTypeAnyType)(senderType)) { + context.report({ + node: receiverElement, + messageId: 'unsafeArrayPatternFromTuple', + data: createData(senderType), + }); + // we want to report on every invalid element in the tuple + didReport = true; + } + else if (receiverElement.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + didReport = checkArrayDestructure(receiverElement, senderType, senderNode); + } + else if (receiverElement.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + didReport = checkObjectDestructure(receiverElement, senderType, senderNode); + } + } + return didReport; + } + // returns true if the assignment reported + function checkObjectDestructureHelper(receiverNode, senderNode) { + if (receiverNode.type !== utils_1.AST_NODE_TYPES.ObjectPattern) { + return false; + } + const senderTsNode = services.esTreeNodeToTSNodeMap.get(senderNode); + const senderType = services.getTypeAtLocation(senderNode); + return checkObjectDestructure(receiverNode, senderType, senderTsNode); + } + // returns true if the assignment reported + function checkObjectDestructure(receiverNode, senderType, senderNode) { + const properties = new Map(senderType + .getProperties() + .map(property => [ + property.getName(), + checker.getTypeOfSymbolAtLocation(property, senderNode), + ])); + let didReport = false; + for (const receiverProperty of receiverNode.properties) { + if (receiverProperty.type === utils_1.AST_NODE_TYPES.RestElement) { + // don't bother checking rest + continue; + } + let key; + if (!receiverProperty.computed) { + key = + receiverProperty.key.type === utils_1.AST_NODE_TYPES.Identifier + ? receiverProperty.key.name + : String(receiverProperty.key.value); + } + else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.Literal) { + key = String(receiverProperty.key.value); + } + else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral && + receiverProperty.key.quasis.length === 1) { + const cooked = (0, util_1.nullThrows)(receiverProperty.key.quasis[0].value.cooked, 'cooked can only be null inside a TaggedTemplateExpression, which is not possible here'); + key = cooked; + } + else { + // can't figure out the name, so skip it + continue; + } + const senderType = properties.get(key); + if (!senderType) { + continue; + } + // check for the any type first so we can handle {x: {y: z}} = {x: any} + if ((0, util_1.isTypeAnyType)(senderType)) { + context.report({ + node: receiverProperty.value, + messageId: 'unsafeObjectPattern', + data: createData(senderType), + }); + didReport = true; + } + else if (receiverProperty.value.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + didReport = checkArrayDestructure(receiverProperty.value, senderType, senderNode); + } + else if (receiverProperty.value.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + didReport = checkObjectDestructure(receiverProperty.value, senderType, senderNode); + } + } + return didReport; + } + // returns true if the assignment reported + function checkAssignment(receiverNode, senderNode, reportingNode, comparisonType) { + const receiverTsNode = services.esTreeNodeToTSNodeMap.get(receiverNode); + const receiverType = comparisonType === ComparisonType.Contextual + ? ((0, util_1.getContextualType)(checker, receiverTsNode) ?? + services.getTypeAtLocation(receiverNode)) + : services.getTypeAtLocation(receiverNode); + const senderType = services.getTypeAtLocation(senderNode); + if ((0, util_1.isTypeAnyType)(senderType)) { + // handle cases when we assign any ==> unknown. + if ((0, util_1.isTypeUnknownType)(receiverType)) { + return false; + } + let messageId = 'anyAssignment'; + if (!isNoImplicitThis) { + // `var foo = this` + const thisExpression = (0, util_1.getThisExpression)(senderNode); + if (thisExpression && + (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) { + messageId = 'anyAssignmentThis'; + } + } + context.report({ + node: reportingNode, + messageId, + data: createData(senderType), + }); + return true; + } + if (comparisonType === ComparisonType.None) { + return false; + } + const result = (0, util_1.isUnsafeAssignment)(senderType, receiverType, checker, senderNode); + if (!result) { + return false; + } + const { receiver, sender } = result; + context.report({ + node: reportingNode, + messageId: 'unsafeAssignment', + data: createData(sender, receiver), + }); + return true; + } + function getComparisonType(typeAnnotation) { + return typeAnnotation + ? // if there's a type annotation, we can do a comparison + ComparisonType.Basic + : // no type annotation means the variable's type will just be inferred, thus equal + ComparisonType.None; + } + function createData(senderType, receiverType) { + if (receiverType) { + return { + receiver: `\`${checker.typeToString(receiverType)}\``, + sender: `\`${checker.typeToString(senderType)}\``, + }; + } + return { + sender: tsutils.isIntrinsicErrorType(senderType) + ? 'error typed' + : '`any`', + }; + } + return { + 'AccessorProperty[value != null]'(node) { + checkAssignment(node.key, node.value, node, getComparisonType(node.typeAnnotation)); + }, + 'AssignmentExpression[operator = "="], AssignmentPattern'(node) { + let didReport = checkAssignment(node.left, node.right, node, + // the variable already has some form of a type to compare against + ComparisonType.Basic); + if (!didReport) { + didReport = checkArrayDestructureHelper(node.left, node.right); + } + if (!didReport) { + checkObjectDestructureHelper(node.left, node.right); + } + }, + 'PropertyDefinition[value != null]'(node) { + checkAssignment(node.key, node.value, node, getComparisonType(node.typeAnnotation)); + }, + 'VariableDeclarator[init != null]'(node) { + const init = (0, util_1.nullThrows)(node.init, util_1.NullThrowsReasons.MissingToken(node.type, 'init')); + let didReport = checkAssignment(node.id, init, node, getComparisonType(node.id.typeAnnotation)); + if (!didReport) { + didReport = checkArrayDestructureHelper(node.id, init); + } + if (!didReport) { + checkObjectDestructureHelper(node.id, init); + } + }, + // object pattern props are checked via assignments + ':not(ObjectPattern) > Property'(node) { + if (node.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern || + node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + // handled by other selector + return; + } + checkAssignment(node.key, node.value, node, ComparisonType.Contextual); + }, + 'ArrayExpression > SpreadElement'(node) { + const restType = services.getTypeAtLocation(node.argument); + if ((0, util_1.isTypeAnyType)(restType) || (0, util_1.isTypeAnyArrayType)(restType, checker)) { + context.report({ + node, + messageId: 'unsafeArraySpread', + data: createData(restType), + }); + } + }, + 'JSXAttribute[value != null]'(node) { + const value = (0, util_1.nullThrows)(node.value, util_1.NullThrowsReasons.MissingToken(node.type, 'value')); + if (value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer || + value.expression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression) { + return; + } + checkAssignment(node.name, value.expression, value.expression, ComparisonType.Contextual); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-assignment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.d.ts new file mode 100644 index 00000000..7ee45d53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.d.ts @@ -0,0 +1,5 @@ +export type MessageIds = 'errorCall' | 'errorCallThis' | 'errorNew' | 'errorTemplateTag' | 'unsafeCall' | 'unsafeCallThis' | 'unsafeNew' | 'unsafeTemplateTag'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.js new file mode 100644 index 00000000..07671550 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-call.js @@ -0,0 +1,137 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-call', + meta: { + type: 'problem', + docs: { + description: 'Disallow calling a value with type `any`', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + errorCall: 'Unsafe call of a type that could not be resolved.', + errorCallThis: 'Unsafe call of a `this` type that could not be resolved.', + errorNew: 'Unsafe construction of a type that could not be resolved.', + errorTemplateTag: 'Unsafe use of a template tag whose type could not be resolved.', + unsafeCall: 'Unsafe call of {{type}} typed value.', + unsafeCallThis: [ + 'Unsafe call of {{type}} typed value. `this` is typed as {{type}}.', + 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.', + ].join('\n'), + unsafeNew: 'Unsafe construction of {{type}} typed value.', + unsafeTemplateTag: 'Unsafe use of {{type}} typed template tag.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const compilerOptions = services.program.getCompilerOptions(); + const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis'); + function checkCall(node, reportingNode, unsafeMessageId, errorMessageId) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + if ((0, util_1.isTypeAnyType)(type)) { + if (!isNoImplicitThis) { + // `this()` or `this.foo()` or `this.foo[bar]()` + const thisExpression = (0, util_1.getThisExpression)(node); + if (thisExpression && + (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) { + unsafeMessageId = 'unsafeCallThis'; + errorMessageId = 'errorCallThis'; + } + } + const isErrorType = tsutils.isIntrinsicErrorType(type); + context.report({ + node: reportingNode, + messageId: isErrorType ? errorMessageId : unsafeMessageId, + data: { + type: 'an `any`', + }, + }); + return; + } + if ((0, util_1.isBuiltinSymbolLike)(services.program, type, 'Function')) { + // this also matches subtypes of `Function`, like `interface Foo extends Function {}`. + // + // For weird TS reasons that I don't understand, these are + // + // safe to construct if: + // - they have at least one call signature _that is not void-returning_, + // - OR they have at least one construct signature. + // + // safe to call (including as template) if: + // - they have at least one call signature + // - OR they have at least one construct signature. + const constructSignatures = type.getConstructSignatures(); + if (constructSignatures.length > 0) { + return; + } + const callSignatures = type.getCallSignatures(); + if (unsafeMessageId === 'unsafeNew') { + if (callSignatures.some(signature => !tsutils.isIntrinsicVoidType(signature.getReturnType()))) { + return; + } + } + else if (callSignatures.length > 0) { + return; + } + context.report({ + node: reportingNode, + messageId: unsafeMessageId, + data: { + type: 'a `Function`', + }, + }); + return; + } + } + return { + 'CallExpression > *.callee'(node) { + checkCall(node, node, 'unsafeCall', 'errorCall'); + }, + NewExpression(node) { + checkCall(node.callee, node, 'unsafeNew', 'errorNew'); + }, + 'TaggedTemplateExpression > *.tag'(node) { + checkCall(node, node, 'unsafeTemplateTag', 'errorTemplateTag'); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-call.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.d.ts new file mode 100644 index 00000000..65b601ec --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.js new file mode 100644 index 00000000..8781f538 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-declaration-merging.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-declaration-merging', + meta: { + type: 'problem', + docs: { + description: 'Disallow unsafe declaration merging', + recommended: 'recommended', + requiresTypeChecking: false, + }, + messages: { + unsafeMerging: 'Unsafe declaration merging between classes and interfaces.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function checkUnsafeDeclaration(scope, node, unsafeKind) { + const variable = scope.set.get(node.name); + if (!variable) { + return; + } + const defs = variable.defs; + if (defs.length <= 1) { + return; + } + if (defs.some(def => def.node.type === unsafeKind)) { + context.report({ + node, + messageId: 'unsafeMerging', + }); + } + } + return { + ClassDeclaration(node) { + if (node.id) { + // by default eslint returns the inner class scope for the ClassDeclaration node + // but we want the outer scope within which merged variables will sit + const currentScope = context.sourceCode.getScope(node).upper; + if (currentScope == null) { + return; + } + checkUnsafeDeclaration(currentScope, node.id, utils_1.AST_NODE_TYPES.TSInterfaceDeclaration); + } + }, + TSInterfaceDeclaration(node) { + checkUnsafeDeclaration(context.sourceCode.getScope(node), node.id, utils_1.AST_NODE_TYPES.ClassDeclaration); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-declaration-merging.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.d.ts new file mode 100644 index 00000000..67ef12b4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.js new file mode 100644 index 00000000..0411b9f5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.js @@ -0,0 +1,82 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +const shared_1 = require("./enum-utils/shared"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-enum-comparison', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow comparing an enum value with a non-enum value', + recommended: 'recommended', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + mismatchedCase: 'The case statement does not have a shared enum type with the switch predicate.', + mismatchedCondition: 'The two values in this comparison do not have a shared enum type.', + replaceValueWithEnum: 'Replace with an enum value comparison.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const parserServices = (0, util_1.getParserServices)(context); + const typeChecker = parserServices.program.getTypeChecker(); + return { + 'BinaryExpression[operator=/^[<>!=]?={0,2}$/]'(node) { + const leftType = parserServices.getTypeAtLocation(node.left); + const rightType = parserServices.getTypeAtLocation(node.right); + if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) { + context.report({ + node, + messageId: 'mismatchedCondition', + suggest: [ + { + messageId: 'replaceValueWithEnum', + fix(fixer) { + // Replace the right side with an enum key if possible: + // + // ```ts + // Fruit.Apple === 'apple'; // Fruit.Apple === Fruit.Apple + // ``` + const leftEnumKey = (0, shared_1.getEnumKeyForLiteral)((0, shared_1.getEnumLiterals)(leftType), (0, util_1.getStaticValue)(node.right)?.value); + if (leftEnumKey) { + return fixer.replaceText(node.right, leftEnumKey); + } + // Replace the left side with an enum key if possible: + // + // ```ts + // declare const fruit: Fruit; + // 'apple' === Fruit.Apple; // Fruit.Apple === Fruit.Apple + // ``` + const rightEnumKey = (0, shared_1.getEnumKeyForLiteral)((0, shared_1.getEnumLiterals)(rightType), (0, util_1.getStaticValue)(node.left)?.value); + if (rightEnumKey) { + return fixer.replaceText(node.left, rightEnumKey); + } + return null; + }, + }, + ], + }); + } + }, + SwitchCase(node) { + // Ignore `default` cases. + if (node.test == null) { + return; + } + const { parent } = node; + const leftType = parserServices.getTypeAtLocation(parent.discriminant); + const rightType = parserServices.getTypeAtLocation(node.test); + if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) { + context.report({ + node, + messageId: 'mismatchedCase', + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-enum-comparison.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.d.ts new file mode 100644 index 00000000..9fbcdc90 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.js new file mode 100644 index 00000000..fd76abe5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-function-type.js @@ -0,0 +1,46 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-function-type', + meta: { + type: 'problem', + docs: { + description: 'Disallow using the unsafe built-in Function type', + recommended: 'recommended', + }, + messages: { + bannedFunctionType: [ + 'The `Function` type accepts any function-like value.', + 'Prefer explicitly defining any function parameters and return type.', + ].join('\n'), + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function checkBannedTypes(node) { + if (node.type === utils_1.AST_NODE_TYPES.Identifier && + node.name === 'Function' && + (0, util_1.isReferenceToGlobalFunction)('Function', node, context.sourceCode)) { + context.report({ + node, + messageId: 'bannedFunctionType', + }); + } + } + return { + TSClassImplements(node) { + checkBannedTypes(node.expression); + }, + TSInterfaceHeritage(node) { + checkBannedTypes(node.expression); + }, + TSTypeReference(node) { + checkBannedTypes(node.typeName); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-function-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.d.ts new file mode 100644 index 00000000..c58dbc05 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.d.ts @@ -0,0 +1,10 @@ +export type Options = [ + { + allowOptionalChaining?: boolean; + } +]; +export type MessageIds = 'errorComputedMemberAccess' | 'errorMemberExpression' | 'errorThisMemberExpression' | 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.js new file mode 100644 index 00000000..2e63f44c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-member-access.js @@ -0,0 +1,184 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +var State; +(function (State) { + State[State["Unsafe"] = 1] = "Unsafe"; + State[State["Safe"] = 2] = "Safe"; + State[State["Chained"] = 3] = "Chained"; +})(State || (State = {})); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-member-access', + meta: { + type: 'problem', + docs: { + description: 'Disallow member access on a value with type `any`', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + errorComputedMemberAccess: 'The type of computed name {{property}} cannot be resolved.', + errorMemberExpression: 'Unsafe member access {{property}} on a type that cannot be resolved.', + errorThisMemberExpression: [ + 'Unsafe member access {{property}}. The type of `this` cannot be resolved.', + 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.', + ].join('\n'), + unsafeComputedMemberAccess: 'Computed name {{property}} resolves to an `any` value.', + unsafeMemberExpression: 'Unsafe member access {{property}} on an `any` value.', + unsafeThisMemberExpression: [ + 'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.', + 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.', + ].join('\n'), + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowOptionalChaining: { + type: 'boolean', + description: 'Whether to allow `?.` optional chains on `any` values.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowOptionalChaining: false, + }, + ], + create(context, [{ allowOptionalChaining }]) { + const services = (0, util_1.getParserServices)(context); + const compilerOptions = services.program.getCompilerOptions(); + const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis'); + const stateCache = new Map(); + // Case notes: + // value?.outer.middle.inner + // The ChainExpression is a child of the root expression, and a parent of all the MemberExpressions. + // But the left-most expression is what we want to report on: the inner-most expressions. + // In fact, this is true even if the chain is on the inside! + // value.outer.middle?.inner; + // It was already true that every `object` (MemberExpression) has optional: boolean + function checkMemberExpression(node) { + if (allowOptionalChaining && node.optional) { + stateCache.set(node, State.Chained); + return State.Chained; + } + const cachedState = stateCache.get(node); + if (cachedState) { + return cachedState; + } + if (node.object.type === utils_1.AST_NODE_TYPES.MemberExpression) { + const objectState = checkMemberExpression(node.object); + if (objectState === State.Unsafe) { + // if the object is unsafe, we know this will be unsafe as well + // we don't need to report, as we have already reported on the inner member expr + stateCache.set(node, objectState); + return objectState; + } + } + const type = services.getTypeAtLocation(node.object); + const state = (0, util_1.isTypeAnyType)(type) ? State.Unsafe : State.Safe; + stateCache.set(node, state); + if (state === State.Unsafe) { + const propertyName = context.sourceCode.getText(node.property); + let messageId; + if (!isNoImplicitThis) { + // `this.foo` or `this.foo[bar]` + const thisExpression = (0, util_1.getThisExpression)(node); + if (thisExpression) { + const thisType = (0, util_1.getConstrainedTypeAtLocation)(services, thisExpression); + if ((0, util_1.isTypeAnyType)(thisType)) { + messageId = tsutils.isIntrinsicErrorType(thisType) + ? 'errorThisMemberExpression' + : 'unsafeThisMemberExpression'; + } + } + } + if (!messageId) { + messageId = tsutils.isIntrinsicErrorType(type) + ? 'errorMemberExpression' + : 'unsafeMemberExpression'; + } + context.report({ + node: node.property, + messageId, + data: { + property: node.computed ? `[${propertyName}]` : `.${propertyName}`, + }, + }); + } + return state; + } + return { + // ignore MemberExpressions with ancestors of type `TSClassImplements` or `TSInterfaceHeritage` + 'MemberExpression:not(TSClassImplements MemberExpression, TSInterfaceHeritage MemberExpression)': checkMemberExpression, + 'MemberExpression[computed = true] > *.property'(node) { + if (allowOptionalChaining && + node.parent.optional) { + return; + } + if ( + // x[1] + node.type === utils_1.AST_NODE_TYPES.Literal || + // x[1++] x[++x] etc + // FUN FACT - **all** update expressions return type number, regardless of the argument's type, + // because JS engines return NaN if there the argument is not a number. + node.type === utils_1.AST_NODE_TYPES.UpdateExpression) { + // perf optimizations - literals can obviously never be `any` + return; + } + const type = services.getTypeAtLocation(node); + if ((0, util_1.isTypeAnyType)(type)) { + const propertyName = context.sourceCode.getText(node); + context.report({ + node, + messageId: tsutils.isIntrinsicErrorType(type) + ? 'errorComputedMemberAccess' + : 'unsafeComputedMemberAccess', + data: { + property: `[${propertyName}]`, + }, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-member-access.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.d.ts new file mode 100644 index 00000000..d600b743 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.js new file mode 100644 index 00000000..7f0e5da5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-return.js @@ -0,0 +1,185 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getParentFunctionNode_1 = require("../util/getParentFunctionNode"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-return', + meta: { + type: 'problem', + docs: { + description: 'Disallow returning a value with type `any` from a function', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + unsafeReturn: 'Unsafe return of a value of type {{type}}.', + unsafeReturnAssignment: 'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.', + unsafeReturnThis: [ + 'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.', + 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.', + ].join('\n'), + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis'); + function checkReturn(returnNode, reportingNode = returnNode) { + const functionNode = (0, getParentFunctionNode_1.getParentFunctionNode)(returnNode); + /* istanbul ignore if */ if (!functionNode) { + return; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(returnNode); + const type = checker.getTypeAtLocation(tsNode); + const anyType = (0, util_1.discriminateAnyType)(type, checker, services.program, tsNode); + // function has an explicit return type, so ensure it's a safe return + const returnNodeType = services.getTypeAtLocation(returnNode); + const constrainedReturnNodeType = (0, util_1.getConstrainedTypeAtLocation)(services, returnNode); + const functionTSNode = services.esTreeNodeToTSNodeMap.get(functionNode); + // function expressions will not have their return type modified based on receiver typing + // so we have to use the contextual typing in these cases, i.e. + // const foo1: () => Set = () => new Set(); + // the return type of the arrow function is Set even though the variable is typed as Set + let functionType = ts.isFunctionExpression(functionTSNode) || + ts.isArrowFunction(functionTSNode) + ? (0, util_1.getContextualType)(checker, functionTSNode) + : services.getTypeAtLocation(functionNode); + functionType ??= services.getTypeAtLocation(functionNode); + const callSignatures = tsutils.getCallSignaturesOfType(functionType); + // If there is an explicit type annotation *and* that type matches the actual + // function return type, we shouldn't complain (it's intentional, even if unsafe) + if (functionTSNode.type) { + for (const signature of callSignatures) { + const signatureReturnType = signature.getReturnType(); + if (returnNodeType === signatureReturnType || + (0, util_1.isTypeFlagSet)(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { + return; + } + if (functionNode.async) { + const awaitedSignatureReturnType = checker.getAwaitedType(signatureReturnType); + const awaitedReturnNodeType = checker.getAwaitedType(returnNodeType); + if (awaitedReturnNodeType === awaitedSignatureReturnType || + (awaitedSignatureReturnType && + (0, util_1.isTypeFlagSet)(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) { + return; + } + } + } + } + if (anyType !== util_1.AnyType.Safe) { + // Allow cases when the declared return type of the function is either unknown or unknown[] + // and the function is returning any or any[]. + for (const signature of callSignatures) { + const functionReturnType = signature.getReturnType(); + if (anyType === util_1.AnyType.Any && + (0, util_1.isTypeUnknownType)(functionReturnType)) { + return; + } + if (anyType === util_1.AnyType.AnyArray && + (0, util_1.isTypeUnknownArrayType)(functionReturnType, checker)) { + return; + } + const awaitedType = checker.getAwaitedType(functionReturnType); + if (awaitedType && + anyType === util_1.AnyType.PromiseAny && + (0, util_1.isTypeUnknownType)(awaitedType)) { + return; + } + } + if (anyType === util_1.AnyType.PromiseAny && !functionNode.async) { + return; + } + let messageId = 'unsafeReturn'; + const isErrorType = tsutils.isIntrinsicErrorType(constrainedReturnNodeType); + if (!isNoImplicitThis) { + // `return this` + const thisExpression = (0, util_1.getThisExpression)(returnNode); + if (thisExpression && + (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) { + messageId = 'unsafeReturnThis'; + } + } + // If the function return type was not unknown/unknown[], mark usage as unsafeReturn. + return context.report({ + node: reportingNode, + messageId, + data: { + type: isErrorType + ? 'error' + : anyType === util_1.AnyType.Any + ? '`any`' + : anyType === util_1.AnyType.PromiseAny + ? '`Promise`' + : '`any[]`', + }, + }); + } + const signature = functionType.getCallSignatures().at(0); + if (signature) { + const functionReturnType = signature.getReturnType(); + const result = (0, util_1.isUnsafeAssignment)(returnNodeType, functionReturnType, checker, returnNode); + if (!result) { + return; + } + const { receiver, sender } = result; + return context.report({ + node: reportingNode, + messageId: 'unsafeReturnAssignment', + data: { + receiver: checker.typeToString(receiver), + sender: checker.typeToString(sender), + }, + }); + } + } + return { + 'ArrowFunctionExpression > :not(BlockStatement).body': checkReturn, + ReturnStatement(node) { + const argument = node.argument; + if (!argument) { + return; + } + checkReturn(argument, node); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-return.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.d.ts new file mode 100644 index 00000000..aed2514d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.js new file mode 100644 index 00000000..3eeb641d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-type-assertion.js @@ -0,0 +1,166 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-unsafe-type-assertion', + meta: { + type: 'problem', + docs: { + description: 'Disallow type assertions that narrow a type', + requiresTypeChecking: true, + }, + messages: { + unsafeOfAnyTypeAssertion: 'Unsafe assertion from {{type}} detected: consider using type guards or a safer assertion.', + unsafeToAnyTypeAssertion: 'Unsafe assertion to {{type}} detected: consider using a more specific type to ensure safety.', + unsafeToUnconstrainedTypeAssertion: "Unsafe type assertion: '{{type}}' could be instantiated with an arbitrary type which could be unrelated to the original type.", + unsafeTypeAssertion: "Unsafe type assertion: type '{{type}}' is more narrow than the original type.", + unsafeTypeAssertionAssignableToConstraint: "Unsafe type assertion: the original type is assignable to the constraint of type '{{type}}', but '{{type}}' could be instantiated with a different subtype of its constraint.", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function getAnyTypeName(type) { + return tsutils.isIntrinsicErrorType(type) ? 'error typed' : '`any`'; + } + function isObjectLiteralType(type) { + return (tsutils.isObjectType(type) && + tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral)); + } + function checkExpression(node) { + const expressionType = services.getTypeAtLocation(node.expression); + const assertedType = services.getTypeAtLocation(node.typeAnnotation); + if (expressionType === assertedType) { + return; + } + // handle cases when asserting unknown ==> any. + if ((0, util_1.isTypeAnyType)(assertedType) && (0, util_1.isTypeUnknownType)(expressionType)) { + context.report({ + node, + messageId: 'unsafeToAnyTypeAssertion', + data: { + type: '`any`', + }, + }); + return; + } + const unsafeExpressionAny = (0, util_1.isUnsafeAssignment)(expressionType, assertedType, checker, node.expression); + if (unsafeExpressionAny) { + context.report({ + node, + messageId: 'unsafeOfAnyTypeAssertion', + data: { + type: getAnyTypeName(unsafeExpressionAny.sender), + }, + }); + return; + } + const unsafeAssertedAny = (0, util_1.isUnsafeAssignment)(assertedType, expressionType, checker, node.typeAnnotation); + if (unsafeAssertedAny) { + context.report({ + node, + messageId: 'unsafeToAnyTypeAssertion', + data: { + type: getAnyTypeName(unsafeAssertedAny.sender), + }, + }); + return; + } + // Use the widened type in case of an object literal so `isTypeAssignableTo()` + // won't fail on excess property check. + const expressionWidenedType = isObjectLiteralType(expressionType) + ? checker.getWidenedType(expressionType) + : expressionType; + let isAssertionSafe; + try { + isAssertionSafe = checker.isTypeAssignableTo(expressionWidenedType, assertedType); + } + catch { + // workaround for https://github.com/microsoft/TypeScript/issues/62933 + return; + } + if (isAssertionSafe) { + return; + } + // Produce a more specific error message when targeting a type parameter + if (tsutils.isTypeParameter(assertedType)) { + const assertedTypeConstraint = checker.getBaseConstraintOfType(assertedType); + if (!assertedTypeConstraint) { + // asserting to an unconstrained type parameter is unsafe + context.report({ + node, + messageId: 'unsafeToUnconstrainedTypeAssertion', + data: { + type: checker.typeToString(assertedType), + }, + }); + return; + } + // special case message if the original type is assignable to the + // constraint of the target type parameter + const isAssignableToConstraint = checker.isTypeAssignableTo(expressionWidenedType, assertedTypeConstraint); + if (isAssignableToConstraint) { + context.report({ + node, + messageId: 'unsafeTypeAssertionAssignableToConstraint', + data: { + type: checker.typeToString(assertedType), + }, + }); + return; + } + } + // General error message + context.report({ + node, + messageId: 'unsafeTypeAssertion', + data: { + type: checker.typeToString(assertedType), + }, + }); + } + return { + 'TSAsExpression, TSTypeAssertion'(node) { + checkExpression(node); + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-type-assertion.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.d.ts new file mode 100644 index 00000000..11751cb7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.d.ts @@ -0,0 +1,6 @@ +export type Options = []; +export type MessageIds = 'unaryMinus'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.js new file mode 100644 index 00000000..0e1b6f6e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.js @@ -0,0 +1,79 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util = __importStar(require("../util")); +exports.default = util.createRule({ + name: 'no-unsafe-unary-minus', + meta: { + type: 'problem', + docs: { + description: 'Require unary negation to take a number', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + unaryMinus: 'Argument of unary negation should be assignable to number | bigint but is {{type}} instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + UnaryExpression(node) { + if (node.operator !== '-') { + return; + } + const services = util.getParserServices(context); + const argType = util.getConstrainedTypeAtLocation(services, node.argument); + const checker = services.program.getTypeChecker(); + if (tsutils + .unionConstituents(argType) + .some(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | + ts.TypeFlags.Never | + ts.TypeFlags.BigIntLike | + ts.TypeFlags.NumberLike))) { + context.report({ + node, + messageId: 'unaryMinus', + data: { type: checker.typeToString(argType) }, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=no-unsafe-unary-minus.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.d.ts new file mode 100644 index 00000000..64997868 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.d.ts @@ -0,0 +1,19 @@ +import { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedExpression", [{ + allowShortCircuit?: boolean; + allowTaggedTemplates?: boolean; + allowTernary?: boolean; +}], unknown, { + ExpressionStatement(node: TSESTree.ExpressionStatement): void; +}>; +export type MessageIds = InferMessageIdsTypeFromRule; +export type Options = InferOptionsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedExpression", [{ + allowShortCircuit?: boolean; + allowTaggedTemplates?: boolean; + allowTernary?: boolean; +}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.js new file mode 100644 index 00000000..64875d11 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-expressions.js @@ -0,0 +1,65 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-unused-expressions'); +const defaultOptions = [ + { + allowShortCircuit: false, + allowTaggedTemplates: false, + allowTernary: false, + }, +]; +exports.default = (0, util_1.createRule)({ + name: 'no-unused-expressions', + meta: { + type: 'suggestion', + defaultOptions, + docs: { + description: 'Disallow unused expressions', + extendsBaseRule: true, + recommended: 'recommended', + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions, + create(context, [{ allowShortCircuit = false, allowTernary = false }]) { + const rules = baseRule.create(context); + function isValidExpression(node) { + if (allowShortCircuit && node.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + return isValidExpression(node.right); + } + if (allowTernary && node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) { + return (isValidExpression(node.alternate) && + isValidExpression(node.consequent)); + } + return ((node.type === utils_1.AST_NODE_TYPES.ChainExpression && + node.expression.type === utils_1.AST_NODE_TYPES.CallExpression) || + node.type === utils_1.AST_NODE_TYPES.ImportExpression); + } + return { + ExpressionStatement(node) { + if (node.directive || isValidExpression(node.expression)) { + return; + } + const expressionType = node.expression.type; + if (expressionType === + utils_1.TSESTree.AST_NODE_TYPES.TSInstantiationExpression || + expressionType === utils_1.TSESTree.AST_NODE_TYPES.TSAsExpression || + expressionType === utils_1.TSESTree.AST_NODE_TYPES.TSNonNullExpression || + expressionType === utils_1.TSESTree.AST_NODE_TYPES.TSTypeAssertion) { + rules.ExpressionStatement({ + ...node, + expression: node.expression.expression, + }); + return; + } + rules.ExpressionStatement(node); + }, + }; + }, +}); +//# sourceMappingURL=no-unused-expressions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.d.ts new file mode 100644 index 00000000..5dc409b4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.d.ts @@ -0,0 +1,6 @@ +import { ESLintUtils } from '@typescript-eslint/utils'; +export type MessageIds = 'unusedPrivateClassMember'; +declare const _default: ESLintUtils.RuleModule<"unusedPrivateClassMember", [], import("../../rules").ESLintPluginDocs, ESLintUtils.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.js new file mode 100644 index 00000000..8f73889f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-private-class-members.js @@ -0,0 +1,45 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const classScopeAnalyzer_1 = require("../util/class-scope-analyzer/classScopeAnalyzer"); +exports.default = (0, util_1.createRule)({ + name: 'no-unused-private-class-members', + meta: { + type: 'problem', + docs: { + description: 'Disallow unused private class members', + extendsBaseRule: true, + requiresTypeChecking: false, + }, + messages: { + unusedPrivateClassMember: "Private class member '{{classMemberName}}' is defined but never used.", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + 'Program:exit'(node) { + const result = (0, classScopeAnalyzer_1.analyzeClassMemberUsage)(node, utils_1.ESLintUtils.nullThrows(context.sourceCode.scopeManager, 'Missing required scope manager')); + for (const classScope of result.values()) { + for (const member of [ + ...classScope.members.instance.values(), + ...classScope.members.static.values(), + ]) { + if ((!member.isPrivate() && !member.isHashPrivate()) || + member.isUsed()) { + continue; + } + context.report({ + node: member.nameNode, + messageId: 'unusedPrivateClassMember', + data: { classMemberName: member.name }, + }); + } + } + }, + }; + }, +}); +//# sourceMappingURL=no-unused-private-class-members.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.d.ts new file mode 100644 index 00000000..63402e95 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.d.ts @@ -0,0 +1,24 @@ +import { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'removeUnusedImportDeclaration' | 'removeUnusedVar' | 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType'; +export type Options = [ + 'all' | 'local' | { + args?: 'after-used' | 'all' | 'none'; + argsIgnorePattern?: string; + caughtErrors?: 'all' | 'none'; + caughtErrorsIgnorePattern?: string; + destructuredArrayIgnorePattern?: string; + enableAutofixRemoval?: { + imports?: boolean; + }; + ignoreClassWithStaticInitBlock?: boolean; + ignoreRestSiblings?: boolean; + ignoreUsingDeclarations?: boolean; + reportUsedIgnorePattern?: boolean; + vars?: 'all' | 'local'; + varsIgnorePattern?: string; + } +]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.js new file mode 100644 index 00000000..366b7f95 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.js @@ -0,0 +1,1036 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const referenceContainsTypePredicate_1 = require("../util/referenceContainsTypePredicate"); +const referenceContainsTypeQuery_1 = require("../util/referenceContainsTypeQuery"); +// this is a superset of DefinitionType which defines sub-types for better granularity +var VariableType; +(function (VariableType) { + // New sub-types + VariableType[VariableType["ArrayDestructure"] = 0] = "ArrayDestructure"; + // DefinitionType + VariableType[VariableType["CatchClause"] = 1] = "CatchClause"; + VariableType[VariableType["ClassName"] = 2] = "ClassName"; + VariableType[VariableType["FunctionName"] = 3] = "FunctionName"; + VariableType[VariableType["ImportBinding"] = 4] = "ImportBinding"; + VariableType[VariableType["ImplicitGlobalVariable"] = 5] = "ImplicitGlobalVariable"; + VariableType[VariableType["Parameter"] = 6] = "Parameter"; + VariableType[VariableType["TSEnumMember"] = 7] = "TSEnumMember"; + VariableType[VariableType["TSEnumName"] = 8] = "TSEnumName"; + VariableType[VariableType["TSModuleName"] = 9] = "TSModuleName"; + VariableType[VariableType["Type"] = 10] = "Type"; + VariableType[VariableType["Variable"] = 11] = "Variable"; +})(VariableType || (VariableType = {})); +const isCommaToken = { + predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ',', + tokenChar: ',', +}; +const isLeftCurlyToken = { + predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '{', + tokenChar: '{', +}; +const isRightCurlyToken = { + predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '}', + tokenChar: '}', +}; +function assertToken({ predicate, tokenChar }, token) { + if (token == null) { + throw new Error(`Expected a valid "${tokenChar}" token, but found no token`); + } + if (!predicate(token)) { + throw new Error(`Expected a valid "${tokenChar}" token, but got "${token.value}" instead`); + } + return token; +} +exports.default = (0, util_1.createRule)({ + name: 'no-unused-vars', + meta: { + type: 'problem', + docs: { + description: 'Disallow unused variables', + extendsBaseRule: true, + recommended: 'recommended', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + removeUnusedImportDeclaration: 'Remove unused import declaration.', + removeUnusedVar: 'Remove unused variable "{{varName}}".', + unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.", + usedIgnoredVar: "'{{varName}}' is marked as ignored but is used{{additional}}.", + usedOnlyAsType: "'{{varName}}' is {{action}} but only used as a type{{additional}}.", + }, + schema: [ + { + oneOf: [ + { + type: 'string', + description: 'Broad setting for unused variables to target.', + enum: ['all', 'local'], + }, + { + type: 'object', + additionalProperties: false, + properties: { + args: { + type: 'string', + description: 'Whether to check all, some, or no arguments.', + enum: ['all', 'after-used', 'none'], + }, + argsIgnorePattern: { + type: 'string', + description: 'Regular expressions of argument names to not check for usage.', + }, + caughtErrors: { + type: 'string', + description: 'Whether to check catch block arguments.', + enum: ['all', 'none'], + }, + caughtErrorsIgnorePattern: { + type: 'string', + description: 'Regular expressions of catch block argument names to not check for usage.', + }, + destructuredArrayIgnorePattern: { + type: 'string', + description: 'Regular expressions of destructured array variable names to not check for usage.', + }, + enableAutofixRemoval: { + type: 'object', + additionalProperties: false, + description: 'Configurable automatic fixes for different types of unused variables.', + properties: { + imports: { + type: 'boolean', + description: 'Whether to enable automatic removal of unused imports.', + }, + }, + }, + ignoreClassWithStaticInitBlock: { + type: 'boolean', + description: 'Whether to ignore classes with at least one static initialization block.', + }, + ignoreRestSiblings: { + type: 'boolean', + description: 'Whether to ignore sibling properties in `...` destructuring.', + }, + ignoreUsingDeclarations: { + type: 'boolean', + description: 'Whether to ignore using or await using declarations.', + }, + reportUsedIgnorePattern: { + type: 'boolean', + description: 'Whether to report variables that match any of the valid ignore pattern options if they have been used.', + }, + vars: { + type: 'string', + description: 'Whether to check all variables or only locally-declared variables.', + enum: ['all', 'local'], + }, + varsIgnorePattern: { + type: 'string', + description: 'Regular expressions of variable names to not check for usage.', + }, + }, + }, + ], + }, + ], + }, + defaultOptions: [{}], + create(context, [firstOption]) { + const MODULE_DECL_CACHE = new Map(); + const reportedUnusedVariables = new Set(); + function areAllSpecifiersUnused(decl) { + return context.sourceCode.getDeclaredVariables(decl).every(variable => { + return reportedUnusedVariables.has(variable); + }); + } + const report = (unusedVar, opts) => { + reportedUnusedVariables.add(unusedVar); + const writeReferences = unusedVar.references.filter(ref => ref.isWrite() && + ref.from.variableScope === unusedVar.scope.variableScope); + const id = writeReferences.length + ? writeReferences[writeReferences.length - 1].identifier + : unusedVar.identifiers[0]; + const { start } = id.loc; + const idLength = id.name.length; + const loc = { + start, + end: { + column: start.column + idLength, + line: start.line, + }, + }; + const fixer = (() => { + const { messageId, fix, useAutofix } = (() => { + if (unusedVar.defs.length !== 1) { + // If there's multiple definitions then we'd have to clean them all + // up! That's complicated and messy so for now let's just ignore it. + return {}; + } + const { type, def } = defToVariableType(unusedVar.defs[0]); + switch (type) { + case VariableType.ArrayDestructure: + // TODO(bradzacher) -- this would be really easy to implement and + // is side-effect free! + return {}; + case VariableType.CatchClause: + // TODO(bradzacher) -- this would be really easy to implement and + // is side-effect free! + return {}; + case VariableType.ClassName: + // This would be easy to implement -- but classes can have + // side-effects in static initializers / static blocks. So it's + // dangerous to ever auto-fix remove them. + // + // Perhaps as an always-suggestion fixer...? + return {}; + case VariableType.FunctionName: + // TODO(bradzacher) -- this would be really easy to implement and + // is side-effect free! + return {}; + case VariableType.ImportBinding: + return { + ...getImportFixer(def), + useAutofix: options.enableAutofixRemoval.imports, + }; + case VariableType.ImplicitGlobalVariable: + // We don't report these via this code path, so no fixer is possible + return {}; + case VariableType.Parameter: + // This is easy to implement -- but we cannot implement it cos it + // changes the signature of the function which in turn might + // introduce type errors in consumers. + // + // Also parameters can have default values which might have + // side-effects. + // + // Perhaps as an always-suggestion fixer...? + return {}; + case VariableType.TSEnumMember: + // We don't report unused enum members so no fixer is ever possible + return {}; + case VariableType.TSEnumName: + // TODO(bradzacher) -- this would be really easy to implement and + // is side-effect free! + return {}; + case VariableType.TSModuleName: + // This is easy to implement -- but TS namespaces are eagerly + // initialized -- meaning that they might have side-effects in + // the body. So it's dangerous to ever auto-fix remove them. + // + // Perhaps as an always-suggestion fixer...? + return {}; + case VariableType.Type: + // TODO(bradzacher) -- this would be really easy to implement and + // is side-effect free! + return {}; + case VariableType.Variable: + // TODO(bradzacher) -- this would be really easy to implement + return {}; + } + })(); + if (!fix) { + return {}; + } + if (useAutofix) { + return { fix }; + } + const data = { + varName: unusedVar.name, + }; + return { + suggest: [ + { + messageId: messageId ?? 'removeUnusedVar', + data, + fix, + }, + ], + }; + })(); + context.report({ + ...opts, + ...fixer, + loc, + node: id, + }); + }; + const options = (() => { + const options = { + args: 'after-used', + caughtErrors: 'all', + enableAutofixRemoval: { + imports: false, + }, + ignoreClassWithStaticInitBlock: false, + ignoreRestSiblings: false, + ignoreUsingDeclarations: false, + reportUsedIgnorePattern: false, + vars: 'all', + }; + if (typeof firstOption === 'string') { + options.vars = firstOption; + } + else { + options.vars = firstOption.vars ?? options.vars; + options.args = firstOption.args ?? options.args; + options.ignoreRestSiblings = + firstOption.ignoreRestSiblings ?? options.ignoreRestSiblings; + options.ignoreUsingDeclarations = + firstOption.ignoreUsingDeclarations ?? + options.ignoreUsingDeclarations; + options.caughtErrors = firstOption.caughtErrors ?? options.caughtErrors; + options.ignoreClassWithStaticInitBlock = + firstOption.ignoreClassWithStaticInitBlock ?? + options.ignoreClassWithStaticInitBlock; + options.reportUsedIgnorePattern = + firstOption.reportUsedIgnorePattern ?? + options.reportUsedIgnorePattern; + if (firstOption.varsIgnorePattern) { + options.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, 'u'); + } + if (firstOption.argsIgnorePattern) { + options.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern, 'u'); + } + if (firstOption.caughtErrorsIgnorePattern) { + options.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern, 'u'); + } + if (firstOption.destructuredArrayIgnorePattern) { + options.destructuredArrayIgnorePattern = new RegExp(firstOption.destructuredArrayIgnorePattern, 'u'); + } + if (firstOption.enableAutofixRemoval) { + // eslint-disable-next-line unicorn/no-lonely-if -- will add more cases later + if (firstOption.enableAutofixRemoval.imports != null) { + options.enableAutofixRemoval.imports = + firstOption.enableAutofixRemoval.imports; + } + } + } + return options; + })(); + function removeNodeWithTrailingNewline(fixer, node) { + const sourceCode = context.sourceCode; + const { line: startLine } = node.loc.start; + const { line: endLine } = node.loc.end; + // Expand range: start of first line to start of next line (or EOF) + const lineRangeStart = sourceCode.getIndexFromLoc({ + column: 0, + line: startLine, + }); + const lineRangeEnd = endLine < sourceCode.lines.length + ? sourceCode.getIndexFromLoc({ column: 0, line: endLine + 1 }) + : sourceCode.text.length; + // If node is the only non-whitespace on its line(s), remove full line(s) + if (sourceCode.getText(node) === + sourceCode.text.slice(lineRangeStart, lineRangeEnd).trim()) { + return fixer.removeRange([lineRangeStart, lineRangeEnd]); + } + return fixer.remove(node); + } + function getImportFixer(def) { + switch (def.node.type) { + case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration: + // import equals declarations can only have one binding -- so we can + // just remove entire import declaration + return { + messageId: 'removeUnusedImportDeclaration', + fix: fixer => removeNodeWithTrailingNewline(fixer, def.node), + }; + case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier: { + const importDecl = def.node.parent; + if (importDecl.specifiers.length === 1 || + areAllSpecifiersUnused(importDecl)) { + // all specifiers are unused -- so we can just remove entire import + // declaration + return { + messageId: 'removeUnusedImportDeclaration', + fix: fixer => removeNodeWithTrailingNewline(fixer, importDecl), + }; + } + // in this branch we know the following things: + // 1) there is at least one specifier that is used + // 2) the default specifier is unused + // + // by process of elimination we can deduce that there is at least one + // named specifier that is used + // + // i.e. the code must be import Unused, { Used, ... } from 'module'; + // + // there's one or more unused named specifiers, so we must remove the + // default specifier in isolation including the trailing comma. + // + // import Unused, { Used, ... } from 'module'; + // ^^^^^^^ remove this + // + // NOTE: we could also remove the spaces between the comma and the + // opening curly brace -- but this does risk removing comments. To be + // safe we'll be conservative for now + // + // TODO(bradzacher) -- consider removing the extra space whilst also + // preserving comments. + return { + messageId: 'removeUnusedVar', + fix: fixer => { + const comma = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(def.node), util_1.NullThrowsReasons.MissingToken(',', 'import specifier')); + assertToken(isCommaToken, comma); + return fixer.removeRange([ + Math.min(def.node.range[0], comma.range[0]), + Math.max(def.node.range[1], comma.range[1]), + ]); + }, + }; + } + case utils_1.AST_NODE_TYPES.ImportSpecifier: { + // guaranteed to NOT be in an export statement as we're inspecting an + // import + const importDecl = def.node.parent; + if (importDecl.specifiers.length === 1 || + areAllSpecifiersUnused(importDecl)) { + // all specifiers are unused -- so we can just remove entire import + // declaration + return { + messageId: 'removeUnusedImportDeclaration', + fix: fixer => removeNodeWithTrailingNewline(fixer, importDecl), + }; + } + return { + messageId: 'removeUnusedVar', + fix: fixer => { + const usedNamedSpecifiers = context.sourceCode + .getDeclaredVariables(importDecl) + .map(variable => { + if (reportedUnusedVariables.has(variable)) { + return null; + } + const specifier = variable.defs[0].node; + if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier) { + return null; + } + return specifier; + }) + .filter(v => v != null); + if (usedNamedSpecifiers.length === 0) { + // in this branch we know the following things: + // 1) there is at least one specifier that is used + // 2) all named specifiers are unused + // + // by process of elimination we can deduce that there is a + // default specifier and it is the only used specifier + // + // i.e. the code must be import Used, { Unused, ... } from + // 'module'; + // + // So we can just remove the entire curly content and the comma + // before, eg import Used, { Unused, ... } from 'module'; + // ^^^^^^^^^^^^^^^^^ remove this + const leftCurly = assertToken(isLeftCurlyToken, context.sourceCode.getFirstToken(importDecl, isLeftCurlyToken.predicate)); + const leftToken = assertToken(isCommaToken, context.sourceCode.getTokenBefore(leftCurly)); + const rightToken = assertToken(isRightCurlyToken, context.sourceCode.getFirstToken(importDecl, isRightCurlyToken.predicate)); + return fixer.removeRange([ + leftToken.range[0], + rightToken.range[1], + ]); + } + // in this branch we know there is at least one used named + // specifier which means we have to remove each unused specifier + // in isolation. + // + // there's 3 possible cases to care about: import { Unused, + // Used... } from 'module'; import { ...Used, Unused } from + // 'module'; import { ...Used, Unused, } from 'module'; + // + // Note that because of the above usedNamedSpecifiers check we + // know that we don't have one of these cases: import { Unused } + // from 'module'; import { Unused, Unused... } from 'module'; + // import { ...Unused, Unused, } from 'module'; + // + // The result is that we know that there _must_ be a comma that + // needs cleaning up + // + // try to remove the leading comma first as it leads to a nicer + // fix output in most cases + // + // leading preferred: import { Used, Unused, Used } from 'module'; + // ^^^^^^^^ remove import { Used, Used } from 'module'; + // + // trailing preferred: import { Used, Unused, Used } from + // 'module'; ^^^^^^^ remove import { Used, Used } from + // 'module'; ^^ ugly double space + // + // But we need to still fallback to the trailing comma for cases + // where the unused specifier is the first in the import eg: + // import { Unused, Used } from 'module'; + const maybeComma = context.sourceCode.getTokenBefore(def.node); + const comma = maybeComma && isCommaToken.predicate(maybeComma) + ? maybeComma + : assertToken(isCommaToken, context.sourceCode.getTokenAfter(def.node)); + return fixer.removeRange([ + Math.min(def.node.range[0], comma.range[0]), + Math.max(def.node.range[1], comma.range[1]), + ]); + }, + }; + } + case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier: { + // namespace specifiers cannot be used with any other specifier -- so + // we can just remove entire import declaration + const importDecl = def.node.parent; + return { + messageId: 'removeUnusedImportDeclaration', + fix: fixer => removeNodeWithTrailingNewline(fixer, importDecl), + }; + } + } + } + /** + * Determines what variable type a def is. + * @param def the declaration to check + * @returns a simple name for the types of variables that this rule supports + */ + function defToVariableType(def) { + /* + * This `destructuredArrayIgnorePattern` error report works differently from the catch + * clause and parameter error reports. _Both_ the `varsIgnorePattern` and the + * `destructuredArrayIgnorePattern` will be checked for array destructuring. However, + * for the purposes of the report, the currently defined behavior is to only inform the + * user of the `destructuredArrayIgnorePattern` if it's present (regardless of the fact + * that the `varsIgnorePattern` would also apply). If it's not present, the user will be + * informed of the `varsIgnorePattern`, assuming that's present. + */ + if (options.destructuredArrayIgnorePattern && + def.name.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + return { type: VariableType.ArrayDestructure, def }; + } + switch (def.type) { + case scope_manager_1.DefinitionType.CatchClause: + return { type: VariableType.CatchClause, def }; + case scope_manager_1.DefinitionType.ClassName: + return { type: VariableType.ClassName, def }; + case scope_manager_1.DefinitionType.FunctionName: + return { type: VariableType.FunctionName, def }; + case scope_manager_1.DefinitionType.ImplicitGlobalVariable: + return { type: VariableType.ImplicitGlobalVariable, def }; + case scope_manager_1.DefinitionType.ImportBinding: + return { type: VariableType.ImportBinding, def }; + case scope_manager_1.DefinitionType.Parameter: + return { type: VariableType.Parameter, def }; + case scope_manager_1.DefinitionType.TSEnumName: + return { type: VariableType.TSEnumName, def }; + case scope_manager_1.DefinitionType.TSEnumMember: + return { type: VariableType.TSEnumMember, def }; + case scope_manager_1.DefinitionType.TSModuleName: + return { type: VariableType.TSModuleName, def }; + case scope_manager_1.DefinitionType.Type: + return { type: VariableType.Type, def }; + case scope_manager_1.DefinitionType.Variable: + return { type: VariableType.Variable, def }; + } + } + /** + * Gets a given variable's description and configured ignore pattern + * based on the provided variableType + * @param variableType a simple name for the types of variables that this rule supports + * @returns the given variable's description and + * ignore pattern + */ + function getVariableDescription(variableType) { + switch (variableType) { + case VariableType.ArrayDestructure: + return { + pattern: options.destructuredArrayIgnorePattern?.toString(), + variableDescription: 'elements of array destructuring', + }; + case VariableType.CatchClause: + return { + pattern: options.caughtErrorsIgnorePattern?.toString(), + variableDescription: 'caught errors', + }; + case VariableType.Parameter: + return { + pattern: options.argsIgnorePattern?.toString(), + variableDescription: 'args', + }; + default: + return { + pattern: options.varsIgnorePattern?.toString(), + variableDescription: 'vars', + }; + } + } + /** + * Generates the message data about the variable being defined and unused, + * including the ignore pattern if configured. + * @param unusedVar eslint-scope variable object. + * @returns The message data to be used with this unused variable. + */ + function getDefinedMessageData(unusedVar) { + const def = unusedVar.defs.at(0); + let additionalMessageData = ''; + if (def) { + const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type); + if (pattern && variableDescription) { + additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`; + } + } + return { + action: 'defined', + additional: additionalMessageData, + varName: unusedVar.name, + }; + } + /** + * Generate the warning message about the variable being + * assigned and unused, including the ignore pattern if configured. + * @param unusedVar eslint-scope variable object. + * @returns The message data to be used with this unused variable. + */ + function getAssignedMessageData(unusedVar) { + const def = unusedVar.defs.at(0); + let additionalMessageData = ''; + if (def) { + const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type); + if (pattern && variableDescription) { + additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`; + } + } + return { + action: 'assigned a value', + additional: additionalMessageData, + varName: unusedVar.name, + }; + } + /** + * Generate the warning message about a variable being used even though + * it is marked as being ignored. + * @param variable eslint-scope variable object + * @param variableType a simple name for the types of variables that this rule supports + * @returns The message data to be used with this used ignored variable. + */ + function getUsedIgnoredMessageData(variable, variableType) { + const { pattern, variableDescription } = getVariableDescription(variableType); + let additionalMessageData = ''; + if (pattern && variableDescription) { + additionalMessageData = `. Used ${variableDescription} must not match ${pattern}`; + } + return { + additional: additionalMessageData, + varName: variable.name, + }; + } + function collectUnusedVariables() { + /** + * Checks whether a node is a sibling of the rest property or not. + * @param node a node to check + * @returns True if the node is a sibling of the rest property, otherwise false. + */ + function hasRestSibling(node) { + return (node.type === utils_1.AST_NODE_TYPES.Property && + node.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern && + node.parent.properties[node.parent.properties.length - 1].type === + utils_1.AST_NODE_TYPES.RestElement); + } + /** + * Determines if a variable has a sibling rest property + * @param variable eslint-scope variable object. + * @returns True if the variable is exported, false if not. + */ + function hasRestSpreadSibling(variable) { + if (options.ignoreRestSiblings) { + const hasRestSiblingDefinition = variable.defs.some(def => hasRestSibling(def.name.parent)); + const hasRestSiblingReference = variable.references.some(ref => hasRestSibling(ref.identifier.parent)); + return hasRestSiblingDefinition || hasRestSiblingReference; + } + return false; + } + /** + * Checks whether the given variable is after the last used parameter. + * @param variable The variable to check. + * @returns `true` if the variable is defined after the last used parameter. + */ + function isAfterLastUsedArg(variable) { + const def = variable.defs[0]; + const params = context.sourceCode.getDeclaredVariables(def.node); + const posteriorParams = params.slice(params.indexOf(variable) + 1); + // If any used parameters occur after this parameter, do not report. + return !posteriorParams.some(v => v.references.length > 0 || v.eslintUsed); + } + const analysisResults = (0, util_1.collectVariables)(context); + const variables = [ + ...Array.from(analysisResults.unusedVariables, variable => ({ + used: false, + variable, + })), + ...Array.from(analysisResults.usedVariables, variable => ({ + used: true, + variable, + })), + ]; + const unusedVariablesReturn = []; + for (const { used, variable } of variables) { + // explicit global variables don't have definitions. + if (variable.defs.length === 0) { + if (!used) { + unusedVariablesReturn.push(variable); + } + continue; + } + const def = variable.defs[0]; + if (variable.scope.type === utils_1.TSESLint.Scope.ScopeType.global && + options.vars === 'local') { + // skip variables in the global scope if configured to + continue; + } + const refUsedInArrayPatterns = variable.references.some(ref => ref.identifier.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern); + // skip elements of array destructuring patterns + if ((def.name.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern || + refUsedInArrayPatterns) && + def.name.type === utils_1.AST_NODE_TYPES.Identifier && + options.destructuredArrayIgnorePattern?.test(def.name.name)) { + if (options.reportUsedIgnorePattern && used) { + report(variable, { + messageId: 'usedIgnoredVar', + data: getUsedIgnoredMessageData(variable, VariableType.ArrayDestructure), + }); + } + continue; + } + if (def.type === utils_1.TSESLint.Scope.DefinitionType.ClassName) { + const hasStaticBlock = def.node.body.body.some(node => node.type === utils_1.AST_NODE_TYPES.StaticBlock); + if (options.ignoreClassWithStaticInitBlock && hasStaticBlock) { + continue; + } + } + // skip catch variables + if (def.type === utils_1.TSESLint.Scope.DefinitionType.CatchClause) { + if (options.caughtErrors === 'none') { + continue; + } + // skip ignored parameters + if (options.caughtErrorsIgnorePattern?.test(def.name.name)) { + if (options.reportUsedIgnorePattern && used) { + report(variable, { + messageId: 'usedIgnoredVar', + data: getUsedIgnoredMessageData(variable, VariableType.CatchClause), + }); + } + continue; + } + } + else if (def.type === utils_1.TSESLint.Scope.DefinitionType.Parameter) { + // if "args" option is "none", skip any parameter + if (options.args === 'none') { + continue; + } + // skip ignored parameters + if (def.name.type === utils_1.AST_NODE_TYPES.Identifier && + options.argsIgnorePattern?.test(def.name.name)) { + if (options.reportUsedIgnorePattern && used) { + report(variable, { + messageId: 'usedIgnoredVar', + data: getUsedIgnoredMessageData(variable, VariableType.Parameter), + }); + } + continue; + } + // if "args" option is "after-used", skip used variables + if (options.args === 'after-used' && + (0, util_1.isFunction)(def.name.parent) && + !isAfterLastUsedArg(variable)) { + continue; + } + } + // skip ignored variables + else if (def.name.type === utils_1.AST_NODE_TYPES.Identifier && + options.varsIgnorePattern?.test(def.name.name)) { + if (options.reportUsedIgnorePattern && + used && + /* enum members are always marked as 'used' by `collectVariables`, but in reality they may be used or + unused. either way, don't complain about their naming. */ + def.type !== utils_1.TSESLint.Scope.DefinitionType.TSEnumMember) { + report(variable, { + messageId: 'usedIgnoredVar', + data: getUsedIgnoredMessageData(variable, VariableType.Variable), + }); + } + continue; + } + if (def.type === utils_1.TSESLint.Scope.DefinitionType.Variable && + options.ignoreUsingDeclarations && + (def.parent.kind === 'await using' || def.parent.kind === 'using')) { + continue; + } + if (hasRestSpreadSibling(variable)) { + continue; + } + // in case another rule has run and used the collectUnusedVariables, + // we want to ensure our selectors that marked variables as used are respected + if (variable.eslintUsed) { + continue; + } + if (!used) { + unusedVariablesReturn.push(variable); + } + } + return unusedVariablesReturn; + } + return { + // top-level declaration file handling + [ambientDeclarationSelector(utils_1.AST_NODE_TYPES.Program)](node) { + if (!(0, util_1.isDefinitionFile)(context.filename)) { + return; + } + const moduleDecl = (0, util_1.nullThrows)(node.parent, util_1.NullThrowsReasons.MissingParent); + if (checkForOverridingExportStatements(moduleDecl)) { + return; + } + markDeclarationChildAsUsed(node); + }, + // children of a namespace that is a child of a declared namespace are auto-exported + [ambientDeclarationSelector('TSModuleDeclaration[declare = true] > TSModuleBlock TSModuleDeclaration > TSModuleBlock')](node) { + const moduleDecl = (0, util_1.nullThrows)(node.parent.parent, util_1.NullThrowsReasons.MissingParent); + if (checkForOverridingExportStatements(moduleDecl)) { + return; + } + markDeclarationChildAsUsed(node); + }, + // declared namespace handling + [ambientDeclarationSelector('TSModuleDeclaration[declare = true] > TSModuleBlock')](node) { + const moduleDecl = (0, util_1.nullThrows)(node.parent.parent, util_1.NullThrowsReasons.MissingParent); + if (checkForOverridingExportStatements(moduleDecl)) { + return; + } + markDeclarationChildAsUsed(node); + }, + // namespace handling in definition files + [ambientDeclarationSelector('TSModuleDeclaration > TSModuleBlock')](node) { + if (!(0, util_1.isDefinitionFile)(context.filename)) { + return; + } + const moduleDecl = (0, util_1.nullThrows)(node.parent.parent, util_1.NullThrowsReasons.MissingParent); + if (checkForOverridingExportStatements(moduleDecl)) { + return; + } + markDeclarationChildAsUsed(node); + }, + // collect + 'Program:exit'(programNode) { + const unusedVars = collectUnusedVariables(); + for (const unusedVar of unusedVars) { + // Report the first declaration. + if (unusedVar.defs.length > 0) { + const usedOnlyAsType = unusedVar.references.some(ref => (0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier) || + (0, referenceContainsTypePredicate_1.referenceContainsTypePredicate)(ref.identifier)); + const messageId = usedOnlyAsType ? 'usedOnlyAsType' : 'unusedVar'; + const isImportUsedOnlyAsType = usedOnlyAsType && + unusedVar.defs.some(def => def.type === scope_manager_1.DefinitionType.ImportBinding); + if (isImportUsedOnlyAsType) { + continue; + } + report(unusedVar, { + messageId, + data: unusedVar.references.some(ref => ref.isWrite()) + ? getAssignedMessageData(unusedVar) + : getDefinedMessageData(unusedVar), + }); + // If there are no regular declaration, report the first `/*globals*/` comment directive. + } + else if ('eslintExplicitGlobalComments' in unusedVar && + unusedVar.eslintExplicitGlobalComments) { + const directiveComment = unusedVar.eslintExplicitGlobalComments[0]; + context.report({ + loc: (0, util_1.getNameLocationInGlobalDirectiveComment)(context.sourceCode, directiveComment, unusedVar.name), + node: programNode, + messageId: 'unusedVar', + data: getDefinedMessageData(unusedVar), + }); + } + } + }, + }; + function checkForOverridingExportStatements(node) { + const cached = MODULE_DECL_CACHE.get(node); + if (cached != null) { + return cached; + } + const body = getStatementsOfNode(node); + if (hasOverridingExportStatement(body)) { + MODULE_DECL_CACHE.set(node, true); + return true; + } + MODULE_DECL_CACHE.set(node, false); + return false; + } + function ambientDeclarationSelector(parent) { + return [ + // Types are ambiently exported + `${parent} > :matches(${[ + utils_1.AST_NODE_TYPES.TSInterfaceDeclaration, + utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration, + ].join(', ')})`, + // Value things are ambiently exported if they are "declare"d + `${parent} > :matches(${[ + utils_1.AST_NODE_TYPES.ClassDeclaration, + utils_1.AST_NODE_TYPES.TSDeclareFunction, + utils_1.AST_NODE_TYPES.TSEnumDeclaration, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + utils_1.AST_NODE_TYPES.VariableDeclaration, + ].join(', ')})`, + ].join(', '); + } + function markDeclarationChildAsUsed(node) { + const identifiers = []; + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: + case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration: + case utils_1.AST_NODE_TYPES.ClassDeclaration: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + case utils_1.AST_NODE_TYPES.TSDeclareFunction: + case utils_1.AST_NODE_TYPES.TSEnumDeclaration: + case utils_1.AST_NODE_TYPES.TSModuleDeclaration: + if (node.id?.type === utils_1.AST_NODE_TYPES.Identifier) { + identifiers.push(node.id); + } + break; + case utils_1.AST_NODE_TYPES.VariableDeclaration: + for (const declaration of node.declarations) { + visitPattern(declaration, pattern => { + identifiers.push(pattern); + }); + } + break; + } + let scope = context.sourceCode.getScope(node); + const shouldUseUpperScope = [ + utils_1.AST_NODE_TYPES.TSDeclareFunction, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + ].includes(node.type); + if (scope.variableScope !== scope) { + scope = scope.variableScope; + } + else if (shouldUseUpperScope && scope.upper) { + scope = scope.upper; + } + for (const id of identifiers) { + const superVar = scope.set.get(id.name); + if (superVar) { + superVar.eslintUsed = true; + } + } + } + function visitPattern(node, cb) { + const visitor = new scope_manager_1.PatternVisitor({}, node, cb); + visitor.visit(node); + } + }, +}); +function hasOverridingExportStatement(body) { + for (const statement of body) { + if ((statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration && + statement.declaration == null) || + statement.type === utils_1.AST_NODE_TYPES.ExportAllDeclaration || + statement.type === utils_1.AST_NODE_TYPES.TSExportAssignment) { + return true; + } + if (statement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration && + statement.declaration.type === utils_1.AST_NODE_TYPES.Identifier) { + return true; + } + } + return false; +} +function getStatementsOfNode(block) { + if (block.type === utils_1.AST_NODE_TYPES.Program) { + return block.body; + } + return block.body.body; +} +/* + +###### TODO ###### + +Edge cases that aren't currently handled due to laziness and them being super edgy edge cases + + +--- function params referenced in typeof type refs in the function declaration --- +--- NOTE - TS gets these cases wrong + +function _foo( + arg: number // arg should be unused +): typeof arg { + return 1 as any; +} + +function _bar( + arg: number, // arg should be unused + _arg2: typeof arg, +) {} + + +--- function names referenced in typeof type refs in the function declaration --- +--- NOTE - TS gets these cases right + +function foo( // foo should be unused +): typeof foo { + return 1 as any; +} + +function bar( // bar should be unused + _arg: typeof bar +) {} + + +--- if an interface is merged into a namespace --- +--- NOTE - TS gets these cases wrong + +namespace Test { + interface Foo { // Foo should be unused here + a: string; + } + export namespace Foo { + export type T = 'b'; + } +} +type T = Test.Foo; // Error: Namespace 'Test' has no exported member 'Foo'. + + +namespace Test { + export interface Foo { + a: string; + } + namespace Foo { // Foo should be unused here + export type T = 'b'; + } +} +type T = Test.Foo.T; // Error: Namespace 'Test' has no exported member 'Foo'. + +--- + +These cases are mishandled because the base rule assumes that each variable has one def, but type-value shadowing +creates a variable with two defs + +--- type-only or value-only references to type/value shadowed variables --- +--- NOTE - TS gets these cases wrong + +type T = 1; +const T = 2; // this T should be unused + +type U = T; // this U should be unused +const U = 3; + +const _V = U; + + +--- partially exported type/value shadowed variables --- +--- NOTE - TS gets these cases wrong + +export interface Foo {} +const Foo = 1; // this Foo should be unused + +interface Bar {} // this Bar should be unused +export const Bar = 1; + +*/ +//# sourceMappingURL=no-unused-vars.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.d.ts new file mode 100644 index 00000000..1ea60695 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.d.ts @@ -0,0 +1,16 @@ +import { TSESLint } from '@typescript-eslint/utils'; +export interface Config { + allowNamedExports?: boolean; + classes?: boolean; + enums?: boolean; + functions?: boolean; + ignoreTypeReferences?: boolean; + typedefs?: boolean; + variables?: boolean; +} +export type Options = ['nofunc' | Config]; +export type MessageIds = 'noUseBeforeDefine'; +declare const _default: TSESLint.RuleModule<"noUseBeforeDefine", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.js new file mode 100644 index 00000000..7d4c80bb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-use-before-define.js @@ -0,0 +1,304 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const referenceContainsTypeQuery_1 = require("../util/referenceContainsTypeQuery"); +const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/; +/** + * Parses a given value as options. + */ +function parseOptions(options) { + let functions = true; + let classes = true; + let enums = true; + let variables = true; + let typedefs = true; + let ignoreTypeReferences = true; + let allowNamedExports = false; + if (typeof options === 'string') { + functions = options !== 'nofunc'; + } + else if (typeof options === 'object' && options != null) { + functions = options.functions !== false; + classes = options.classes !== false; + enums = options.enums !== false; + variables = options.variables !== false; + typedefs = options.typedefs !== false; + ignoreTypeReferences = options.ignoreTypeReferences !== false; + allowNamedExports = options.allowNamedExports !== false; + } + return { + allowNamedExports, + classes, + enums, + functions, + ignoreTypeReferences, + typedefs, + variables, + }; +} +/** + * Checks whether or not a given variable is a function declaration. + */ +function isFunction(variable) { + return variable.defs[0].type === scope_manager_1.DefinitionType.FunctionName; +} +/** + * Checks whether or not a given variable is a type declaration. + */ +function isTypedef(variable) { + return variable.defs[0].type === scope_manager_1.DefinitionType.Type; +} +/** + * Checks whether or not a given variable is a enum declaration. + */ +function isOuterEnum(variable, reference) { + return (variable.defs[0].type === scope_manager_1.DefinitionType.TSEnumName && + variable.scope.variableScope !== reference.from.variableScope); +} +/** + * Checks whether or not a given variable is a class declaration in an upper function scope. + */ +function isOuterClass(variable, reference) { + return (variable.defs[0].type === scope_manager_1.DefinitionType.ClassName && + variable.scope.variableScope !== reference.from.variableScope); +} +/** + * Checks whether or not a given variable is a variable declaration in an upper function scope. + */ +function isOuterVariable(variable, reference) { + return (variable.defs[0].type === scope_manager_1.DefinitionType.Variable && + variable.scope.variableScope !== reference.from.variableScope); +} +/** + * Checks whether or not a given reference is a export reference. + */ +function isNamedExports(reference) { + const { identifier } = reference; + return (identifier.parent.type === utils_1.AST_NODE_TYPES.ExportSpecifier && + identifier.parent.local === identifier); +} +/** + * Checks whether or not a given reference is a type reference. + */ +function isTypeReference(reference) { + return (reference.isTypeReference || + (0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(reference.identifier)); +} +/** + * Checks whether or not a given location is inside of the range of a given node. + */ +function isInRange(node, location) { + return !!node && node.range[0] <= location && location <= node.range[1]; +} +/** + * Decorators are transpiled such that the decorator is placed after the class declaration + * So it is considered safe + */ +function isClassRefInClassDecorator(variable, reference) { + if (variable.defs[0].type !== scope_manager_1.DefinitionType.ClassName || + variable.defs[0].node.decorators.length === 0) { + return false; + } + for (const deco of variable.defs[0].node.decorators) { + if (reference.identifier.range[0] >= deco.range[0] && + reference.identifier.range[1] <= deco.range[1]) { + return true; + } + } + return false; +} +/** + * Checks whether or not a given reference is inside of the initializers of a given variable. + * + * @returns `true` in the following cases: + * - var a = a + * - var [a = a] = list + * - var {a = a} = obj + * - for (var a in a) {} + * - for (var a of a) {} + */ +function isInInitializer(variable, reference) { + if (variable.scope !== reference.from) { + return false; + } + let node = variable.identifiers[0].parent; + const location = reference.identifier.range[1]; + while (node) { + if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) { + if (isInRange(node.init, location)) { + return true; + } + if ((node.parent.parent.type === utils_1.AST_NODE_TYPES.ForInStatement || + node.parent.parent.type === utils_1.AST_NODE_TYPES.ForOfStatement) && + isInRange(node.parent.parent.right, location)) { + return true; + } + break; + } + else if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + if (isInRange(node.right, location)) { + return true; + } + } + else if (SENTINEL_TYPE.test(node.type)) { + break; + } + node = node.parent; + } + return false; +} +exports.default = (0, util_1.createRule)({ + name: 'no-use-before-define', + meta: { + type: 'problem', + docs: { + description: 'Disallow the use of variables before they are defined', + extendsBaseRule: true, + }, + messages: { + noUseBeforeDefine: "'{{name}}' was used before it was defined.", + }, + schema: [ + { + oneOf: [ + { + type: 'string', + description: 'Broadly set functions and allowNamedExports to false.', + enum: ['nofunc'], + }, + { + type: 'object', + additionalProperties: false, + properties: { + allowNamedExports: { + type: 'boolean', + description: 'Whether to ignore named exports.', + }, + classes: { + type: 'boolean', + description: 'Whether to ignore references to class declarations.', + }, + enums: { + type: 'boolean', + description: 'Whether to check references to enums.', + }, + functions: { + type: 'boolean', + description: 'Whether to ignore references to function declarations.', + }, + ignoreTypeReferences: { + type: 'boolean', + description: 'Whether to ignore type references, such as in type annotations and assertions.', + }, + typedefs: { + type: 'boolean', + description: 'Whether to check references to types.', + }, + variables: { + type: 'boolean', + description: 'Whether to ignore references to variables.', + }, + }, + }, + ], + }, + ], + }, + defaultOptions: [ + { + allowNamedExports: false, + classes: true, + enums: true, + functions: true, + ignoreTypeReferences: true, + typedefs: true, + variables: true, + }, + ], + create(context, optionsWithDefault) { + const options = parseOptions(optionsWithDefault[0]); + /** + * Determines whether a given use-before-define case should be reported according to the options. + * @param variable The variable that gets used before being defined + * @param reference The reference to the variable + */ + function isForbidden(variable, reference) { + if (options.ignoreTypeReferences && isTypeReference(reference)) { + return false; + } + if (isFunction(variable)) { + return options.functions; + } + if (isOuterClass(variable, reference)) { + return options.classes; + } + if (isOuterVariable(variable, reference)) { + return options.variables; + } + if (isOuterEnum(variable, reference)) { + return options.enums; + } + if (isTypedef(variable)) { + return options.typedefs; + } + return true; + } + function isDefinedBeforeUse(variable, reference) { + return (variable.identifiers[0].range[1] <= reference.identifier.range[1] && + !(reference.isValueReference && isInInitializer(variable, reference))); + } + /** + * Finds and validates all variables in a given scope. + */ + function findVariablesInScope(scope) { + scope.references.forEach(reference => { + const variable = reference.resolved; + function report() { + context.report({ + node: reference.identifier, + messageId: 'noUseBeforeDefine', + data: { + name: reference.identifier.name, + }, + }); + } + // Skips when the reference is: + // - initializations. + // - referring to an undefined variable. + // - referring to a global environment variable (there're no identifiers). + // - located preceded by the variable (except in initializers). + // - allowed by options. + if (reference.init) { + return; + } + if (!options.allowNamedExports && isNamedExports(reference)) { + if (!variable || !isDefinedBeforeUse(variable, reference)) { + report(); + } + return; + } + if (!variable) { + return; + } + if (variable.identifiers.length === 0 || + isDefinedBeforeUse(variable, reference) || + !isForbidden(variable, reference) || + isClassRefInClassDecorator(variable, reference) || + reference.from.type === utils_1.TSESLint.Scope.ScopeType.functionType) { + return; + } + // Reports. + report(); + }); + scope.childScopes.forEach(findVariablesInScope); + } + return { + Program(node) { + findVariablesInScope(context.sourceCode.getScope(node)); + }, + }; + }, +}); +//# sourceMappingURL=no-use-before-define.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.d.ts new file mode 100644 index 00000000..96745246 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.d.ts @@ -0,0 +1,11 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], unknown, { + MethodDefinition(node: TSESTree.MethodDefinition): void; +}>; +export type Options = InferOptionsTypeFromRule; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.js new file mode 100644 index 00000000..4166f5e8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-constructor.js @@ -0,0 +1,58 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-useless-constructor'); +/** + * Check if method with accessibility is not useless + */ +function checkAccessibility(node) { + switch (node.accessibility) { + case 'protected': + case 'private': + return false; + case 'public': + if (node.parent.parent.superClass) { + return false; + } + break; + } + return true; +} +/** + * Check if method is not useless due to typescript parameter properties and decorators + */ +function checkParams(node) { + return !node.value.params.some(param => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty || + param.decorators.length); +} +exports.default = (0, util_1.createRule)({ + name: 'no-useless-constructor', + meta: { + type: 'problem', + // defaultOptions, -- base rule does not use defaultOptions + docs: { + description: 'Disallow unnecessary constructors', + extendsBaseRule: true, + recommended: 'strict', + }, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema: baseRule.meta.schema, + }, + defaultOptions: [], + create(context) { + const rules = baseRule.create(context); + return { + MethodDefinition(node) { + if (node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression && + checkAccessibility(node) && + checkParams(node)) { + rules.MethodDefinition(node); + } + }, + }; + }, +}); +//# sourceMappingURL=no-useless-constructor.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.d.ts new file mode 100644 index 00000000..d88cb33d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.d.ts @@ -0,0 +1,11 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +type MessageId = 'noStrictNullCheck' | 'preferOptionalSyntax' | 'removeDefaultAssignment' | 'uselessDefaultAssignment' | 'uselessUndefined' | 'useOptionalSyntax'; +type Options = [ + { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + } +]; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.js new file mode 100644 index 00000000..3789829b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-default-assignment.js @@ -0,0 +1,345 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-useless-default-assignment', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow default values that will never be used', + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.', + preferOptionalSyntax: 'Using `= undefined` to make a parameter optional adds unnecessary runtime logic.', + removeDefaultAssignment: 'Remove the default value.', + uselessDefaultAssignment: 'Default value is useless because the {{ type }} is not optional.', + uselessUndefined: 'Default value is useless because it is undefined. Optional {{ type }}s are already undefined by default.', + useOptionalSyntax: 'Use the `?` optional syntax instead.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: { + type: 'boolean', + description: 'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false, + }, + ], + create(context, [{ allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing }]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks'); + if (!isStrictNullChecks && + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) { + context.report({ + loc: { + start: { column: 0, line: 0 }, + end: { column: 0, line: 0 }, + }, + messageId: 'noStrictNullCheck', + }); + } + function canBeUndefined(type) { + if ((0, util_1.isTypeAnyType)(type) || (0, util_1.isTypeUnknownType)(type)) { + return true; + } + return tsutils + .unionConstituents(type) + .some(part => (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined)); + } + function getArrayElementType(arrayType, elementIndex) { + if (checker.isTupleType(arrayType)) { + const tupleArgs = checker.getTypeArguments(arrayType); + if (elementIndex < tupleArgs.length) { + return tupleArgs[elementIndex]; + } + } + return arrayType.getNumberIndexType() ?? null; + } + function checkAssignmentPattern(node) { + if (node.right.type === utils_1.AST_NODE_TYPES.Identifier && + node.right.name === 'undefined') { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (ts.isParameter(tsNode) && + tsNode.type && + canBeUndefined(checker.getTypeFromTypeNode(tsNode.type))) { + reportPreferOptionalSyntax(node); + return; + } + const type = node.parent.type === utils_1.AST_NODE_TYPES.Property || + node.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern + ? 'property' + : 'parameter'; + reportUselessUndefined(node, type); + return; + } + const parent = node.parent; + if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + parent.type === utils_1.AST_NODE_TYPES.FunctionExpression) { + const paramIndex = parent.params.indexOf(node); + if (paramIndex !== -1) { + const tsFunc = services.esTreeNodeToTSNodeMap.get(parent); + // tsFunc is already a FunctionLike subtype; defensive runtime check + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + if (ts.isFunctionLike(tsFunc)) { + const contextualType = checker.getContextualType(tsFunc); + if (!contextualType) { + return; + } + const signatures = contextualType.getCallSignatures(); + if (signatures.length === 0 || + signatures[0].getDeclaration() === tsFunc) { + return; + } + const defaultCanBeUsed = signatures.some(signature => { + const params = signature.getParameters(); + if (paramIndex >= params.length) { + return true; + } + const paramSymbol = params[paramIndex]; + if (paramSymbol.valueDeclaration && + (0, util_1.isRestParameterDeclaration)(paramSymbol.valueDeclaration)) { + return true; + } + if (tsutils.isSymbolFlagSet(paramSymbol, ts.SymbolFlags.Optional)) { + return true; + } + const paramType = checker.getTypeOfSymbol(paramSymbol); + return (tsutils.isTypeParameter(paramType) || canBeUndefined(paramType)); + }); + if (!defaultCanBeUsed) { + reportUselessDefaultAssignment(node, 'parameter'); + } + } + } + return; + } + if (parent.type === utils_1.AST_NODE_TYPES.Property) { + const propertyType = getTypeOfProperty(parent); + if (!propertyType) { + return; + } + if (!canBeUndefined(propertyType)) { + reportUselessDefaultAssignment(node, 'property'); + } + } + else if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + const sourceType = getSourceTypeForPattern(parent); + if (!sourceType) { + return; + } + if (!checker.isTupleType(sourceType)) { + return; + } + const tupleArgs = checker.getTypeArguments(sourceType); + const elementIndex = parent.elements.indexOf(node); + if (elementIndex < 0 || elementIndex >= tupleArgs.length) { + return; + } + const { fixedLength, minLength } = sourceType.target; + if (elementIndex >= minLength) { + return; + } + const elementTypes = elementIndex < fixedLength + ? [tupleArgs[elementIndex]] + : tupleArgs.slice(fixedLength); + if (!elementTypes.some(canBeUndefined)) { + reportUselessDefaultAssignment(node, 'property'); + } + } + } + function getTypeOfProperty(node) { + const objectPattern = node.parent; + const sourceType = getSourceTypeForPattern(objectPattern); + if (!sourceType) { + return null; + } + const propertyName = getPropertyName(node.key); + if (!propertyName) { + return null; + } + const symbol = sourceType.getProperty(propertyName); + if (!symbol) { + return null; + } + if (tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Optional)) { + const parent = objectPattern.parent; + if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && + parent.init && + hasConditionalInitializer(objectPattern)) { + const propertyName = getPropertyName(node.key); + if (!propertyName || + !hasPropertyInAllBranches(parent.init, propertyName)) { + return null; + } + } + } + return checker.getTypeOfSymbol(symbol); + } + function hasConditionalInitializer(node) { + const parent = node.parent; + if (!parent) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.init) { + return (parent.init.type === utils_1.AST_NODE_TYPES.ConditionalExpression || + parent.init.type === utils_1.AST_NODE_TYPES.LogicalExpression); + } + return hasConditionalInitializer(parent); + } + function getSourceTypeForPattern(pattern) { + const parent = (0, util_1.nullThrows)(pattern.parent, util_1.NullThrowsReasons.MissingParent); + if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.init) { + const tsNode = services.esTreeNodeToTSNodeMap.get(parent.init); + return checker.getTypeAtLocation(tsNode); + } + if ((0, util_1.isFunction)(parent)) { + let paramIndex = parent.params.indexOf(pattern); + const tsFunc = services.esTreeNodeToTSNodeMap.get(parent); + const signature = (0, util_1.nullThrows)(checker.getSignatureFromDeclaration(tsFunc), util_1.NullThrowsReasons.MissingToken('signature', 'function')); + const params = signature.getParameters(); + if (signature.thisParameter) { + paramIndex--; + } + if (paramIndex < 0 || paramIndex >= params.length) { + return null; + } + return checker.getTypeOfSymbol(params[paramIndex]); + } + if (parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + return getSourceTypeForPattern(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.Property) { + return getTypeOfProperty(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + const arrayType = getSourceTypeForPattern(parent); + if (!arrayType) { + return null; + } + const elementIndex = parent.elements.indexOf(pattern); + return getArrayElementType(arrayType, elementIndex); + } + return null; + } + function getPropertyName(key) { + switch (key.type) { + case utils_1.AST_NODE_TYPES.Identifier: + return key.name; + case utils_1.AST_NODE_TYPES.Literal: + return String(key.value); + case utils_1.AST_NODE_TYPES.TemplateLiteral: + return key.expressions.length ? null : key.quasis[0].value.cooked; + default: + return null; + } + } + function reportUselessDefaultAssignment(node, type) { + context.report({ + node: node.right, + messageId: 'uselessDefaultAssignment', + data: { type }, + suggest: [removeDefaultSuggestion(node)], + }); + } + function reportUselessUndefined(node, type) { + context.report({ + node: node.right, + messageId: 'uselessUndefined', + data: { type }, + suggest: [removeDefaultSuggestion(node)], + }); + } + function reportPreferOptionalSyntax(node) { + context.report({ + node: node.right, + messageId: 'preferOptionalSyntax', + suggest: [useOptionalSyntaxSuggestion(node)], + }); + } + function useOptionalSyntaxSuggestion(node) { + return { + messageId: 'useOptionalSyntax', + *fix(fixer) { + yield removeDefault(fixer, node); + const { left } = node; + if (left.type === utils_1.AST_NODE_TYPES.Identifier) { + yield fixer.insertTextAfterRange([left.range[0], left.range[0] + left.name.length], '?'); + } + }, + }; + } + function removeDefaultSuggestion(node) { + return { + messageId: 'removeDefaultAssignment', + fix: fixer => removeDefault(fixer, node), + }; + } + function removeDefault(fixer, node) { + const start = node.left.range[1]; + const end = node.range[1]; + return fixer.removeRange([start, end]); + } + function hasPropertyInAllBranches(expression, propertyName) { + return ((expression.type === utils_1.AST_NODE_TYPES.ObjectExpression && + expression.properties.some(prop => prop.type === utils_1.AST_NODE_TYPES.Property && + getPropertyName(prop.key) === propertyName)) || + (expression.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + hasPropertyInAllBranches(expression.consequent, propertyName) && + hasPropertyInAllBranches(expression.alternate, propertyName))); + } + return { + AssignmentPattern: checkAssignmentPattern, + }; + }, +}); +//# sourceMappingURL=no-useless-default-assignment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.d.ts new file mode 100644 index 00000000..47f46564 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.js new file mode 100644 index 00000000..c369fe5a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-useless-empty-export.js @@ -0,0 +1,71 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +function isEmptyExport(node) { + return (node.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration && + node.specifiers.length === 0 && + !node.declaration); +} +const exportOrImportNodeTypes = new Set([ + utils_1.AST_NODE_TYPES.ExportAllDeclaration, + utils_1.AST_NODE_TYPES.ExportDefaultDeclaration, + utils_1.AST_NODE_TYPES.ExportNamedDeclaration, + utils_1.AST_NODE_TYPES.ExportSpecifier, + utils_1.AST_NODE_TYPES.ImportDeclaration, + utils_1.AST_NODE_TYPES.TSExportAssignment, + utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration, +]); +exports.default = (0, util_1.createRule)({ + name: 'no-useless-empty-export', + meta: { + type: 'suggestion', + docs: { + description: "Disallow empty exports that don't change anything in a module file", + }, + fixable: 'code', + hasSuggestions: false, + messages: { + uselessExport: 'Empty export does nothing and can be removed.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + // In a definition file, export {} is necessary to make the module properly + // encapsulated, even when there are other exports + // https://github.com/typescript-eslint/typescript-eslint/issues/4975 + if ((0, util_1.isDefinitionFile)(context.filename)) { + return {}; + } + function checkNode(node) { + if (!Array.isArray(node.body)) { + return; + } + const emptyExports = []; + let foundOtherExport = false; + for (const statement of node.body) { + if (isEmptyExport(statement)) { + emptyExports.push(statement); + } + else if (exportOrImportNodeTypes.has(statement.type)) { + foundOtherExport = true; + } + } + if (foundOtherExport) { + for (const emptyExport of emptyExports) { + context.report({ + node: emptyExport, + messageId: 'uselessExport', + fix: fixer => fixer.remove(emptyExport), + }); + } + } + } + return { + Program: checkNode, + TSModuleDeclaration: checkNode, + }; + }, +}); +//# sourceMappingURL=no-useless-empty-export.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.d.ts new file mode 100644 index 00000000..6a2f40b5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.d.ts @@ -0,0 +1,10 @@ +export type Options = [ + { + allow: string[]; + } +]; +export type MessageIds = 'noVarReqs'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVarReqs", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.js new file mode 100644 index 00000000..9256712f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-var-requires.js @@ -0,0 +1,84 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'no-var-requires', + meta: { + type: 'problem', + deprecated: { + deprecatedSince: '8.0.0', + replacedBy: [ + { + rule: { + name: '@typescript-eslint/no-require-imports', + url: 'https://typescript-eslint.io/rules/no-require-imports', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/8334', + }, + docs: { + description: 'Disallow `require` statements except in import statements', + }, + messages: { + noVarReqs: 'Require statement not part of import statement.', + }, + replacedBy: ['@typescript-eslint/no-require-imports'], + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + type: 'array', + description: 'Patterns of import paths to allow requiring from.', + items: { type: 'string' }, + }, + }, + }, + ], + }, + defaultOptions: [{ allow: [] }], + create(context, options) { + const allowPatterns = options[0].allow.map(pattern => new RegExp(pattern, 'u')); + function isImportPathAllowed(importPath) { + return allowPatterns.some(pattern => importPath.match(pattern)); + } + function isStringOrTemplateLiteral(node) { + return ((node.type === utils_1.AST_NODE_TYPES.Literal && + typeof node.value === 'string') || + node.type === utils_1.AST_NODE_TYPES.TemplateLiteral); + } + return { + 'CallExpression[callee.name="require"]'(node) { + if (node.arguments[0] && isStringOrTemplateLiteral(node.arguments[0])) { + const argValue = (0, util_1.getStaticStringValue)(node.arguments[0]); + if (typeof argValue === 'string' && isImportPathAllowed(argValue)) { + return; + } + } + const parent = node.parent.type === utils_1.AST_NODE_TYPES.ChainExpression + ? node.parent.parent + : node.parent; + if ([ + utils_1.AST_NODE_TYPES.CallExpression, + utils_1.AST_NODE_TYPES.MemberExpression, + utils_1.AST_NODE_TYPES.NewExpression, + utils_1.AST_NODE_TYPES.TSAsExpression, + utils_1.AST_NODE_TYPES.TSTypeAssertion, + utils_1.AST_NODE_TYPES.VariableDeclarator, + ].includes(parent.type)) { + const variable = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(node), 'require'); + if (!variable?.identifiers.length) { + context.report({ + node, + messageId: 'noVarReqs', + }); + } + } + }, + }; + }, +}); +//# sourceMappingURL=no-var-requires.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.d.ts new file mode 100644 index 00000000..fa0ff454 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"bannedClassType", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.js new file mode 100644 index 00000000..9a450bfc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-wrapper-object-types.js @@ -0,0 +1,61 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const classNames = new Set([ + 'BigInt', + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + 'Boolean', + 'Number', + 'Object', + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + 'String', + 'Symbol', +]); +exports.default = (0, util_1.createRule)({ + name: 'no-wrapper-object-types', + meta: { + type: 'problem', + docs: { + description: 'Disallow using confusing built-in primitive class wrappers', + recommended: 'recommended', + }, + fixable: 'code', + messages: { + bannedClassType: 'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function checkBannedTypes(node, includeFix) { + const typeName = node.type === utils_1.AST_NODE_TYPES.Identifier && node.name; + if (!typeName || + !classNames.has(typeName) || + !(0, util_1.isReferenceToGlobalFunction)(typeName, node, context.sourceCode)) { + return; + } + const preferred = typeName.toLowerCase(); + context.report({ + node, + messageId: 'bannedClassType', + data: { preferred, typeName }, + fix: includeFix + ? (fixer) => fixer.replaceText(node, preferred) + : undefined, + }); + } + return { + TSClassImplements(node) { + checkBannedTypes(node.expression, false); + }, + TSInterfaceHeritage(node) { + checkBannedTypes(node.expression, false); + }, + TSTypeReference(node) { + checkBannedTypes(node.typeName, true); + }, + }; + }, +}); +//# sourceMappingURL=no-wrapper-object-types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.d.ts new file mode 100644 index 00000000..6dcf6a61 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.js new file mode 100644 index 00000000..b12e62d8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.js @@ -0,0 +1,133 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'non-nullable-type-assertion-style', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce non-null assertions over explicit type assertions', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + preferNonNullAssertion: 'Use a ! assertion to more succinctly remove null and undefined from the type.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const getTypesIfNotLoose = (node) => { + const type = services.getTypeAtLocation(node); + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { + return undefined; + } + return tsutils.unionConstituents(type); + }; + const couldBeNullish = (type) => { + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.TypeParameter)) { + const constraint = type.getConstraint(); + return constraint == null || couldBeNullish(constraint); + } + if (tsutils.isUnionType(type)) { + for (const part of type.types) { + if (couldBeNullish(part)) { + return true; + } + } + return false; + } + return tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined); + }; + const sameTypeWithoutNullish = (assertedTypes, originalTypes) => { + const nonNullishOriginalTypes = originalTypes.filter(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined)); + if (nonNullishOriginalTypes.length === originalTypes.length) { + return false; + } + for (const assertedType of assertedTypes) { + if (couldBeNullish(assertedType) || + !nonNullishOriginalTypes.includes(assertedType)) { + return false; + } + } + for (const originalType of nonNullishOriginalTypes) { + if (!assertedTypes.includes(originalType)) { + return false; + } + } + return true; + }; + const isConstAssertion = (node) => { + return (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference && + node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + node.typeAnnotation.typeName.name === 'const'); + }; + return { + 'TSAsExpression, TSTypeAssertion'(node) { + if (isConstAssertion(node)) { + return; + } + const originalTypes = getTypesIfNotLoose(node.expression); + if (!originalTypes) { + return; + } + const assertedTypes = getTypesIfNotLoose(node.typeAnnotation); + if (!assertedTypes) { + return; + } + if (sameTypeWithoutNullish(assertedTypes, originalTypes)) { + const expressionSourceCode = context.sourceCode.getText(node.expression); + const higherPrecedenceThanUnary = (0, util_1.getOperatorPrecedence)(services.esTreeNodeToTSNodeMap.get(node.expression).kind, ts.SyntaxKind.Unknown) > util_1.OperatorPrecedence.Unary; + context.report({ + node, + messageId: 'preferNonNullAssertion', + fix(fixer) { + return fixer.replaceText(node, higherPrecedenceThanUnary + ? `${expressionSourceCode}!` + : `(${expressionSourceCode})!`); + }, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=non-nullable-type-assertion-style.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts new file mode 100644 index 00000000..e2d8c4bd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts @@ -0,0 +1,14 @@ +import type { TypeOrValueSpecifier } from '../util'; +export type MessageIds = 'object' | 'undef'; +export type Options = [ + { + allow?: TypeOrValueSpecifier[]; + allowRethrowing?: boolean; + allowThrowingAny?: boolean; + allowThrowingUnknown?: boolean; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.js new file mode 100644 index 00000000..1a0c7848 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.js @@ -0,0 +1,159 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts_api_utils_1 = require("ts-api-utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const promiseUtils_1 = require("../util/promiseUtils"); +exports.default = (0, util_1.createRule)({ + name: 'only-throw-error', + meta: { + type: 'problem', + docs: { + description: 'Disallow throwing non-`Error` values as exceptions', + extendsBaseRule: 'no-throw-literal', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + object: 'Expected an error object to be thrown.', + undef: 'Do not throw undefined.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + ...util_1.typeOrValueSpecifiersSchema, + description: 'Type specifiers that can be thrown.', + }, + allowRethrowing: { + type: 'boolean', + description: 'Whether to allow rethrowing caught values that are not `Error` objects.', + }, + allowThrowingAny: { + type: 'boolean', + description: 'Whether to always allow throwing values typed as `any`.', + }, + allowThrowingUnknown: { + type: 'boolean', + description: 'Whether to always allow throwing values typed as `unknown`.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + allowRethrowing: true, + allowThrowingAny: true, + allowThrowingUnknown: true, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const allow = options.allow; + function isRethrownError(node) { + if (node.type !== utils_1.AST_NODE_TYPES.Identifier) { + return false; + } + const scope = context.sourceCode.getScope(node); + const smVariable = (0, util_1.nullThrows)((0, util_1.findVariable)(scope, node), `Variable ${node.name} should exist in scope manager`); + const variableDefinitions = smVariable.defs.filter(def => def.isVariableDefinition); + if (variableDefinitions.length !== 1) { + return false; + } + const def = smVariable.defs[0]; + // try { /* ... */ } catch (x) { throw x; } + if (def.node.type === utils_1.AST_NODE_TYPES.CatchClause) { + return true; + } + // promise.catch(x => { throw x; }) + // promise.then(onFulfilled, x => { throw x; }) + if (def.node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + def.node.params.length >= 1 && + def.node.params[0] === def.name && + def.node.parent.type === utils_1.AST_NODE_TYPES.CallExpression) { + const callExpression = def.node.parent; + const parsedPromiseHandlingCall = (0, promiseUtils_1.parseCatchCall)(callExpression, context) ?? + (0, promiseUtils_1.parseThenCall)(callExpression, context); + if (parsedPromiseHandlingCall != null) { + const { object, onRejected } = parsedPromiseHandlingCall; + if (onRejected === def.node) { + const tsObjectNode = services.esTreeNodeToTSNodeMap.get(object); + // make sure we're actually dealing with a promise + if ((0, ts_api_utils_1.isThenableType)(services.program.getTypeChecker(), tsObjectNode)) { + return true; + } + } + } + } + return false; + } + function checkThrowArgument(node) { + if (options.allowRethrowing && isRethrownError(node)) { + return; + } + const type = services.getTypeAtLocation(node); + if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program)) { + return; + } + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Undefined)) { + context.report({ node, messageId: 'undef' }); + return; + } + if (options.allowThrowingAny && (0, util_1.isTypeAnyType)(type)) { + return; + } + if (options.allowThrowingUnknown && (0, util_1.isTypeUnknownType)(type)) { + return; + } + if ((0, util_1.isErrorLike)(services.program, type)) { + return; + } + context.report({ node, messageId: 'object' }); + } + return { + ThrowStatement(node) { + checkThrowArgument(node.argument); + }, + }; + }, +}); +//# sourceMappingURL=only-throw-error.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.d.ts new file mode 100644 index 00000000..3cb3aad2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.d.ts @@ -0,0 +1,13 @@ +type Modifier = 'private' | 'private readonly' | 'protected' | 'protected readonly' | 'public' | 'public readonly' | 'readonly'; +type Prefer = 'class-property' | 'parameter-property'; +export type Options = [ + { + allow?: Modifier[]; + prefer?: Prefer; + } +]; +export type MessageIds = 'preferClassProperty' | 'preferParameterProperty'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.js new file mode 100644 index 00000000..980b5e4b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/parameter-properties.js @@ -0,0 +1,165 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'parameter-properties', + meta: { + type: 'problem', + docs: { + description: 'Require or disallow parameter properties in class constructors', + }, + messages: { + preferClassProperty: 'Property {{parameter}} should be declared as a class property.', + preferParameterProperty: 'Property {{parameter}} should be declared as a parameter property.', + }, + schema: [ + { + type: 'object', + $defs: { + modifier: { + type: 'string', + enum: [ + 'readonly', + 'private', + 'protected', + 'public', + 'private readonly', + 'protected readonly', + 'public readonly', + ], + }, + }, + additionalProperties: false, + properties: { + allow: { + type: 'array', + description: 'Whether to allow certain kinds of properties to be ignored.', + items: { + $ref: '#/items/0/$defs/modifier', + }, + }, + prefer: { + type: 'string', + description: 'Whether to prefer class properties or parameter properties.', + enum: ['class-property', 'parameter-property'], + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + prefer: 'class-property', + }, + ], + create(context, [{ allow = [], prefer = 'class-property' }]) { + /** + * Gets the modifiers of `node`. + * @param node the node to be inspected. + */ + function getModifiers(node) { + const modifiers = []; + if (node.accessibility) { + modifiers.push(node.accessibility); + } + if (node.readonly) { + modifiers.push('readonly'); + } + return modifiers.filter(Boolean).join(' '); + } + if (prefer === 'class-property') { + return { + TSParameterProperty(node) { + const modifiers = getModifiers(node); + if (!allow.includes(modifiers)) { + const name = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier + ? node.parameter.name + : node.parameter.left.name; + context.report({ + node, + messageId: 'preferClassProperty', + data: { + parameter: name, + }, + }); + } + }, + }; + } + const propertyNodesByNameStack = []; + function getNodesByName(name) { + const propertyNodesByName = propertyNodesByNameStack[propertyNodesByNameStack.length - 1]; + const existing = propertyNodesByName.get(name); + if (existing) { + return existing; + } + const created = {}; + propertyNodesByName.set(name, created); + return created; + } + function typeAnnotationsMatch(classProperty, constructorParameter) { + if (!classProperty.typeAnnotation || + !constructorParameter.typeAnnotation) { + return (classProperty.typeAnnotation === constructorParameter.typeAnnotation); + } + return (context.sourceCode.getText(classProperty.typeAnnotation) === + context.sourceCode.getText(constructorParameter.typeAnnotation)); + } + return { + ':matches(ClassDeclaration, ClassExpression):exit'() { + const propertyNodesByName = (0, util_1.nullThrows)(propertyNodesByNameStack.pop(), 'Stack should exist on class exit'); + for (const [name, nodes] of propertyNodesByName) { + if (nodes.classProperty && + nodes.constructorAssignment && + nodes.constructorParameter && + typeAnnotationsMatch(nodes.classProperty, nodes.constructorParameter)) { + context.report({ + node: nodes.classProperty, + messageId: 'preferParameterProperty', + data: { + parameter: name, + }, + }); + } + } + }, + ClassBody(node) { + for (const element of node.body) { + if (element.type === utils_1.AST_NODE_TYPES.PropertyDefinition && + element.key.type === utils_1.AST_NODE_TYPES.Identifier && + !element.value && + !allow.includes(getModifiers(element))) { + getNodesByName(element.key.name).classProperty = element; + } + } + }, + 'ClassDeclaration, ClassExpression'() { + propertyNodesByNameStack.push(new Map()); + }, + 'MethodDefinition[kind="constructor"]'(node) { + for (const parameter of node.value.params) { + if (parameter.type === utils_1.AST_NODE_TYPES.Identifier) { + getNodesByName(parameter.name).constructorParameter = parameter; + } + } + for (const statement of node.value.body?.body ?? []) { + if (statement.type !== utils_1.AST_NODE_TYPES.ExpressionStatement || + statement.expression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression || + statement.expression.left.type !== + utils_1.AST_NODE_TYPES.MemberExpression || + statement.expression.left.object.type !== + utils_1.AST_NODE_TYPES.ThisExpression || + statement.expression.left.property.type !== + utils_1.AST_NODE_TYPES.Identifier || + statement.expression.right.type !== utils_1.AST_NODE_TYPES.Identifier) { + break; + } + getNodesByName(statement.expression.right.name).constructorAssignment = statement.expression; + } + }, + }; + }, +}); +//# sourceMappingURL=parameter-properties.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.d.ts new file mode 100644 index 00000000..99318497 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.js new file mode 100644 index 00000000..3702fd25 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-as-const.js @@ -0,0 +1,73 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-as-const', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce the use of `as const` over literal type', + recommended: 'recommended', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + preferConstAssertion: 'Expected a `const` instead of a literal type assertion.', + variableConstAssertion: 'Expected a `const` assertion instead of a literal type annotation.', + variableSuggest: 'You should use `as const` instead of type annotation.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function compareTypes(valueNode, typeNode, canFix) { + if (valueNode.type === utils_1.AST_NODE_TYPES.Literal && + typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType && + typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal && + valueNode.raw === typeNode.literal.raw) { + if (canFix) { + context.report({ + node: typeNode, + messageId: 'preferConstAssertion', + fix: fixer => fixer.replaceText(typeNode, 'const'), + }); + } + else { + context.report({ + node: typeNode, + messageId: 'variableConstAssertion', + suggest: [ + { + messageId: 'variableSuggest', + fix: (fixer) => [ + fixer.remove(typeNode.parent), + fixer.insertTextAfter(valueNode, ' as const'), + ], + }, + ], + }); + } + } + } + return { + PropertyDefinition(node) { + if (node.value && node.typeAnnotation) { + compareTypes(node.value, node.typeAnnotation.typeAnnotation, false); + } + }, + TSAsExpression(node) { + compareTypes(node.expression, node.typeAnnotation, true); + }, + TSTypeAssertion(node) { + compareTypes(node.expression, node.typeAnnotation, true); + }, + VariableDeclarator(node) { + if (node.init && node.id.typeAnnotation) { + compareTypes(node.init, node.id.typeAnnotation.typeAnnotation, false); + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-as-const.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.d.ts new file mode 100644 index 00000000..a60564c0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.d.ts @@ -0,0 +1,19 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util'; +declare const baseRule: TSESLint.RuleModule<"preferDestructuring", [import("eslint/lib/rules/prefer-destructuring").DestructuringTypeConfig | { + AssignmentExpression?: import("eslint/lib/rules/prefer-destructuring").DestructuringTypeConfig; + VariableDeclarator?: import("eslint/lib/rules/prefer-destructuring").DestructuringTypeConfig; +}, (import("eslint/lib/rules/prefer-destructuring").Option1 | undefined)?], unknown, { + AssignmentExpression(node: TSESTree.AssignmentExpression): void; + VariableDeclarator(node: TSESTree.VariableDeclarator): void; +}>; +type BaseOptions = InferOptionsTypeFromRule; +type EnforcementOptions = { + enforceForDeclarationWithTypeAnnotation?: boolean; +} & BaseOptions[1]; +export type Options = [BaseOptions[0], EnforcementOptions]; +export type MessageIds = InferMessageIdsTypeFromRule; +declare const _default: TSESLint.RuleModule<"preferDestructuring", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.js new file mode 100644 index 00000000..33797885 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-destructuring.js @@ -0,0 +1,217 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +const getESLintCoreRule_1 = require("../util/getESLintCoreRule"); +const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('prefer-destructuring'); +const destructuringTypeConfig = { + type: 'object', + additionalProperties: false, + properties: { + array: { + type: 'boolean', + }, + object: { + type: 'boolean', + }, + }, +}; +const schema = [ + { + oneOf: [ + { + type: 'object', + additionalProperties: false, + properties: { + AssignmentExpression: destructuringTypeConfig, + VariableDeclarator: destructuringTypeConfig, + }, + }, + destructuringTypeConfig, + ], + }, + { + type: 'object', + additionalProperties: false, + properties: { + enforceForDeclarationWithTypeAnnotation: { + type: 'boolean', + description: 'Whether to enforce destructuring on variable declarations with type annotations.', + }, + enforceForRenamedProperties: { + type: 'boolean', + description: 'Whether to enforce destructuring that use a different variable name than the property name.', + }, + }, + }, +]; +exports.default = (0, util_1.createRule)({ + name: 'prefer-destructuring', + meta: { + type: 'suggestion', + // defaultOptions, -- base rule does not use defaultOptions + docs: { + description: 'Require destructuring from arrays and/or objects', + extendsBaseRule: true, + frozen: true, + requiresTypeChecking: true, + }, + fixable: baseRule.meta.fixable, + hasSuggestions: baseRule.meta.hasSuggestions, + messages: baseRule.meta.messages, + schema, + }, + defaultOptions: [ + { + AssignmentExpression: { + array: true, + object: true, + }, + VariableDeclarator: { + array: true, + object: true, + }, + }, + {}, + ], + create(context, [enabledTypes, options]) { + const { enforceForDeclarationWithTypeAnnotation = false, enforceForRenamedProperties = false, } = options; + const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context); + const typeChecker = program.getTypeChecker(); + const baseRules = baseRule.create(context); + let baseRulesWithoutFixCache = null; + return { + AssignmentExpression(node) { + if (node.operator !== '=') { + return; + } + performCheck(node.left, node.right, node); + }, + VariableDeclarator(node) { + performCheck(node.id, node.init, node); + }, + }; + function performCheck(leftNode, rightNode, reportNode) { + const rules = leftNode.type === utils_1.AST_NODE_TYPES.Identifier && + leftNode.typeAnnotation == null + ? baseRules + : baseRulesWithoutFix(); + if ((leftNode.type === utils_1.AST_NODE_TYPES.ArrayPattern || + leftNode.type === utils_1.AST_NODE_TYPES.Identifier || + leftNode.type === utils_1.AST_NODE_TYPES.ObjectPattern) && + leftNode.typeAnnotation != null && + !enforceForDeclarationWithTypeAnnotation) { + return; + } + if (rightNode != null && + isArrayLiteralIntegerIndexAccess(rightNode) && + rightNode.object.type !== utils_1.AST_NODE_TYPES.Super) { + const tsObj = esTreeNodeToTSNodeMap.get(rightNode.object); + const objType = typeChecker.getTypeAtLocation(tsObj); + if (!isTypeAnyOrIterableType(objType, typeChecker)) { + if (!enforceForRenamedProperties || + !getNormalizedEnabledType(reportNode.type, 'object')) { + return; + } + context.report({ + node: reportNode, + messageId: 'preferDestructuring', + data: { type: 'object' }, + }); + return; + } + } + if (reportNode.type === utils_1.AST_NODE_TYPES.AssignmentExpression) { + rules.AssignmentExpression(reportNode); + } + else { + rules.VariableDeclarator(reportNode); + } + } + function getNormalizedEnabledType(nodeType, destructuringType) { + if ('object' in enabledTypes || 'array' in enabledTypes) { + return enabledTypes[destructuringType]; + } + return enabledTypes[nodeType][destructuringType]; + } + function baseRulesWithoutFix() { + baseRulesWithoutFixCache ??= baseRule.create(noFixContext(context)); + return baseRulesWithoutFixCache; + } + }, +}); +function noFixContext(context) { + const customContext = { + report: (descriptor) => { + context.report({ + ...descriptor, + fix: undefined, + }); + }, + }; + // we can't directly proxy `context` because its `report` property is non-configurable + // and non-writable. So we proxy `customContext` and redirect all + // property access to the original context except for `report` + return new Proxy(customContext, { + get(target, path, receiver) { + if (path !== 'report') { + return Reflect.get(context, path, receiver); + } + return Reflect.get(target, path, receiver); + }, + }); +} +function isTypeAnyOrIterableType(type, typeChecker) { + if ((0, util_1.isTypeAnyType)(type)) { + return true; + } + if (!type.isUnion()) { + const iterator = tsutils.getWellKnownSymbolPropertyOfType(type, 'iterator', typeChecker); + return iterator != null; + } + return type.types.every(t => isTypeAnyOrIterableType(t, typeChecker)); +} +function isArrayLiteralIntegerIndexAccess(node) { + if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return false; + } + if (node.property.type !== utils_1.AST_NODE_TYPES.Literal) { + return false; + } + return Number.isInteger(node.property.value); +} +//# sourceMappingURL=prefer-destructuring.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.d.ts new file mode 100644 index 00000000..244c414d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'defineInitializer' | 'defineInitializerSuggestion'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.js new file mode 100644 index 00000000..39f8b7e2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-enum-initializers.js @@ -0,0 +1,63 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-enum-initializers', + meta: { + type: 'suggestion', + docs: { + description: 'Require each enum member value to be explicitly initialized', + }, + hasSuggestions: true, + messages: { + defineInitializer: "The value of the member '{{ name }}' should be explicitly defined.", + defineInitializerSuggestion: 'Can be fixed to {{ name }} = {{ suggested }}', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function TSEnumDeclaration(node) { + const { members } = node.body; + members.forEach((member, index) => { + if (member.initializer == null) { + const name = context.sourceCode.getText(member); + context.report({ + node: member, + messageId: 'defineInitializer', + data: { + name, + }, + suggest: [ + { + messageId: 'defineInitializerSuggestion', + data: { name, suggested: index }, + fix: (fixer) => { + return fixer.replaceText(member, `${name} = ${index}`); + }, + }, + { + messageId: 'defineInitializerSuggestion', + data: { name, suggested: index + 1 }, + fix: (fixer) => { + return fixer.replaceText(member, `${name} = ${index + 1}`); + }, + }, + { + messageId: 'defineInitializerSuggestion', + data: { name, suggested: `'${name}'` }, + fix: (fixer) => { + return fixer.replaceText(member, `${name} = '${name}'`); + }, + }, + ], + }); + } + }); + } + return { + TSEnumDeclaration, + }; + }, +}); +//# sourceMappingURL=prefer-enum-initializers.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.d.ts new file mode 100644 index 00000000..d427bc51 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"preferFind" | "preferFindSuggestion", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.js new file mode 100644 index 00000000..5cfbc43d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.js @@ -0,0 +1,248 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-find', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + preferFind: 'Prefer .find(...) instead of .filter(...)[0].', + preferFindSuggestion: 'Use .find(...) instead of .filter(...)[0].', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const globalScope = context.sourceCode.getScope(context.sourceCode.ast); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function parseArrayFilterExpressions(expression) { + const node = (0, util_1.skipChainExpression)(expression); + if (node.type === utils_1.AST_NODE_TYPES.SequenceExpression) { + // Only the last expression in (a, b, [1, 2, 3].filter(condition))[0] matters + const lastExpression = (0, util_1.nullThrows)(node.expressions.at(-1), 'Expected to have more than zero expressions in a sequence expression'); + return parseArrayFilterExpressions(lastExpression); + } + // This is the only reason we're returning a list rather than a single value. + if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) { + // Both branches of the ternary _must_ return results. + const consequentResult = parseArrayFilterExpressions(node.consequent); + if (consequentResult.length === 0) { + return []; + } + const alternateResult = parseArrayFilterExpressions(node.alternate); + if (alternateResult.length === 0) { + return []; + } + // Accumulate the results from both sides and pass up the chain. + return [...consequentResult, ...alternateResult]; + } + // Check if it looks like <>(...), but not <>?.(...) + if (node.type === utils_1.AST_NODE_TYPES.CallExpression && !node.optional) { + const callee = node.callee; + // Check if it looks like <>.filter(...) or <>['filter'](...), + // or the optional chaining variants. + if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) { + const isBracketSyntaxForFilter = callee.computed; + if ((0, util_1.isStaticMemberAccessOfValue)(callee, context, 'filter')) { + const filterNode = callee.property; + const filteredObjectType = (0, util_1.getConstrainedTypeAtLocation)(services, callee.object); + // As long as the object is a (possibly nullable) array, + // this is an Array.prototype.filter expression. + if (isArrayish(filteredObjectType)) { + return [ + { + filterNode, + isBracketSyntaxForFilter, + }, + ]; + } + } + } + } + // not a filter expression. + return []; + } + /** + * Tells whether the type is a possibly nullable array/tuple or union thereof. + */ + function isArrayish(type) { + let isAtLeastOneArrayishComponent = false; + for (const unionPart of tsutils.unionConstituents(type)) { + if (tsutils.isIntrinsicNullType(unionPart) || + tsutils.isIntrinsicUndefinedType(unionPart)) { + continue; + } + // apparently checker.isArrayType(T[] & S[]) => false. + // so we need to check the intersection parts individually. + const isArrayOrIntersectionThereof = tsutils + .intersectionConstituents(unionPart) + .every(intersectionPart => checker.isArrayType(intersectionPart) || + checker.isTupleType(intersectionPart)); + if (!isArrayOrIntersectionThereof) { + // There is a non-array, non-nullish type component, + // so it's not an array. + return false; + } + isAtLeastOneArrayishComponent = true; + } + return isAtLeastOneArrayishComponent; + } + function getObjectIfArrayAtZeroExpression(node) { + // .at() should take exactly one argument. + if (node.arguments.length !== 1) { + return undefined; + } + const callee = node.callee; + if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression && + !callee.optional && + (0, util_1.isStaticMemberAccessOfValue)(callee, context, 'at')) { + const atArgument = (0, util_1.getStaticValue)(node.arguments[0], globalScope); + if (atArgument != null && isTreatedAsZeroByArrayAt(atArgument.value)) { + return callee.object; + } + } + return undefined; + } + /** + * Implements the algorithm for array indexing by `.at()` method. + * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at#parameters + */ + function isTreatedAsZeroByArrayAt(value) { + // This would cause the number constructor coercion to throw. Other static + // values are safe. + if (typeof value === 'symbol') { + return false; + } + const asNumber = Number(value); + if (isNaN(asNumber)) { + return true; + } + return Math.trunc(asNumber) === 0; + } + function isMemberAccessOfZero(node) { + const property = (0, util_1.getStaticValue)(node.property, globalScope); + // Check if it looks like <>[0] or <>['0'], but not <>?.[0] + return (!node.optional && + property != null && + isTreatedAsZeroByMemberAccess(property.value)); + } + /** + * Implements the algorithm for array indexing by member operator. + * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#array_indices + */ + function isTreatedAsZeroByMemberAccess(value) { + return String(value) === '0'; + } + function generateFixToRemoveArrayElementAccess(fixer, arrayNode, wholeExpressionBeingFlagged) { + const tokenToStartDeletingFrom = (0, util_1.nullThrows)( + // The next `.` or `[` is what we're looking for. + // think of (...).at(0) or (...)[0] or even (...)["at"](0). + context.sourceCode.getTokenAfter(arrayNode, token => token.value === '.' || token.value === '['), 'Expected to find a member access token!'); + return fixer.removeRange([ + tokenToStartDeletingFrom.range[0], + wholeExpressionBeingFlagged.range[1], + ]); + } + function generateFixToReplaceFilterWithFind(fixer, filterExpression) { + return fixer.replaceText(filterExpression.filterNode, filterExpression.isBracketSyntaxForFilter ? '"find"' : 'find'); + } + return { + // This query will be used to find things like `filteredResults.at(0)`. + CallExpression(node) { + const object = getObjectIfArrayAtZeroExpression(node); + if (object) { + const filterExpressions = parseArrayFilterExpressions(object); + if (filterExpressions.length !== 0) { + context.report({ + node, + messageId: 'preferFind', + suggest: [ + { + messageId: 'preferFindSuggestion', + fix: (fixer) => { + return [ + ...filterExpressions.map(filterExpression => generateFixToReplaceFilterWithFind(fixer, filterExpression)), + // Get rid of the .at(0) or ['at'](0). + generateFixToRemoveArrayElementAccess(fixer, object, node), + ]; + }, + }, + ], + }); + } + } + }, + // This query will be used to find things like `filteredResults[0]`. + // + // Note: we're always looking for array member access to be "computed", + // i.e. `filteredResults[0]`, since `filteredResults.0` isn't a thing. + 'MemberExpression[computed=true]'(node) { + if (isMemberAccessOfZero(node)) { + const object = node.object; + const filterExpressions = parseArrayFilterExpressions(object); + if (filterExpressions.length !== 0) { + context.report({ + node, + messageId: 'preferFind', + suggest: [ + { + messageId: 'preferFindSuggestion', + fix: (fixer) => { + return [ + ...filterExpressions.map(filterExpression => generateFixToReplaceFilterWithFind(fixer, filterExpression)), + // Get rid of the [0]. + generateFixToRemoveArrayElementAccess(fixer, object, node), + ]; + }, + }, + ], + }); + } + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-find.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.d.ts new file mode 100644 index 00000000..f6145bf3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"preferForOf", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.js new file mode 100644 index 00000000..7618ac8d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-for-of.js @@ -0,0 +1,116 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-for-of', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce the use of `for-of` loop over the standard `for` loop where possible', + recommended: 'stylistic', + }, + messages: { + preferForOf: 'Expected a `for-of` loop instead of a `for` loop with this simple iteration.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + function isSingleVariableDeclaration(node) { + return (node?.type === utils_1.AST_NODE_TYPES.VariableDeclaration && + node.kind !== 'const' && + node.declarations.length === 1); + } + function isLiteral(node, value) { + return node.type === utils_1.AST_NODE_TYPES.Literal && node.value === value; + } + function isZeroInitialized(node) { + return node.init != null && isLiteral(node.init, 0); + } + function isMatchingIdentifier(node, name) { + return node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === name; + } + function isLessThanLengthExpression(node, name) { + if (node?.type === utils_1.AST_NODE_TYPES.BinaryExpression && + node.operator === '<' && + isMatchingIdentifier(node.left, name) && + node.right.type === utils_1.AST_NODE_TYPES.MemberExpression && + isMatchingIdentifier(node.right.property, 'length')) { + return node.right.object; + } + return null; + } + function isIncrement(node, name) { + if (!node) { + return false; + } + switch (node.type) { + case utils_1.AST_NODE_TYPES.UpdateExpression: + // x++ or ++x + return (node.operator === '++' && isMatchingIdentifier(node.argument, name)); + case utils_1.AST_NODE_TYPES.AssignmentExpression: + if (isMatchingIdentifier(node.left, name)) { + if (node.operator === '+=') { + // x += 1 + return isLiteral(node.right, 1); + } + if (node.operator === '=') { + // x = x + 1 or x = 1 + x + const expr = node.right; + return (expr.type === utils_1.AST_NODE_TYPES.BinaryExpression && + expr.operator === '+' && + ((isMatchingIdentifier(expr.left, name) && + isLiteral(expr.right, 1)) || + (isLiteral(expr.left, 1) && + isMatchingIdentifier(expr.right, name)))); + } + } + } + return false; + } + function contains(outer, inner) { + return (outer.range[0] <= inner.range[0] && outer.range[1] >= inner.range[1]); + } + function isIndexOnlyUsedWithArray(body, indexVar, arrayExpression) { + const arrayText = context.sourceCode.getText(arrayExpression); + return indexVar.references.every(reference => { + const id = reference.identifier; + const node = id.parent; + return (!contains(body, id) || + (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.object.type !== utils_1.AST_NODE_TYPES.ThisExpression && + node.property === id && + context.sourceCode.getText(node.object) === arrayText && + !(0, util_1.isAssignee)(node))); + }); + } + return { + 'ForStatement:exit'(node) { + if (!isSingleVariableDeclaration(node.init)) { + return; + } + const declarator = node.init.declarations[0]; + if (!declarator || + !isZeroInitialized(declarator) || + declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) { + return; + } + const indexName = declarator.id.name; + const arrayExpression = isLessThanLengthExpression(node.test, indexName); + if (!arrayExpression) { + return; + } + const [indexVar] = context.sourceCode.getDeclaredVariables(node.init); + if (isIncrement(node.update, indexName) && + isIndexOnlyUsedWithArray(node.body, indexVar, arrayExpression)) { + context.report({ + node, + messageId: 'preferForOf', + }); + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-for-of.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.d.ts new file mode 100644 index 00000000..8093082e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.d.ts @@ -0,0 +1,9 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export declare const phrases: { + readonly TSInterfaceDeclaration: 'Interface'; + readonly TSTypeLiteral: 'Type literal'; +}; +declare const _default: TSESLint.RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.js new file mode 100644 index 00000000..1e3e2961 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-function-type.js @@ -0,0 +1,187 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.phrases = void 0; +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.phrases = { + [utils_1.AST_NODE_TYPES.TSInterfaceDeclaration]: 'Interface', + [utils_1.AST_NODE_TYPES.TSTypeLiteral]: 'Type literal', +}; +exports.default = (0, util_1.createRule)({ + name: 'prefer-function-type', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce using function types instead of interfaces with call signatures', + recommended: 'stylistic', + }, + fixable: 'code', + messages: { + functionTypeOverCallableType: '{{ literalOrInterface }} only has a call signature, you should use a function type instead.', + unexpectedThisOnFunctionOnlyInterface: "`this` refers to the function type '{{ interfaceName }}', did you intend to use a generic `this` parameter like `(this: Self, ...) => Self` instead?", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + /** + * Checks if there the interface has exactly one supertype that isn't named 'Function' + * @param node The node being checked + */ + function hasOneSupertype(node) { + if (node.extends.length === 0) { + return false; + } + if (node.extends.length !== 1) { + return true; + } + const expr = node.extends[0].expression; + return (expr.type !== utils_1.AST_NODE_TYPES.Identifier || expr.name !== 'Function'); + } + /** + * @param parent The parent of the call signature causing the diagnostic + */ + function shouldWrapSuggestion(parent) { + if (!parent) { + return false; + } + switch (parent.type) { + case utils_1.AST_NODE_TYPES.TSUnionType: + case utils_1.AST_NODE_TYPES.TSIntersectionType: + case utils_1.AST_NODE_TYPES.TSArrayType: + return true; + default: + return false; + } + } + /** + * @param member The TypeElement being checked + * @param node The parent of member being checked + */ + function checkMember(member, node, tsThisTypes = null) { + if ((member.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration || + member.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration) && + member.returnType != null) { + if (tsThisTypes?.length && + node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) { + // the message can be confusing if we don't point directly to the `this` node instead of the whole member + // and in favour of generating at most one error we'll only report the first occurrence of `this` if there are multiple + context.report({ + node: tsThisTypes[0], + messageId: 'unexpectedThisOnFunctionOnlyInterface', + data: { + interfaceName: node.id.name, + }, + }); + return; + } + const fixable = node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration; + const fix = fixable + ? null + : (fixer) => { + const fixes = []; + const start = member.range[0]; + // https://github.com/microsoft/TypeScript/pull/56908 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const colonPos = member.returnType.range[0] - start; + const text = context.sourceCode + .getText() + .slice(start, member.range[1]); + const comments = [ + ...context.sourceCode.getCommentsBefore(member), + ...context.sourceCode.getCommentsAfter(member), + ]; + let suggestion = `${text.slice(0, colonPos)} =>${text.slice(colonPos + 1)}`; + const lastChar = suggestion.endsWith(';') ? ';' : ''; + if (lastChar) { + suggestion = suggestion.slice(0, -1); + } + if (shouldWrapSuggestion(node.parent)) { + suggestion = `(${suggestion})`; + } + if (node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) { + if (node.typeParameters != null) { + suggestion = `type ${context.sourceCode + .getText() + .slice(node.id.range[0], node.typeParameters.range[1])} = ${suggestion}${lastChar}`; + } + else { + suggestion = `type ${node.id.name} = ${suggestion}${lastChar}`; + } + } + const isParentExported = node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration; + if (node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration && + isParentExported) { + const commentsText = comments + .map(({ type, value }) => type === utils_1.AST_TOKEN_TYPES.Line + ? `//${value}\n` + : `/*${value}*/\n`) + .join(''); + // comments should move before export and not between export and interface declaration + fixes.push(fixer.insertTextBefore(node.parent, commentsText)); + } + else { + comments.forEach(comment => { + let commentText = comment.type === utils_1.AST_TOKEN_TYPES.Line + ? `//${comment.value}` + : `/*${comment.value}*/`; + const isCommentOnTheSameLine = comment.loc.start.line === member.loc.start.line; + if (!isCommentOnTheSameLine) { + commentText += '\n'; + } + else { + commentText += ' '; + } + suggestion = commentText + suggestion; + }); + } + const fixStart = node.range[0]; + fixes.push(fixer.replaceTextRange([fixStart, node.range[1]], suggestion)); + return fixes; + }; + context.report({ + node: member, + messageId: 'functionTypeOverCallableType', + data: { + literalOrInterface: exports.phrases[node.type], + }, + fix, + }); + } + } + let tsThisTypes = null; + let literalNesting = 0; + return { + TSInterfaceDeclaration() { + // when entering an interface reset the count of `this`s to empty. + tsThisTypes = []; + }, + 'TSInterfaceDeclaration:exit'(node) { + if (!hasOneSupertype(node) && node.body.body.length === 1) { + checkMember(node.body.body[0], node, tsThisTypes); + } + // on exit check member and reset the array to nothing. + tsThisTypes = null; + }, + 'TSInterfaceDeclaration TSThisType'(node) { + // inside an interface keep track of all ThisType references. + // unless it's inside a nested type literal in which case it's invalid code anyway + // we don't want to incorrectly say "it refers to name" while typescript says it's completely invalid. + if (literalNesting === 0 && tsThisTypes != null) { + tsThisTypes.push(node); + } + }, + // keep track of nested literals to avoid complaining about invalid `this` uses + 'TSInterfaceDeclaration TSTypeLiteral'() { + literalNesting += 1; + }, + 'TSInterfaceDeclaration TSTypeLiteral:exit'() { + literalNesting -= 1; + }, + 'TSTypeLiteral[members.length = 1]'(node) { + checkMember(node.members[0], node); + }, + }; + }, +}); +//# sourceMappingURL=prefer-function-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.d.ts new file mode 100644 index 00000000..3f456edf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.js new file mode 100644 index 00000000..759cb6df --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-includes.js @@ -0,0 +1,243 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const regexpp_1 = require("@eslint-community/regexpp"); +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-includes', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce `includes` method over `indexOf` method', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + preferIncludes: "Use 'includes()' method instead.", + preferStringIncludes: 'Use `String#includes()` method with a string instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const globalScope = context.sourceCode.getScope(context.sourceCode.ast); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function isNumber(node, value) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + return evaluated?.value === value; + } + function isPositiveCheck(node) { + switch (node.operator) { + case '!==': + case '!=': + case '>': + return isNumber(node.right, -1); + case '>=': + return isNumber(node.right, 0); + default: + return false; + } + } + function isNegativeCheck(node) { + switch (node.operator) { + case '===': + case '==': + case '<=': + return isNumber(node.right, -1); + case '<': + return isNumber(node.right, 0); + default: + return false; + } + } + function hasSameParameters(nodeA, nodeB) { + if (!ts.isFunctionLike(nodeA) || !ts.isFunctionLike(nodeB)) { + return false; + } + const paramsA = nodeA.parameters; + const paramsB = nodeB.parameters; + if (paramsA.length !== paramsB.length) { + return false; + } + for (let i = 0; i < paramsA.length; ++i) { + const paramA = paramsA[i]; + const paramB = paramsB[i]; + // Check name, type, and question token once. + if (paramA.getText() !== paramB.getText()) { + return false; + } + } + return true; + } + /** + * Parse a given node if it's a `RegExp` instance. + * @param node The node to parse. + */ + function parseRegExp(node) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + if (evaluated == null || !(evaluated.value instanceof RegExp)) { + return null; + } + const { flags, pattern } = (0, regexpp_1.parseRegExpLiteral)(evaluated.value); + if (pattern.alternatives.length !== 1 || + flags.ignoreCase || + flags.global) { + return null; + } + // Check if it can determine a unique string. + const chars = pattern.alternatives[0].elements; + if (!chars.every(c => c.type === 'Character')) { + return null; + } + // To string. + return String.fromCodePoint(...chars.map(c => c.value)); + } + function escapeString(str) { + const EscapeMap = { + '\0': '\\0', + '\t': '\\t', + '\n': '\\n', + '\v': '\\v', + '\f': '\\f', + '\r': '\\r', + "'": "\\'", + '\\': '\\\\', + // "\b" cause unexpected replacements + // '\b': '\\b', + }; + const replaceRegex = new RegExp(Object.values(EscapeMap).join('|'), 'g'); + return str.replaceAll(replaceRegex, char => EscapeMap[char]); + } + function checkArrayIndexOf(node, allowFixing) { + if (!(0, util_1.isStaticMemberAccessOfValue)(node, context, 'indexOf')) { + return; + } + // Check if the comparison is equivalent to `includes()`. + const callNode = node.parent; + const compareNode = (callNode.parent.type === utils_1.AST_NODE_TYPES.ChainExpression + ? callNode.parent.parent + : callNode.parent); + const negative = isNegativeCheck(compareNode); + if (!negative && !isPositiveCheck(compareNode)) { + return; + } + // Get the symbol of `indexOf` method. + const indexofMethodDeclarations = services + .getSymbolAtLocation(node.property) + ?.getDeclarations(); + if (indexofMethodDeclarations == null || + indexofMethodDeclarations.length === 0) { + return; + } + // Check if every declaration of `indexOf` method has `includes` method + // and the two methods have the same parameters. + for (const instanceofMethodDecl of indexofMethodDeclarations) { + const typeDecl = instanceofMethodDecl.parent; + const type = checker.getTypeAtLocation(typeDecl); + const includesMethodDecl = type + .getProperty('includes') + ?.getDeclarations(); + if (!includesMethodDecl?.some(includesMethodDecl => hasSameParameters(includesMethodDecl, instanceofMethodDecl))) { + return; + } + } + // Report it. + context.report({ + node: compareNode, + messageId: 'preferIncludes', + ...(allowFixing && { + *fix(fixer) { + if (negative) { + yield fixer.insertTextBefore(callNode, '!'); + } + yield fixer.replaceText(node.property, 'includes'); + yield fixer.removeRange([callNode.range[1], compareNode.range[1]]); + }, + }), + }); + } + return { + // a.indexOf(b) !== 1 + 'BinaryExpression > CallExpression.left > MemberExpression'(node) { + checkArrayIndexOf(node, /* allowFixing */ true); + }, + // a?.indexOf(b) !== 1 + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression'(node) { + checkArrayIndexOf(node, /* allowFixing */ false); + }, + // /bar/.test(foo) + 'CallExpression[arguments.length=1] > MemberExpression.callee[property.name="test"][computed=false]'(node) { + const callNode = node.parent; + const text = parseRegExp(node.object); + if (text == null) { + return; + } + //check the argument type of test methods + const argument = callNode.arguments[0]; + const type = (0, util_1.getConstrainedTypeAtLocation)(services, argument); + const includesMethodDecl = type + .getProperty('includes') + ?.getDeclarations(); + if (includesMethodDecl == null) { + return; + } + context.report({ + node: callNode, + messageId: 'preferStringIncludes', + *fix(fixer) { + const argNode = callNode.arguments[0]; + const needsParen = argNode.type !== utils_1.AST_NODE_TYPES.Literal && + argNode.type !== utils_1.AST_NODE_TYPES.TemplateLiteral && + argNode.type !== utils_1.AST_NODE_TYPES.Identifier && + argNode.type !== utils_1.AST_NODE_TYPES.MemberExpression && + argNode.type !== utils_1.AST_NODE_TYPES.CallExpression; + yield fixer.removeRange([callNode.range[0], argNode.range[0]]); + yield fixer.removeRange([argNode.range[1], callNode.range[1]]); + if (needsParen) { + yield fixer.insertTextBefore(argNode, '('); + yield fixer.insertTextAfter(argNode, ')'); + } + yield fixer.insertTextAfter(argNode, `${node.optional ? '?.' : '.'}includes('${escapeString(text)}')`); + }, + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-includes.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.d.ts new file mode 100644 index 00000000..02b07894 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.d.ts @@ -0,0 +1,6 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{ + allowBitwiseExpressions: boolean; +}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.js new file mode 100644 index 00000000..d73390ea --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-literal-enum-member.js @@ -0,0 +1,117 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-literal-enum-member', + meta: { + type: 'suggestion', + docs: { + description: 'Require all enum members to be literal values', + recommended: 'strict', + requiresTypeChecking: false, + }, + messages: { + notLiteral: `Explicit enum value must only be a literal value (string or number).`, + notLiteralOrBitwiseExpression: `Explicit enum value must only be a literal value (string or number) or a bitwise expression.`, + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowBitwiseExpressions: { + type: 'boolean', + description: 'Whether to allow using bitwise expressions in enum initializers.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowBitwiseExpressions: false, + }, + ], + create(context, [{ allowBitwiseExpressions }]) { + function isIdentifierWithName(node, name) { + return node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === name; + } + function hasEnumMember(decl, name) { + return decl.body.members.some(member => isIdentifierWithName(member.id, name) || + (member.id.type === utils_1.AST_NODE_TYPES.Literal && + (0, util_1.getStaticStringValue)(member.id) === name)); + } + function isSelfEnumMember(decl, node) { + if (node.type === utils_1.AST_NODE_TYPES.Identifier) { + return hasEnumMember(decl, node.name); + } + if (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + isIdentifierWithName(node.object, decl.id.name)) { + if (node.property.type === utils_1.AST_NODE_TYPES.Identifier) { + return hasEnumMember(decl, node.property.name); + } + if (node.computed) { + const propertyName = (0, util_1.getStaticStringValue)(node.property); + if (propertyName) { + return hasEnumMember(decl, propertyName); + } + } + } + return false; + } + return { + TSEnumMember(node) { + // If there is no initializer, then this node is just the name of the member, so ignore. + if (node.initializer == null) { + return; + } + const declaration = node.parent.parent; + function isAllowedInitializerExpressionRecursive(node, partOfBitwiseComputation) { + // You can only refer to an enum member if it's part of a bitwise computation. + // so C = B isn't allowed (special case), but C = A | B is. + if (partOfBitwiseComputation && isSelfEnumMember(declaration, node)) { + return true; + } + switch (node.type) { + // any old literal + case utils_1.AST_NODE_TYPES.Literal: + return true; + // TemplateLiteral without expressions + case utils_1.AST_NODE_TYPES.TemplateLiteral: + return node.expressions.length === 0; + case utils_1.AST_NODE_TYPES.UnaryExpression: + // +123, -123, etc. + if (['-', '+'].includes(node.operator)) { + return isAllowedInitializerExpressionRecursive(node.argument, partOfBitwiseComputation); + } + if (allowBitwiseExpressions) { + return (node.operator === '~' && + isAllowedInitializerExpressionRecursive(node.argument, true)); + } + return false; + case utils_1.AST_NODE_TYPES.BinaryExpression: + if (allowBitwiseExpressions) { + return (['&', '^', '<<', '>>', '>>>', '|'].includes(node.operator) && + isAllowedInitializerExpressionRecursive(node.left, true) && + isAllowedInitializerExpressionRecursive(node.right, true)); + } + return false; + default: + return false; + } + } + if (isAllowedInitializerExpressionRecursive(node.initializer, false)) { + return; + } + context.report({ + node: node.id, + messageId: allowBitwiseExpressions + ? 'notLiteralOrBitwiseExpression' + : 'notLiteral', + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-literal-enum-member.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.d.ts new file mode 100644 index 00000000..998def95 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.js new file mode 100644 index 00000000..2d002007 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-namespace-keyword.js @@ -0,0 +1,43 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-namespace-keyword', + meta: { + type: 'suggestion', + docs: { + description: 'Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules', + recommended: 'recommended', + }, + fixable: 'code', + messages: { + useNamespace: "Use 'namespace' instead of 'module' to declare custom TypeScript modules.", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + return { + TSModuleDeclaration(node) { + // Do nothing if the name is a string. + if (node.id.type === utils_1.AST_NODE_TYPES.Literal) { + return; + } + // Get tokens of the declaration header. + const moduleType = context.sourceCode.getTokenBefore(node.id); + if (moduleType?.type === utils_1.AST_TOKEN_TYPES.Identifier && + moduleType.value === 'module') { + context.report({ + node, + messageId: 'useNamespace', + fix(fixer) { + return fixer.replaceText(moduleType, 'namespace'); + }, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-namespace-keyword.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.d.ts new file mode 100644 index 00000000..4d0f4009 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.d.ts @@ -0,0 +1,22 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + ignoreBooleanCoercion?: boolean; + ignoreConditionalTests?: boolean; + ignoreIfStatements?: boolean; + ignoreMixedLogicalExpressions?: boolean; + ignorePrimitives?: true | { + bigint?: boolean; + boolean?: boolean; + number?: boolean; + string?: boolean; + }; + ignoreTernaryTests?: boolean; + } +]; +export type MessageIds = 'noStrictNullCheck' | 'preferNullishOverAssignment' | 'preferNullishOverOr' | 'preferNullishOverTernary' | 'suggestNullish'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.js new file mode 100644 index 00000000..3dd29693 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.js @@ -0,0 +1,618 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getWrappedCode_1 = require("../util/getWrappedCode"); +const isMemberAccessLike = (0, util_1.isNodeOfTypes)([ + utils_1.AST_NODE_TYPES.ChainExpression, + utils_1.AST_NODE_TYPES.Identifier, + utils_1.AST_NODE_TYPES.MemberExpression, +]); +const isNullLiteralOrUndefinedIdentifier = (node) => (0, util_1.isNullLiteral)(node) || (0, util_1.isUndefinedIdentifier)(node); +const isNodeNullishComparison = (node) => isNullLiteralOrUndefinedIdentifier(node.left) && + isNullLiteralOrUndefinedIdentifier(node.right); +exports.default = (0, util_1.createRule)({ + name: 'prefer-nullish-coalescing', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce using the nullish coalescing operator instead of logical assignments or chaining', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.', + preferNullishOverAssignment: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of an assignment expression, as it is simpler to read.', + preferNullishOverOr: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of a logical {{ description }} (`||{{ equals }}`), as it is a safer operator.', + preferNullishOverTernary: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of a ternary expression, as it is simpler to read.', + suggestNullish: 'Fix to nullish coalescing operator (`??{{ equals }}`).', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: { + type: 'boolean', + description: 'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.', + }, + ignoreBooleanCoercion: { + type: 'boolean', + description: 'Whether to ignore arguments to the `Boolean` constructor', + }, + ignoreConditionalTests: { + type: 'boolean', + description: 'Whether to ignore cases that are located within a conditional test.', + }, + ignoreIfStatements: { + type: 'boolean', + description: 'Whether to ignore any if statements that could be simplified by using the nullish coalescing operator.', + }, + ignoreMixedLogicalExpressions: { + type: 'boolean', + description: 'Whether to ignore any logical or expressions that are part of a mixed logical expression (with `&&`).', + }, + ignorePrimitives: { + description: 'Whether to ignore all (`true`) or some (an object with properties) primitive types.', + oneOf: [ + { + type: 'object', + additionalProperties: false, + description: 'Which primitives types may be ignored.', + properties: { + bigint: { + type: 'boolean', + description: 'Ignore bigint primitive types.', + }, + boolean: { + type: 'boolean', + description: 'Ignore boolean primitive types.', + }, + number: { + type: 'boolean', + description: 'Ignore number primitive types.', + }, + string: { + type: 'boolean', + description: 'Ignore string primitive types.', + }, + }, + }, + { + type: 'boolean', + description: 'Ignore all primitive types.', + enum: [true], + }, + ], + }, + ignoreTernaryTests: { + type: 'boolean', + description: 'Whether to ignore any ternary expressions that could be simplified by using the nullish coalescing operator.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false, + ignoreBooleanCoercion: false, + ignoreConditionalTests: true, + ignoreIfStatements: false, + ignoreMixedLogicalExpressions: false, + ignorePrimitives: { + bigint: false, + boolean: false, + number: false, + string: false, + }, + ignoreTernaryTests: false, + }, + ], + create(context, [{ allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, ignoreBooleanCoercion, ignoreConditionalTests, ignoreIfStatements, ignoreMixedLogicalExpressions, ignorePrimitives, ignoreTernaryTests, },]) { + const parserServices = (0, util_1.getParserServices)(context); + const compilerOptions = parserServices.program.getCompilerOptions(); + const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks'); + if (!isStrictNullChecks && + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) { + context.report({ + loc: { + start: { column: 0, line: 0 }, + end: { column: 0, line: 0 }, + }, + messageId: 'noStrictNullCheck', + }); + } + /** + * Checks whether a type tested for truthiness is eligible for conversion to + * a nullishness check, taking into account the rule's configuration. + */ + function isTypeEligibleForPreferNullish(type) { + if (!(0, util_1.isNullableType)(type)) { + return false; + } + const ignorableFlags = [ + /* eslint-disable @typescript-eslint/no-non-null-assertion */ + (ignorePrimitives === true || ignorePrimitives.bigint) && + ts.TypeFlags.BigIntLike, + (ignorePrimitives === true || ignorePrimitives.boolean) && + ts.TypeFlags.BooleanLike, + (ignorePrimitives === true || ignorePrimitives.number) && + ts.TypeFlags.NumberLike, + (ignorePrimitives === true || ignorePrimitives.string) && + ts.TypeFlags.StringLike, + /* eslint-enable @typescript-eslint/no-non-null-assertion */ + ] + .filter((flag) => typeof flag === 'number') + .reduce((previous, flag) => previous | flag, 0); + if (ignorableFlags === 0) { + // any types are eligible for conversion. + return true; + } + // if the type is `any` or `unknown` we can't make any assumptions + // about the value, so it could be any primitive, even though the flags + // won't be set. + // + // technically, this is true of `void` as well, however, it's a TS error + // to test `void` for truthiness, so we don't need to bother checking for + // it in valid code. + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { + return false; + } + if (tsutils + .typeConstituents(type) + .some(t => tsutils + .intersectionConstituents(t) + .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)))) { + return false; + } + return true; + } + /** + * Determines whether a control flow construct that uses the truthiness of + * a test expression is eligible for conversion to the nullish coalescing + * operator, taking into account (both dependent on the rule's configuration): + * 1. Whether the construct is in a permitted syntactic context + * 2. Whether the type of the test expression is deemed eligible for + * conversion + * + * @param node The overall node to be converted (e.g. `a || b` or `a ? a : b`) + * @param testNode The node being tested (i.e. `a`) + */ + function isTruthinessCheckEligibleForPreferNullish({ node, testNode, }) { + if (ignoreConditionalTests === true && (0, util_1.isConditionalTest)(node)) { + return false; + } + if (ignoreBooleanCoercion === true && + isBooleanConstructorContext(node, context) && + !(node.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + node.parent.type === utils_1.AST_NODE_TYPES.CallExpression)) { + return false; + } + const testType = parserServices.getTypeAtLocation(testNode); + if (!isTypeEligibleForPreferNullish(testType)) { + return false; + } + return true; + } + function checkAndFixWithPreferNullishOverOr(node, description, equals) { + if (!isTruthinessCheckEligibleForPreferNullish({ + node, + testNode: node.left, + })) { + return; + } + if (ignoreMixedLogicalExpressions === true && + isMixedLogicalExpression(node)) { + return; + } + const barBarOperator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.left, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === node.operator), util_1.NullThrowsReasons.MissingToken('operator', node.type)); + function* fix(fixer) { + if ((0, util_1.isLogicalOrOperator)(node.parent)) { + // '&&' and '??' operations cannot be mixed without parentheses (e.g. a && b ?? c) + if (node.left.type === utils_1.AST_NODE_TYPES.LogicalExpression && + !(0, util_1.isLogicalOrOperator)(node.left.left)) { + yield fixer.insertTextBefore(node.left.right, '('); + } + else { + yield fixer.insertTextBefore(node.left, '('); + } + yield fixer.insertTextAfter(node.right, ')'); + } + yield fixer.replaceText(barBarOperator, node.operator.replace('||', '??')); + } + context.report({ + node: barBarOperator, + messageId: 'preferNullishOverOr', + data: { description, equals }, + suggest: [ + { + messageId: 'suggestNullish', + data: { equals }, + fix, + }, + ], + }); + } + function getNullishCoalescingParams(node, nonNullishNode, nodesInsideTestExpression, operator) { + let nullishCoalescingLeftNode; + let hasTruthinessCheck = false; + let hasNullCheckWithoutTruthinessCheck = false; + let hasUndefinedCheckWithoutTruthinessCheck = false; + if (!nodesInsideTestExpression.length) { + hasTruthinessCheck = true; + nullishCoalescingLeftNode = + node.test.type === utils_1.AST_NODE_TYPES.UnaryExpression + ? node.test.argument + : node.test; + if (!areNodesSimilarMemberAccess(nullishCoalescingLeftNode, nonNullishNode)) { + return { isFixable: false }; + } + } + else { + // we check that the test only contains null, undefined and the identifier + for (const testNode of nodesInsideTestExpression) { + if ((0, util_1.isNullLiteral)(testNode)) { + hasNullCheckWithoutTruthinessCheck = true; + } + else if ((0, util_1.isUndefinedIdentifier)(testNode)) { + hasUndefinedCheckWithoutTruthinessCheck = true; + } + else if (areNodesSimilarMemberAccess(testNode, nonNullishNode)) { + // Only consider the first expression in a multi-part nullish check, + // as subsequent expressions might not require all the optional chaining operators. + // For example: a?.b?.c !== undefined && a.b.c !== null ? a.b.c : 'foo'; + // This works because `node.test` is always evaluated first in the loop + // and has the same or more necessary optional chaining operators + // than `node.alternate` or `node.consequent`. + nullishCoalescingLeftNode ??= testNode; + } + else { + return { isFixable: false }; + } + } + } + if (!nullishCoalescingLeftNode) { + return { isFixable: false }; + } + const isFixable = (() => { + if (hasTruthinessCheck) { + return isTruthinessCheckEligibleForPreferNullish({ + node, + testNode: nullishCoalescingLeftNode, + }); + } + // it is fixable if we check for both null and undefined, or not if neither + if (hasUndefinedCheckWithoutTruthinessCheck === + hasNullCheckWithoutTruthinessCheck) { + return hasUndefinedCheckWithoutTruthinessCheck; + } + // it is fixable if we loosely check for either null or undefined + if (['==', '!='].includes(operator)) { + return true; + } + const type = parserServices.getTypeAtLocation(nullishCoalescingLeftNode); + const flags = (0, util_1.getTypeFlags)(type); + if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { + return false; + } + const hasNullType = (flags & ts.TypeFlags.Null) !== 0; + // it is fixable if we check for undefined and the type is not nullable + if (hasUndefinedCheckWithoutTruthinessCheck && !hasNullType) { + return true; + } + const hasUndefinedType = (flags & ts.TypeFlags.Undefined) !== 0; + // it is fixable if we check for null and the type can't be undefined + return hasNullCheckWithoutTruthinessCheck && !hasUndefinedType; + })(); + return isFixable + ? { isFixable: true, nullishCoalescingLeftNode } + : { isFixable: false }; + } + return { + 'AssignmentExpression[operator = "||="]'(node) { + checkAndFixWithPreferNullishOverOr(node, 'assignment', '='); + }, + ConditionalExpression(node) { + if (ignoreTernaryTests) { + return; + } + const { nodesInsideTestExpression, operator } = getOperatorAndNodesInsideTestExpression(node); + if (operator == null) { + return; + } + const { nonNullishBranch, nullishBranch } = getBranchNodes(node, operator); + const nullishCoalescingParams = getNullishCoalescingParams(node, nonNullishBranch, nodesInsideTestExpression, operator); + if (nullishCoalescingParams.isFixable) { + context.report({ + node, + messageId: 'preferNullishOverTernary', + // TODO: also account for = in the ternary clause + data: { equals: '' }, + suggest: [ + { + messageId: 'suggestNullish', + data: { equals: '' }, + fix(fixer) { + const nullishBranchText = (0, util_1.getTextWithParentheses)(context.sourceCode, nullishBranch); + const rightOperandReplacement = (0, util_1.isParenthesized)(nullishBranch, context.sourceCode) + ? nullishBranchText + : (0, getWrappedCode_1.getWrappedCode)(nullishBranchText, (0, util_1.getOperatorPrecedenceForNode)(nullishBranch), util_1.OperatorPrecedence.Coalesce); + return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${rightOperandReplacement}`); + }, + }, + ], + }); + } + }, + IfStatement(node) { + if (ignoreIfStatements || node.alternate != null) { + return; + } + let assignmentExpression; + if (node.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement && + node.consequent.body.length === 1 && + node.consequent.body[0].type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + assignmentExpression = node.consequent.body[0].expression; + } + else if (node.consequent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + assignmentExpression = node.consequent.expression; + } + if (assignmentExpression?.type !== utils_1.AST_NODE_TYPES.AssignmentExpression || + !isMemberAccessLike(assignmentExpression.left)) { + return; + } + const nullishCoalescingLeftNode = assignmentExpression.left; + const nullishCoalescingRightNode = assignmentExpression.right; + const { nodesInsideTestExpression, operator } = getOperatorAndNodesInsideTestExpression(node); + if (operator == null || !['!', '==', '==='].includes(operator)) { + return; + } + const nullishCoalescingParams = getNullishCoalescingParams(node, nullishCoalescingLeftNode, nodesInsideTestExpression, operator); + if (nullishCoalescingParams.isFixable) { + // Handle comments + const isConsequentNodeBlockStatement = node.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement; + const commentsBefore = formatComments(context.sourceCode.getCommentsBefore(assignmentExpression), isConsequentNodeBlockStatement ? '\n' : ' '); + const commentsAfter = isConsequentNodeBlockStatement + ? formatComments(context.sourceCode.getCommentsAfter(assignmentExpression.parent), '\n') + : ''; + context.report({ + node, + messageId: 'preferNullishOverAssignment', + data: { equals: '=' }, + suggest: [ + { + messageId: 'suggestNullish', + data: { equals: '=' }, + fix(fixer) { + const fixes = []; + if (commentsBefore) { + fixes.push(fixer.insertTextBefore(node, commentsBefore)); + } + fixes.push(fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingLeftNode)} ??= ${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingRightNode)};`)); + if (commentsAfter) { + fixes.push(fixer.insertTextAfter(node, ` ${commentsAfter.slice(0, -1)}`)); + } + return fixes; + }, + }, + ], + }); + } + }, + 'LogicalExpression[operator = "||"]'(node) { + checkAndFixWithPreferNullishOverOr(node, 'or', ''); + }, + }; + }, +}); +function isBooleanConstructorContext(node, context) { + const parent = node.parent; + if (parent == null) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + return isBooleanConstructorContext(parent, context); + } + if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + (parent.consequent === node || parent.alternate === node)) { + return isBooleanConstructorContext(parent, context); + } + if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression && + parent.expressions.at(-1) === node) { + return isBooleanConstructorContext(parent, context); + } + return isBuiltInBooleanCall(parent, context); +} +function isBuiltInBooleanCall(node, context) { + if (node.type === utils_1.AST_NODE_TYPES.CallExpression && + node.callee.type === utils_1.AST_NODE_TYPES.Identifier && + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + node.callee.name === 'Boolean' && + node.arguments[0]) { + const scope = context.sourceCode.getScope(node); + const variable = utils_1.ASTUtils.findVariable(scope, node.callee); + return variable == null || variable.defs.length === 0; + } + return false; +} +function isMixedLogicalExpression(node) { + const seen = new Set(); + const queue = [node.parent, node.left, node.right]; + for (const current of queue) { + if (seen.has(current)) { + continue; + } + seen.add(current); + if (current.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + if (current.operator === '&&') { + return true; + } + if (['||', '||='].includes(current.operator)) { + // check the pieces of the node to catch cases like `a || b || c && d` + queue.push(current.parent, current.left, current.right); + } + } + } + return false; +} +/** + * Checks if two TSESTree nodes have the same member access sequence, + * regardless of optional chaining differences. + * + * Note: This does not imply that the nodes are runtime-equivalent. + * + * Example: `a.b.c`, `a?.b.c`, `a.b?.c`, `(a?.b).c`, `(a.b)?.c` are considered similar. + * + * @param a First TSESTree node. + * @param b Second TSESTree node. + * @returns `true` if the nodes access members in the same order; otherwise, `false`. + */ +function areNodesSimilarMemberAccess(a, b) { + if (a.type === utils_1.AST_NODE_TYPES.MemberExpression && + b.type === utils_1.AST_NODE_TYPES.MemberExpression) { + if (!areNodesSimilarMemberAccess(a.object, b.object)) { + return false; + } + if (a.computed === b.computed) { + return (0, util_1.isNodeEqual)(a.property, b.property); + } + if (a.property.type === utils_1.AST_NODE_TYPES.Literal && + b.property.type === utils_1.AST_NODE_TYPES.Identifier) { + return a.property.value === b.property.name; + } + if (a.property.type === utils_1.AST_NODE_TYPES.Identifier && + b.property.type === utils_1.AST_NODE_TYPES.Literal) { + return a.property.name === b.property.value; + } + return false; + } + if (a.type === utils_1.AST_NODE_TYPES.ChainExpression || + b.type === utils_1.AST_NODE_TYPES.ChainExpression) { + return areNodesSimilarMemberAccess((0, util_1.skipChainExpression)(a), (0, util_1.skipChainExpression)(b)); + } + return (0, util_1.isNodeEqual)(a, b); +} +/** + * Returns the branch nodes of a conditional expression: + * - the "nonNullish branch" is the branch when test node is not nullish + * - the "nullish branch" is the branch when test node is nullish + */ +function getBranchNodes(node, operator) { + if (['', '!=', '!=='].includes(operator)) { + return { nonNullishBranch: node.consequent, nullishBranch: node.alternate }; + } + return { nonNullishBranch: node.alternate, nullishBranch: node.consequent }; +} +function getOperatorAndNodesInsideTestExpression(node) { + let operator = null; + let nodesInsideTestExpression = []; + if (isMemberAccessLike(node.test) || + node.test.type === utils_1.AST_NODE_TYPES.UnaryExpression) { + operator = getNonBinaryNodeOperator(node.test); + } + else if (node.test.type === utils_1.AST_NODE_TYPES.BinaryExpression) { + nodesInsideTestExpression = [node.test.left, node.test.right]; + if (node.test.operator === '==' || + node.test.operator === '!=' || + node.test.operator === '===' || + node.test.operator === '!==') { + operator = node.test.operator; + } + } + else if (node.test.type === utils_1.AST_NODE_TYPES.LogicalExpression && + node.test.left.type === utils_1.AST_NODE_TYPES.BinaryExpression && + node.test.right.type === utils_1.AST_NODE_TYPES.BinaryExpression) { + if (isNodeNullishComparison(node.test.left) || + isNodeNullishComparison(node.test.right)) { + return { nodesInsideTestExpression, operator }; + } + nodesInsideTestExpression = [ + node.test.left.left, + node.test.left.right, + node.test.right.left, + node.test.right.right, + ]; + if (['||', '||='].includes(node.test.operator)) { + if (node.test.left.operator === '===' && + node.test.right.operator === '===') { + operator = '==='; + } + else if (((node.test.left.operator === '===' || + node.test.right.operator === '===') && + (node.test.left.operator === '==' || + node.test.right.operator === '==')) || + (node.test.left.operator === '==' && node.test.right.operator === '==')) { + operator = '=='; + } + } + else if (node.test.operator === '&&') { + if (node.test.left.operator === '!==' && + node.test.right.operator === '!==') { + operator = '!=='; + } + else if (((node.test.left.operator === '!==' || + node.test.right.operator === '!==') && + (node.test.left.operator === '!=' || + node.test.right.operator === '!=')) || + (node.test.left.operator === '!=' && node.test.right.operator === '!=')) { + operator = '!='; + } + } + } + return { nodesInsideTestExpression, operator }; +} +function getNonBinaryNodeOperator(node) { + if (node.type !== utils_1.AST_NODE_TYPES.UnaryExpression) { + return ''; + } + if (isMemberAccessLike(node.argument) && node.operator === '!') { + return '!'; + } + return null; +} +function formatComments(comments, separator) { + return comments + .map(({ type, value }) => type === utils_1.AST_TOKEN_TYPES.Line + ? `//${value}${separator}` + : `/*${value}*/${separator}`) + .join(''); +} +//# sourceMappingURL=prefer-nullish-coalescing.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.d.ts new file mode 100644 index 00000000..26bb56f7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.d.ts @@ -0,0 +1,11 @@ +export type PreferOptionalChainMessageIds = 'optionalChainSuggest' | 'preferOptionalChain'; +export interface PreferOptionalChainOptions { + allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean; + checkAny?: boolean; + checkBigInt?: boolean; + checkBoolean?: boolean; + checkNumber?: boolean; + checkString?: boolean; + checkUnknown?: boolean; + requireNullish?: boolean; +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.js new file mode 100644 index 00000000..9dec4475 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=PreferOptionalChainOptions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.d.ts new file mode 100644 index 00000000..5e3a9a4e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.d.ts @@ -0,0 +1,7 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +import type { LastChainOperand, ValidOperand } from './gatherLogicalOperands'; +import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './PreferOptionalChainOptions'; +export declare function analyzeChain(context: RuleContext, parserServices: ParserServicesWithTypeInformation, options: PreferOptionalChainOptions, node: TSESTree.Node, operator: TSESTree.LogicalExpression['operator'], chain: ValidOperand[], lastChainOperand?: LastChainOperand): void; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.js new file mode 100644 index 00000000..25ff7a8e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.js @@ -0,0 +1,615 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.analyzeChain = analyzeChain; +const utils_1 = require("@typescript-eslint/utils"); +const ts_api_utils_1 = require("ts-api-utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../../util"); +const checkNullishAndReport_1 = require("./checkNullishAndReport"); +const compareNodes_1 = require("./compareNodes"); +const gatherLogicalOperands_1 = require("./gatherLogicalOperands"); +function includesType(parserServices, node, typeFlagIn) { + const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown; + const types = (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node)); + for (const type of types) { + if ((0, util_1.isTypeFlagSet)(type, typeFlag)) { + return true; + } + } + return false; +} +function isValidAndLastChainOperand(ComparisonValueType, comparisonType, parserServices) { + const type = parserServices.getTypeAtLocation(ComparisonValueType); + const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown; + const types = (0, ts_api_utils_1.unionConstituents)(type); + switch (comparisonType) { + case gatherLogicalOperands_1.ComparisonType.Equal: { + const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined)); + return !isNullish; + } + case gatherLogicalOperands_1.ComparisonType.StrictEqual: { + const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined)); + return !isUndefined; + } + case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: { + return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined)); + } + case gatherLogicalOperands_1.ComparisonType.NotEqual: { + return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined | ts.TypeFlags.Null)); + } + } +} +function isValidOrLastChainOperand(ComparisonValueType, comparisonType, parserServices) { + const type = parserServices.getTypeAtLocation(ComparisonValueType); + const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown; + const types = (0, ts_api_utils_1.unionConstituents)(type); + switch (comparisonType) { + case gatherLogicalOperands_1.ComparisonType.NotEqual: { + const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined)); + return !isNullish; + } + case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: { + const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined)); + return !isUndefined; + } + case gatherLogicalOperands_1.ComparisonType.Equal: + return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined | ts.TypeFlags.Null)); + case gatherLogicalOperands_1.ComparisonType.StrictEqual: + return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined)); + } +} +const analyzeAndChainOperand = (parserServices, operand, index, chain) => { + switch (operand.comparisonType) { + case gatherLogicalOperands_1.NullishComparisonType.Boolean: + case gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined: + return [operand]; + case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull: { + // handle `x !== null && x !== undefined` + const nextOperand = chain.at(index + 1); + if (nextOperand?.comparisonType === + gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined && + (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) === + compareNodes_1.NodeComparisonResult.Equal) { + return [operand, nextOperand]; + } + if (nextOperand && + !includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) { + // we know the next operand is not an `undefined` check and that this + // operand includes `undefined` - which means that making this an + // optional chain would change the runtime behavior of the expression + return [operand]; + } + return null; + } + case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined: { + // handle `x !== undefined && x !== null` + const nextOperand = chain.at(index + 1); + if (nextOperand?.comparisonType === + gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull && + (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) === + compareNodes_1.NodeComparisonResult.Equal) { + return [operand, nextOperand]; + } + if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Null)) { + // we know the next operand is not a `null` check and that this + // operand includes `null` - which means that making this an + // optional chain would change the runtime behavior of the expression + return null; + } + return [operand]; + } + default: + return null; + } +}; +const analyzeOrChainOperand = (parserServices, operand, index, chain) => { + switch (operand.comparisonType) { + case gatherLogicalOperands_1.NullishComparisonType.NotBoolean: + case gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined: + return [operand]; + case gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull: { + // handle `x === null || x === undefined` + const nextOperand = chain.at(index + 1); + if (nextOperand?.comparisonType === + gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined && + (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) === + compareNodes_1.NodeComparisonResult.Equal) { + return [operand, nextOperand]; + } + if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) { + // we know the next operand is not an `undefined` check and that this + // operand includes `undefined` - which means that making this an + // optional chain would change the runtime behavior of the expression + return null; + } + return [operand]; + } + case gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined: { + // handle `x === undefined || x === null` + const nextOperand = chain.at(index + 1); + if (nextOperand?.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull && + (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) === + compareNodes_1.NodeComparisonResult.Equal) { + return [operand, nextOperand]; + } + if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Null)) { + // we know the next operand is not a `null` check and that this + // operand includes `null` - which means that making this an + // optional chain would change the runtime behavior of the expression + return null; + } + return [operand]; + } + default: + return null; + } +}; +const resolveOperandSubset = (previousOperand, lastChainOperand) => { + const isNameSubset = (0, compareNodes_1.compareNodes)(previousOperand.comparedName, lastChainOperand.comparedName) === compareNodes_1.NodeComparisonResult.Subset; + if (lastChainOperand.yoda !== gatherLogicalOperands_1.Yoda.Unknown) { + return { + comparedName: lastChainOperand.comparedName, + comparisonValue: lastChainOperand.comparisonValue, + isSubset: isNameSubset, + isYoda: lastChainOperand.yoda === gatherLogicalOperands_1.Yoda.Yes, + }; + } + const isValueSubset = (0, compareNodes_1.compareNodes)(previousOperand.comparedName, lastChainOperand.comparisonValue) === compareNodes_1.NodeComparisonResult.Subset; + if (isNameSubset && !isValueSubset) { + return { + comparedName: lastChainOperand.comparedName, + comparisonValue: lastChainOperand.comparisonValue, + isSubset: true, + isYoda: false, + }; + } + if (!isNameSubset && isValueSubset) { + return { + comparedName: lastChainOperand.comparisonValue, + comparisonValue: lastChainOperand.comparedName, + isSubset: true, + isYoda: true, + }; + } + return { + comparedName: lastChainOperand.comparisonValue, + comparisonValue: lastChainOperand.comparisonValue, + isSubset: false, + isYoda: true, + }; +}; +/** + * Returns the range that needs to be reported from the chain. + * @param chain The chain of logical expressions. + * @param boundary The boundary range that the range to report cannot fall outside. + * @param sourceCode The source code to get tokens. + * @returns The range to report. + */ +function getReportRange(chain, boundary, sourceCode) { + const leftNode = chain[0].node; + const rightNode = chain[chain.length - 1].node; + let leftMost = (0, util_1.nullThrows)(sourceCode.getFirstToken(leftNode), util_1.NullThrowsReasons.MissingToken('any token', leftNode.type)); + let rightMost = (0, util_1.nullThrows)(sourceCode.getLastToken(rightNode), util_1.NullThrowsReasons.MissingToken('any token', rightNode.type)); + while (leftMost.range[0] > boundary[0]) { + const token = sourceCode.getTokenBefore(leftMost); + if (!token || !(0, util_1.isOpeningParenToken)(token) || token.range[0] < boundary[0]) { + break; + } + leftMost = token; + } + while (rightMost.range[1] < boundary[1]) { + const token = sourceCode.getTokenAfter(rightMost); + if (!token || !(0, util_1.isClosingParenToken)(token) || token.range[1] > boundary[1]) { + break; + } + rightMost = token; + } + return [leftMost.range[0], rightMost.range[1]]; +} +function getReportDescriptor(sourceCode, parserServices, node, operator, options, subChain, lastChain) { + const chain = lastChain ? [...subChain, lastChain] : subChain; + const lastOperand = chain[chain.length - 1]; + let useSuggestionFixer; + if (options.allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing === + true) { + // user has opted-in to the unsafe behavior + useSuggestionFixer = false; + } + // optional chain specifically will union `undefined` into the final type + // so we need to make sure that there is at least one operand that includes + // `undefined`, or else we're going to change the final type - which is + // unsafe and might cause downstream type errors. + else if (lastChain) { + useSuggestionFixer = true; + } + else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined || + lastOperand.comparisonType === + gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined || + lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined || + lastOperand.comparisonType === + gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined || + (operator === '||' && + lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.NotBoolean)) { + // we know the last operand is an equality check - so the change in types + // DOES NOT matter and will not change the runtime result or cause a type + // check error + useSuggestionFixer = false; + } + else { + useSuggestionFixer = true; + for (const operand of chain) { + if (includesType(parserServices, operand.node, ts.TypeFlags.Undefined)) { + useSuggestionFixer = false; + break; + } + } + // TODO - we could further reduce the false-positive rate of this check by + // checking for cases where the change in types don't matter like + // the test location of an if/while/etc statement. + // but it's quite complex to do this without false-negatives, so + // for now we'll just be over-eager with our matching. + // + // it's MUCH better to false-positive here and only provide a + // suggestion fixer, rather than false-negative and autofix to + // broken code. + } + // In its most naive form we could just slap `?.` for every single part of the + // chain. However this would be undesirable because it'd create unnecessary + // conditions in the user's code where there were none before - and it would + // cause errors with rules like our `no-unnecessary-condition`. + // + // Instead we want to include the minimum number of `?.` required to correctly + // unify the code into a single chain. Naively you might think that we can + // just take the final operand add `?.` after the locations from the previous + // operands - however this won't be correct either because earlier operands + // can include a necessary `?.` that's not needed or included in a later + // operand. + // + // So instead what we need to do is to start at the first operand and + // iteratively diff it against the next operand, and add the difference to the + // first operand. + // + // eg + // `foo && foo.bar && foo.bar.baz?.bam && foo.bar.baz.bam()` + // 1) `foo` + // 2) diff(`foo`, `foo.bar`) = `.bar` + // 3) result = `foo?.bar` + // 4) diff(`foo.bar`, `foo.bar.baz?.bam`) = `.baz?.bam` + // 5) result = `foo?.bar?.baz?.bam` + // 6) diff(`foo.bar.baz?.bam`, `foo.bar.baz.bam()`) = `()` + // 7) result = `foo?.bar?.baz?.bam?.()` + const parts = []; + for (const current of chain) { + const nextOperand = flattenChainExpression(sourceCode, current.comparedName); + const diff = nextOperand.slice(parts.length); + if (diff.length > 0) { + if (parts.length > 0) { + // we need to make the first operand of the diff optional so it matches the + // logic before merging + // foo.bar && foo.bar.baz + // diff = .baz + // result = foo.bar?.baz + diff[0].optional = true; + } + parts.push(...diff); + } + } + let newCode = parts + .map(part => { + let str = ''; + if (part.optional) { + str += '?.'; + } + else { + if (part.nonNull) { + str += '!'; + } + if (part.requiresDot) { + str += '.'; + } + } + if (part.precedence !== util_1.OperatorPrecedence.Invalid && + part.precedence < util_1.OperatorPrecedence.Member) { + str += `(${part.text})`; + } + else { + str += part.text; + } + return str; + }) + .join(''); + if (lastOperand.node.type === utils_1.AST_NODE_TYPES.BinaryExpression) { + // retain the ending comparison for cases like + // x && x.a != null + // x && typeof x.a !== 'undefined' + const operator = lastOperand.node.operator; + const { left, right } = (() => { + if (lastOperand.isYoda) { + const unaryOperator = lastOperand.node.right.type === utils_1.AST_NODE_TYPES.UnaryExpression + ? `${lastOperand.node.right.operator} ` + : ''; + return { + left: sourceCode.getText(lastOperand.node.left), + right: unaryOperator + newCode, + }; + } + const unaryOperator = lastOperand.node.left.type === utils_1.AST_NODE_TYPES.UnaryExpression + ? `${lastOperand.node.left.operator} ` + : ''; + return { + left: unaryOperator + newCode, + right: sourceCode.getText(lastOperand.node.right), + }; + })(); + newCode = `${left} ${operator} ${right}`; + } + else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.NotBoolean) { + newCode = `!${newCode}`; + } + const reportRange = getReportRange(chain, node.range, sourceCode); + const fix = fixer => { + let unclosedParens = 0; + const tokensInRange = sourceCode.getTokens(node, { + filter: token => token.range[0] >= reportRange[0] && token.range[1] <= reportRange[1], + }); + for (const token of tokensInRange) { + if ((0, util_1.isOpeningParenToken)(token)) { + unclosedParens++; + } + else if ((0, util_1.isClosingParenToken)(token)) { + unclosedParens--; + } + } + if (unclosedParens > 0 && reportRange[1] < node.range[1]) { + const openParensOutsideRange = []; + const unmatchedCloseParens = []; + const tokensOutRange = sourceCode.getTokens(node, { + filter: token => token.range[1] > reportRange[1], + }); + for (const token of tokensOutRange) { + if ((0, util_1.isOpeningParenToken)(token)) { + openParensOutsideRange.push(token.range[0]); + } + if ((0, util_1.isClosingParenToken)(token)) { + if (openParensOutsideRange.length > 0) { + openParensOutsideRange.pop(); + } + else { + unmatchedCloseParens.push(token.range[0]); + } + } + } + let leftCode = sourceCode.getText(node); + unmatchedCloseParens.reverse(); + for (const unmatchedParenIndex of unmatchedCloseParens) { + leftCode = + leftCode.slice(0, unmatchedParenIndex) + + leftCode.slice(unmatchedParenIndex + 1); + } + leftCode = leftCode.slice(reportRange[1]); + return fixer.replaceTextRange(node.range, newCode + leftCode); + } + return fixer.replaceTextRange(reportRange, newCode); + }; + return { + loc: { + end: sourceCode.getLocFromIndex(reportRange[1]), + start: sourceCode.getLocFromIndex(reportRange[0]), + }, + messageId: 'preferOptionalChain', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: useSuggestionFixer ? 'suggest' : 'fix', + suggestion: { + fix, + messageId: 'optionalChainSuggest', + }, + }), + }; + function flattenChainExpression(sourceCode, node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.ChainExpression: + return flattenChainExpression(sourceCode, node.expression); + case utils_1.AST_NODE_TYPES.CallExpression: { + const argumentsText = (() => { + const closingParenToken = (0, util_1.nullThrows)(sourceCode.getLastToken(node), util_1.NullThrowsReasons.MissingToken('closing parenthesis', node.type)); + const openingParenToken = (0, util_1.nullThrows)(sourceCode.getFirstTokenBetween(node.typeArguments ?? node.callee, closingParenToken, util_1.isOpeningParenToken), util_1.NullThrowsReasons.MissingToken('opening parenthesis', node.type)); + return sourceCode.text.substring(openingParenToken.range[0], closingParenToken.range[1]); + })(); + const typeArgumentsText = (() => { + if (node.typeArguments == null) { + return ''; + } + return sourceCode.getText(node.typeArguments); + })(); + return [ + ...flattenChainExpression(sourceCode, node.callee), + { + nonNull: false, + optional: node.optional, + // no precedence for this + precedence: util_1.OperatorPrecedence.Invalid, + requiresDot: false, + text: typeArgumentsText + argumentsText, + }, + ]; + } + case utils_1.AST_NODE_TYPES.MemberExpression: { + const propertyText = sourceCode.getText(node.property); + return [ + ...flattenChainExpression(sourceCode, node.object), + { + nonNull: node.object.type === utils_1.AST_NODE_TYPES.TSNonNullExpression, + optional: node.optional, + precedence: node.computed + ? // computed is already wrapped in [] so no need to wrap in () as well + util_1.OperatorPrecedence.Invalid + : (0, util_1.getOperatorPrecedenceForNode)(node.property), + requiresDot: !node.computed, + text: node.computed ? `[${propertyText}]` : propertyText, + }, + ]; + } + case utils_1.AST_NODE_TYPES.TSNonNullExpression: + return flattenChainExpression(sourceCode, node.expression); + default: + return [ + { + nonNull: false, + optional: false, + precedence: (0, util_1.getOperatorPrecedenceForNode)(node), + requiresDot: false, + text: sourceCode.getText(node), + }, + ]; + } + } +} +function analyzeChain(context, parserServices, options, node, operator, chain, lastChainOperand) { + // need at least 2 operands in a chain for it to be a chain + if (chain.length + (lastChainOperand ? 1 : 0) <= 1 || + /* istanbul ignore next -- previous checks make this unreachable, but keep it for exhaustiveness check */ + operator === '??') { + return; + } + const analyzeOperand = (() => { + switch (operator) { + case '&&': + return analyzeAndChainOperand; + case '||': + return analyzeOrChainOperand; + } + })(); + // Things like x !== null && x !== undefined have two nodes, but they are + // one logical unit here, so we'll allow them to be grouped. + let subChain = []; + let lastChain = undefined; + const maybeReportThenReset = (newChainSeed) => { + if (subChain.length + (lastChain ? 1 : 0) > 1) { + const subChainFlat = subChain.flat(); + const maybeNullishNodes = lastChain + ? subChainFlat.map(({ node }) => node) + : subChainFlat.slice(0, -1).map(({ node }) => node); + (0, checkNullishAndReport_1.checkNullishAndReport)(context, parserServices, options, maybeNullishNodes, getReportDescriptor(context.sourceCode, parserServices, node, operator, options, subChainFlat, lastChain)); + } + // we've reached the end of a chain of logical expressions + // i.e. the current operand doesn't belong to the previous chain. + // + // we don't want to throw away the current operand otherwise we will skip it + // and that can cause us to miss chains. So instead we seed the new chain + // with the current operand + // + // eg this means we can catch cases like: + // unrelated != null && foo != null && foo.bar != null; + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ first "chain" + // ^^^^^^^^^^^ newChainSeed + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ second chain + subChain = newChainSeed ? [newChainSeed] : []; + lastChain = undefined; + }; + for (let i = 0; i < chain.length; i += 1) { + const lastOperand = subChain.flat().at(-1); + const operand = chain[i]; + const validatedOperands = analyzeOperand(parserServices, operand, i, chain); + if (!validatedOperands) { + // TODO - #7170 + // check if the name is a superset/equal - if it is, then it likely + // intended to be part of the chain and something we should include in the + // report, eg + // foo == null || foo.bar; + // ^^^^^^^^^^^ valid OR chain + // ^^^^^^^ invalid OR chain logical, but still part of + // the chain for combination purposes + if (lastOperand) { + const comparisonResult = (0, compareNodes_1.compareNodes)(lastOperand.comparedName, operand.comparedName); + switch (operand.comparisonType) { + case gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined: + case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined: { + if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset) { + lastChain = operand; + } + break; + } + } + } + maybeReportThenReset(); + continue; + } + // in case multiple operands were consumed - make sure to correctly increment the index + i += validatedOperands.length - 1; + const currentOperand = validatedOperands[0]; + if (lastOperand) { + const comparisonResult = (0, compareNodes_1.compareNodes)(lastOperand.comparedName, + // purposely inspect and push the last operand because the prior operands don't matter + // this also means we won't false-positive in cases like + // foo !== null && foo !== undefined + validatedOperands[validatedOperands.length - 1].comparedName); + if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset) { + // the operands are comparable, so we can continue searching + subChain.push(currentOperand); + } + else if (comparisonResult === compareNodes_1.NodeComparisonResult.Invalid) { + maybeReportThenReset(validatedOperands); + } + else { + // purposely don't push this case because the node is a no-op and if + // we consider it then we might report on things like + // foo && foo + } + } + else { + subChain.push(currentOperand); + } + } + const lastOperand = subChain.flat().at(-1); + if (lastOperand && lastChainOperand) { + const isValidLastChainOperand = operator === '&&' + ? isValidAndLastChainOperand + : isValidOrLastChainOperand; + const { comparedName, comparisonValue, isSubset, isYoda } = resolveOperandSubset(lastOperand, lastChainOperand); + if (isSubset && + isValidLastChainOperand(comparisonValue, lastChainOperand.comparisonType, parserServices)) { + lastChain = { + ...lastChainOperand, + comparedName, + comparisonValue, + isYoda, + }; + } + } + // check the leftovers + maybeReportThenReset(); +} +//# sourceMappingURL=analyzeChain.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.d.ts new file mode 100644 index 00000000..19284f7c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.d.ts @@ -0,0 +1,6 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import type { ReportDescriptor, RuleContext } from '@typescript-eslint/utils/ts-eslint'; +import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './PreferOptionalChainOptions'; +export declare function checkNullishAndReport(context: RuleContext, parserServices: ParserServicesWithTypeInformation, { requireNullish }: PreferOptionalChainOptions, maybeNullishNodes: TSESTree.Expression[], descriptor: ReportDescriptor): void; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js new file mode 100644 index 00000000..cf7e47d9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js @@ -0,0 +1,46 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkNullishAndReport = checkNullishAndReport; +const type_utils_1 = require("@typescript-eslint/type-utils"); +const ts_api_utils_1 = require("ts-api-utils"); +const ts = __importStar(require("typescript")); +function checkNullishAndReport(context, parserServices, { requireNullish }, maybeNullishNodes, descriptor) { + if (!requireNullish || + maybeNullishNodes.some(node => (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) { + context.report(descriptor); + } +} +//# sourceMappingURL=checkNullishAndReport.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.d.ts new file mode 100644 index 00000000..40daa838 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.d.ts @@ -0,0 +1,15 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare const enum NodeComparisonResult { + /** the two nodes are comparably the same */ + Equal = "Equal", + /** the left node is a subset of the right node */ + Subset = "Subset", + /** the left node is not the same or is a superset of the right node */ + Invalid = "Invalid" +} +type CompareNodesArgument = TSESTree.Node | null | undefined; +/** + * Compares two nodes' ASTs to determine if the A is equal to or a subset of B + */ +export declare function compareNodes(nodeA: CompareNodesArgument, nodeB: CompareNodesArgument): NodeComparisonResult; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.js new file mode 100644 index 00000000..b056f795 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/compareNodes.js @@ -0,0 +1,327 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NodeComparisonResult = void 0; +exports.compareNodes = compareNodes; +const utils_1 = require("@typescript-eslint/utils"); +const visitor_keys_1 = require("@typescript-eslint/visitor-keys"); +var NodeComparisonResult; +(function (NodeComparisonResult) { + /** the two nodes are comparably the same */ + NodeComparisonResult["Equal"] = "Equal"; + /** the left node is a subset of the right node */ + NodeComparisonResult["Subset"] = "Subset"; + /** the left node is not the same or is a superset of the right node */ + NodeComparisonResult["Invalid"] = "Invalid"; +})(NodeComparisonResult || (exports.NodeComparisonResult = NodeComparisonResult = {})); +function compareArrays(arrayA, arrayB) { + if (arrayA.length !== arrayB.length) { + return NodeComparisonResult.Invalid; + } + const result = arrayA.every((elA, idx) => { + const elB = arrayB[idx]; + if (elA == null || elB == null) { + return elA === elB; + } + return compareUnknownValues(elA, elB) === NodeComparisonResult.Equal; + }); + if (result) { + return NodeComparisonResult.Equal; + } + return NodeComparisonResult.Invalid; +} +function isValidNode(x) { + return (typeof x === 'object' && + x != null && + 'type' in x && + typeof x.type === 'string'); +} +function isValidChainExpressionToLookThrough(node) { + return (!(node.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.parent.object === node) && + !(node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression && + node.parent.callee === node) && + node.type === utils_1.AST_NODE_TYPES.ChainExpression); +} +function compareUnknownValues(valueA, valueB) { + /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */ + if (valueA == null || valueB == null) { + if (valueA !== valueB) { + return NodeComparisonResult.Invalid; + } + return NodeComparisonResult.Equal; + } + /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */ + if (!isValidNode(valueA) || !isValidNode(valueB)) { + return NodeComparisonResult.Invalid; + } + return compareNodes(valueA, valueB); +} +function compareByVisiting(nodeA, nodeB) { + const currentVisitorKeys = visitor_keys_1.visitorKeys[nodeA.type]; + /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */ + if (currentVisitorKeys == null) { + // we don't know how to visit this node, so assume it's invalid to avoid false-positives / broken fixers + return NodeComparisonResult.Invalid; + } + if (currentVisitorKeys.length === 0) { + // assume nodes with no keys are constant things like keywords + return NodeComparisonResult.Equal; + } + for (const key of currentVisitorKeys) { + // @ts-expect-error - dynamic access but it's safe + const nodeAChildOrChildren = nodeA[key]; + // @ts-expect-error - dynamic access but it's safe + const nodeBChildOrChildren = nodeB[key]; + if (Array.isArray(nodeAChildOrChildren)) { + const arrayA = nodeAChildOrChildren; + const arrayB = nodeBChildOrChildren; + const result = compareArrays(arrayA, arrayB); + if (result !== NodeComparisonResult.Equal) { + return NodeComparisonResult.Invalid; + } + // fallthrough to the next key as the key was "equal" + } + else { + const result = compareUnknownValues(nodeAChildOrChildren, nodeBChildOrChildren); + if (result !== NodeComparisonResult.Equal) { + return NodeComparisonResult.Invalid; + } + // fallthrough to the next key as the key was "equal" + } + } + return NodeComparisonResult.Equal; +} +function compareNodesUncached(nodeA, nodeB) { + if (nodeA.type !== nodeB.type) { + // special cases where nodes are allowed to be non-equal + // look through a chain expression node at the top-level because it only + // exists to delimit the end of an optional chain + // + // a?.b && a.b.c + // ^^^^ ChainExpression, MemberExpression + // ^^^^^ MemberExpression + // + // except for in this class of cases + // (a?.b).c && a.b.c + // because the parentheses have runtime meaning (sad face) + if (isValidChainExpressionToLookThrough(nodeA)) { + return compareNodes(nodeA.expression, nodeB); + } + if (isValidChainExpressionToLookThrough(nodeB)) { + return compareNodes(nodeA, nodeB.expression); + } + // look through the type-only non-null assertion because its existence could + // possibly be replaced by an optional chain instead + // + // a.b! && a.b.c + // ^^^^ TSNonNullExpression + if (nodeA.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) { + return compareNodes(nodeA.expression, nodeB); + } + if (nodeB.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) { + return compareNodes(nodeA, nodeB.expression); + } + // special case for subset optional chains where the node types don't match, + // but we want to try comparing by discarding the "extra" code + // + // a && a.b + // ^ compare this + // a && a() + // ^ compare this + // a.b && a.b() + // ^^^ compare this + // a() && a().b + // ^^^ compare this + // import.meta && import.meta.b + // ^^^^^^^^^^^ compare this + if (nodeA.type === utils_1.AST_NODE_TYPES.CallExpression || + nodeA.type === utils_1.AST_NODE_TYPES.Identifier || + nodeA.type === utils_1.AST_NODE_TYPES.MemberExpression || + nodeA.type === utils_1.AST_NODE_TYPES.MetaProperty) { + switch (nodeB.type) { + case utils_1.AST_NODE_TYPES.MemberExpression: + if (nodeB.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + // Private identifiers in optional chaining is not currently allowed + // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734) + return NodeComparisonResult.Invalid; + } + if (compareNodes(nodeA, nodeB.object) !== NodeComparisonResult.Invalid) { + return NodeComparisonResult.Subset; + } + return NodeComparisonResult.Invalid; + case utils_1.AST_NODE_TYPES.CallExpression: + if (compareNodes(nodeA, nodeB.callee) !== NodeComparisonResult.Invalid) { + return NodeComparisonResult.Subset; + } + return NodeComparisonResult.Invalid; + default: + return NodeComparisonResult.Invalid; + } + } + return NodeComparisonResult.Invalid; + } + switch (nodeA.type) { + // these expressions create a new instance each time - so it makes no sense to compare the chain + case utils_1.AST_NODE_TYPES.ArrayExpression: + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.ClassExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.JSXElement: + case utils_1.AST_NODE_TYPES.JSXFragment: + case utils_1.AST_NODE_TYPES.NewExpression: + case utils_1.AST_NODE_TYPES.ObjectExpression: + return NodeComparisonResult.Invalid; + // chaining from assignments could change the value irrevocably - so it makes no sense to compare the chain + case utils_1.AST_NODE_TYPES.AssignmentExpression: + return NodeComparisonResult.Invalid; + case utils_1.AST_NODE_TYPES.CallExpression: { + const nodeBCall = nodeB; + // check for cases like + // foo() && foo()(bar) + // ^^^^^ nodeA + // ^^^^^^^^^^ nodeB + // we don't want to check the arguments in this case + const aSubsetOfB = compareNodes(nodeA, nodeBCall.callee); + if (aSubsetOfB !== NodeComparisonResult.Invalid) { + return NodeComparisonResult.Subset; + } + const calleeCompare = compareNodes(nodeA.callee, nodeBCall.callee); + if (calleeCompare !== NodeComparisonResult.Equal) { + return NodeComparisonResult.Invalid; + } + // NOTE - we purposely ignore optional flag because for our purposes + // foo?.bar() && foo.bar?.()?.baz + // or + // foo.bar() && foo?.bar?.()?.baz + // are going to be exactly the same + const argumentCompare = compareArrays(nodeA.arguments, nodeBCall.arguments); + if (argumentCompare !== NodeComparisonResult.Equal) { + return NodeComparisonResult.Invalid; + } + const typeParamCompare = compareNodes(nodeA.typeArguments, nodeBCall.typeArguments); + if (typeParamCompare === NodeComparisonResult.Equal) { + return NodeComparisonResult.Equal; + } + return NodeComparisonResult.Invalid; + } + case utils_1.AST_NODE_TYPES.ChainExpression: + // special case handling for ChainExpression because it's allowed to be a subset + return compareNodes(nodeA, nodeB.expression); + case utils_1.AST_NODE_TYPES.Identifier: + case utils_1.AST_NODE_TYPES.PrivateIdentifier: + if (nodeA.name === nodeB.name) { + return NodeComparisonResult.Equal; + } + return NodeComparisonResult.Invalid; + case utils_1.AST_NODE_TYPES.Literal: { + const nodeBLiteral = nodeB; + if (nodeA.raw === nodeBLiteral.raw && + nodeA.value === nodeBLiteral.value) { + return NodeComparisonResult.Equal; + } + return NodeComparisonResult.Invalid; + } + case utils_1.AST_NODE_TYPES.MemberExpression: { + const nodeBMember = nodeB; + if (nodeBMember.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + // Private identifiers in optional chaining is not currently allowed + // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734) + return NodeComparisonResult.Invalid; + } + // check for cases like + // foo.bar && foo.bar.baz + // ^^^^^^^ nodeA + // ^^^^^^^^^^^ nodeB + // result === Equal + // + // foo.bar && foo.bar.baz.bam + // ^^^^^^^ nodeA + // ^^^^^^^^^^^^^^^ nodeB + // result === Subset + // + // we don't want to check the property in this case + const aSubsetOfB = compareNodes(nodeA, nodeBMember.object); + if (aSubsetOfB !== NodeComparisonResult.Invalid) { + return NodeComparisonResult.Subset; + } + if (nodeA.computed !== nodeBMember.computed) { + return NodeComparisonResult.Invalid; + } + // NOTE - we purposely ignore optional flag because for our purposes + // foo?.bar && foo.bar?.baz + // or + // foo.bar && foo?.bar?.baz + // are going to be exactly the same + const objectCompare = compareNodes(nodeA.object, nodeBMember.object); + if (objectCompare !== NodeComparisonResult.Equal) { + return NodeComparisonResult.Invalid; + } + return compareNodes(nodeA.property, nodeBMember.property); + } + case utils_1.AST_NODE_TYPES.TSTemplateLiteralType: + case utils_1.AST_NODE_TYPES.TemplateLiteral: { + const nodeBTemplate = nodeB; + const areQuasisEqual = nodeA.quasis.length === nodeBTemplate.quasis.length && + nodeA.quasis.every((elA, idx) => { + const elB = nodeBTemplate.quasis[idx]; + return elA.value.cooked === elB.value.cooked; + }); + if (!areQuasisEqual) { + return NodeComparisonResult.Invalid; + } + return NodeComparisonResult.Equal; + } + case utils_1.AST_NODE_TYPES.TemplateElement: { + const nodeBElement = nodeB; + if (nodeA.value.cooked === nodeBElement.value.cooked) { + return NodeComparisonResult.Equal; + } + return NodeComparisonResult.Invalid; + } + // these aren't actually valid expressions. + // https://github.com/typescript-eslint/typescript-eslint/blob/20d7caee35ab84ae6381fdf04338c9e2b9e2bc48/packages/ast-spec/src/unions/Expression.ts#L37-L43 + case utils_1.AST_NODE_TYPES.ArrayPattern: + case utils_1.AST_NODE_TYPES.ObjectPattern: + /* istanbul ignore next */ + return NodeComparisonResult.Invalid; + // update expression returns a number and also changes the value each time - so it makes no sense to compare the chain + case utils_1.AST_NODE_TYPES.UpdateExpression: + return NodeComparisonResult.Invalid; + // yield returns the value passed to the `next` function, so it may not be the same each time - so it makes no sense to compare the chain + case utils_1.AST_NODE_TYPES.YieldExpression: + return NodeComparisonResult.Invalid; + // general-case automatic handling of nodes to save us implementing every + // single case by hand. This just iterates the visitor keys to recursively + // check the children. + // + // Any specific logic cases or short-circuits should be listed as separate + // cases so that they don't fall into this generic handling + default: + return compareByVisiting(nodeA, nodeB); + } +} +const COMPARE_NODES_CACHE = new WeakMap(); +/** + * Compares two nodes' ASTs to determine if the A is equal to or a subset of B + */ +function compareNodes(nodeA, nodeB) { + if (nodeA == null || nodeB == null) { + if (nodeA !== nodeB) { + return NodeComparisonResult.Invalid; + } + return NodeComparisonResult.Equal; + } + const cached = COMPARE_NODES_CACHE.get(nodeA)?.get(nodeB); + if (cached) { + return cached; + } + const result = compareNodesUncached(nodeA, nodeB); + let mapA = COMPARE_NODES_CACHE.get(nodeA); + if (mapA == null) { + mapA = new WeakMap(); + COMPARE_NODES_CACHE.set(nodeA, mapA); + } + mapA.set(nodeB, result); + return result; +} +//# sourceMappingURL=compareNodes.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts new file mode 100644 index 00000000..eb28991f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts @@ -0,0 +1,61 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import type { SourceCode } from '@typescript-eslint/utils/ts-eslint'; +import type { PreferOptionalChainOptions } from './PreferOptionalChainOptions'; +export declare const enum Yoda { + Yes = 0, + No = 1, + Unknown = 2 +} +export declare const enum OperandValidity { + Valid = "Valid", + Last = "Last", + Invalid = "Invalid" +} +export declare const enum NullishComparisonType { + /** `x != null`, `x != undefined` */ + NotEqualNullOrUndefined = "NotEqualNullOrUndefined", + /** `x == null`, `x == undefined` */ + EqualNullOrUndefined = "EqualNullOrUndefined", + /** `x !== null` */ + NotStrictEqualNull = "NotStrictEqualNull", + /** `x === null` */ + StrictEqualNull = "StrictEqualNull", + /** `x !== undefined`, `typeof x !== 'undefined'` */ + NotStrictEqualUndefined = "NotStrictEqualUndefined", + /** `x === undefined`, `typeof x === 'undefined'` */ + StrictEqualUndefined = "StrictEqualUndefined", + /** `!x` */ + NotBoolean = "NotBoolean", + /** `x` */ + Boolean = "Boolean" +} +export declare const enum ComparisonType { + NotEqual = "NotEqual", + Equal = "Equal", + NotStrictEqual = "NotStrictEqual", + StrictEqual = "StrictEqual" +} +export interface ValidOperand { + comparedName: TSESTree.Node; + comparisonType: NullishComparisonType; + isYoda: boolean; + node: TSESTree.Expression; + type: OperandValidity.Valid; +} +export interface LastChainOperand { + comparedName: TSESTree.Node; + comparisonType: ComparisonType; + comparisonValue: TSESTree.Node; + yoda: Yoda; + node: TSESTree.BinaryExpression; + type: OperandValidity.Last; +} +export interface InvalidOperand { + type: OperandValidity.Invalid; +} +type Operand = InvalidOperand | LastChainOperand | ValidOperand; +export declare function gatherLogicalOperands(node: TSESTree.LogicalExpression, parserServices: ParserServicesWithTypeInformation, sourceCode: Readonly, options: PreferOptionalChainOptions): { + newlySeenLogicals: Set; + operands: Operand[]; +}; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js new file mode 100644 index 00000000..6f164c8f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js @@ -0,0 +1,412 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ComparisonType = exports.NullishComparisonType = exports.OperandValidity = exports.Yoda = void 0; +exports.gatherLogicalOperands = gatherLogicalOperands; +const utils_1 = require("@typescript-eslint/utils"); +const ts_api_utils_1 = require("ts-api-utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../../util"); +var Yoda; +(function (Yoda) { + Yoda[Yoda["Yes"] = 0] = "Yes"; + Yoda[Yoda["No"] = 1] = "No"; + Yoda[Yoda["Unknown"] = 2] = "Unknown"; +})(Yoda || (exports.Yoda = Yoda = {})); +var ComparisonValueType; +(function (ComparisonValueType) { + ComparisonValueType["Null"] = "Null"; + ComparisonValueType["Undefined"] = "Undefined"; + ComparisonValueType["UndefinedStringLiteral"] = "UndefinedStringLiteral"; +})(ComparisonValueType || (ComparisonValueType = {})); +var OperandValidity; +(function (OperandValidity) { + OperandValidity["Valid"] = "Valid"; + OperandValidity["Last"] = "Last"; + OperandValidity["Invalid"] = "Invalid"; +})(OperandValidity || (exports.OperandValidity = OperandValidity = {})); +var NullishComparisonType; +(function (NullishComparisonType) { + /** `x != null`, `x != undefined` */ + NullishComparisonType["NotEqualNullOrUndefined"] = "NotEqualNullOrUndefined"; + /** `x == null`, `x == undefined` */ + NullishComparisonType["EqualNullOrUndefined"] = "EqualNullOrUndefined"; + /** `x !== null` */ + NullishComparisonType["NotStrictEqualNull"] = "NotStrictEqualNull"; + /** `x === null` */ + NullishComparisonType["StrictEqualNull"] = "StrictEqualNull"; + /** `x !== undefined`, `typeof x !== 'undefined'` */ + NullishComparisonType["NotStrictEqualUndefined"] = "NotStrictEqualUndefined"; + /** `x === undefined`, `typeof x === 'undefined'` */ + NullishComparisonType["StrictEqualUndefined"] = "StrictEqualUndefined"; + /** `!x` */ + NullishComparisonType["NotBoolean"] = "NotBoolean"; + /** `x` */ + NullishComparisonType["Boolean"] = "Boolean"; +})(NullishComparisonType || (exports.NullishComparisonType = NullishComparisonType = {})); +var ComparisonType; +(function (ComparisonType) { + ComparisonType["NotEqual"] = "NotEqual"; + ComparisonType["Equal"] = "Equal"; + ComparisonType["NotStrictEqual"] = "NotStrictEqual"; + ComparisonType["StrictEqual"] = "StrictEqual"; +})(ComparisonType || (exports.ComparisonType = ComparisonType = {})); +const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined; +function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) { + const type = parserServices.getTypeAtLocation(node); + const types = (0, ts_api_utils_1.unionConstituents)(type); + const primitiveAndObjectParts = types.flatMap(type => (0, ts_api_utils_1.intersectionConstituents)(type)); + if (disallowFalseyLiteral && + /* + ``` + declare const x: false | {a: string}; + x && x.a; + !x || x.a; + ``` + + We don't want to consider these two cases because the boolean expression + narrows out the non-nullish falsy cases - so converting the chain to `x?.a` + would introduce a build error + */ (primitiveAndObjectParts.some(t => (0, ts_api_utils_1.isBooleanLiteralType)(t) && t.intrinsicName === 'false') || + primitiveAndObjectParts.some(t => (0, ts_api_utils_1.isStringLiteralType)(t) && t.value === '') || + primitiveAndObjectParts.some(t => (0, ts_api_utils_1.isNumberLiteralType)(t) && t.value === 0) || + primitiveAndObjectParts.some(t => (0, ts_api_utils_1.isBigIntLiteralType)(t) && t.value.base10Value === '0'))) { + return false; + } + let allowedFlags = NULLISH_FLAGS | ts.TypeFlags.Object; + if (options.checkAny === true) { + allowedFlags |= ts.TypeFlags.Any; + } + if (options.checkUnknown === true) { + allowedFlags |= ts.TypeFlags.Unknown; + } + if (options.checkString === true) { + allowedFlags |= ts.TypeFlags.StringLike; + } + if (options.checkNumber === true) { + allowedFlags |= ts.TypeFlags.NumberLike; + } + if (options.checkBoolean === true) { + allowedFlags |= ts.TypeFlags.BooleanLike; + } + if (options.checkBigInt === true) { + allowedFlags |= ts.TypeFlags.BigIntLike; + } + return primitiveAndObjectParts.every(t => (0, util_1.isTypeFlagSet)(t, allowedFlags)); +} +function gatherLogicalOperands(node, parserServices, sourceCode, options) { + const result = []; + const { newlySeenLogicals, operands } = flattenLogicalOperands(node); + for (const operand of operands) { + const areMoreOperands = operand !== operands.at(-1); + switch (operand.type) { + case utils_1.AST_NODE_TYPES.BinaryExpression: { + // check for "yoda" style logical: null != x + const { comparedExpression, comparedValue, isYoda } = (() => { + // non-yoda checks are by far the most common, so check for them first + const comparedValueRight = getComparisonValueType(operand.right); + if (comparedValueRight) { + return { + comparedExpression: operand.left, + comparedValue: comparedValueRight, + isYoda: false, + }; + } + return { + comparedExpression: operand.right, + comparedValue: getComparisonValueType(operand.left), + isYoda: true, + }; + })(); + if (comparedValue === ComparisonValueType.UndefinedStringLiteral) { + if (comparedExpression.type === utils_1.AST_NODE_TYPES.UnaryExpression && + comparedExpression.operator === 'typeof') { + const argument = comparedExpression.argument; + if (argument.type === utils_1.AST_NODE_TYPES.Identifier && + // typeof window === 'undefined' + (0, util_1.isReferenceToGlobalFunction)(argument.name, argument, sourceCode)) { + result.push({ type: OperandValidity.Invalid }); + continue; + } + // typeof x.y === 'undefined' + result.push({ + comparedName: comparedExpression.argument, + comparisonType: operand.operator.startsWith('!') + ? NullishComparisonType.NotStrictEqualUndefined + : NullishComparisonType.StrictEqualUndefined, + isYoda, + node: operand, + type: OperandValidity.Valid, + }); + continue; + } + // y === 'undefined' + result.push({ type: OperandValidity.Invalid }); + continue; + } + if (operand.operator.startsWith('!') !== (node.operator === '||')) { + switch (operand.operator) { + case '!=': + case '==': + if (comparedValue === ComparisonValueType.Null || + comparedValue === ComparisonValueType.Undefined) { + // x == null, x == undefined + result.push({ + comparedName: comparedExpression, + comparisonType: operand.operator.startsWith('!') + ? NullishComparisonType.NotEqualNullOrUndefined + : NullishComparisonType.EqualNullOrUndefined, + isYoda, + node: operand, + type: OperandValidity.Valid, + }); + continue; + } + break; + case '!==': + case '===': { + const comparedName = comparedExpression; + switch (comparedValue) { + case ComparisonValueType.Null: + result.push({ + comparedName, + comparisonType: operand.operator.startsWith('!') + ? NullishComparisonType.NotStrictEqualNull + : NullishComparisonType.StrictEqualNull, + isYoda, + node: operand, + type: OperandValidity.Valid, + }); + continue; + case ComparisonValueType.Undefined: + result.push({ + comparedName, + comparisonType: operand.operator.startsWith('!') + ? NullishComparisonType.NotStrictEqualUndefined + : NullishComparisonType.StrictEqualUndefined, + isYoda, + node: operand, + type: OperandValidity.Valid, + }); + continue; + } + } + } + } + // x == something :( + // x === something :( + // x != something :( + // x !== something :( + const binaryComparisonChain = getBinaryComparisonChain(operand); + if (binaryComparisonChain) { + const { comparedName, comparedValue, yoda } = binaryComparisonChain; + switch (operand.operator) { + case '==': + case '===': { + const comparisonType = operand.operator === '==' + ? ComparisonType.Equal + : ComparisonType.StrictEqual; + result.push({ + comparedName, + comparisonType, + comparisonValue: comparedValue, + node: operand, + type: OperandValidity.Last, + yoda, + }); + continue; + } + case '!=': + case '!==': { + const comparisonType = operand.operator === '!=' + ? ComparisonType.NotEqual + : ComparisonType.NotStrictEqual; + result.push({ + comparedName, + comparisonType, + comparisonValue: comparedValue, + node: operand, + type: OperandValidity.Last, + yoda, + }); + continue; + } + } + } + result.push({ type: OperandValidity.Invalid }); + continue; + } + case utils_1.AST_NODE_TYPES.UnaryExpression: + if (operand.operator === '!' && + (!areMoreOperands || + isValidFalseBooleanCheckType(operand.argument, node.operator === '||', parserServices, options))) { + result.push({ + comparedName: operand.argument, + comparisonType: NullishComparisonType.NotBoolean, + isYoda: false, + node: operand, + type: OperandValidity.Valid, + }); + continue; + } + result.push({ type: OperandValidity.Invalid }); + continue; + case utils_1.AST_NODE_TYPES.LogicalExpression: + // explicitly ignore the mixed logical expression cases + result.push({ type: OperandValidity.Invalid }); + continue; + default: + if (!areMoreOperands || + isValidFalseBooleanCheckType(operand, node.operator === '&&', parserServices, options)) { + result.push({ + comparedName: operand, + comparisonType: NullishComparisonType.Boolean, + isYoda: false, + node: operand, + type: OperandValidity.Valid, + }); + } + else { + result.push({ type: OperandValidity.Invalid }); + } + continue; + } + } + return { + newlySeenLogicals, + operands: result, + }; + /* + The AST is always constructed such the first element is always the deepest element. + I.e. for this code: `foo && foo.bar && foo.bar.baz && foo.bar.baz.buzz` + The AST will look like this: + { + left: { + left: { + left: foo + right: foo.bar + } + right: foo.bar.baz + } + right: foo.bar.baz.buzz + } + + So given any logical expression, we can perform a depth-first traversal to get + the operands in order. + + Note that this function purposely does not inspect mixed logical expressions + like `foo || foo.bar && foo.bar.baz` - separate selector + */ + function flattenLogicalOperands(node) { + const operands = []; + const newlySeenLogicals = new Set([node]); + const stack = [node.right, node.left]; + let current; + while ((current = stack.pop())) { + if (current.type === utils_1.AST_NODE_TYPES.LogicalExpression && + current.operator === node.operator) { + newlySeenLogicals.add(current); + stack.push(current.right); + stack.push(current.left); + } + else { + operands.push(current); + } + } + return { + newlySeenLogicals, + operands, + }; + } + function getComparisonValueType(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.Literal: + // eslint-disable-next-line eqeqeq, @typescript-eslint/internal/eqeq-nullish -- intentional exact comparison against null + if (node.value === null && node.raw === 'null') { + return ComparisonValueType.Null; + } + if (node.value === 'undefined') { + return ComparisonValueType.UndefinedStringLiteral; + } + return null; + case utils_1.AST_NODE_TYPES.Identifier: + if (node.name === 'undefined') { + return ComparisonValueType.Undefined; + } + return null; + } + return null; + } + function isMemberBasedExpression(node) { + if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) { + return true; + } + if (node.type === utils_1.AST_NODE_TYPES.CallExpression && + node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) { + return true; + } + return false; + } + function getBinaryComparisonChain(node) { + const { left, right } = node; + const isLeftMemberExpression = isMemberBasedExpression(left); + const isRightMemberExpression = isMemberBasedExpression(right); + if (isLeftMemberExpression && !isRightMemberExpression) { + const [comparedName, comparedValue] = [left, right]; + return { + comparedName, + comparedValue, + yoda: Yoda.No, + }; + } + if (!isLeftMemberExpression && isRightMemberExpression) { + const [comparedName, comparedValue] = [right, left]; + return { + comparedName, + comparedValue, + yoda: Yoda.Yes, + }; + } + if (isLeftMemberExpression && isRightMemberExpression) { + return { + comparedName: left, + comparedValue: right, + yoda: Yoda.Unknown, + }; + } + return null; + } +} +//# sourceMappingURL=gatherLogicalOperands.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.d.ts new file mode 100644 index 00000000..c2ef7f04 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.d.ts @@ -0,0 +1,5 @@ +import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './prefer-optional-chain-utils/PreferOptionalChainOptions'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.js new file mode 100644 index 00000000..e11c26df --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain.js @@ -0,0 +1,151 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const analyzeChain_1 = require("./prefer-optional-chain-utils/analyzeChain"); +const checkNullishAndReport_1 = require("./prefer-optional-chain-utils/checkNullishAndReport"); +const gatherLogicalOperands_1 = require("./prefer-optional-chain-utils/gatherLogicalOperands"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-optional-chain', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: 'code', + hasSuggestions: true, + messages: { + optionalChainSuggest: 'Change to an optional chain.', + preferOptionalChain: "Prefer using an optional chain expression instead, as it's more concise and easier to read.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: { + type: 'boolean', + description: 'Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.', + }, + checkAny: { + type: 'boolean', + description: 'Check operands that are typed as `any` when inspecting "loose boolean" operands.', + }, + checkBigInt: { + type: 'boolean', + description: 'Check operands that are typed as `bigint` when inspecting "loose boolean" operands.', + }, + checkBoolean: { + type: 'boolean', + description: 'Check operands that are typed as `boolean` when inspecting "loose boolean" operands.', + }, + checkNumber: { + type: 'boolean', + description: 'Check operands that are typed as `number` when inspecting "loose boolean" operands.', + }, + checkString: { + type: 'boolean', + description: 'Check operands that are typed as `string` when inspecting "loose boolean" operands.', + }, + checkUnknown: { + type: 'boolean', + description: 'Check operands that are typed as `unknown` when inspecting "loose boolean" operands.', + }, + requireNullish: { + type: 'boolean', + description: 'Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing: false, + checkAny: true, + checkBigInt: true, + checkBoolean: true, + checkNumber: true, + checkString: true, + checkUnknown: true, + requireNullish: false, + }, + ], + create(context, [options]) { + const parserServices = (0, util_1.getParserServices)(context); + const seenLogicals = new Set(); + return { + 'LogicalExpression[operator!="??"]'(node) { + if (seenLogicals.has(node)) { + return; + } + const { newlySeenLogicals, operands } = (0, gatherLogicalOperands_1.gatherLogicalOperands)(node, parserServices, context.sourceCode, options); + for (const logical of newlySeenLogicals) { + seenLogicals.add(logical); + } + let currentChain = []; + for (const operand of operands) { + if (operand.type === gatherLogicalOperands_1.OperandValidity.Invalid) { + (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain); + currentChain = []; + } + else if (operand.type === gatherLogicalOperands_1.OperandValidity.Last) { + (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain, operand); + currentChain = []; + } + else { + currentChain.push(operand); + } + } + // make sure to check whatever's left + if (currentChain.length > 0) { + (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain); + } + }, + // specific handling for `(foo ?? {}).bar` / `(foo || {}).bar` + 'LogicalExpression[operator="||"], LogicalExpression[operator="??"]'(node) { + const leftNode = node.left; + const rightNode = node.right; + const parentNode = node.parent; + const isRightNodeAnEmptyObjectLiteral = rightNode.type === utils_1.AST_NODE_TYPES.ObjectExpression && + rightNode.properties.length === 0; + if (!isRightNodeAnEmptyObjectLiteral || + parentNode.type !== utils_1.AST_NODE_TYPES.MemberExpression || + parentNode.optional) { + return; + } + seenLogicals.add(node); + function isLeftSideLowerPrecedence() { + const logicalTsNode = parserServices.esTreeNodeToTSNodeMap.get(node); + const leftTsNode = parserServices.esTreeNodeToTSNodeMap.get(leftNode); + const leftPrecedence = (0, util_1.getOperatorPrecedence)(leftTsNode.kind, logicalTsNode.operatorToken.kind); + return leftPrecedence < util_1.OperatorPrecedence.LeftHandSide; + } + (0, checkNullishAndReport_1.checkNullishAndReport)(context, parserServices, options, [leftNode], { + node: parentNode, + messageId: 'preferOptionalChain', + suggest: [ + { + messageId: 'optionalChainSuggest', + fix: (fixer) => { + const leftNodeText = context.sourceCode.getText(leftNode); + // Any node that is made of an operator with higher or equal precedence, + const maybeWrappedLeftNode = isLeftSideLowerPrecedence() + ? `(${leftNodeText})` + : leftNodeText; + const propertyToBeOptionalText = context.sourceCode.getText(parentNode.property); + const maybeWrappedProperty = parentNode.computed + ? `[${propertyToBeOptionalText}]` + : propertyToBeOptionalText; + return fixer.replaceTextRange(parentNode.range, `${maybeWrappedLeftNode}?.${maybeWrappedProperty}`); + }, + }, + ], + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-optional-chain.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.d.ts new file mode 100644 index 00000000..2760f215 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.d.ts @@ -0,0 +1,14 @@ +import type { TypeOrValueSpecifier } from '../util'; +export type MessageIds = 'rejectAnError'; +export type Options = [ + { + allow?: TypeOrValueSpecifier[]; + allowEmptyReject?: boolean; + allowThrowingAny?: boolean; + allowThrowingUnknown?: boolean; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.js new file mode 100644 index 00000000..fd964acd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-promise-reject-errors.js @@ -0,0 +1,125 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-promise-reject-errors', + meta: { + type: 'suggestion', + docs: { + description: 'Require using Error objects as Promise rejection reasons', + extendsBaseRule: true, + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + rejectAnError: 'Expected the Promise rejection reason to be an Error.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + ...util_1.typeOrValueSpecifiersSchema, + description: 'Type specifiers that can be used as Promise rejection reasons.', + }, + allowEmptyReject: { + type: 'boolean', + description: 'Whether to allow calls to `Promise.reject()` with no arguments.', + }, + allowThrowingAny: { + type: 'boolean', + description: 'Whether to always allow throwing values typed as `any`.', + }, + allowThrowingUnknown: { + type: 'boolean', + description: 'Whether to always allow throwing values typed as `unknown`.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [], + allowEmptyReject: false, + allowThrowingAny: false, + allowThrowingUnknown: false, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + function checkRejectCall(callExpression) { + const argument = callExpression.arguments.at(0); + if (argument) { + const type = services.getTypeAtLocation(argument); + if ((0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program)) { + return; + } + if (options.allowThrowingAny && (0, util_1.isTypeAnyType)(type)) { + return; + } + if (options.allowThrowingUnknown && (0, util_1.isTypeUnknownType)(type)) { + return; + } + if ((0, util_1.isErrorLike)(services.program, type) || + (0, util_1.isReadonlyErrorLike)(services.program, type)) { + return; + } + } + else if (options.allowEmptyReject) { + return; + } + context.report({ + node: callExpression, + messageId: 'rejectAnError', + }); + } + function typeAtLocationIsLikePromise(node) { + const type = services.getTypeAtLocation(node); + return ((0, util_1.isPromiseConstructorLike)(services.program, type) || + (0, util_1.isPromiseLike)(services.program, type)); + } + return { + CallExpression(node) { + const callee = (0, util_1.skipChainExpression)(node.callee); + if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return; + } + if (!(0, util_1.isStaticMemberAccessOfValue)(callee, context, 'reject') || + !typeAtLocationIsLikePromise(callee.object)) { + return; + } + checkRejectCall(node); + }, + NewExpression(node) { + const callee = (0, util_1.skipChainExpression)(node.callee); + if (!(0, util_1.isPromiseConstructorLike)(services.program, services.getTypeAtLocation(callee))) { + return; + } + const executor = node.arguments.at(0); + if (!executor || !(0, util_1.isFunction)(executor)) { + return; + } + const rejectParamNode = executor.params.at(1); + if (!rejectParamNode || !(0, util_1.isIdentifier)(rejectParamNode)) { + return; + } + // reject param is always present in variables declared by executor + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const rejectVariable = context.sourceCode + .getDeclaredVariables(executor) + .find(variable => variable.identifiers.includes(rejectParamNode)); + rejectVariable.references.forEach(ref => { + if (ref.identifier.parent.type !== utils_1.AST_NODE_TYPES.CallExpression || + ref.identifier !== ref.identifier.parent.callee) { + return; + } + checkRejectCall(ref.identifier.parent); + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-promise-reject-errors.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.d.ts new file mode 100644 index 00000000..3cc3a867 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.d.ts @@ -0,0 +1,14 @@ +import type { TypeOrValueSpecifier } from '../util'; +export type Options = [ + { + allow?: TypeOrValueSpecifier[]; + checkParameterProperties?: boolean; + ignoreInferredTypes?: boolean; + treatMethodsAsReadonly?: boolean; + } +]; +export type MessageIds = 'shouldBeReadonly'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.js new file mode 100644 index 00000000..003cf1d9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly-parameter-types.js @@ -0,0 +1,99 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-readonly-parameter-types', + meta: { + type: 'suggestion', + docs: { + description: 'Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs', + requiresTypeChecking: true, + }, + messages: { + shouldBeReadonly: 'Parameter should be a read only type.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allow: { + ...util_1.readonlynessOptionsSchema.properties.allow, + description: 'An array of type specifiers to ignore.', + }, + checkParameterProperties: { + type: 'boolean', + description: 'Whether to check class parameter properties.', + }, + ignoreInferredTypes: { + type: 'boolean', + description: "Whether to ignore parameters which don't explicitly specify a type.", + }, + treatMethodsAsReadonly: { + ...util_1.readonlynessOptionsSchema.properties.treatMethodsAsReadonly, + description: 'Whether to treat all mutable methods as though they are readonly.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: util_1.readonlynessOptionsDefaults.allow, + checkParameterProperties: true, + ignoreInferredTypes: false, + treatMethodsAsReadonly: util_1.readonlynessOptionsDefaults.treatMethodsAsReadonly, + }, + ], + create(context, [{ allow, checkParameterProperties, ignoreInferredTypes, treatMethodsAsReadonly, },]) { + const services = (0, util_1.getParserServices)(context); + function getParameterType(actualParam) { + if (actualParam.typeAnnotation?.typeAnnotation) { + // Get type from annotation node to preserve aliasSymbol + const checker = services.program.getTypeChecker(); + const tsTypeNode = services.esTreeNodeToTSNodeMap.get(actualParam.typeAnnotation.typeAnnotation); + return checker.getTypeFromTypeNode(tsTypeNode); + } + return services.getTypeAtLocation(actualParam); + } + return { + [[ + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.FunctionExpression, + utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration, + utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration, + utils_1.AST_NODE_TYPES.TSDeclareFunction, + utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression, + utils_1.AST_NODE_TYPES.TSFunctionType, + utils_1.AST_NODE_TYPES.TSMethodSignature, + ].join(', ')](node) { + for (const param of node.params) { + if (!checkParameterProperties && + param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) { + continue; + } + const actualParam = param.type === utils_1.AST_NODE_TYPES.TSParameterProperty + ? param.parameter + : param; + if (ignoreInferredTypes && actualParam.typeAnnotation == null) { + continue; + } + const type = getParameterType(actualParam); + const isReadOnly = (0, util_1.isTypeReadonly)(services.program, type, { + allow, + treatMethodsAsReadonly: !!treatMethodsAsReadonly, + }); + if (!isReadOnly && !(0, util_1.isTypeBrandedLiteralLike)(type)) { + context.report({ + node: actualParam, + messageId: 'shouldBeReadonly', + }); + } + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-readonly-parameter-types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.d.ts new file mode 100644 index 00000000..848998f5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.d.ts @@ -0,0 +1,10 @@ +export type MessageIds = 'preferReadonly'; +export type Options = [ + { + onlyInlineLambdas?: boolean; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferReadonly", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.js new file mode 100644 index 00000000..a540c5ea --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-readonly.js @@ -0,0 +1,440 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const getMemberHeadLoc_1 = require("../util/getMemberHeadLoc"); +const functionScopeBoundaries = [ + utils_1.AST_NODE_TYPES.ArrowFunctionExpression, + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.FunctionExpression, + utils_1.AST_NODE_TYPES.MethodDefinition, +].join(', '); +exports.default = (0, util_1.createRule)({ + name: 'prefer-readonly', + meta: { + type: 'suggestion', + docs: { + description: "Require private members to be marked as `readonly` if they're never modified outside of the constructor", + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + preferReadonly: "Member '{{name}}' is never reassigned; mark it as `readonly`.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + onlyInlineLambdas: { + type: 'boolean', + description: 'Whether to restrict checking only to members immediately assigned a lambda value.', + }, + }, + }, + ], + }, + defaultOptions: [{ onlyInlineLambdas: false }], + create(context, [{ onlyInlineLambdas }]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const classScopeStack = []; + function handlePropertyAccessExpression(node, parent, classScope) { + if (ts.isBinaryExpression(parent)) { + handleParentBinaryExpression(node, parent, classScope); + return; + } + if (ts.isDeleteExpression(parent) || isDestructuringAssignment(node)) { + classScope.addVariableModification(node); + return; + } + if (ts.isPostfixUnaryExpression(parent) || + ts.isPrefixUnaryExpression(parent)) { + handleParentPostfixOrPrefixUnaryExpression(parent, classScope); + } + } + function handleParentBinaryExpression(node, parent, classScope) { + if (parent.left === node && + tsutils.isAssignmentKind(parent.operatorToken.kind)) { + classScope.addVariableModification(node); + } + } + function handleParentPostfixOrPrefixUnaryExpression(node, classScope) { + if (node.operator === ts.SyntaxKind.PlusPlusToken || + node.operator === ts.SyntaxKind.MinusMinusToken) { + classScope.addVariableModification(node.operand); + } + } + function isDestructuringAssignment(node) { + let current = node.parent; + while (current) { + const parent = current.parent; + if (ts.isObjectLiteralExpression(parent) || + ts.isArrayLiteralExpression(parent) || + ts.isSpreadAssignment(parent) || + (ts.isSpreadElement(parent) && + ts.isArrayLiteralExpression(parent.parent))) { + current = parent; + } + else if (ts.isBinaryExpression(parent) && + !ts.isPropertyAccessExpression(current)) { + return (parent.left === current && + parent.operatorToken.kind === ts.SyntaxKind.EqualsToken); + } + else { + break; + } + } + return false; + } + function isFunctionScopeBoundaryInStack(node) { + if (classScopeStack.length === 0) { + return false; + } + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (ts.isConstructorDeclaration(tsNode)) { + return false; + } + return tsutils.isFunctionScopeBoundary(tsNode); + } + function getEsNodesFromViolatingNode(violatingNode) { + return { + esNode: services.tsNodeToESTreeNodeMap.get(violatingNode), + nameNode: services.tsNodeToESTreeNodeMap.get(violatingNode.name), + }; + } + function getTypeAnnotationForViolatingNode(node, type, initializerType) { + const annotation = checker.typeToString(type); + // verify the about-to-be-added type annotation is in-scope + if (tsutils.isTypeFlagSet(initializerType, ts.TypeFlags.EnumLiteral)) { + const scope = context.sourceCode.getScope(node); + const variable = utils_1.ASTUtils.findVariable(scope, annotation); + if (variable == null) { + return null; + } + const definition = variable.defs.find(def => def.isTypeDefinition); + if (definition == null) { + return null; + } + const definitionType = services.getTypeAtLocation(definition.node); + if (definitionType !== type) { + return null; + } + } + return annotation; + } + return { + [`${functionScopeBoundaries}:exit`](node) { + if (utils_1.ASTUtils.isConstructor(node)) { + classScopeStack[classScopeStack.length - 1].exitConstructor(); + } + else if (isFunctionScopeBoundaryInStack(node)) { + classScopeStack[classScopeStack.length - 1].exitNonConstructor(); + } + }, + 'ClassDeclaration, ClassExpression'(node) { + classScopeStack.push(new ClassScope(checker, services.esTreeNodeToTSNodeMap.get(node), onlyInlineLambdas)); + }, + 'ClassDeclaration, ClassExpression:exit'() { + const finalizedClassScope = (0, util_1.nullThrows)(classScopeStack.pop(), 'Stack should exist on class exit'); + for (const violatingNode of finalizedClassScope.finalizeUnmodifiedPrivateNonReadonlys()) { + const { esNode, nameNode } = getEsNodesFromViolatingNode(violatingNode); + const reportNodeOrLoc = (() => { + switch (esNode.type) { + case utils_1.AST_NODE_TYPES.MethodDefinition: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + return { loc: (0, getMemberHeadLoc_1.getMemberHeadLoc)(context.sourceCode, esNode) }; + case utils_1.AST_NODE_TYPES.TSParameterProperty: + return { + loc: (0, getMemberHeadLoc_1.getParameterPropertyHeadLoc)(context.sourceCode, esNode, nameNode.name), + }; + default: + return { node: esNode }; + } + })(); + const typeAnnotation = (() => { + if (esNode.type !== utils_1.AST_NODE_TYPES.PropertyDefinition) { + return null; + } + if (esNode.typeAnnotation || !esNode.value) { + return null; + } + if (nameNode.type !== utils_1.AST_NODE_TYPES.Identifier) { + return null; + } + const hasConstructorModifications = finalizedClassScope.memberHasConstructorModifications(nameNode.name); + if (!hasConstructorModifications) { + return null; + } + const violatingType = services.getTypeAtLocation(esNode); + const initializerType = services.getTypeAtLocation(esNode.value); + // if the RHS is a literal, its type would be narrowed, while the + // type of the initializer (which isn't `readonly`) would be the + // widened type + if (initializerType === violatingType) { + return null; + } + if (!tsutils.isLiteralType(initializerType)) { + return null; + } + return getTypeAnnotationForViolatingNode(esNode, violatingType, initializerType); + })(); + context.report({ + ...reportNodeOrLoc, + messageId: 'preferReadonly', + data: { + name: context.sourceCode.getText(nameNode), + }, + *fix(fixer) { + const readonlyInsertionTarget = esNode.type === utils_1.AST_NODE_TYPES.PropertyDefinition && + esNode.computed + ? (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(nameNode), 'Expected to find a token before computed property name') + : nameNode; + yield fixer.insertTextBefore(readonlyInsertionTarget, 'readonly '); + if (typeAnnotation) { + yield fixer.insertTextAfter(nameNode, `: ${typeAnnotation}`); + } + }, + }); + } + }, + [functionScopeBoundaries](node) { + if (utils_1.ASTUtils.isConstructor(node)) { + classScopeStack[classScopeStack.length - 1].enterConstructor(services.esTreeNodeToTSNodeMap.get(node)); + } + else if (isFunctionScopeBoundaryInStack(node)) { + classScopeStack[classScopeStack.length - 1].enterNonConstructor(); + } + }, + MemberExpression(node) { + if (classScopeStack.length === 0) { + return; + } + const classScope = classScopeStack[classScopeStack.length - 1]; + if (!node.computed) { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + handlePropertyAccessExpression(tsNode, tsNode.parent, classScope); + } + else { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + if (ts.isElementAccessExpression(tsNode) && + ts.isBinaryExpression(tsNode.parent) && + tsNode.parent.left === tsNode && + tsutils.isAssignmentKind(tsNode.parent.operatorToken.kind)) { + const memberName = (0, util_1.getStaticMemberAccessValue)(node, context); + if (typeof memberName === 'string') { + classScope.addVariableModificationByName(tsNode.expression, memberName); + } + } + } + }, + }; + }, +}); +const OUTSIDE_CONSTRUCTOR = -1; +const DIRECTLY_INSIDE_CONSTRUCTOR = 0; +var TypeToClassRelation; +(function (TypeToClassRelation) { + TypeToClassRelation[TypeToClassRelation["ClassAndInstance"] = 0] = "ClassAndInstance"; + TypeToClassRelation[TypeToClassRelation["Class"] = 1] = "Class"; + TypeToClassRelation[TypeToClassRelation["Instance"] = 2] = "Instance"; + TypeToClassRelation[TypeToClassRelation["None"] = 3] = "None"; +})(TypeToClassRelation || (TypeToClassRelation = {})); +class ClassScope { + checker; + onlyInlineLambdas; + classType; + constructorScopeDepth = OUTSIDE_CONSTRUCTOR; + memberVariableModifications = new Set(); + memberVariableWithConstructorModifications = new Set(); + privateModifiableMembers = new Map(); + privateModifiableStatics = new Map(); + staticVariableModifications = new Set(); + constructor(checker, classNode, onlyInlineLambdas) { + this.checker = checker; + this.onlyInlineLambdas = onlyInlineLambdas; + const classType = checker.getTypeAtLocation(classNode); + if (tsutils.isIntersectionType(classType)) { + this.classType = classType.types[0]; + } + else { + this.classType = classType; + } + for (const member of classNode.members) { + if (ts.isPropertyDeclaration(member)) { + this.addDeclaredVariable(member); + } + } + } + addDeclaredVariable(node) { + if (!(tsutils.isModifierFlagSet(node, ts.ModifierFlags.Private) || + node.name.kind === ts.SyntaxKind.PrivateIdentifier) || + tsutils.isModifierFlagSet(node, ts.ModifierFlags.Accessor | ts.ModifierFlags.Readonly)) { + return; + } + if (this.onlyInlineLambdas && + node.initializer != null && + !ts.isArrowFunction(node.initializer)) { + return; + } + const memberName = getMemberName(node.name); + if (memberName == null) { + return; + } + (tsutils.isModifierFlagSet(node, ts.ModifierFlags.Static) + ? this.privateModifiableStatics + : this.privateModifiableMembers).set(memberName, node); + } + addVariableModification(node) { + this.addVariableModificationByName(node.expression, node.name.text); + } + addVariableModificationByName(expression, memberName) { + const modifierType = this.checker.getTypeAtLocation(expression); + const relationOfModifierTypeToClass = this.getTypeToClassRelation(modifierType); + if (relationOfModifierTypeToClass === TypeToClassRelation.Instance && + this.constructorScopeDepth === DIRECTLY_INSIDE_CONSTRUCTOR) { + this.memberVariableWithConstructorModifications.add(memberName); + return; + } + if (relationOfModifierTypeToClass === TypeToClassRelation.Instance || + relationOfModifierTypeToClass === TypeToClassRelation.ClassAndInstance) { + this.memberVariableModifications.add(memberName); + } + if (relationOfModifierTypeToClass === TypeToClassRelation.Class || + relationOfModifierTypeToClass === TypeToClassRelation.ClassAndInstance) { + this.staticVariableModifications.add(memberName); + } + } + enterConstructor(node) { + this.constructorScopeDepth = DIRECTLY_INSIDE_CONSTRUCTOR; + for (const parameter of node.parameters) { + if (tsutils.isModifierFlagSet(parameter, ts.ModifierFlags.Private)) { + this.addDeclaredVariable(parameter); + } + } + } + enterNonConstructor() { + if (this.constructorScopeDepth !== OUTSIDE_CONSTRUCTOR) { + this.constructorScopeDepth += 1; + } + } + exitConstructor() { + this.constructorScopeDepth = OUTSIDE_CONSTRUCTOR; + } + exitNonConstructor() { + if (this.constructorScopeDepth !== OUTSIDE_CONSTRUCTOR) { + this.constructorScopeDepth -= 1; + } + } + finalizeUnmodifiedPrivateNonReadonlys() { + this.memberVariableModifications.forEach(variableName => { + this.privateModifiableMembers.delete(variableName); + }); + this.staticVariableModifications.forEach(variableName => { + this.privateModifiableStatics.delete(variableName); + }); + return [ + ...this.privateModifiableMembers.values(), + ...this.privateModifiableStatics.values(), + ]; + } + getTypeToClassRelation(type) { + if (type.isIntersection()) { + let result = TypeToClassRelation.None; + for (const subType of type.types) { + const subTypeResult = this.getTypeToClassRelation(subType); + switch (subTypeResult) { + case TypeToClassRelation.Class: + if (result === TypeToClassRelation.Instance) { + return TypeToClassRelation.ClassAndInstance; + } + result = TypeToClassRelation.Class; + break; + case TypeToClassRelation.Instance: + if (result === TypeToClassRelation.Class) { + return TypeToClassRelation.ClassAndInstance; + } + result = TypeToClassRelation.Instance; + break; + } + } + return result; + } + if (type.isUnion()) { + // any union of class/instance and something else will prevent access to + // private members, so we assume that union consists only of classes + // or class instances, because otherwise tsc will report an error + return this.getTypeToClassRelation(type.types[0]); + } + if (!type.getSymbol() || !(0, util_1.typeIsOrHasBaseType)(type, this.classType)) { + return TypeToClassRelation.None; + } + const typeIsClass = tsutils.isObjectType(type) && + tsutils.isObjectFlagSet(type, ts.ObjectFlags.Anonymous); + if (typeIsClass) { + return TypeToClassRelation.Class; + } + return TypeToClassRelation.Instance; + } + memberHasConstructorModifications(name) { + return this.memberVariableWithConstructorModifications.has(name); + } +} +function getMemberName(name) { + if (ts.isIdentifier(name) || + ts.isPrivateIdentifier(name) || + ts.isStringLiteral(name) || + ts.isNoSubstitutionTemplateLiteral(name) || + ts.isNumericLiteral(name)) { + return name.text; + } + if (ts.isComputedPropertyName(name)) { + const expression = name.expression; + if (ts.isNumericLiteral(expression)) { + return expression.text; + } + if (ts.isPropertyAccessExpression(expression) && + ts.isIdentifier(expression.expression) && + expression.expression.text === 'Symbol') { + return expression.getText(); + } + } + return undefined; +} +//# sourceMappingURL=prefer-readonly.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.d.ts new file mode 100644 index 00000000..960932ac --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.js new file mode 100644 index 00000000..9450232c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.js @@ -0,0 +1,115 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-reduce-type-parameter', + meta: { + type: 'problem', + docs: { + description: 'Enforce using type parameter when calling `Array#reduce` instead of using a type assertion', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + preferTypeParameter: 'Unnecessary assertion: Array#reduce accepts a type parameter for the default value.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function isArrayType(type) { + return tsutils + .unionConstituents(type) + .every(unionPart => tsutils + .intersectionConstituents(unionPart) + .every(t => checker.isArrayType(t) || checker.isTupleType(t))); + } + return { + 'CallExpression > MemberExpression.callee'(callee) { + if (!(0, util_1.isStaticMemberAccessOfValue)(callee, context, 'reduce')) { + return; + } + const [, secondArg] = callee.parent.arguments; + if (callee.parent.arguments.length < 2) { + return; + } + if ((0, util_1.isTypeAssertion)(secondArg)) { + const initializerType = services.getTypeAtLocation(secondArg.expression); + const assertedType = services.getTypeAtLocation(secondArg.typeAnnotation); + const isAssertionNecessary = !checker.isTypeAssignableTo(initializerType, assertedType); + // don't report this if the resulting fix will be a type error + if (isAssertionNecessary) { + return; + } + } + else { + return; + } + // Get the symbol of the `reduce` method. + const calleeObjType = (0, util_1.getConstrainedTypeAtLocation)(services, callee.object); + // Check the owner type of the `reduce` method. + if (isArrayType(calleeObjType)) { + context.report({ + node: secondArg, + messageId: 'preferTypeParameter', + fix: fixer => { + const fixes = [ + fixer.removeRange([ + secondArg.range[0], + secondArg.expression.range[0], + ]), + fixer.removeRange([ + secondArg.expression.range[1], + secondArg.range[1], + ]), + ]; + if (!callee.parent.typeArguments) { + fixes.push(fixer.insertTextAfter(callee, `<${context.sourceCode.getText(secondArg.typeAnnotation)}>`)); + } + return fixes; + }, + }); + return; + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-reduce-type-parameter.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.d.ts new file mode 100644 index 00000000..411c2a1d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.js new file mode 100644 index 00000000..9060be30 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.js @@ -0,0 +1,183 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +var ArgumentType; +(function (ArgumentType) { + ArgumentType[ArgumentType["Other"] = 0] = "Other"; + ArgumentType[ArgumentType["String"] = 1] = "String"; + ArgumentType[ArgumentType["RegExp"] = 2] = "RegExp"; + ArgumentType[ArgumentType["Both"] = 3] = "Both"; +})(ArgumentType || (ArgumentType = {})); +exports.default = (0, util_1.createRule)({ + name: 'prefer-regexp-exec', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce `RegExp#exec` over `String#match` if no global flag is provided', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + regExpExecOverStringMatch: 'Use the `RegExp#exec()` method instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const globalScope = context.sourceCode.getScope(context.sourceCode.ast); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + /** + * Check if a given node type is a string. + * @param type The node type to check. + */ + function isStringType(type) { + return (0, util_1.getTypeName)(checker, type) === 'string'; + } + /** + * Check if a given node type is a RegExp. + * @param type The node type to check. + */ + function isRegExpType(type) { + return (0, util_1.getTypeName)(checker, type) === 'RegExp'; + } + function collectArgumentTypes(types) { + let result = ArgumentType.Other; + for (const type of types) { + if (isRegExpType(type)) { + result |= ArgumentType.RegExp; + } + else if (isStringType(type)) { + result |= ArgumentType.String; + } + } + return result; + } + /** + * Returns true if and only if we have syntactic proof that the /g flag is + * absent. Returns false in all other cases (i.e. it still might or might + * not contain the global flag). + */ + function definitelyDoesNotContainGlobalFlag(node) { + if ((node.type === utils_1.AST_NODE_TYPES.CallExpression || + node.type === utils_1.AST_NODE_TYPES.NewExpression) && + node.callee.type === utils_1.AST_NODE_TYPES.Identifier && + node.callee.name === 'RegExp') { + const flags = node.arguments.at(1); + if (!flags) { + return true; + } + const flagsValue = (0, util_1.getStaticValue)(flags, globalScope); + return (!!flagsValue && + (typeof flagsValue.value !== 'string' || + !flagsValue.value.includes('g'))); + } + return false; + } + return { + 'CallExpression[arguments.length=1] > MemberExpression'(memberNode) { + if (!(0, util_1.isStaticMemberAccessOfValue)(memberNode, context, 'match')) { + return; + } + const objectNode = memberNode.object; + const callNode = memberNode.parent; + const [argumentNode] = callNode.arguments; + const argumentValue = (0, util_1.getStaticValue)(argumentNode, globalScope); + if (!isStringType(services.getTypeAtLocation(objectNode))) { + return; + } + // Don't report regular expressions with global flag. + if ((!argumentValue && + !definitelyDoesNotContainGlobalFlag(argumentNode)) || + (argumentValue && + argumentValue.value instanceof RegExp && + argumentValue.value.flags.includes('g'))) { + return; + } + if (argumentNode.type === utils_1.AST_NODE_TYPES.Literal && + typeof argumentNode.value === 'string') { + let regExp; + try { + regExp = RegExp(argumentNode.value); + } + catch { + return; + } + return context.report({ + node: memberNode.property, + messageId: 'regExpExecOverStringMatch', + fix: (0, util_1.getWrappingFixer)({ + node: callNode, + innerNode: [objectNode], + sourceCode: context.sourceCode, + wrap: objectCode => `${regExp.toString()}.exec(${objectCode})`, + }), + }); + } + const argumentType = services.getTypeAtLocation(argumentNode); + const argumentTypes = collectArgumentTypes(tsutils.unionConstituents(argumentType)); + switch (argumentTypes) { + case ArgumentType.RegExp: + return context.report({ + node: memberNode.property, + messageId: 'regExpExecOverStringMatch', + fix: (0, util_1.getWrappingFixer)({ + node: callNode, + innerNode: [objectNode, argumentNode], + sourceCode: context.sourceCode, + wrap: (objectCode, argumentCode) => `${argumentCode}.exec(${objectCode})`, + }), + }); + case ArgumentType.String: + return context.report({ + node: memberNode.property, + messageId: 'regExpExecOverStringMatch', + fix: (0, util_1.getWrappingFixer)({ + node: callNode, + innerNode: [objectNode, argumentNode], + sourceCode: context.sourceCode, + wrap: (objectCode, argumentCode) => `RegExp(${argumentCode}).exec(${objectCode})`, + }), + }); + } + }, + }; + }, +}); +//# sourceMappingURL=prefer-regexp-exec.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.d.ts new file mode 100644 index 00000000..fa654080 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.js new file mode 100644 index 00000000..54145a63 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.js @@ -0,0 +1,155 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ts_api_utils_1 = require("ts-api-utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-return-this-type', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce that `this` is used when only `this` type is returned', + recommended: 'strict', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + useThisType: 'Use `this` type instead.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function tryGetNameInType(name, typeNode) { + if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference && + typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + typeNode.typeName.name === name) { + return typeNode; + } + if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) { + for (const type of typeNode.types) { + const found = tryGetNameInType(name, type); + if (found) { + return found; + } + } + } + return undefined; + } + function isThisSpecifiedInParameters(originalFunc) { + const firstArg = originalFunc.params.at(0); + return (firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this'); + } + function isFunctionReturningThis(originalFunc, originalClass) { + if (isThisSpecifiedInParameters(originalFunc)) { + return false; + } + const func = services.esTreeNodeToTSNodeMap.get(originalFunc); + if (!func.body) { + return false; + } + const classType = services.getTypeAtLocation(originalClass); + if (func.body.kind !== ts.SyntaxKind.Block) { + const type = checker.getTypeAtLocation(func.body); + return classType.thisType === type; + } + let hasReturnThis = false; + let hasReturnClassType = false; + (0, util_1.forEachReturnStatement)(func.body, stmt => { + const expr = stmt.expression; + if (!expr) { + return; + } + // fast check + if (expr.kind === ts.SyntaxKind.ThisKeyword) { + hasReturnThis = true; + return; + } + const type = checker.getTypeAtLocation(expr); + if (classType === type) { + hasReturnClassType = true; + return true; + } + if (classType.thisType === type) { + hasReturnThis = true; + return; + } + if ((0, ts_api_utils_1.isUnionType)(type) && + type.types.some(typePart => typePart === classType)) { + hasReturnClassType = true; + return true; + } + return; + }); + return !hasReturnClassType && hasReturnThis; + } + function checkFunction(originalFunc, originalClass) { + const className = originalClass.id?.name; + if (!className || !originalFunc.returnType) { + return; + } + const node = tryGetNameInType(className, originalFunc.returnType.typeAnnotation); + if (!node) { + return; + } + if (isFunctionReturningThis(originalFunc, originalClass)) { + context.report({ + node, + messageId: 'useThisType', + fix: fixer => fixer.replaceText(node, 'this'), + }); + } + } + function checkProperty(node) { + if (!(node.value?.type === utils_1.AST_NODE_TYPES.FunctionExpression || + node.value?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) { + return; + } + checkFunction(node.value, node.parent.parent); + } + return { + 'ClassBody > AccessorProperty': checkProperty, + 'ClassBody > MethodDefinition'(node) { + checkFunction(node.value, node.parent.parent); + }, + 'ClassBody > PropertyDefinition': checkProperty, + }; + }, +}); +//# sourceMappingURL=prefer-return-this-type.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.d.ts new file mode 100644 index 00000000..e152a125 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.d.ts @@ -0,0 +1,12 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +type AllowedSingleElementEquality = 'always' | 'never'; +export type Options = [ + { + allowSingleElementEquality?: AllowedSingleElementEquality; + } +]; +export type MessageIds = 'preferEndsWith' | 'preferStartsWith'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.js new file mode 100644 index 00000000..2515a61e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.js @@ -0,0 +1,514 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const regexpp_1 = require("@eslint-community/regexpp"); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +const EQ_OPERATORS = /^[=!]=/; +const regexpp = new regexpp_1.RegExpParser(); +exports.default = (0, util_1.createRule)({ + name: 'prefer-string-starts-ends-with', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings', + recommended: 'stylistic', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + preferEndsWith: "Use the 'String#endsWith' method instead.", + preferStartsWith: "Use 'String#startsWith' method instead.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowSingleElementEquality: { + type: 'string', + description: 'Whether to allow equality checks against the first or last element of a string.', + enum: ['always', 'never'], + }, + }, + }, + ], + }, + defaultOptions: [{ allowSingleElementEquality: 'never' }], + create(context, [{ allowSingleElementEquality }]) { + const globalScope = context.sourceCode.getScope(context.sourceCode.ast); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + /** + * Check if a given node is a string. + * @param node The node to check. + */ + function isStringType(node) { + const objectType = services.getTypeAtLocation(node); + return (0, util_1.getTypeName)(checker, objectType) === 'string'; + } + /** + * Check if a given node is a `Literal` node that is null. + * @param node The node to check. + */ + function isNull(node) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + return evaluated != null && evaluated.value == null; + } + /** + * Check if a given node is a `Literal` node that is a given value. + * @param node The node to check. + * @param value The expected value of the `Literal` node. + */ + function isNumber(node, value) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + return evaluated?.value === value; + } + /** + * Check if a given node is a `Literal` node that is a character. + * @param node The node to check. + */ + function isCharacter(node) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + return (evaluated != null && + typeof evaluated.value === 'string' && + // checks if the string is a character long + evaluated.value[0] === evaluated.value); + } + /** + * Check if a given node is `==`, `===`, `!=`, or `!==`. + * @param node The node to check. + */ + function isEqualityComparison(node) { + return (node.type === utils_1.AST_NODE_TYPES.BinaryExpression && + EQ_OPERATORS.test(node.operator)); + } + /** + * Check if two given nodes are the same meaning. + * @param node1 A node to compare. + * @param node2 Another node to compare. + */ + function isSameTokens(node1, node2) { + const tokens1 = context.sourceCode.getTokens(node1); + const tokens2 = context.sourceCode.getTokens(node2); + if (tokens1.length !== tokens2.length) { + return false; + } + for (let i = 0; i < tokens1.length; ++i) { + const token1 = tokens1[i]; + const token2 = tokens2[i]; + if (token1.type !== token2.type || token1.value !== token2.value) { + return false; + } + } + return true; + } + /** + * Check if a given node is the expression of the length of a string. + * + * - If `length` property access of `expectedObjectNode`, it's `true`. + * E.g., `foo` → `foo.length` / `"foo"` → `"foo".length` + * - If `expectedObjectNode` is a string literal, `node` can be a number. + * E.g., `"foo"` → `3` + * + * @param node The node to check. + * @param expectedObjectNode The node which is expected as the receiver of `length` property. + */ + function isLengthExpression(node, expectedObjectNode) { + if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) { + return ((0, util_1.getPropertyName)(node, globalScope) === 'length' && + isSameTokens(node.object, expectedObjectNode)); + } + const evaluatedLength = (0, util_1.getStaticValue)(node, globalScope); + const evaluatedString = (0, util_1.getStaticValue)(expectedObjectNode, globalScope); + return (evaluatedLength != null && + evaluatedString != null && + typeof evaluatedLength.value === 'number' && + typeof evaluatedString.value === 'string' && + evaluatedLength.value === evaluatedString.value.length); + } + /** + * Returns true if `node` is `-substring.length` or + * `parentString.length - substring.length` + */ + function isLengthAheadOfEnd(node, substring, parentString) { + return ((node.type === utils_1.AST_NODE_TYPES.UnaryExpression && + node.operator === '-' && + isLengthExpression(node.argument, substring)) || + (node.type === utils_1.AST_NODE_TYPES.BinaryExpression && + node.operator === '-' && + isLengthExpression(node.left, parentString) && + isLengthExpression(node.right, substring))); + } + /** + * Check if a given node is the expression of the last index. + * + * E.g. `foo.length - 1` + * + * @param node The node to check. + * @param expectedObjectNode The node which is expected as the receiver of `length` property. + */ + function isLastIndexExpression(node, expectedObjectNode) { + return (node.type === utils_1.AST_NODE_TYPES.BinaryExpression && + node.operator === '-' && + isLengthExpression(node.left, expectedObjectNode) && + isNumber(node.right, 1)); + } + /** + * Get the range of the property of a given `MemberExpression` node. + * + * - `obj[foo]` → the range of `[foo]` + * - `obf.foo` → the range of `.foo` + * - `(obj).foo` → the range of `.foo` + * + * @param node The member expression node to get. + */ + function getPropertyRange(node) { + const dotOrOpenBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.object, util_1.isNotClosingParenToken), util_1.NullThrowsReasons.MissingToken('closing parenthesis', 'member')); + return [dotOrOpenBracket.range[0], node.range[1]]; + } + /** + * Parse a given `RegExp` pattern to that string if it's a static string. + * @param pattern The RegExp pattern text to parse. + * @param unicode Whether the RegExp is unicode. + */ + function parseRegExpText(pattern, unicode) { + // Parse it. + const ast = regexpp.parsePattern(pattern, undefined, undefined, { + unicode, + }); + if (ast.alternatives.length !== 1) { + return null; + } + // Drop `^`/`$` assertion. + const chars = ast.alternatives[0].elements; + const first = chars[0]; + if (first.type === 'Assertion' && first.kind === 'start') { + chars.shift(); + } + else { + chars.pop(); + } + // Check if it can determine a unique string. + if (!chars.every(c => c.type === 'Character')) { + return null; + } + // To string. + return String.fromCodePoint(...chars.map(c => c.value)); + } + /** + * Parse a given node if it's a `RegExp` instance. + * @param node The node to parse. + */ + function parseRegExp(node) { + const evaluated = (0, util_1.getStaticValue)(node, globalScope); + if (evaluated == null || !(evaluated.value instanceof RegExp)) { + return null; + } + const { flags, source } = evaluated.value; + const isStartsWith = source.startsWith('^'); + // ends with a $ preceded by an even number of backslashes (or zero) + const isEndsWith = /[^\\](\\\\)*\$$/.test(source); + if (isStartsWith === isEndsWith || + flags.includes('i') || + flags.includes('m')) { + return null; + } + const text = parseRegExpText(source, flags.includes('u')); + if (text == null) { + return null; + } + return { isEndsWith, isStartsWith, text }; + } + function getLeftNode(init) { + const node = (0, util_1.skipChainExpression)(init); + const leftNode = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node; + if (leftNode.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + throw new Error(`Expected a MemberExpression, got ${leftNode.type}`); + } + return leftNode; + } + /** + * Fix code with using the right operand as the search string. + * For example: `foo.slice(0, 3) === 'bar'` → `foo.startsWith('bar')` + * @param fixer The rule fixer. + * @param node The node which was reported. + * @param kind The kind of the report. + * @param isNegative The flag to fix to negative condition. + */ + function* fixWithRightOperand(fixer, node, kind, isNegative, isOptional) { + // left is CallExpression or MemberExpression. + const leftNode = getLeftNode(node.left); + const propertyRange = getPropertyRange(leftNode); + if (isNegative) { + yield fixer.insertTextBefore(node, '!'); + } + yield fixer.replaceTextRange([propertyRange[0], node.right.range[0]], `${isOptional ? '?.' : '.'}${kind}sWith(`); + yield fixer.replaceTextRange([node.right.range[1], node.range[1]], ')'); + } + /** + * Fix code with using the first argument as the search string. + * For example: `foo.indexOf('bar') === 0` → `foo.startsWith('bar')` + * @param fixer The rule fixer. + * @param node The node which was reported. + * @param kind The kind of the report. + * @param negative The flag to fix to negative condition. + */ + function* fixWithArgument(fixer, node, callNode, calleeNode, kind, negative, isOptional) { + if (negative) { + yield fixer.insertTextBefore(node, '!'); + } + yield fixer.replaceTextRange(getPropertyRange(calleeNode), `${isOptional ? '?.' : '.'}${kind}sWith`); + yield fixer.removeRange([callNode.range[1], node.range[1]]); + } + function getParent(node) { + return node.parent.type === utils_1.AST_NODE_TYPES.ChainExpression + ? node.parent.parent + : node.parent; + } + return { + // foo[0] === "a" + // foo.charAt(0) === "a" + // foo[foo.length - 1] === "a" + // foo.charAt(foo.length - 1) === "a" + [[ + 'BinaryExpression > MemberExpression.left[computed=true]', + 'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="charAt"][computed=false]', + 'BinaryExpression > ChainExpression.left > MemberExpression[computed=true]', + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression.callee[property.name="charAt"][computed=false]', + ].join(', ')](node) { + let parentNode = getParent(node); + let indexNode = null; + if (parentNode.type === utils_1.AST_NODE_TYPES.CallExpression) { + if (parentNode.arguments.length === 1) { + indexNode = parentNode.arguments[0]; + } + parentNode = getParent(parentNode); + } + else { + indexNode = node.property; + } + if (indexNode == null || + !isEqualityComparison(parentNode) || + !isStringType(node.object)) { + return; + } + const isEndsWith = isLastIndexExpression(indexNode, node.object); + if (allowSingleElementEquality === 'always' && isEndsWith) { + return; + } + const isStartsWith = !isEndsWith && isNumber(indexNode, 0); + if ((allowSingleElementEquality === 'always' && isStartsWith) || + (!isStartsWith && !isEndsWith)) { + return; + } + const eqNode = parentNode; + context.report({ + node: parentNode, + messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith', + fix(fixer) { + // Don't fix if it can change the behavior. + if (!isCharacter(eqNode.right)) { + return null; + } + return fixWithRightOperand(fixer, eqNode, isStartsWith ? 'start' : 'end', eqNode.operator.startsWith('!'), node.optional); + }, + }); + }, + // foo.indexOf('bar') === 0 + [[ + 'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="indexOf"][computed=false]', + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression.callee[property.name="indexOf"][computed=false]', + ].join(', ')](node) { + const callNode = getParent(node); + const parentNode = getParent(callNode); + if (callNode.arguments.length !== 1 || + !isEqualityComparison(parentNode) || + !isNumber(parentNode.right, 0) || + !isStringType(node.object)) { + return; + } + context.report({ + node: parentNode, + messageId: 'preferStartsWith', + fix(fixer) { + return fixWithArgument(fixer, parentNode, callNode, node, 'start', parentNode.operator.startsWith('!'), node.optional); + }, + }); + }, + // foo.lastIndexOf('bar') === foo.length - 3 + // foo.lastIndexOf(bar) === foo.length - bar.length + [[ + 'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="lastIndexOf"][computed=false]', + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression.callee[property.name="lastIndexOf"][computed=false]', + ].join(', ')](node) { + const callNode = getParent(node); + const parentNode = getParent(callNode); + if (callNode.arguments.length !== 1 || + !isEqualityComparison(parentNode) || + parentNode.right.type !== utils_1.AST_NODE_TYPES.BinaryExpression || + parentNode.right.operator !== '-' || + !isLengthExpression(parentNode.right.left, node.object) || + !isLengthExpression(parentNode.right.right, callNode.arguments[0]) || + !isStringType(node.object)) { + return; + } + context.report({ + node: parentNode, + messageId: 'preferEndsWith', + fix(fixer) { + return fixWithArgument(fixer, parentNode, callNode, node, 'end', parentNode.operator.startsWith('!'), node.optional); + }, + }); + }, + // foo.match(/^bar/) === null + // foo.match(/bar$/) === null + [[ + 'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="match"][computed=false]', + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression.callee[property.name="match"][computed=false]', + ].join(', ')](node) { + const callNode = getParent(node); + const parentNode = getParent(callNode); + if (!isNull(parentNode.right) || !isStringType(node.object)) { + return; + } + const parsed = callNode.arguments.length === 1 + ? parseRegExp(callNode.arguments[0]) + : null; + if (parsed == null) { + return; + } + const { isStartsWith, text } = parsed; + context.report({ + node: callNode, + messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith', + *fix(fixer) { + if (!parentNode.operator.startsWith('!')) { + yield fixer.insertTextBefore(parentNode, '!'); + } + yield fixer.replaceTextRange(getPropertyRange(node), `${node.optional ? '?.' : '.'}${isStartsWith ? 'start' : 'end'}sWith`); + yield fixer.replaceText(callNode.arguments[0], JSON.stringify(text)); + yield fixer.removeRange([callNode.range[1], parentNode.range[1]]); + }, + }); + }, + // foo.slice(0, 3) === 'bar' + // foo.slice(-3) === 'bar' + // foo.slice(-3, foo.length) === 'bar' + // foo.substring(0, 3) === 'bar' + // foo.substring(foo.length - 3) === 'bar' + // foo.substring(foo.length - 3, foo.length) === 'bar' + [[ + 'BinaryExpression > CallExpression.left > MemberExpression', + 'BinaryExpression > ChainExpression.left > CallExpression > MemberExpression', + ].join(', ')](node) { + if (!(0, util_1.isStaticMemberAccessOfValue)(node, context, 'slice', 'substring')) { + return; + } + const callNode = getParent(node); + const parentNode = getParent(callNode); + if (!isEqualityComparison(parentNode) || !isStringType(node.object)) { + return; + } + let isEndsWith = false; + let isStartsWith = false; + if (callNode.arguments.length === 1) { + if ( + // foo.slice(-bar.length) === bar + // foo.slice(foo.length - bar.length) === bar + isLengthAheadOfEnd(callNode.arguments[0], parentNode.right, node.object)) { + isEndsWith = true; + } + } + else if (callNode.arguments.length === 2) { + if ( + // foo.slice(0, bar.length) === bar + isNumber(callNode.arguments[0], 0) && + isLengthExpression(callNode.arguments[1], parentNode.right)) { + isStartsWith = true; + } + else if ( + // foo.slice(foo.length - bar.length, foo.length) === bar + // foo.slice(foo.length - bar.length, 0) === bar + // foo.slice(-bar.length, foo.length) === bar + // foo.slice(-bar.length, 0) === bar + (isLengthExpression(callNode.arguments[1], node.object) || + isNumber(callNode.arguments[1], 0)) && + isLengthAheadOfEnd(callNode.arguments[0], parentNode.right, node.object)) { + isEndsWith = true; + } + } + if (!isStartsWith && !isEndsWith) { + return; + } + const eqNode = parentNode; + const negativeIndexSupported = node.property.name === 'slice'; + context.report({ + node: parentNode, + messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith', + fix(fixer) { + // Don't fix if it can change the behavior. + if (eqNode.operator.length === 2 && + (eqNode.right.type !== utils_1.AST_NODE_TYPES.Literal || + typeof eqNode.right.value !== 'string')) { + return null; + } + // code being checked is likely mistake: + // unequal length of strings being checked for equality + // or reliant on behavior of substring (negative indices interpreted as 0) + if (isStartsWith) { + if (!isLengthExpression(callNode.arguments[1], eqNode.right)) { + return null; + } + } + else { + const posNode = callNode.arguments[0]; + const posNodeIsAbsolutelyValid = (posNode.type === utils_1.AST_NODE_TYPES.BinaryExpression && + posNode.operator === '-' && + isLengthExpression(posNode.left, node.object) && + isLengthExpression(posNode.right, eqNode.right)) || + (negativeIndexSupported && + posNode.type === utils_1.AST_NODE_TYPES.UnaryExpression && + posNode.operator === '-' && + isLengthExpression(posNode.argument, eqNode.right)); + if (!posNodeIsAbsolutelyValid) { + return null; + } + } + return fixWithRightOperand(fixer, parentNode, isStartsWith ? 'start' : 'end', parentNode.operator.startsWith('!'), node.optional); + }, + }); + }, + // /^bar/.test(foo) + // /bar$/.test(foo) + 'CallExpression > MemberExpression.callee[property.name="test"][computed=false]'(node) { + const callNode = getParent(node); + const parsed = callNode.arguments.length === 1 ? parseRegExp(node.object) : null; + if (parsed == null) { + return; + } + const { isStartsWith, text } = parsed; + const messageId = isStartsWith ? 'preferStartsWith' : 'preferEndsWith'; + const methodName = isStartsWith ? 'startsWith' : 'endsWith'; + context.report({ + node: callNode, + messageId, + *fix(fixer) { + const argNode = callNode.arguments[0]; + const needsParen = argNode.type !== utils_1.AST_NODE_TYPES.Literal && + argNode.type !== utils_1.AST_NODE_TYPES.TemplateLiteral && + argNode.type !== utils_1.AST_NODE_TYPES.Identifier && + argNode.type !== utils_1.AST_NODE_TYPES.MemberExpression && + argNode.type !== utils_1.AST_NODE_TYPES.CallExpression; + yield fixer.removeRange([callNode.range[0], argNode.range[0]]); + if (needsParen) { + yield fixer.insertTextBefore(argNode, '('); + yield fixer.insertTextAfter(argNode, ')'); + } + yield fixer.insertTextAfter(argNode, `${node.optional ? '?.' : '.'}${methodName}(${JSON.stringify(text)}`); + }, + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-string-starts-ends-with.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.d.ts new file mode 100644 index 00000000..95bb5630 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.d.ts @@ -0,0 +1,5 @@ +export type MessageIds = 'preferExpectErrorComment'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.js new file mode 100644 index 00000000..f5fbac74 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-ts-expect-error.js @@ -0,0 +1,72 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'prefer-ts-expect-error', + meta: { + type: 'problem', + deprecated: { + deprecatedSince: '7.11.0', + replacedBy: [ + { + rule: { + name: '@typescript-eslint/ban-ts-comment', + url: 'https://typescript-eslint.io/rules/ban-ts-comment', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/9081', + }, + docs: { + description: 'Enforce using `@ts-expect-error` over `@ts-ignore`', + }, + fixable: 'code', + messages: { + preferExpectErrorComment: 'Use "@ts-expect-error" to ensure an error is actually being suppressed.', + }, + replacedBy: ['@typescript-eslint/ban-ts-comment'], + schema: [], + }, + defaultOptions: [], + create(context) { + const tsIgnoreRegExpSingleLine = /^\s*\/?\s*@ts-ignore/; + const tsIgnoreRegExpMultiLine = /^\s*(?:\/|\*)*\s*@ts-ignore/; + function isLineComment(comment) { + return comment.type === utils_1.AST_TOKEN_TYPES.Line; + } + function getLastCommentLine(comment) { + if (isLineComment(comment)) { + return comment.value; + } + // For multiline comments - we look at only the last line. + const commentlines = comment.value.split(utils_1.ASTUtils.LINEBREAK_MATCHER); + return commentlines[commentlines.length - 1]; + } + function isValidTsIgnorePresent(comment) { + const line = getLastCommentLine(comment); + return isLineComment(comment) + ? tsIgnoreRegExpSingleLine.test(line) + : tsIgnoreRegExpMultiLine.test(line); + } + return { + Program() { + const comments = context.sourceCode.getAllComments(); + comments.forEach(comment => { + if (isValidTsIgnorePresent(comment)) { + const lineCommentRuleFixer = (fixer) => fixer.replaceText(comment, `//${comment.value.replace('@ts-ignore', '@ts-expect-error')}`); + const blockCommentRuleFixer = (fixer) => fixer.replaceText(comment, `/*${comment.value.replace('@ts-ignore', '@ts-expect-error')}*/`); + context.report({ + node: comment, + messageId: 'preferExpectErrorComment', + fix: isLineComment(comment) + ? lineCommentRuleFixer + : blockCommentRuleFixer, + }); + } + }); + }, + }; + }, +}); +//# sourceMappingURL=prefer-ts-expect-error.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.d.ts new file mode 100644 index 00000000..60ae3b7d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.d.ts @@ -0,0 +1,15 @@ +export type Options = [ + { + allowAny?: boolean; + allowedPromiseNames?: string[]; + checkArrowFunctions?: boolean; + checkFunctionDeclarations?: boolean; + checkFunctionExpressions?: boolean; + checkMethodDeclarations?: boolean; + } +]; +export type MessageIds = 'missingAsync' | 'missingAsyncHybridReturn'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.js new file mode 100644 index 00000000..47ef45f8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/promise-function-async.js @@ -0,0 +1,205 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'promise-function-async', + meta: { + type: 'suggestion', + docs: { + description: 'Require any function or method that returns a Promise to be marked async', + requiresTypeChecking: true, + }, + fixable: 'code', + messages: { + missingAsync: 'Functions that return promises must be async.', + missingAsyncHybridReturn: 'Functions that return promises must be async. Consider adding an explicit return type annotation if the function is intended to return a union of promise and non-promise types.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowAny: { + type: 'boolean', + description: 'Whether to consider `any` and `unknown` to be Promises.', + }, + allowedPromiseNames: { + type: 'array', + description: 'Any extra names of classes or interfaces to be considered Promises.', + items: { + type: 'string', + }, + }, + checkArrowFunctions: { + type: 'boolean', + description: 'Whether to check arrow functions.', + }, + checkFunctionDeclarations: { + type: 'boolean', + description: 'Whether to check standalone function declarations.', + }, + checkFunctionExpressions: { + type: 'boolean', + description: 'Whether to check inline function expressions', + }, + checkMethodDeclarations: { + type: 'boolean', + description: 'Whether to check methods on classes and object literals.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowAny: true, + allowedPromiseNames: [], + checkArrowFunctions: true, + checkFunctionDeclarations: true, + checkFunctionExpressions: true, + checkMethodDeclarations: true, + }, + ], + create(context, [{ allowAny, allowedPromiseNames, checkArrowFunctions, checkFunctionDeclarations, checkFunctionExpressions, checkMethodDeclarations, },]) { + const allAllowedPromiseNames = new Set([ + 'Promise', + // https://github.com/typescript-eslint/typescript-eslint/issues/5439 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + ...allowedPromiseNames, + ]); + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + function validateNode(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) { + // Abstract method can't be async + return; + } + if ((node.parent.type === utils_1.AST_NODE_TYPES.Property || + node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) && + (node.parent.kind === 'get' || node.parent.kind === 'set')) { + // Getters and setters can't be async + return; + } + const signatures = services.getTypeAtLocation(node).getCallSignatures(); + if (!signatures.length) { + return; + } + const returnTypes = signatures.map(signature => checker.getReturnTypeOfSignature(signature)); + if (!allowAny && + returnTypes.some(type => (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) { + // Report without auto fixer because the return type is unknown + return context.report({ + loc: (0, util_1.getFunctionHeadLoc)(node, context.sourceCode), + node, + messageId: 'missingAsync', + }); + } + if ( + // require all potential return types to be promise/any/unknown + returnTypes.every(type => (0, util_1.containsAllTypesByName)(type, true, allAllowedPromiseNames, + // If no return type is explicitly set, we check if any parts of the return type match a Promise (instead of requiring all to match). + node.returnType == null))) { + const isHybridReturnType = returnTypes.some(type => type.isUnion() && + !type.types.every(part => (0, util_1.containsAllTypesByName)(part, true, allAllowedPromiseNames))); + context.report({ + loc: (0, util_1.getFunctionHeadLoc)(node, context.sourceCode), + node, + messageId: isHybridReturnType + ? 'missingAsyncHybridReturn' + : 'missingAsync', + fix: fixer => { + if (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition || + (node.parent.type === utils_1.AST_NODE_TYPES.Property && + node.parent.method)) { + // this function is a class method or object function property shorthand + const method = node.parent; + // the token to put `async` before + let keyToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(method), util_1.NullThrowsReasons.MissingToken('key token', 'method')); + // if there are decorators then skip past them + if (method.type === utils_1.AST_NODE_TYPES.MethodDefinition && + method.decorators.length) { + const lastDecorator = method.decorators[method.decorators.length - 1]; + keyToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(lastDecorator), util_1.NullThrowsReasons.MissingToken('key token', 'last decorator')); + } + // if current token is a keyword like `static` or `public`, or the `override` modifier, then skip it + while ((keyToken.type === utils_1.AST_TOKEN_TYPES.Keyword || + (keyToken.type === utils_1.AST_TOKEN_TYPES.Identifier && + keyToken.value === 'override')) && + keyToken.range[0] < method.key.range[0]) { + keyToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(keyToken), util_1.NullThrowsReasons.MissingToken('token', 'modifier keyword')); + } + // check if there is a space between key and previous token + const insertSpace = !context.sourceCode.isSpaceBetween((0, util_1.nullThrows)(context.sourceCode.getTokenBefore(keyToken), util_1.NullThrowsReasons.MissingToken('token', 'keyword')), keyToken); + let code = 'async '; + if (insertSpace) { + code = ` ${code}`; + } + return fixer.insertTextBefore(keyToken, code); + } + return fixer.insertTextBefore(node, 'async '); + }, + }); + } + } + return { + ...(checkArrowFunctions && { + 'ArrowFunctionExpression[async = false]'(node) { + validateNode(node); + }, + }), + ...(checkFunctionDeclarations && { + 'FunctionDeclaration[async = false]'(node) { + validateNode(node); + }, + }), + 'FunctionExpression[async = false]'(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.parent.kind === 'method') { + if (checkMethodDeclarations) { + validateNode(node); + } + return; + } + if (checkFunctionExpressions) { + validateNode(node); + } + }, + }; + }, +}); +//# sourceMappingURL=promise-function-async.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.d.ts new file mode 100644 index 00000000..3878d5b6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.js new file mode 100644 index 00000000..562c26b8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/related-getter-setter-pairs.js @@ -0,0 +1,72 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'related-getter-setter-pairs', + meta: { + type: 'problem', + docs: { + description: 'Enforce that `get()` types should be assignable to their equivalent `set()` type', + recommended: 'strict', + requiresTypeChecking: true, + }, + messages: { + mismatch: '`get()` type should be assignable to its equivalent `set()` type.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const methodPairsStack = []; + function addPropertyNode(member, inner, kind) { + const methodPairs = methodPairsStack[methodPairsStack.length - 1]; + const { name } = (0, util_1.getNameFromMember)(member, context.sourceCode); + methodPairs.set(name, { + ...methodPairs.get(name), + [kind]: inner, + }); + } + return { + ':matches(ClassBody, TSInterfaceBody, TSTypeLiteral):exit'() { + const methodPairs = methodPairsStack[methodPairsStack.length - 1]; + for (const pair of methodPairs.values()) { + if (!pair.get || !pair.set) { + continue; + } + const getter = pair.get; + const getType = services.getTypeAtLocation(getter); + const setType = services.getTypeAtLocation(pair.set.params[0]); + if (!checker.isTypeAssignableTo(getType, setType)) { + context.report({ + node: getter.returnType.typeAnnotation, + messageId: 'mismatch', + }); + } + } + methodPairsStack.pop(); + }, + ':matches(MethodDefinition, TSMethodSignature)[kind=get]'(node) { + const getter = getMethodFromNode(node); + if (getter.returnType) { + addPropertyNode(node, getter, 'get'); + } + }, + ':matches(MethodDefinition, TSMethodSignature)[kind=set]'(node) { + const setter = getMethodFromNode(node); + if (setter.params.length === 1) { + addPropertyNode(node, setter, 'set'); + } + }, + 'ClassBody, TSInterfaceBody, TSTypeLiteral'() { + methodPairsStack.push(new Map()); + }, + }; + }, +}); +function getMethodFromNode(node) { + return node.type === utils_1.AST_NODE_TYPES.TSMethodSignature ? node : node.value; +} +//# sourceMappingURL=related-getter-setter-pairs.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.d.ts new file mode 100644 index 00000000..59d778e4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.d.ts @@ -0,0 +1,10 @@ +export type Options = [ + { + ignoreStringArrays?: boolean; + } +]; +export type MessageIds = 'requireCompare'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.js new file mode 100644 index 00000000..e079a79a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.js @@ -0,0 +1,64 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'require-array-sort-compare', + meta: { + type: 'problem', + docs: { + description: 'Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction`', + requiresTypeChecking: true, + }, + messages: { + requireCompare: "Require 'compare' argument.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreStringArrays: { + type: 'boolean', + description: 'Whether to ignore arrays in which all elements are strings.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreStringArrays: true, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + /** + * Check if a given node is an array which all elements are string. + */ + function isStringArrayNode(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + if (checker.isArrayType(type) || checker.isTupleType(type)) { + const typeArgs = checker.getTypeArguments(type); + return typeArgs.every(arg => (0, util_1.getTypeName)(checker, arg) === 'string'); + } + return false; + } + function checkSortArgument(callee) { + if (!(0, util_1.isStaticMemberAccessOfValue)(callee, context, 'sort', 'toSorted')) { + return; + } + const calleeObjType = (0, util_1.getConstrainedTypeAtLocation)(services, callee.object); + if (options.ignoreStringArrays && isStringArrayNode(callee.object)) { + return; + } + if ((0, util_1.isTypeArrayTypeOrUnionOfArrayTypes)(calleeObjType, checker)) { + context.report({ node: callee.parent, messageId: 'requireCompare' }); + } + } + return { + 'CallExpression[arguments.length=0] > MemberExpression': checkSortArgument, + }; + }, +}); +//# sourceMappingURL=require-array-sort-compare.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.d.ts new file mode 100644 index 00000000..2b28e806 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.d.ts @@ -0,0 +1,4 @@ +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.js new file mode 100644 index 00000000..7c16637e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-await.js @@ -0,0 +1,264 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'require-await', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow async functions which do not return promises and have no `await` expression', + extendsBaseRule: true, + recommended: 'recommended', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + missingAwait: "{{name}} has no 'await' expression.", + removeAsync: "Remove 'async'.", + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + let scopeInfo = null; + /** + * Push the scope info object to the stack. + */ + function enterFunction(node) { + scopeInfo = { + hasAsync: node.async, + hasAwait: false, + isAsyncYield: false, + isGen: node.generator || false, + upper: scopeInfo, + }; + } + /** + * Pop the top scope info object from the stack. + * Also, it reports the function if needed. + */ + function exitFunction(node) { + /* istanbul ignore if */ if (!scopeInfo) { + // this shouldn't ever happen, as we have to exit a function after we enter it + return; + } + if (node.async && + !scopeInfo.hasAwait && + !isEmptyFunction(node) && + !(scopeInfo.isGen && scopeInfo.isAsyncYield)) { + // If the function belongs to a method definition or + // property, then the function's range may not include the + // `async` keyword and we should look at the parent instead. + const nodeWithAsyncKeyword = (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && + node.parent.value === node) || + (node.parent.type === utils_1.AST_NODE_TYPES.Property && + node.parent.method && + node.parent.value === node) + ? node.parent + : node; + const asyncToken = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(nodeWithAsyncKeyword, token => token.value === 'async'), 'The node is an async function, so it must have an "async" token.'); + const asyncRange = [ + asyncToken.range[0], + (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(asyncToken, { + includeComments: true, + }), 'There will always be a token after the "async" keyword.').range[0], + ]; + // Removing the `async` keyword can cause parsing errors if the + // current statement is relying on automatic semicolon insertion. + // If ASI is currently being used, then we should replace the + // `async` keyword with a semicolon. + const nextToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(asyncToken), 'There will always be a token after the "async" keyword.'); + const addSemiColon = nextToken.type === utils_1.AST_TOKEN_TYPES.Punctuator && + (nextToken.value === '[' || nextToken.value === '(') && + (nodeWithAsyncKeyword.type === utils_1.AST_NODE_TYPES.MethodDefinition || + (0, util_1.isStartOfExpressionStatement)(nodeWithAsyncKeyword)) && + (0, util_1.needsPrecedingSemicolon)(context.sourceCode, nodeWithAsyncKeyword); + const changes = [ + { range: asyncRange, replacement: addSemiColon ? ';' : undefined }, + ]; + // If there's a return type annotation and it's a + // `Promise`, we can also change the return type + // annotation to just `T` as part of the suggestion. + // Alternatively, if the function is a generator and + // the return type annotation is `AsyncGenerator`, + // then we can change it to `Generator`. + if (node.returnType?.typeAnnotation.type === + utils_1.AST_NODE_TYPES.TSTypeReference) { + if (scopeInfo.isGen) { + if (hasTypeName(node.returnType.typeAnnotation, 'AsyncGenerator')) { + changes.push({ + range: node.returnType.typeAnnotation.typeName.range, + replacement: 'Generator', + }); + } + } + else if (hasTypeName(node.returnType.typeAnnotation, 'Promise') && + node.returnType.typeAnnotation.typeArguments != null) { + const openAngle = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(node.returnType.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === '<'), 'There are type arguments, so the angle bracket will exist.'); + const closeAngle = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node.returnType.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && + token.value === '>'), 'There are type arguments, so the angle bracket will exist.'); + changes.push( + // Remove the closing angled bracket. + { range: closeAngle.range, replacement: undefined }, + // Remove the "Promise" identifier + // and the opening angled bracket. + { + range: [ + node.returnType.typeAnnotation.typeName.range[0], + openAngle.range[1], + ], + replacement: undefined, + }); + } + } + context.report({ + loc: (0, util_1.getFunctionHeadLoc)(node, context.sourceCode), + node, + messageId: 'missingAwait', + data: { + name: (0, util_1.upperCaseFirst)((0, util_1.getFunctionNameWithKind)(node)), + }, + suggest: [ + { + messageId: 'removeAsync', + fix: (fixer) => changes.map(change => change.replacement != null + ? fixer.replaceTextRange(change.range, change.replacement) + : fixer.removeRange(change.range)), + }, + ], + }); + } + scopeInfo = scopeInfo.upper; + } + /** + * Checks if the node returns a thenable type + */ + function isThenableType(node) { + const type = checker.getTypeAtLocation(node); + return tsutils.isThenableType(checker, node, type); + } + /** + * Marks the current scope as having an await + */ + function markAsHasAwait() { + if (!scopeInfo) { + return; + } + scopeInfo.hasAwait = true; + } + /** + * Mark `scopeInfo.isAsyncYield` to `true` if it + * 1) delegates async generator function + * or + * 2) yields thenable type + */ + function visitYieldExpression(node) { + if (!scopeInfo?.isGen || !node.argument) { + return; + } + if (node.argument.type === utils_1.AST_NODE_TYPES.Literal) { + // ignoring this as for literals we don't need to check the definition + // eg : async function* run() { yield* 1 } + return; + } + if (!node.delegate) { + if (isThenableType(services.esTreeNodeToTSNodeMap.get(node.argument))) { + scopeInfo.isAsyncYield = true; + } + return; + } + const type = services.getTypeAtLocation(node.argument); + const typesToCheck = expandUnionOrIntersectionType(type); + for (const type of typesToCheck) { + const asyncIterator = tsutils.getWellKnownSymbolPropertyOfType(type, 'asyncIterator', checker); + if (asyncIterator != null) { + scopeInfo.isAsyncYield = true; + break; + } + } + } + return { + ArrowFunctionExpression: enterFunction, + 'ArrowFunctionExpression:exit': exitFunction, + AwaitExpression: markAsHasAwait, + 'ForOfStatement[await = true]': markAsHasAwait, + FunctionDeclaration: enterFunction, + 'FunctionDeclaration:exit': exitFunction, + FunctionExpression: enterFunction, + 'FunctionExpression:exit': exitFunction, + 'VariableDeclaration[kind = "await using"]': markAsHasAwait, + YieldExpression: visitYieldExpression, + // check body-less async arrow function. + // ignore `async () => await foo` because it's obviously correct + 'ArrowFunctionExpression[async = true] > :not(BlockStatement, AwaitExpression)'(node) { + const expression = services.esTreeNodeToTSNodeMap.get(node); + if (isThenableType(expression)) { + markAsHasAwait(); + } + }, + ReturnStatement(node) { + // short circuit early to avoid unnecessary type checks + if (!scopeInfo || scopeInfo.hasAwait || !scopeInfo.hasAsync) { + return; + } + const { expression } = services.esTreeNodeToTSNodeMap.get(node); + if (expression && isThenableType(expression)) { + markAsHasAwait(); + } + }, + }; + }, +}); +function isEmptyFunction(node) { + return (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement && + node.body.body.length === 0); +} +function expandUnionOrIntersectionType(type) { + if (type.isUnionOrIntersection()) { + return type.types.flatMap(expandUnionOrIntersectionType); + } + return [type]; +} +function hasTypeName(typeReference, typeName) { + return (typeReference.typeName.type === utils_1.AST_NODE_TYPES.Identifier && + typeReference.typeName.name === typeName); +} +//# sourceMappingURL=require-await.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.d.ts new file mode 100644 index 00000000..4b2ceb56 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.d.ts @@ -0,0 +1,15 @@ +export type Options = [ + { + allowAny?: boolean; + allowBoolean?: boolean; + allowNullish?: boolean; + allowNumberAndString?: boolean; + allowRegExp?: boolean; + skipCompoundAssignments?: boolean; + } +]; +export type MessageIds = 'bigintAndNumber' | 'invalid' | 'mismatched'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js new file mode 100644 index 00000000..eaf8d559 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js @@ -0,0 +1,232 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'restrict-plus-operands', + meta: { + type: 'problem', + docs: { + description: 'Require both operands of addition to be the same type and be `bigint`, `number`, or `string`', + recommended: { + recommended: true, + strict: [ + { + allowAny: false, + allowBoolean: false, + allowNullish: false, + allowNumberAndString: false, + allowRegExp: false, + }, + ], + }, + requiresTypeChecking: true, + }, + messages: { + bigintAndNumber: "Numeric '+' operations must either be both bigints or both numbers. Got `{{left}}` + `{{right}}`.", + invalid: "Invalid operand for a '+' operation. Operands must each be a number or {{stringLike}}. Got `{{type}}`.", + mismatched: "Operands of '+' operations must be a number or {{stringLike}}. Got `{{left}}` + `{{right}}`.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowAny: { + type: 'boolean', + description: 'Whether to allow `any` typed values.', + }, + allowBoolean: { + type: 'boolean', + description: 'Whether to allow `boolean` typed values.', + }, + allowNullish: { + type: 'boolean', + description: 'Whether to allow potentially `null` or `undefined` typed values.', + }, + allowNumberAndString: { + type: 'boolean', + description: 'Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.', + }, + allowRegExp: { + type: 'boolean', + description: 'Whether to allow `regexp` typed values.', + }, + skipCompoundAssignments: { + type: 'boolean', + description: 'Whether to skip compound assignments such as `+=`.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowAny: true, + allowBoolean: true, + allowNullish: true, + allowNumberAndString: true, + allowRegExp: true, + skipCompoundAssignments: false, + }, + ], + create(context, [{ allowAny, allowBoolean, allowNullish, allowNumberAndString, allowRegExp, skipCompoundAssignments, },]) { + const services = (0, util_1.getParserServices)(context); + const typeChecker = services.program.getTypeChecker(); + const stringLikes = [ + allowAny && '`any`', + allowBoolean && '`boolean`', + allowNullish && '`null`', + allowRegExp && '`RegExp`', + allowNullish && '`undefined`', + ].filter((value) => typeof value === 'string'); + const stringLike = stringLikes.length + ? stringLikes.length === 1 + ? `string, allowing a string + ${stringLikes[0]}` + : `string, allowing a string + any of: ${stringLikes.join(', ')}` + : 'string'; + function getTypeConstrained(node) { + return typeChecker.getBaseTypeOfLiteralType((0, util_1.getConstrainedTypeAtLocation)(services, node)); + } + function checkPlusOperands(node) { + const leftType = getTypeConstrained(node.left); + const rightType = getTypeConstrained(node.right); + if (leftType === rightType && + tsutils.isTypeFlagSet(leftType, ts.TypeFlags.BigIntLike | + ts.TypeFlags.NumberLike | + ts.TypeFlags.StringLike)) { + return; + } + let hadIndividualComplaint = false; + for (const [baseNode, baseType, otherType] of [ + [node.left, leftType, rightType], + [node.right, rightType, leftType], + ]) { + if (isTypeFlagSetInUnion(baseType, ts.TypeFlags.ESSymbolLike | + ts.TypeFlags.Never | + ts.TypeFlags.Unknown) || + (!allowAny && isTypeFlagSetInUnion(baseType, ts.TypeFlags.Any)) || + (!allowBoolean && + isTypeFlagSetInUnion(baseType, ts.TypeFlags.BooleanLike)) || + (!allowNullish && + (0, util_1.isTypeFlagSet)(baseType, ts.TypeFlags.Null | ts.TypeFlags.Undefined))) { + context.report({ + node: baseNode, + messageId: 'invalid', + data: { + type: typeChecker.typeToString(baseType), + stringLike, + }, + }); + hadIndividualComplaint = true; + continue; + } + // RegExps also contain ts.TypeFlags.Any & ts.TypeFlags.Object + for (const subBaseType of tsutils.unionConstituents(baseType)) { + const typeName = (0, util_1.getTypeName)(typeChecker, subBaseType); + if (typeName === 'RegExp' + ? !allowRegExp || + tsutils.isTypeFlagSet(otherType, ts.TypeFlags.NumberLike) + : (!allowAny && (0, util_1.isTypeAnyType)(subBaseType)) || + isDeeplyObjectType(subBaseType)) { + context.report({ + node: baseNode, + messageId: 'invalid', + data: { + type: typeChecker.typeToString(subBaseType), + stringLike, + }, + }); + hadIndividualComplaint = true; + continue; + } + } + } + if (hadIndividualComplaint) { + return; + } + for (const [baseType, otherType] of [ + [leftType, rightType], + [rightType, leftType], + ]) { + if (!allowNumberAndString && + isTypeFlagSetInUnion(baseType, ts.TypeFlags.StringLike) && + isTypeFlagSetInUnion(otherType, ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike)) { + return context.report({ + node, + messageId: 'mismatched', + data: { + left: typeChecker.typeToString(leftType), + right: typeChecker.typeToString(rightType), + stringLike, + }, + }); + } + if (isTypeFlagSetInUnion(baseType, ts.TypeFlags.NumberLike) && + isTypeFlagSetInUnion(otherType, ts.TypeFlags.BigIntLike)) { + return context.report({ + node, + messageId: 'bigintAndNumber', + data: { + left: typeChecker.typeToString(leftType), + right: typeChecker.typeToString(rightType), + }, + }); + } + } + } + return { + "BinaryExpression[operator='+']": checkPlusOperands, + ...(!skipCompoundAssignments && { + "AssignmentExpression[operator='+=']"(node) { + checkPlusOperands(node); + }, + }), + }; + }, +}); +function isDeeplyObjectType(type) { + return type.isIntersection() + ? tsutils.intersectionConstituents(type).every(tsutils.isObjectType) + : tsutils.unionConstituents(type).every(tsutils.isObjectType); +} +function isTypeFlagSetInUnion(type, flag) { + return tsutils + .unionConstituents(type) + .some(subType => tsutils.isTypeFlagSet(subType, flag)); +} +//# sourceMappingURL=restrict-plus-operands.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.d.ts new file mode 100644 index 00000000..015af38b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.d.ts @@ -0,0 +1,19 @@ +import type { Type, TypeChecker } from 'typescript'; +import type { TypeOrValueSpecifier } from '../util'; +import { isTypeAnyType, isTypeNeverType } from '../util'; +type OptionTester = (type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean; +declare const optionTesters: { + type: "Any" | "Array" | "Boolean" | "Never" | "Nullish" | "Number" | "RegExp"; + option: "allowAny" | "allowArray" | "allowBoolean" | "allowNever" | "allowNullish" | "allowNumber" | "allowRegExp"; + tester: OptionTester | typeof isTypeNeverType | typeof isTypeAnyType | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean); +}[]; +export type Options = [ + { + allow?: TypeOrValueSpecifier[]; + } & Partial> +]; +export type MessageId = 'invalidType'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.js new file mode 100644 index 00000000..95eec88b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-template-expressions.js @@ -0,0 +1,120 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const type_utils_1 = require("@typescript-eslint/type-utils"); +const utils_1 = require("@typescript-eslint/utils"); +const typescript_1 = require("typescript"); +const util_1 = require("../util"); +const testTypeFlag = (flagsToCheck) => type => (0, util_1.isTypeFlagSet)(type, flagsToCheck); +const optionTesters = [ + ['Any', util_1.isTypeAnyType], + [ + 'Array', + (type, checker, recursivelyCheckType) => (checker.isArrayType(type) || checker.isTupleType(type)) && + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + recursivelyCheckType(type.getNumberIndexType()), + ], + // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum + ['Boolean', testTypeFlag(typescript_1.TypeFlags.BooleanLike)], + ['Nullish', testTypeFlag(typescript_1.TypeFlags.Null | typescript_1.TypeFlags.Undefined)], + ['Number', testTypeFlag(typescript_1.TypeFlags.NumberLike | typescript_1.TypeFlags.BigIntLike)], + [ + 'RegExp', + (type, checker) => (0, util_1.getTypeName)(checker, type) === 'RegExp', + ], + ['Never', util_1.isTypeNeverType], +].map(([type, tester]) => ({ + type, + option: `allow${type}`, + tester, +})); +exports.default = (0, util_1.createRule)({ + name: 'restrict-template-expressions', + meta: { + type: 'problem', + docs: { + description: 'Enforce template literal expressions to be of `string` type', + recommended: { + recommended: true, + strict: [ + { + allowAny: false, + allowBoolean: false, + allowNever: false, + allowNullish: false, + allowNumber: false, + allowRegExp: false, + }, + ], + }, + requiresTypeChecking: true, + }, + messages: { + invalidType: 'Invalid type "{{type}}" of template literal expression.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ...Object.fromEntries(optionTesters.map(({ type, option }) => [ + option, + { + type: 'boolean', + description: `Whether to allow \`${type.toLowerCase()}\` typed values in template expressions.`, + }, + ])), + allow: { + description: `Types to allow in template expressions.`, + ...type_utils_1.typeOrValueSpecifiersSchema, + }, + }, + }, + ], + }, + defaultOptions: [ + { + allow: [{ name: ['Error', 'URL', 'URLSearchParams'], from: 'lib' }], + allowAny: true, + allowBoolean: true, + allowNullish: true, + allowNumber: true, + allowRegExp: true, + }, + ], + create(context, [{ allow, ...options }]) { + const services = (0, util_1.getParserServices)(context); + const { program } = services; + const checker = program.getTypeChecker(); + const enabledOptionTesters = optionTesters.filter(({ option }) => options[option]); + return { + TemplateLiteral(node) { + // don't check tagged template literals + if (node.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) { + return; + } + for (const expression of node.expressions) { + const expressionType = (0, util_1.getConstrainedTypeAtLocation)(services, expression); + if (!recursivelyCheckType(expressionType)) { + context.report({ + node: expression, + messageId: 'invalidType', + data: { type: checker.typeToString(expressionType) }, + }); + } + } + }, + }; + function recursivelyCheckType(innerType) { + if (innerType.isUnion()) { + return innerType.types.every(recursivelyCheckType); + } + if (innerType.isIntersection()) { + return innerType.types.some(recursivelyCheckType); + } + return ((0, util_1.isTypeFlagSet)(innerType, typescript_1.TypeFlags.StringLike) || + (0, util_1.matchesTypeOrBaseType)(services, type => (0, type_utils_1.typeMatchesSomeSpecifier)(type, allow, program), innerType) || + enabledOptionTesters.some(({ tester }) => tester(innerType, checker, recursivelyCheckType))); + } + }, +}); +//# sourceMappingURL=restrict-template-expressions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.d.ts new file mode 100644 index 00000000..4e865c0c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.d.ts @@ -0,0 +1,5 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.js new file mode 100644 index 00000000..41e686a8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.js @@ -0,0 +1,365 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'return-await', + meta: { + type: 'problem', + docs: { + description: 'Enforce consistent awaiting of returned promises', + recommended: { + strict: ['error-handling-correctness-only'], + }, + requiresTypeChecking: true, + }, + fixable: 'code', + // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- suggestions are exposed through a helper. + hasSuggestions: true, + messages: { + disallowedPromiseAwait: 'Returning an awaited promise is not allowed in this context.', + disallowedPromiseAwaitSuggestion: 'Remove `await` before the expression. Use caution as this may impact control flow.', + nonPromiseAwait: 'Returning an awaited value that is not a promise is not allowed.', + requiredPromiseAwait: 'Returning an awaited promise is required in this context.', + requiredPromiseAwaitSuggestion: 'Add `await` before the expression. Use caution as this may impact control flow.', + }, + schema: [ + { + type: 'string', + oneOf: [ + { + type: 'string', + description: 'Requires that all returned promises be awaited.', + enum: ['always'], + }, + { + type: 'string', + description: 'In error-handling contexts, the rule enforces that returned promises must be awaited. In ordinary contexts, the rule does not enforce any particular behavior around whether returned promises are awaited.', + enum: ['error-handling-correctness-only'], + }, + { + type: 'string', + description: 'In error-handling contexts, the rule enforces that returned promises must be awaited. In ordinary contexts, the rule enforces that returned promises _must not_ be awaited.', + enum: ['in-try-catch'], + }, + { + type: 'string', + description: 'Disallows awaiting any returned promises.', + enum: ['never'], + }, + ], + }, + ], + }, + defaultOptions: ['in-try-catch'], + create(context, [option]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const scopeInfoStack = []; + function enterFunction(node) { + scopeInfoStack.push({ + hasAsync: node.async, + owningFunc: node, + }); + } + function exitFunction() { + scopeInfoStack.pop(); + } + function affectsExplicitResourceManagement(node) { + // just need to determine if there is a `using` declaration in scope. + let scope = context.sourceCode.getScope(node); + const functionScope = scope.variableScope; + while (true) { + for (const variable of scope.variables) { + if (variable.defs.length !== 1) { + // This can't be the case for `using` or `await using` since it's + // an error to redeclare those more than once in the same scope, + // unlike, say, `var` declarations. + continue; + } + const declaration = variable.defs[0]; + const declaratorNode = declaration.node; + const declarationNode = declaratorNode.parent; + // if it's a using/await using declaration, and it comes _before_ the + // node we're checking, it affects control flow for that node. + if (['await using', 'using'].includes(declarationNode.kind) && + declaratorNode.range[1] < node.range[0]) { + return true; + } + } + if (scope === functionScope) { + // We've checked all the relevant scopes + break; + } + // This should always exist, since the rule should only be checking + // contexts in which `return` statements are legal, which should always + // be inside a function. + scope = (0, util_1.nullThrows)(scope.upper, 'Expected parent scope to exist. return-await should only operate on return statements within functions'); + } + return false; + } + /** + * Tests whether a node is inside of an explicit error handling context + * (try/catch/finally) in a way that throwing an exception will have an + * impact on the program's control flow. + */ + function affectsExplicitErrorHandling(node) { + // If an error-handling block is followed by another error-handling block, + // control flow is affected by whether promises in it are awaited or not. + // Otherwise, we need to check recursively for nested try statements until + // we get to the top level of a function or the program. If by then, + // there's no offending error-handling blocks, it doesn't affect control + // flow. + const tryAncestorResult = findContainingTryStatement(node); + if (tryAncestorResult == null) { + return false; + } + const { block, tryStatement } = tryAncestorResult; + switch (block) { + case 'catch': + // Exceptions thrown in catch blocks followed by a finally block affect + // control flow. + if (tryStatement.finallyBlock != null) { + return true; + } + // Otherwise recurse. + return affectsExplicitErrorHandling(tryStatement); + case 'finally': + return affectsExplicitErrorHandling(tryStatement); + case 'try': + // Try blocks are always followed by either a catch or finally, + // so exceptions thrown here always affect control flow. + return true; + default: { + const __never = block; + throw new Error(`Unexpected block type: ${String(__never)}`); + } + } + } + /** + * A try _statement_ is the whole thing that encompasses try block, + * catch clause, and finally block. This function finds the nearest + * enclosing try statement (if present) for a given node, and reports which + * part of the try statement the node is in. + */ + function findContainingTryStatement(node) { + let child = node; + let ancestor = node.parent; + while (ancestor && !ts.isFunctionLike(ancestor)) { + if (ts.isTryStatement(ancestor)) { + let block; + if (child === ancestor.tryBlock) { + block = 'try'; + } + else if (child === ancestor.catchClause) { + block = 'catch'; + } + else if (child === ancestor.finallyBlock) { + block = 'finally'; + } + return { + block: (0, util_1.nullThrows)(block, 'Child of a try statement must be a try block, catch clause, or finally block'), + tryStatement: ancestor, + }; + } + child = ancestor; + ancestor = ancestor.parent; + } + return undefined; + } + function removeAwait(fixer, node) { + // Should always be an await node; but let's be safe. + /* istanbul ignore if */ if (!(0, util_1.isAwaitExpression)(node)) { + return null; + } + const awaitToken = context.sourceCode.getFirstToken(node, util_1.isAwaitKeyword); + // Should always be the case; but let's be safe. + /* istanbul ignore if */ if (!awaitToken) { + return null; + } + const awaitTokenRemovalRange = (0, util_1.getAwaitTokenRemovalRange)(context.sourceCode, awaitToken); + const awaitRemovalFix = fixer.removeRange(awaitTokenRemovalRange); + const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitToken), util_1.NullThrowsReasons.MissingToken('operand', 'await expression')); + if ((0, util_1.isStartOfArrowFunctionBodyNeedingParentheses)(node, firstOperandToken, context.sourceCode)) { + return [ + awaitRemovalFix, + fixer.insertTextBefore(node.argument, '('), + fixer.insertTextAfter(node.argument, ')'), + ]; + } + return awaitRemovalFix; + } + function insertAwait(fixer, node, isHighPrecedence) { + if (isHighPrecedence) { + return fixer.insertTextBefore(node, 'await '); + } + return [ + fixer.insertTextBefore(node, 'await ('), + fixer.insertTextAfter(node, ')'), + ]; + } + function test(node, expression) { + let child; + const isAwait = ts.isAwaitExpression(expression); + if (isAwait) { + child = expression.getChildAt(1); + } + else { + child = expression; + } + const type = checker.getTypeAtLocation(child); + const certainty = (0, util_1.needsToBeAwaited)(checker, expression, type); + // handle awaited _non_thenables + if (certainty !== util_1.Awaitable.Always) { + if (isAwait) { + if (certainty === util_1.Awaitable.May) { + return; + } + context.report({ + node, + messageId: 'nonPromiseAwait', + fix: fixer => removeAwait(fixer, node), + }); + } + return; + } + // At this point it's definitely a thenable. + const affectsErrorHandling = affectsExplicitErrorHandling(expression) || + affectsExplicitResourceManagement(node); + const useAutoFix = !affectsErrorHandling; + const ruleConfiguration = getConfiguration(option); + const shouldAwaitInCurrentContext = affectsErrorHandling + ? ruleConfiguration.errorHandlingContext + : ruleConfiguration.ordinaryContext; + switch (shouldAwaitInCurrentContext) { + case 'await': + if (!isAwait) { + context.report({ + node, + messageId: 'requiredPromiseAwait', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: useAutoFix ? 'fix' : 'suggest', + suggestion: { + messageId: 'requiredPromiseAwaitSuggestion', + fix: fixer => insertAwait(fixer, node, (0, util_1.isHigherPrecedenceThanAwait)(expression)), + }, + }), + }); + } + break; + case "don't-care": + break; + case 'no-await': + if (isAwait) { + context.report({ + node, + messageId: 'disallowedPromiseAwait', + ...(0, util_1.getFixOrSuggest)({ + fixOrSuggest: useAutoFix ? 'fix' : 'suggest', + suggestion: { + messageId: 'disallowedPromiseAwaitSuggestion', + fix: fixer => removeAwait(fixer, node), + }, + }), + }); + } + break; + } + } + function findPossiblyReturnedNodes(node) { + if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) { + return [ + ...findPossiblyReturnedNodes(node.alternate), + ...findPossiblyReturnedNodes(node.consequent), + ]; + } + return [node]; + } + return { + ArrowFunctionExpression: enterFunction, + 'ArrowFunctionExpression:exit': exitFunction, + FunctionDeclaration: enterFunction, + 'FunctionDeclaration:exit': exitFunction, + FunctionExpression: enterFunction, + 'FunctionExpression:exit': exitFunction, + // executes after less specific handler, so exitFunction is called + 'ArrowFunctionExpression[async = true]:exit'(node) { + if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + findPossiblyReturnedNodes(node.body).forEach(node => { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + test(node, tsNode); + }); + } + }, + ReturnStatement(node) { + const scopeInfo = scopeInfoStack.at(-1); + if (!scopeInfo?.hasAsync || !node.argument) { + return; + } + findPossiblyReturnedNodes(node.argument).forEach(node => { + const tsNode = services.esTreeNodeToTSNodeMap.get(node); + test(node, tsNode); + }); + }, + }; + }, +}); +function getConfiguration(option) { + switch (option) { + case 'always': + return { + errorHandlingContext: 'await', + ordinaryContext: 'await', + }; + case 'error-handling-correctness-only': + return { + errorHandlingContext: 'await', + ordinaryContext: "don't-care", + }; + case 'in-try-catch': + return { + errorHandlingContext: 'await', + ordinaryContext: 'no-await', + }; + case 'never': + return { + errorHandlingContext: 'no-await', + ordinaryContext: 'no-await', + }; + } +} +//# sourceMappingURL=return-await.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.d.ts new file mode 100644 index 00000000..87603aa8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.d.ts @@ -0,0 +1,14 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + caseSensitive?: boolean; + checkIntersections?: boolean; + checkUnions?: boolean; + groupOrder?: string[]; + } +]; +export type MessageIds = 'notSorted' | 'notSortedNamed' | 'suggestFix'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.js new file mode 100644 index 00000000..2c607feb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.js @@ -0,0 +1,273 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +var Group; +(function (Group) { + Group["conditional"] = "conditional"; + Group["function"] = "function"; + Group["import"] = "import"; + Group["intersection"] = "intersection"; + Group["keyword"] = "keyword"; + Group["nullish"] = "nullish"; + Group["literal"] = "literal"; + Group["named"] = "named"; + Group["object"] = "object"; + Group["operator"] = "operator"; + Group["tuple"] = "tuple"; + Group["union"] = "union"; +})(Group || (Group = {})); +function getGroup(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSConditionalType: + return Group.conditional; + case utils_1.AST_NODE_TYPES.TSConstructorType: + case utils_1.AST_NODE_TYPES.TSFunctionType: + return Group.function; + case utils_1.AST_NODE_TYPES.TSImportType: + return Group.import; + case utils_1.AST_NODE_TYPES.TSIntersectionType: + return Group.intersection; + case utils_1.AST_NODE_TYPES.TSAnyKeyword: + case utils_1.AST_NODE_TYPES.TSBigIntKeyword: + case utils_1.AST_NODE_TYPES.TSBooleanKeyword: + case utils_1.AST_NODE_TYPES.TSNeverKeyword: + case utils_1.AST_NODE_TYPES.TSNumberKeyword: + case utils_1.AST_NODE_TYPES.TSObjectKeyword: + case utils_1.AST_NODE_TYPES.TSStringKeyword: + case utils_1.AST_NODE_TYPES.TSSymbolKeyword: + case utils_1.AST_NODE_TYPES.TSThisType: + case utils_1.AST_NODE_TYPES.TSUnknownKeyword: + case utils_1.AST_NODE_TYPES.TSIntrinsicKeyword: + return Group.keyword; + case utils_1.AST_NODE_TYPES.TSNullKeyword: + case utils_1.AST_NODE_TYPES.TSUndefinedKeyword: + case utils_1.AST_NODE_TYPES.TSVoidKeyword: + return Group.nullish; + case utils_1.AST_NODE_TYPES.TSLiteralType: + case utils_1.AST_NODE_TYPES.TSTemplateLiteralType: + return Group.literal; + case utils_1.AST_NODE_TYPES.TSArrayType: + case utils_1.AST_NODE_TYPES.TSIndexedAccessType: + case utils_1.AST_NODE_TYPES.TSInferType: + case utils_1.AST_NODE_TYPES.TSTypeReference: + case utils_1.AST_NODE_TYPES.TSQualifiedName: + return Group.named; + case utils_1.AST_NODE_TYPES.TSMappedType: + case utils_1.AST_NODE_TYPES.TSTypeLiteral: + return Group.object; + case utils_1.AST_NODE_TYPES.TSTypeOperator: + case utils_1.AST_NODE_TYPES.TSTypeQuery: + return Group.operator; + case utils_1.AST_NODE_TYPES.TSTupleType: + return Group.tuple; + case utils_1.AST_NODE_TYPES.TSUnionType: + return Group.union; + // These types should never occur as part of a union/intersection + case utils_1.AST_NODE_TYPES.TSAbstractKeyword: + case utils_1.AST_NODE_TYPES.TSAsyncKeyword: + case utils_1.AST_NODE_TYPES.TSDeclareKeyword: + case utils_1.AST_NODE_TYPES.TSExportKeyword: + case utils_1.AST_NODE_TYPES.TSNamedTupleMember: + case utils_1.AST_NODE_TYPES.TSOptionalType: + case utils_1.AST_NODE_TYPES.TSPrivateKeyword: + case utils_1.AST_NODE_TYPES.TSProtectedKeyword: + case utils_1.AST_NODE_TYPES.TSPublicKeyword: + case utils_1.AST_NODE_TYPES.TSReadonlyKeyword: + case utils_1.AST_NODE_TYPES.TSRestType: + case utils_1.AST_NODE_TYPES.TSStaticKeyword: + case utils_1.AST_NODE_TYPES.TSTypePredicate: + /* istanbul ignore next */ + throw new Error(`Unexpected Type ${node.type}`); + } +} +function caseSensitiveSort(a, b) { + if (a < b) { + return -1; + } + if (a > b) { + return 1; + } + return 0; +} +exports.default = (0, util_1.createRule)({ + name: 'sort-type-constituents', + meta: { + type: 'suggestion', + deprecated: { + deprecatedSince: '7.13.0', + replacedBy: [ + { + plugin: { + name: 'eslint-plugin-perfectionist', + url: 'https://perfectionist.dev', + }, + rule: { + name: 'perfectionist/sort-intersection-types', + url: 'https://perfectionist.dev/rules/sort-intersection-types', + }, + }, + { + plugin: { + name: 'eslint-plugin-perfectionist', + url: 'https://perfectionist.dev', + }, + rule: { + name: 'perfectionist/sort-union-types', + url: 'https://perfectionist.dev/rules/sort-union-types', + }, + }, + ], + url: 'https://github.com/typescript-eslint/typescript-eslint/pull/9253', + }, + docs: { + description: 'Enforce constituents of a type union/intersection to be sorted alphabetically', + }, + fixable: 'code', + hasSuggestions: true, + messages: { + notSorted: '{{type}} type constituents must be sorted.', + notSortedNamed: '{{type}} type {{name}} constituents must be sorted.', + suggestFix: 'Sort constituents of type (removes all comments).', + }, + replacedBy: [ + 'perfectionist/sort-intersection-types', + 'perfectionist/sort-union-types', + ], + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + caseSensitive: { + type: 'boolean', + description: 'Whether to sort using case sensitive string comparisons.', + }, + checkIntersections: { + type: 'boolean', + description: 'Whether to check intersection types (`&`).', + }, + checkUnions: { + type: 'boolean', + description: 'Whether to check union types (`|`).', + }, + groupOrder: { + type: 'array', + description: 'Ordering of the groups.', + items: { + type: 'string', + enum: (0, util_1.getEnumNames)(Group), + }, + }, + }, + }, + ], + }, + defaultOptions: [ + { + caseSensitive: false, + checkIntersections: true, + checkUnions: true, + groupOrder: [ + Group.named, + Group.keyword, + Group.operator, + Group.literal, + Group.function, + Group.import, + Group.conditional, + Group.object, + Group.tuple, + Group.intersection, + Group.union, + Group.nullish, + ], + }, + ], + create(context, [{ caseSensitive, checkIntersections, checkUnions, groupOrder }]) { + const collator = new Intl.Collator('en', { + numeric: true, + sensitivity: 'base', + }); + function checkSorting(node) { + const sourceOrder = node.types.map(type => { + const group = groupOrder?.indexOf(getGroup(type)) ?? -1; + return { + node: type, + group: group === -1 ? Number.MAX_SAFE_INTEGER : group, + text: context.sourceCode.getText(type), + }; + }); + const expectedOrder = [...sourceOrder].sort((a, b) => { + if (a.group !== b.group) { + return a.group - b.group; + } + if (caseSensitive) { + return caseSensitiveSort(a.text, b.text); + } + return (collator.compare(a.text, b.text) || + (a.text < b.text ? -1 : a.text > b.text ? 1 : 0)); + }); + const hasComments = node.types.some(type => { + const count = context.sourceCode.getCommentsBefore(type).length + + context.sourceCode.getCommentsAfter(type).length; + return count > 0; + }); + for (let i = 0; i < expectedOrder.length; i += 1) { + if (expectedOrder[i].node !== sourceOrder[i].node) { + let messageId = 'notSorted'; + const data = { + name: '', + type: node.type === utils_1.AST_NODE_TYPES.TSIntersectionType + ? 'Intersection' + : 'Union', + }; + if (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) { + messageId = 'notSortedNamed'; + data.name = node.parent.id.name; + } + const fix = fixer => { + const sorted = expectedOrder + .map(t => (0, util_1.typeNodeRequiresParentheses)(t.node, t.text) || + (node.type === utils_1.AST_NODE_TYPES.TSIntersectionType && + t.node.type === utils_1.AST_NODE_TYPES.TSUnionType) + ? `(${t.text})` + : t.text) + .join(node.type === utils_1.AST_NODE_TYPES.TSIntersectionType ? ' & ' : ' | '); + return fixer.replaceText(node, sorted); + }; + return context.report({ + node, + messageId, + data, + // don't autofix if any of the types have leading/trailing comments + // the logic for preserving them correctly is a pain - we may implement this later + ...(hasComments + ? { + suggest: [ + { + messageId: 'suggestFix', + fix, + }, + ], + } + : { fix }), + }); + } + } + } + return { + ...(checkIntersections && { + TSIntersectionType(node) { + checkSorting(node); + }, + }), + ...(checkUnions && { + TSUnionType(node) { + checkSorting(node); + }, + }), + }; + }, +}); +//# sourceMappingURL=sort-type-constituents.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.d.ts new file mode 100644 index 00000000..bf4a4cc3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.d.ts @@ -0,0 +1,19 @@ +export type Options = [ + { + allowAny?: boolean; + allowNullableBoolean?: boolean; + allowNullableEnum?: boolean; + allowNullableNumber?: boolean; + allowNullableObject?: boolean; + allowNullableString?: boolean; + allowNumber?: boolean; + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; + allowString?: boolean; + } +]; +type ConditionErrorMessageId = 'conditionErrorAny' | 'conditionErrorNullableBoolean' | 'conditionErrorNullableEnum' | 'conditionErrorNullableNumber' | 'conditionErrorNullableObject' | 'conditionErrorNullableString' | 'conditionErrorNullish' | 'conditionErrorNumber' | 'conditionErrorObject' | 'conditionErrorOther' | 'conditionErrorString'; +export type MessageId = 'conditionFixCastBoolean' | 'conditionFixCompareArrayLengthNonzero' | 'conditionFixCompareArrayLengthZero' | 'conditionFixCompareEmptyString' | 'conditionFixCompareFalse' | 'conditionFixCompareNaN' | 'conditionFixCompareNullish' | 'conditionFixCompareStringLength' | 'conditionFixCompareTrue' | 'conditionFixCompareZero' | 'conditionFixDefaultEmptyString' | 'conditionFixDefaultFalse' | 'conditionFixDefaultZero' | 'explicitBooleanReturnType' | 'noStrictNullCheck' | 'predicateCannotBeAsync' | ConditionErrorMessageId; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js new file mode 100644 index 00000000..abb99ecb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js @@ -0,0 +1,883 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const assertionFunctionUtils_1 = require("../util/assertionFunctionUtils"); +exports.default = (0, util_1.createRule)({ + name: 'strict-boolean-expressions', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow certain types in boolean expressions', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + conditionErrorAny: 'Unexpected any value in {{context}}. ' + + 'An explicit comparison or type conversion is required.', + conditionErrorNullableBoolean: 'Unexpected nullable boolean value in {{context}}. ' + + 'Please handle the nullish case explicitly.', + conditionErrorNullableEnum: 'Unexpected nullable enum value in {{context}}. ' + + 'Please handle the nullish/zero/NaN cases explicitly.', + conditionErrorNullableNumber: 'Unexpected nullable number value in {{context}}. ' + + 'Please handle the nullish/zero/NaN cases explicitly.', + conditionErrorNullableObject: 'Unexpected nullable object value in {{context}}. ' + + 'An explicit null check is required.', + conditionErrorNullableString: 'Unexpected nullable string value in {{context}}. ' + + 'Please handle the nullish/empty cases explicitly.', + conditionErrorNullish: 'Unexpected nullish value in conditional. ' + + 'The condition is always false.', + conditionErrorNumber: 'Unexpected number value in {{context}}. ' + + 'An explicit zero/NaN check is required.', + conditionErrorObject: 'Unexpected object value in {{context}}. ' + + 'The condition is always true.', + conditionErrorOther: 'Unexpected value in conditional. ' + + 'A boolean expression is required.', + conditionErrorString: 'Unexpected string value in {{context}}. ' + + 'An explicit empty string check is required.', + conditionFixCastBoolean: 'Explicitly convert value to a boolean (`Boolean(value)`)', + conditionFixCompareArrayLengthNonzero: "Change condition to check array's length (`value.length > 0`)", + conditionFixCompareArrayLengthZero: "Change condition to check array's length (`value.length === 0`)", + conditionFixCompareEmptyString: 'Change condition to check for empty string (`value !== ""`)', + conditionFixCompareFalse: 'Change condition to check if false (`value === false`)', + conditionFixCompareNaN: 'Change condition to check for NaN (`!Number.isNaN(value)`)', + conditionFixCompareNullish: 'Change condition to check for null/undefined (`value != null`)', + conditionFixCompareStringLength: "Change condition to check string's length (`value.length !== 0`)", + conditionFixCompareTrue: 'Change condition to check if true (`value === true`)', + conditionFixCompareZero: 'Change condition to check for 0 (`value !== 0`)', + conditionFixDefaultEmptyString: 'Explicitly treat nullish value the same as an empty string (`value ?? ""`)', + conditionFixDefaultFalse: 'Explicitly treat nullish value the same as false (`value ?? false`)', + conditionFixDefaultZero: 'Explicitly treat nullish value the same as 0 (`value ?? 0`)', + explicitBooleanReturnType: 'Add an explicit `boolean` return type annotation.', + noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.', + predicateCannotBeAsync: "Predicate function should not be 'async'; expected a boolean return type.", + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowAny: { + type: 'boolean', + description: 'Whether to allow `any`s in a boolean context.', + }, + allowNullableBoolean: { + type: 'boolean', + description: 'Whether to allow nullable `boolean`s in a boolean context.', + }, + allowNullableEnum: { + type: 'boolean', + description: 'Whether to allow nullable `enum`s in a boolean context.', + }, + allowNullableNumber: { + type: 'boolean', + description: 'Whether to allow nullable `number`s in a boolean context.', + }, + allowNullableObject: { + type: 'boolean', + description: 'Whether to allow nullable `object`s, `symbol`s, and functions in a boolean context.', + }, + allowNullableString: { + type: 'boolean', + description: 'Whether to allow nullable `string`s in a boolean context.', + }, + allowNumber: { + type: 'boolean', + description: 'Whether to allow `number`s in a boolean context.', + }, + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: { + type: 'boolean', + description: 'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.', + }, + allowString: { + type: 'boolean', + description: 'Whether to allow `string`s in a boolean context.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowAny: false, + allowNullableBoolean: false, + allowNullableEnum: false, + allowNullableNumber: false, + allowNullableObject: true, + allowNullableString: false, + allowNumber: true, + allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false, + allowString: true, + }, + ], + create(context, [options]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks'); + if (!isStrictNullChecks && + options.allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) { + context.report({ + loc: { + start: { column: 0, line: 0 }, + end: { column: 0, line: 0 }, + }, + messageId: 'noStrictNullCheck', + }); + } + const traversedNodes = new Set(); + return { + CallExpression: traverseCallExpression, + ConditionalExpression: traverseTestExpression, + DoWhileStatement: traverseTestExpression, + ForStatement: traverseTestExpression, + IfStatement: traverseTestExpression, + 'LogicalExpression[operator!="??"]': traverseLogicalExpression, + 'UnaryExpression[operator="!"]': traverseUnaryLogicalExpression, + WhileStatement: traverseTestExpression, + }; + /** + * Inspects condition of a test expression. (`if`, `while`, `for`, etc.) + */ + function traverseTestExpression(node) { + if (node.test == null) { + return; + } + traverseNode(node.test, true); + } + /** + * Inspects the argument of a unary logical expression (`!`). + */ + function traverseUnaryLogicalExpression(node) { + traverseNode(node.argument, true); + } + /** + * Inspects the arguments of a logical expression (`&&`, `||`). + * + * If the logical expression is a descendant of a test expression, + * the `isCondition` flag should be set to true. + * Otherwise, if the logical expression is there on it's own, + * it's used for control flow and is not a condition itself. + */ + function traverseLogicalExpression(node, isCondition = false) { + // left argument is always treated as a condition + traverseNode(node.left, true); + // if the logical expression is used for control flow, + // then its right argument is used for its side effects only + traverseNode(node.right, isCondition); + } + function traverseCallExpression(node) { + const assertedArgument = (0, assertionFunctionUtils_1.findTruthinessAssertedArgument)(services, node); + if (assertedArgument != null) { + traverseNode(assertedArgument, true); + } + if ((0, util_1.isArrayMethodCallWithPredicate)(context, services, node)) { + const predicate = node.arguments.at(0); + if (predicate) { + checkArrayMethodCallPredicate(predicate); + } + } + } + /** + * Dedicated function to check array method predicate calls. Reports predicate + * arguments that don't return a boolean value. + */ + function checkArrayMethodCallPredicate(predicateNode) { + const isFunctionExpression = utils_1.ASTUtils.isFunction(predicateNode); + // custom message for accidental `async` function expressions + if (isFunctionExpression && predicateNode.async) { + return context.report({ + node: predicateNode, + messageId: 'predicateCannotBeAsync', + }); + } + const returnTypes = services + .getTypeAtLocation(predicateNode) + .getCallSignatures() + .map(signature => { + const type = signature.getReturnType(); + if (tsutils.isTypeParameter(type)) { + return checker.getBaseConstraintOfType(type) ?? type; + } + return type; + }); + const flattenTypes = [ + ...new Set(returnTypes.flatMap(type => tsutils.unionConstituents(type))), + ]; + const types = inspectVariantTypes(flattenTypes); + const reportType = determineReportType(types); + if (reportType == null) { + return; + } + const suggestions = []; + if (isFunctionExpression && + predicateNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + suggestions.push(...getSuggestionsForConditionError(predicateNode.body, reportType)); + } + if (isFunctionExpression && !predicateNode.returnType) { + suggestions.push({ + messageId: 'explicitBooleanReturnType', + fix: fixer => { + if (predicateNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + (0, util_1.isParenlessArrowFunction)(predicateNode, context.sourceCode)) { + return [ + fixer.insertTextBefore(predicateNode.params[0], '('), + fixer.insertTextAfter(predicateNode.params[0], '): boolean'), + ]; + } + if (predicateNode.params.length === 0) { + const closingBracket = (0, util_1.nullThrows)(context.sourceCode.getFirstToken(predicateNode, token => token.value === ')'), 'function expression has to have a closing parenthesis.'); + return fixer.insertTextAfter(closingBracket, ': boolean'); + } + const lastClosingParenthesis = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(predicateNode.params[predicateNode.params.length - 1], token => token.value === ')'), 'function expression has to have a closing parenthesis.'); + return fixer.insertTextAfter(lastClosingParenthesis, ': boolean'); + }, + }); + } + return context.report({ + node: predicateNode, + messageId: reportType, + data: { + context: 'array predicate return type', + }, + suggest: suggestions, + }); + } + /** + * Inspects any node. + * + * If it's a logical expression then it recursively traverses its arguments. + * If it's any other kind of node then it's type is finally checked against the rule, + * unless `isCondition` flag is set to false, in which case + * it's assumed to be used for side effects only and is skipped. + */ + function traverseNode(node, isCondition) { + // prevent checking the same node multiple times + if (traversedNodes.has(node)) { + return; + } + traversedNodes.add(node); + // for logical operator, we check its operands + if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression && + node.operator !== '??') { + traverseLogicalExpression(node, isCondition); + return; + } + // skip if node is not a condition + if (!isCondition) { + return; + } + checkNode(node); + } + function determineReportType(types) { + const is = (...wantedTypes) => types.size === wantedTypes.length && + wantedTypes.every(type => types.has(type)); + // boolean + if (is('boolean') || is('truthy boolean')) { + // boolean is always ok + return undefined; + } + // never + if (is('never')) { + // never is always okay + return undefined; + } + // nullish + if (is('nullish')) { + // condition is always false + return 'conditionErrorNullish'; + } + // Known edge case: boolean `true` and nullish values are always valid boolean expressions + if (is('nullish', 'truthy boolean')) { + return; + } + // nullable boolean + if (is('nullish', 'boolean')) { + return !options.allowNullableBoolean + ? 'conditionErrorNullableBoolean' + : undefined; + } + // Known edge case: truthy primitives and nullish values are always valid boolean expressions + if ((options.allowNumber && is('nullish', 'truthy number')) || + (options.allowString && is('nullish', 'truthy string'))) { + return; + } + // string + if (is('string') || is('truthy string')) { + return !options.allowString ? 'conditionErrorString' : undefined; + } + // nullable string + if (is('nullish', 'string')) { + return !options.allowNullableString + ? 'conditionErrorNullableString' + : undefined; + } + // number + if (is('number') || is('truthy number')) { + return !options.allowNumber ? 'conditionErrorNumber' : undefined; + } + // nullable number + if (is('nullish', 'number')) { + return !options.allowNullableNumber + ? 'conditionErrorNullableNumber' + : undefined; + } + // object + if (is('object')) { + return 'conditionErrorObject'; + } + // nullable object + if (is('nullish', 'object')) { + return !options.allowNullableObject + ? 'conditionErrorNullableObject' + : undefined; + } + // nullable enum + if (is('nullish', 'number', 'enum') || + is('nullish', 'string', 'enum') || + is('nullish', 'truthy number', 'enum') || + is('nullish', 'truthy string', 'enum') || + // mixed enums + is('nullish', 'truthy number', 'truthy string', 'enum') || + is('nullish', 'truthy number', 'string', 'enum') || + is('nullish', 'truthy string', 'number', 'enum') || + is('nullish', 'number', 'string', 'enum')) { + return !options.allowNullableEnum + ? 'conditionErrorNullableEnum' + : undefined; + } + // any + if (is('any')) { + return !options.allowAny ? 'conditionErrorAny' : undefined; + } + return 'conditionErrorOther'; + } + function getSuggestionsForConditionError(node, conditionError) { + switch (conditionError) { + case 'conditionErrorAny': + return [ + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `Boolean(${code})`, + }), + }, + ]; + case 'conditionErrorNullableBoolean': + if (isLogicalNegationExpression(node.parent)) { + // if (!nullableBoolean) + return [ + { + messageId: 'conditionFixDefaultFalse', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? false`, + }), + }, + { + messageId: 'conditionFixCompareFalse', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} === false`, + }), + }, + ]; + } + // if (nullableBoolean) + return [ + { + messageId: 'conditionFixDefaultFalse', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? false`, + }), + }, + { + messageId: 'conditionFixCompareTrue', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} === true`, + }), + }, + ]; + case 'conditionErrorNullableEnum': + if (isLogicalNegationExpression(node.parent)) { + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} == null`, + }), + }, + ]; + } + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} != null`, + }), + }, + ]; + case 'conditionErrorNullableNumber': + if (isLogicalNegationExpression(node.parent)) { + // if (!nullableNumber) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} == null`, + }), + }, + { + messageId: 'conditionFixDefaultZero', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? 0`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `!Boolean(${code})`, + }), + }, + ]; + } + // if (nullableNumber) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} != null`, + }), + }, + { + messageId: 'conditionFixDefaultZero', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? 0`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `Boolean(${code})`, + }), + }, + ]; + case 'conditionErrorNullableObject': + if (isLogicalNegationExpression(node.parent)) { + // if (!nullableObject) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} == null`, + }), + }, + ]; + } + // if (nullableObject) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} != null`, + }), + }, + ]; + case 'conditionErrorNullableString': + if (isLogicalNegationExpression(node.parent)) { + // if (!nullableString) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} == null`, + }), + }, + { + messageId: 'conditionFixDefaultEmptyString', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? ""`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `!Boolean(${code})`, + }), + }, + ]; + } + // if (nullableString) + return [ + { + messageId: 'conditionFixCompareNullish', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} != null`, + }), + }, + { + messageId: 'conditionFixDefaultEmptyString', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} ?? ""`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `Boolean(${code})`, + }), + }, + ]; + case 'conditionErrorNumber': + if (isArrayLengthExpression(node, checker, services)) { + if (isLogicalNegationExpression(node.parent)) { + // if (!array.length) + return [ + { + messageId: 'conditionFixCompareArrayLengthZero', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} === 0`, + }), + }, + ]; + } + // if (array.length) + return [ + { + messageId: 'conditionFixCompareArrayLengthNonzero', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} > 0`, + }), + }, + ]; + } + if (isLogicalNegationExpression(node.parent)) { + // if (!number) + return [ + { + messageId: 'conditionFixCompareZero', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + // TODO: we have to compare to 0n if the type is bigint + wrap: code => `${code} === 0`, + }), + }, + { + // TODO: don't suggest this for bigint because it can't be NaN + messageId: 'conditionFixCompareNaN', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `Number.isNaN(${code})`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `!Boolean(${code})`, + }), + }, + ]; + } + // if (number) + return [ + { + messageId: 'conditionFixCompareZero', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} !== 0`, + }), + }, + { + messageId: 'conditionFixCompareNaN', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `!Number.isNaN(${code})`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `Boolean(${code})`, + }), + }, + ]; + case 'conditionErrorString': + if (isLogicalNegationExpression(node.parent)) { + // if (!string) + return [ + { + messageId: 'conditionFixCompareStringLength', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code}.length === 0`, + }), + }, + { + messageId: 'conditionFixCompareEmptyString', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `${code} === ""`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node: node.parent, + innerNode: node, + sourceCode: context.sourceCode, + wrap: code => `!Boolean(${code})`, + }), + }, + ]; + } + // if (string) + return [ + { + messageId: 'conditionFixCompareStringLength', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code}.length > 0`, + }), + }, + { + messageId: 'conditionFixCompareEmptyString', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `${code} !== ""`, + }), + }, + { + messageId: 'conditionFixCastBoolean', + fix: (0, util_1.getWrappingFixer)({ + node, + sourceCode: context.sourceCode, + wrap: code => `Boolean(${code})`, + }), + }, + ]; + case 'conditionErrorObject': + case 'conditionErrorNullish': + case 'conditionErrorOther': + return []; + default: + conditionError; + throw new Error('Unreachable'); + } + } + /** + * This function does the actual type check on a node. + * It analyzes the type of a node and checks if it is allowed in a boolean context. + */ + function checkNode(node) { + const type = (0, util_1.getConstrainedTypeAtLocation)(services, node); + const types = inspectVariantTypes(tsutils.unionConstituents(type)); + const reportType = determineReportType(types); + if (reportType != null) { + context.report({ + node, + messageId: reportType, + data: { + context: 'conditional', + }, + suggest: getSuggestionsForConditionError(node, reportType), + }); + } + } + /** + * Check union variants for the types we care about + */ + function inspectVariantTypes(types) { + const variantTypes = new Set(); + if (types.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike))) { + variantTypes.add('nullish'); + } + const booleans = types.filter(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.BooleanLike)); + // If incoming type is either "true" or "false", there will be one type + // object with intrinsicName set accordingly + // If incoming type is boolean, there will be two type objects with + // intrinsicName set "true" and "false" each because of ts-api-utils.unionConstituents() + if (booleans.length === 1) { + variantTypes.add(tsutils.isTrueLiteralType(booleans[0]) ? 'truthy boolean' : 'boolean'); + } + else if (booleans.length === 2) { + variantTypes.add('boolean'); + } + const strings = types.filter(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.StringLike)); + if (strings.length) { + if (strings.every(type => type.isStringLiteral() && type.value !== '')) { + variantTypes.add('truthy string'); + } + else { + variantTypes.add('string'); + } + } + const numbers = types.filter(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike)); + if (numbers.length) { + if (numbers.every(type => type.isNumberLiteral() && type.value !== 0)) { + variantTypes.add('truthy number'); + } + else { + variantTypes.add('number'); + } + } + if (types.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.EnumLike))) { + variantTypes.add('enum'); + } + if (types.some(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Null | + ts.TypeFlags.Undefined | + ts.TypeFlags.VoidLike | + ts.TypeFlags.BooleanLike | + ts.TypeFlags.StringLike | + ts.TypeFlags.NumberLike | + ts.TypeFlags.BigIntLike | + ts.TypeFlags.TypeParameter | + ts.TypeFlags.Any | + ts.TypeFlags.Unknown | + ts.TypeFlags.Never))) { + variantTypes.add(types.some(isBrandedBoolean) ? 'boolean' : 'object'); + } + if (types.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.TypeParameter | + ts.TypeFlags.Any | + ts.TypeFlags.Unknown))) { + variantTypes.add('any'); + } + if (types.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Never))) { + variantTypes.add('never'); + } + return variantTypes; + } + }, +}); +function isLogicalNegationExpression(node) { + return node.type === utils_1.AST_NODE_TYPES.UnaryExpression && node.operator === '!'; +} +function isArrayLengthExpression(node, typeChecker, services) { + if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return false; + } + if (node.computed) { + return false; + } + if (node.property.name !== 'length') { + return false; + } + const objectType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object); + return (0, util_1.isTypeArrayTypeOrUnionOfArrayTypes)(objectType, typeChecker); +} +/** + * Verify is the type is a branded boolean (e.g. `type Foo = boolean & { __brand: 'Foo' }`) + * + * @param type The type checked + */ +function isBrandedBoolean(type) { + return (type.isIntersection() && + type.types.some(childType => isBooleanType(childType))); +} +function isBooleanType(expressionType) { + return tsutils.isTypeFlagSet(expressionType, ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral); +} +//# sourceMappingURL=strict-boolean-expressions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.d.ts new file mode 100644 index 00000000..71515084 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.d.ts @@ -0,0 +1,11 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +type Options = [ + { + allowReturnAny?: boolean; + } +]; +type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn` | `suggestAddVoidOp` | `suggestWrapInAsyncIIFE`; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.js new file mode 100644 index 00000000..f318fa43 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.js @@ -0,0 +1,469 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util = __importStar(require("../util")); +exports.default = util.createRule({ + name: 'strict-void-return', + meta: { + type: 'problem', + docs: { + description: 'Disallow passing a value-returning function in a position accepting a void function', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + asyncFunc: 'Async function used in a context where a void function is expected.', + nonVoidFunc: 'Value-returning function used in a context where a void function is expected.', + nonVoidReturn: 'Value returned in a context where a void return is expected.', + suggestAddVoidOp: 'Add a void operator to discard the return value.', + suggestWrapInAsyncIIFE: 'Wrap the function body in an async IIFE.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowReturnAny: { + type: 'boolean', + description: 'Whether to allow functions returning `any` to be used in place expecting a `void` function.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowReturnAny: false, + }, + ], + create(context, [options]) { + const sourceCode = context.sourceCode; + const parserServices = util.getParserServices(context); + const checker = parserServices.program.getTypeChecker(); + return { + ArrayExpression: (node) => { + for (const elemNode of node.elements) { + if (elemNode != null && + elemNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) { + checkExpressionNode(elemNode); + } + } + }, + ArrowFunctionExpression: (node) => { + if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + checkExpressionNode(node.body); + } + }, + AssignmentExpression: (node) => { + checkExpressionNode(node.right); // should ignore operators like `+=` or `-=` automatically + }, + 'CallExpression, NewExpression': checkFunctionCallNode, + JSXAttribute: (node) => { + if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer && + node.value.expression.type !== utils_1.AST_NODE_TYPES.JSXEmptyExpression) { + checkExpressionNode(node.value.expression); + } + }, + MethodDefinition: checkClassMethodNode, + ObjectExpression: (node) => { + for (const propNode of node.properties) { + if (propNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) { + checkObjectPropertyNode(propNode); + } + } + }, + PropertyDefinition: checkClassPropertyNode, + ReturnStatement: (node) => { + if (node.argument != null) { + checkExpressionNode(node.argument); + } + }, + VariableDeclarator: (node) => { + if (node.init != null) { + checkExpressionNode(node.init); + } + }, + }; + function isVoidReturningFunctionType(type) { + const returnTypes = tsutils + .getCallSignaturesOfType(type) + .flatMap(signature => tsutils.unionConstituents(signature.getReturnType())); + return (returnTypes.length > 0 && + returnTypes.every(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void))); + } + /** + * Finds errors in any expression node. + * + * Compares the type of the node against the contextual (expected) type. + * + * @returns `true` if the expected type was void function. + */ + function checkExpressionNode(node) { + const expectedType = parserServices.getContextualType(node); + if (expectedType != null && isVoidReturningFunctionType(expectedType)) { + reportIfNonVoidFunction(node); + return true; + } + return false; + } + /** + * Finds errors in function calls. + * + * When checking arguments, we also manually figure out the argument types + * by iterating over all the function signatures. + * Thanks to this, we can find arguments like `(() => void) | (() => any)` + * and treat them as void too. + * This is done to also support checking functions like `addEventListener` + * which have overloads where one callback returns any. + * + * Implementation mostly based on no-misused-promises, + * which does this to find `(() => void) | (() => NotThenable)` + * and report them too. + */ + function checkFunctionCallNode(callNode) { + if (callNode.arguments.length === 0) { + return; + } + const callTsNode = parserServices.esTreeNodeToTSNodeMap.get(callNode); + const funcType = checker.getTypeAtLocation(callTsNode.expression); + const funcSignatures = tsutils + .unionConstituents(funcType) + .flatMap(type => ts.isCallExpression(callTsNode) + ? type.getCallSignatures() + : type.getConstructSignatures()); + for (const [argIdx, argNode] of callNode.arguments.entries()) { + if (argNode.type === utils_1.AST_NODE_TYPES.SpreadElement) { + continue; + } + // Collect the types from all of the call signatures + const argExpectedReturnTypes = funcSignatures + .map(s => s.parameters[argIdx]) + .filter(Boolean) + .map(param => checker.getTypeOfSymbolAtLocation(param, callTsNode.expression)) + .flatMap(paramType => tsutils.unionConstituents(paramType)) + .flatMap(paramType => paramType.getCallSignatures()) + .map(paramSignature => paramSignature.getReturnType()); + const hasSingleSignature = funcSignatures.length === 1; + const allSignaturesReturnVoid = argExpectedReturnTypes.every(type => isVoid(type) || + // Treat as void even though it might be technically any. + isNullishOrAny(type) || + // `getTypeOfSymbolAtLocation` returns unresolved type parameters + // (e.g. `T`), even for overloads that match the call. + // + // Since we can't tell whether a generic overload currently matches, + // we treat TypeParameters similar to void. + tsutils.isTypeParameter(type)); + // Check against the contextual type first, but only when there is a + // single signature or when all signatures return void, because + // `getContextualType` resolves to the first overload's return type even + // though there may be another one that matches the call. + if ((hasSingleSignature || allSignaturesReturnVoid) && + checkExpressionNode(argNode)) { + continue; + } + if ( + // At least one return type is void + argExpectedReturnTypes.some(isVoid) && + // The rest are nullish or any + argExpectedReturnTypes.every(isNullishOrAny)) { + // We treat this argument as void even though it might be technically any. + reportIfNonVoidFunction(argNode); + } + } + } + function isNullishOrAny(type) { + return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike | + ts.TypeFlags.Undefined | + ts.TypeFlags.Null | + ts.TypeFlags.Any | + ts.TypeFlags.Never); + } + function isVoid(type) { + return tsutils.isTypeFlagSet(type, ts.TypeFlags.Void); + } + /** + * Finds errors in an object property. + * + * Object properties require different logic + * when the property is a method shorthand. + */ + function checkObjectPropertyNode(propNode) { + const valueNode = propNode.value; + const propTsNode = parserServices.esTreeNodeToTSNodeMap.get(propNode); + if (propTsNode.kind === ts.SyntaxKind.MethodDeclaration) { + // Object property is a method shorthand. + if (propTsNode.name.kind === ts.SyntaxKind.ComputedPropertyName) { + // Don't check object methods with computed name. + return; + } + const objType = parserServices.getContextualType(propNode.parent); + if (objType == null) { + // Expected object type is unknown. + return; + } + const propSymbol = checker.getPropertyOfType(objType, propTsNode.name.text); + if (propSymbol == null) { + // Expected object type is known, but it doesn't have this method. + return; + } + const propExpectedType = checker.getTypeOfSymbolAtLocation(propSymbol, propTsNode); + if (isVoidReturningFunctionType(propExpectedType)) { + reportIfNonVoidFunction(valueNode); + } + return; + } + // Object property is a regular property. + checkExpressionNode(valueNode); + } + /** + * Finds errors in a class property. + * + * In addition to the regular check against the contextual type, + * we also check against the base class property (when the class extends another class) + * and the implemented interfaces (when the class implements an interface). + */ + function checkClassPropertyNode(propNode) { + if (propNode.value == null) { + return; + } + // Check in comparison to the base types. + for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, propNode)) { + if (isVoidReturningFunctionType(baseMemberType)) { + reportIfNonVoidFunction(propNode.value); + return; // Report at most one error. + } + } + // Check in comparison to the contextual type. + checkExpressionNode(propNode.value); + } + /** + * Finds errors in a class method. + * + * We check against the base class method (when the class extends another class) + * and the implemented interfaces (when the class implements an interface). + */ + function checkClassMethodNode(methodNode) { + if (methodNode.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + return; + } + // Check in comparison to the base types. + for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, methodNode)) { + if (isVoidReturningFunctionType(baseMemberType)) { + reportIfNonVoidFunction(methodNode.value); + return; // Report at most one error. + } + } + } + /** + * Reports an error if the provided node is not allowed in a void function context. + */ + function reportIfNonVoidFunction(funcNode) { + const allowedReturnType = ts.TypeFlags.Void | + ts.TypeFlags.Never | + ts.TypeFlags.Undefined | + (options.allowReturnAny ? ts.TypeFlags.Any : 0); + const tsNode = parserServices.esTreeNodeToTSNodeMap.get(funcNode); + const actualType = checker.getApparentType(checker.getTypeAtLocation(tsNode)); + if (tsutils + .getCallSignaturesOfType(actualType) + .map(signature => signature.getReturnType()) + .flatMap(returnType => tsutils.unionConstituents(returnType)) + .every(type => tsutils.isTypeFlagSet(type, allowedReturnType))) { + // The function is already void. + return; + } + if (funcNode.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + funcNode.type !== utils_1.AST_NODE_TYPES.FunctionExpression) { + // The provided function is not a function literal. + // Report a generic error. + return context.report({ + node: funcNode, + messageId: `nonVoidFunc`, + }); + } + // The provided function is a function literal. + if (funcNode.generator) { + // The provided function is a generator function. + // Generator functions are not allowed. + return context.report({ + loc: util.getFunctionHeadLoc(funcNode, sourceCode), + messageId: `nonVoidFunc`, + }); + } + if (funcNode.async) { + // The provided function is an async function. + if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + // This async function is an arrow function shorthand without braces. + return context.report({ + loc: util.getFunctionHeadLoc(funcNode, sourceCode), + messageId: 'asyncFunc', + suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode) + ? // This function has side effects, e.g. `async () => doSomething()`. + // Suggest removing the async keyword and adding a void operator. + [ + { + messageId: 'suggestAddVoidOp', + fix: fixer => addVoidToArrowFix(fixer, funcNode), + }, + ] + : [], + }); + } + // This async function has a block body. + // Suggest wrapping its body in an async IIFE. + return context.report({ + loc: util.getFunctionHeadLoc(funcNode, sourceCode), + messageId: 'asyncFunc', + suggest: [ + { + messageId: 'suggestWrapInAsyncIIFE', + fix: fixer => wrapInAsyncIIFEFix(fixer, funcNode), + }, + ], + }); + } + // This function is a regular or arrow sync function. + if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) { + // This function is an arrow function shorthand without braces. + return context.report({ + node: funcNode.body, + messageId: 'nonVoidReturn', + suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode) + ? // This function has side effects, e.g. `() => doSomething()`. + // Suggest adding a void operator. + [ + { + messageId: 'suggestAddVoidOp', + fix: fixer => addVoidToArrowFix(fixer, funcNode), + }, + ] + : [], + }); + } + // This function is a regular or arrow sync function with a block body. + // Check return type annotation. + if (funcNode.returnType != null) { + // The provided function has an explicit return type annotation. + const typeAnnotationNode = funcNode.returnType.typeAnnotation; + if (typeAnnotationNode.type !== utils_1.AST_NODE_TYPES.TSVoidKeyword) { + // The explicit return type is not `void`. + return context.report({ + node: typeAnnotationNode, + messageId: `nonVoidFunc`, + }); + } + } + // Iterate over all function's return statements. + for (const statement of util.walkStatements(funcNode.body.body)) { + if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement || + statement.argument == null) { + // We only care about return statements with a value. + continue; + } + const returnType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(statement.argument)); + if (tsutils.isTypeFlagSet(returnType, allowedReturnType)) { + // Only visit return statements with invalid type. + continue; + } + // This return statement causes the non-void return type. + const returnKeyword = util.nullThrows(sourceCode.getFirstToken(statement, { + filter: token => token.value === 'return', + }), util.NullThrowsReasons.MissingToken('return keyword', statement.type)); + context.report({ + node: returnKeyword, + messageId: `nonVoidReturn`, + }); + } + // No invalid returns found. The function is allowed. + } + /** + * Removes the async keyword and replaces the return type with void. + */ + function* makeSyncFuncFix(fixer, funcNode) { + if (funcNode.async) { + // Remove async keyword + const funcHeadNode = funcNode.parent.type === utils_1.AST_NODE_TYPES.Property || + funcNode.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition + ? funcNode.parent + : funcNode; + const asyncToken = util.nullThrows(sourceCode.getFirstToken(funcHeadNode, { + filter: token => token.value === 'async', + }), util.NullThrowsReasons.MissingToken('async keyword', funcNode.type)); + yield fixer.remove(asyncToken); + } + // Replace return type with void + if (funcNode.returnType != null) { + yield fixer.replaceText(funcNode.returnType.typeAnnotation, 'void'); + } + } + /** + * Makes the function sync and adds a void operator to the arrow shorthand body. + */ + function* addVoidToArrowFix(fixer, funcNode) { + yield* makeSyncFuncFix(fixer, funcNode); + // Add void operator + yield util.getWrappingFixer({ + node: funcNode.body, + sourceCode, + wrap: code => `void ${code}`, + })(fixer); + } + /** + * Makes the function sync and wraps the body in an inner async IIFE. + */ + function* wrapInAsyncIIFEFix(fixer, funcNode) { + yield* makeSyncFuncFix(fixer, funcNode); + // Wrap body in async IIFE. + // This preserves the node kind (normal/arrow) for the _outer_ function + // and uses an arrow function for the _inner_ function, + // so that `this` will always refer to the same value as before. + if (funcNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + const arrowToken = util.nullThrows(sourceCode.getTokenBefore(funcNode.body, { + filter: token => token.value === '=>', + }), util.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body')); + yield fixer.insertTextAfter(arrowToken, ' void (async () =>'); + yield fixer.insertTextAfter(funcNode, ')()'); + } + else { + yield fixer.insertTextBefore(funcNode.body, '{ (async () => '); + yield fixer.insertTextAfter(funcNode.body, ')(); }'); + } + } + }, +}); +//# sourceMappingURL=strict-void-return.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.d.ts new file mode 100644 index 00000000..d4549f17 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.d.ts @@ -0,0 +1,33 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type Options = [ + { + /** + * If `true`, allow `default` cases on switch statements with exhaustive + * cases. + * + * @default true + */ + allowDefaultCaseForExhaustiveSwitch?: boolean; + /** + * If `true`, require a `default` clause for switches on non-union types. + * + * @default false + */ + requireDefaultForNonUnion?: boolean; + /** + * Regular expression for a comment that can indicate an intentionally omitted default case. + */ + defaultCaseCommentPattern?: string; + /** + * If `true`, the `default` clause is used to determine whether the switch statement is exhaustive for union types. + * + * @default false + */ + considerDefaultExhaustiveForUnions?: boolean; + } +]; +export type MessageIds = 'addMissingCases' | 'dangerousDefaultCase' | 'switchIsNotExhaustive'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js new file mode 100644 index 00000000..9506849c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js @@ -0,0 +1,292 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +const DEFAULT_COMMENT_PATTERN = /^no default$/iu; +exports.default = (0, util_1.createRule)({ + name: 'switch-exhaustiveness-check', + meta: { + type: 'suggestion', + docs: { + description: 'Require switch-case statements to be exhaustive', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + addMissingCases: 'Add branches for missing cases.', + dangerousDefaultCase: 'The switch statement is exhaustive, so the default case is unnecessary.', + switchIsNotExhaustive: 'Switch is not exhaustive. Cases not matched: {{missingBranches}}', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + allowDefaultCaseForExhaustiveSwitch: { + type: 'boolean', + description: `If 'true', allow 'default' cases on switch statements with exhaustive cases.`, + }, + considerDefaultExhaustiveForUnions: { + type: 'boolean', + description: `If 'true', the 'default' clause is used to determine whether the switch statement is exhaustive for union type`, + }, + defaultCaseCommentPattern: { + type: 'string', + description: `Regular expression for a comment that can indicate an intentionally omitted default case.`, + }, + requireDefaultForNonUnion: { + type: 'boolean', + description: `If 'true', require a 'default' clause for switches on non-union types.`, + }, + }, + }, + ], + }, + defaultOptions: [ + { + allowDefaultCaseForExhaustiveSwitch: true, + considerDefaultExhaustiveForUnions: false, + requireDefaultForNonUnion: false, + }, + ], + create(context, [{ allowDefaultCaseForExhaustiveSwitch, considerDefaultExhaustiveForUnions, defaultCaseCommentPattern, requireDefaultForNonUnion, },]) { + const services = (0, util_1.getParserServices)(context); + const checker = services.program.getTypeChecker(); + const compilerOptions = services.program.getCompilerOptions(); + const commentRegExp = defaultCaseCommentPattern != null + ? new RegExp(defaultCaseCommentPattern, 'u') + : DEFAULT_COMMENT_PATTERN; + function getCommentDefaultCase(node) { + const lastCase = node.cases.at(-1); + const commentsAfterLastCase = lastCase + ? context.sourceCode.getCommentsAfter(lastCase) + : []; + const defaultCaseComment = commentsAfterLastCase.at(-1); + if (commentRegExp.test(defaultCaseComment?.value.trim() || '')) { + return defaultCaseComment; + } + return; + } + function typeToString(type) { + return checker.typeToString(type, undefined, ts.TypeFormatFlags.AllowUniqueESSymbolType | + ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | + ts.TypeFormatFlags.UseFullyQualifiedType); + } + function getSwitchMetadata(node) { + const defaultCase = node.cases.find(switchCase => switchCase.test == null); + const discriminantType = (0, util_1.getConstrainedTypeAtLocation)(services, node.discriminant); + const symbolName = discriminantType.getSymbol()?.escapedName; + const containsNonLiteralType = doesTypeContainNonLiteralType(discriminantType); + const caseTypes = new Set(); + for (const switchCase of node.cases) { + // If the `test` property of the switch case is `null`, then we are on a + // `default` case. + if (switchCase.test == null) { + continue; + } + const caseType = (0, util_1.getConstrainedTypeAtLocation)(services, switchCase.test); + caseTypes.add(caseType); + } + const missingLiteralBranchTypes = []; + for (const unionPart of tsutils.unionConstituents(discriminantType)) { + for (const intersectionPart of tsutils.intersectionConstituents(unionPart)) { + if (caseTypes.has(intersectionPart) || + !isTypeLiteralLikeType(intersectionPart)) { + continue; + } + // "missing", "optional" and "undefined" types are different runtime objects, + // but all of them have TypeFlags.Undefined type flag + if ([...caseTypes].some(tsutils.isIntrinsicUndefinedType) && + tsutils.isIntrinsicUndefinedType(intersectionPart)) { + continue; + } + missingLiteralBranchTypes.push(intersectionPart); + } + } + return { + containsNonLiteralType, + defaultCase: defaultCase ?? getCommentDefaultCase(node), + missingLiteralBranchTypes, + symbolName, + }; + } + function checkSwitchExhaustive(node, switchMetadata) { + const { defaultCase, missingLiteralBranchTypes, symbolName } = switchMetadata; + // If considerDefaultExhaustiveForUnions is enabled, the presence of a default case + // always makes the switch exhaustive. + if (considerDefaultExhaustiveForUnions && defaultCase != null) { + return; + } + if (missingLiteralBranchTypes.length > 0) { + context.report({ + node: node.discriminant, + messageId: 'switchIsNotExhaustive', + data: { + missingBranches: missingLiteralBranchTypes + .map(missingType => tsutils.isTypeFlagSet(missingType, ts.TypeFlags.ESSymbolLike) + ? `typeof ${missingType.getSymbol()?.escapedName}` + : typeToString(missingType)) + .join(' | '), + }, + suggest: [ + { + messageId: 'addMissingCases', + fix(fixer) { + return fixSwitch(fixer, node, missingLiteralBranchTypes, defaultCase, symbolName?.toString()); + }, + }, + ], + }); + } + } + function fixSwitch(fixer, node, missingBranchTypes, // null means default branch + defaultCase, symbolName) { + const lastCase = node.cases.length > 0 ? node.cases[node.cases.length - 1] : null; + const caseIndent = lastCase + ? ' '.repeat(lastCase.loc.start.column) + : // If there are no cases, use indentation of the switch statement and + // leave it to the user to format it correctly. + ' '.repeat(node.loc.start.column); + const missingCases = []; + for (const missingBranchType of missingBranchTypes) { + if (missingBranchType == null) { + missingCases.push(`default: { throw new Error('default case') }`); + continue; + } + const missingBranchName = missingBranchType.getSymbol()?.escapedName; + let caseTest = tsutils.isTypeFlagSet(missingBranchType, ts.TypeFlags.ESSymbolLike) + ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + missingBranchName + : typeToString(missingBranchType); + if (symbolName && + (missingBranchName || missingBranchName === '') && + (0, util_1.requiresQuoting)(missingBranchName.toString(), compilerOptions.target)) { + const escapedBranchName = missingBranchName + .replaceAll("'", "\\'") + .replaceAll('\n', '\\n') + .replaceAll('\r', '\\r'); + caseTest = `${symbolName}['${escapedBranchName}']`; + } + missingCases.push(`case ${caseTest}: { throw new Error('Not implemented yet: ${caseTest + .replaceAll('\\', '\\\\') + .replaceAll("'", "\\'")} case') }`); + } + const fixString = missingCases + .map(code => `${caseIndent}${code}`) + .join('\n'); + if (lastCase) { + if (defaultCase) { + const beforeFixString = missingCases + .map(code => `${code}\n${caseIndent}`) + .join(''); + return fixer.insertTextBefore(defaultCase, beforeFixString); + } + return fixer.insertTextAfter(lastCase, `\n${fixString}`); + } + // There were no existing cases. + const openingBrace = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.discriminant, util_1.isOpeningBraceToken), util_1.NullThrowsReasons.MissingToken('{', 'discriminant')); + const closingBrace = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.discriminant, util_1.isClosingBraceToken), util_1.NullThrowsReasons.MissingToken('}', 'discriminant')); + return fixer.replaceTextRange([openingBrace.range[0], closingBrace.range[1]], ['{', fixString, `${caseIndent}}`].join('\n')); + } + function checkSwitchUnnecessaryDefaultCase(switchMetadata) { + if (allowDefaultCaseForExhaustiveSwitch) { + return; + } + const { containsNonLiteralType, defaultCase, missingLiteralBranchTypes } = switchMetadata; + if (missingLiteralBranchTypes.length === 0 && + defaultCase != null && + !containsNonLiteralType) { + context.report({ + node: defaultCase, + messageId: 'dangerousDefaultCase', + }); + } + } + function checkSwitchNoUnionDefaultCase(node, switchMetadata) { + if (!requireDefaultForNonUnion) { + return; + } + const { containsNonLiteralType, defaultCase } = switchMetadata; + if (containsNonLiteralType && defaultCase == null) { + context.report({ + node: node.discriminant, + messageId: 'switchIsNotExhaustive', + data: { missingBranches: 'default' }, + suggest: [ + { + messageId: 'addMissingCases', + fix(fixer) { + return fixSwitch(fixer, node, [null], defaultCase); + }, + }, + ], + }); + } + } + return { + SwitchStatement(node) { + const switchMetadata = getSwitchMetadata(node); + checkSwitchExhaustive(node, switchMetadata); + checkSwitchUnnecessaryDefaultCase(switchMetadata); + checkSwitchNoUnionDefaultCase(node, switchMetadata); + }, + }; + }, +}); +function isTypeLiteralLikeType(type) { + return tsutils.isTypeFlagSet(type, ts.TypeFlags.Literal | + ts.TypeFlags.Undefined | + ts.TypeFlags.Null | + ts.TypeFlags.UniqueESSymbol); +} +/** + * For example: + * + * - `"foo" | "bar"` is a type with all literal types. + * - `"foo" | number` is a type that contains non-literal types. + * - `"foo" & { bar: 1 }` is a type that contains non-literal types. + * + * Default cases are never superfluous in switches with non-literal types. + */ +function doesTypeContainNonLiteralType(type) { + return tsutils + .unionConstituents(type) + .some(type => tsutils + .intersectionConstituents(type) + .every(subType => !isTypeLiteralLikeType(subType))); +} +//# sourceMappingURL=switch-exhaustiveness-check.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.d.ts new file mode 100644 index 00000000..abddeec2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.d.ts @@ -0,0 +1,12 @@ +export type Options = [ + { + lib?: 'always' | 'never'; + path?: 'always' | 'never'; + types?: 'always' | 'never' | 'prefer-import'; + } +]; +export type MessageIds = 'tripleSlashReference'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.js new file mode 100644 index 00000000..3fbb427d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.js @@ -0,0 +1,111 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'triple-slash-reference', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow certain triple slash directives in favor of ES6-style import declarations', + recommended: 'recommended', + }, + messages: { + tripleSlashReference: 'Do not use a triple slash reference for {{module}}, use `import` style instead.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + lib: { + type: 'string', + description: 'What to enforce for `/// ` references.', + enum: ['always', 'never'], + }, + path: { + type: 'string', + description: 'What to enforce for `/// ` references.', + enum: ['always', 'never'], + }, + types: { + type: 'string', + description: 'What to enforce for `/// ` references.', + enum: ['always', 'never', 'prefer-import'], + }, + }, + }, + ], + }, + defaultOptions: [ + { + lib: 'always', + path: 'never', + types: 'prefer-import', + }, + ], + create(context, [{ lib, path, types }]) { + let programNode; + const references = []; + function hasMatchingReference(source) { + references.forEach(reference => { + if (reference.importName === source.value) { + context.report({ + node: reference.comment, + messageId: 'tripleSlashReference', + data: { + module: reference.importName, + }, + }); + } + }); + } + return { + ImportDeclaration(node) { + if (programNode) { + hasMatchingReference(node.source); + } + }, + Program(node) { + if (lib === 'always' && path === 'always' && types === 'always') { + return; + } + programNode = node; + const referenceRegExp = /^\/\s* { + if (comment.type !== utils_1.AST_TOKEN_TYPES.Line) { + return; + } + const referenceResult = referenceRegExp.exec(comment.value); + if (referenceResult) { + if ((referenceResult[1] === 'types' && types === 'never') || + (referenceResult[1] === 'path' && path === 'never') || + (referenceResult[1] === 'lib' && lib === 'never')) { + context.report({ + node: comment, + messageId: 'tripleSlashReference', + data: { + module: referenceResult[2], + }, + }); + return; + } + if (referenceResult[1] === 'types' && types === 'prefer-import') { + references.push({ comment, importName: referenceResult[2] }); + } + } + }); + }, + TSImportEqualsDeclaration(node) { + if (programNode) { + const reference = node.moduleReference; + if (reference.type === utils_1.AST_NODE_TYPES.TSExternalModuleReference) { + hasMatchingReference(reference.expression); + } + } + }, + }; + }, +}); +//# sourceMappingURL=triple-slash-reference.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.d.ts new file mode 100644 index 00000000..f61f165d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.d.ts @@ -0,0 +1,16 @@ +export declare const enum OptionKeys { + ArrayDestructuring = "arrayDestructuring", + ArrowParameter = "arrowParameter", + MemberVariableDeclaration = "memberVariableDeclaration", + ObjectDestructuring = "objectDestructuring", + Parameter = "parameter", + PropertyDeclaration = "propertyDeclaration", + VariableDeclaration = "variableDeclaration", + VariableDeclarationIgnoreFunction = "variableDeclarationIgnoreFunction" +} +export type Options = [Partial>]; +export type MessageIds = 'expectedTypedef' | 'expectedTypedefNamed'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.js new file mode 100644 index 00000000..1b69ec24 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.js @@ -0,0 +1,240 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.OptionKeys = void 0; +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +var OptionKeys; +(function (OptionKeys) { + OptionKeys["ArrayDestructuring"] = "arrayDestructuring"; + OptionKeys["ArrowParameter"] = "arrowParameter"; + OptionKeys["MemberVariableDeclaration"] = "memberVariableDeclaration"; + OptionKeys["ObjectDestructuring"] = "objectDestructuring"; + OptionKeys["Parameter"] = "parameter"; + OptionKeys["PropertyDeclaration"] = "propertyDeclaration"; + OptionKeys["VariableDeclaration"] = "variableDeclaration"; + OptionKeys["VariableDeclarationIgnoreFunction"] = "variableDeclarationIgnoreFunction"; +})(OptionKeys || (exports.OptionKeys = OptionKeys = {})); +exports.default = (0, util_1.createRule)({ + name: 'typedef', + meta: { + type: 'suggestion', + deprecated: { + deprecatedSince: '8.33.0', + message: 'This is an old rule that is no longer recommended for use.', + }, + docs: { + description: 'Require type annotations in certain places', + }, + messages: { + expectedTypedef: 'Expected a type annotation.', + expectedTypedefNamed: 'Expected {{name}} to have a type annotation.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + [OptionKeys.ArrayDestructuring]: { + type: 'boolean', + description: 'Whether to enforce type annotations on variables declared using array destructuring.', + }, + [OptionKeys.ArrowParameter]: { + type: 'boolean', + description: 'Whether to enforce type annotations for parameters of arrow functions.', + }, + [OptionKeys.MemberVariableDeclaration]: { + type: 'boolean', + description: 'Whether to enforce type annotations on member variables of classes.', + }, + [OptionKeys.ObjectDestructuring]: { + type: 'boolean', + description: 'Whether to enforce type annotations on variables declared using object destructuring.', + }, + [OptionKeys.Parameter]: { + type: 'boolean', + description: 'Whether to enforce type annotations for parameters of functions and methods.', + }, + [OptionKeys.PropertyDeclaration]: { + type: 'boolean', + description: 'Whether to enforce type annotations for properties of interfaces and types.', + }, + [OptionKeys.VariableDeclaration]: { + type: 'boolean', + description: 'Whether to enforce type annotations for variable declarations, excluding array and object destructuring.', + }, + [OptionKeys.VariableDeclarationIgnoreFunction]: { + type: 'boolean', + description: 'Whether to ignore variable declarations for non-arrow and arrow functions.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + [OptionKeys.ArrayDestructuring]: false, + [OptionKeys.ArrowParameter]: false, + [OptionKeys.MemberVariableDeclaration]: false, + [OptionKeys.ObjectDestructuring]: false, + [OptionKeys.Parameter]: false, + [OptionKeys.PropertyDeclaration]: false, + [OptionKeys.VariableDeclaration]: false, + [OptionKeys.VariableDeclarationIgnoreFunction]: false, + }, + ], + create(context, [{ arrayDestructuring, arrowParameter, memberVariableDeclaration, objectDestructuring, parameter, propertyDeclaration, variableDeclaration, variableDeclarationIgnoreFunction, },]) { + function report(location, name) { + context.report({ + node: location, + messageId: name ? 'expectedTypedefNamed' : 'expectedTypedef', + data: { name }, + }); + } + function getNodeName(node) { + return node.type === utils_1.AST_NODE_TYPES.Identifier ? node.name : undefined; + } + function isForOfStatementContext(node) { + let current = node.parent; + while (current) { + switch (current.type) { + case utils_1.AST_NODE_TYPES.VariableDeclarator: + case utils_1.AST_NODE_TYPES.VariableDeclaration: + case utils_1.AST_NODE_TYPES.ObjectPattern: + case utils_1.AST_NODE_TYPES.ArrayPattern: + case utils_1.AST_NODE_TYPES.Property: + current = current.parent; + break; + case utils_1.AST_NODE_TYPES.ForOfStatement: + return true; + default: + current = undefined; + } + } + return false; + } + function checkParameters(params) { + for (const param of params) { + let annotationNode; + switch (param.type) { + case utils_1.AST_NODE_TYPES.AssignmentPattern: + annotationNode = param.left; + break; + case utils_1.AST_NODE_TYPES.TSParameterProperty: + annotationNode = param.parameter; + // Check TS parameter property with default value like `constructor(private param: string = 'something') {}` + if (annotationNode.type === utils_1.AST_NODE_TYPES.AssignmentPattern) { + annotationNode = annotationNode.left; + } + break; + default: + annotationNode = param; + break; + } + if (!annotationNode.typeAnnotation) { + report(param, getNodeName(param)); + } + } + } + function isVariableDeclarationIgnoreFunction(node) { + return (variableDeclarationIgnoreFunction === true && + (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + node.type === utils_1.AST_NODE_TYPES.FunctionExpression)); + } + function isAncestorHasTypeAnnotation(node) { + let ancestor = node.parent; + while (ancestor) { + if ((ancestor.type === utils_1.AST_NODE_TYPES.ObjectPattern || + ancestor.type === utils_1.AST_NODE_TYPES.ArrayPattern) && + ancestor.typeAnnotation) { + return true; + } + ancestor = ancestor.parent; + } + return false; + } + return { + ...(arrayDestructuring && { + ArrayPattern(node) { + if (node.parent.type === utils_1.AST_NODE_TYPES.RestElement && + node.parent.typeAnnotation) { + return; + } + if (!node.typeAnnotation && + !isForOfStatementContext(node) && + !isAncestorHasTypeAnnotation(node) && + node.parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression) { + report(node); + } + }, + }), + ...(arrowParameter && { + ArrowFunctionExpression(node) { + checkParameters(node.params); + }, + }), + ...(memberVariableDeclaration && { + PropertyDefinition(node) { + if (!(node.value && isVariableDeclarationIgnoreFunction(node.value)) && + !node.typeAnnotation) { + report(node, node.key.type === utils_1.AST_NODE_TYPES.Identifier + ? node.key.name + : undefined); + } + }, + }), + ...(parameter && { + 'FunctionDeclaration, FunctionExpression'(node) { + checkParameters(node.params); + }, + }), + ...(objectDestructuring && { + ObjectPattern(node) { + if (!node.typeAnnotation && + !isForOfStatementContext(node) && + !isAncestorHasTypeAnnotation(node)) { + report(node); + } + }, + }), + ...(propertyDeclaration && { + 'TSIndexSignature, TSPropertySignature'(node) { + if (!node.typeAnnotation) { + report(node, node.type === utils_1.AST_NODE_TYPES.TSPropertySignature + ? getNodeName(node.key) + : undefined); + } + }, + }), + VariableDeclarator(node) { + if (!variableDeclaration || + node.id.typeAnnotation || + (node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern && + !arrayDestructuring) || + (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern && + !objectDestructuring) || + (node.init && isVariableDeclarationIgnoreFunction(node.init))) { + return; + } + let current = node.parent; + while (current) { + switch (current.type) { + case utils_1.AST_NODE_TYPES.VariableDeclaration: + // Keep looking upwards + current = current.parent; + break; + case utils_1.AST_NODE_TYPES.ForOfStatement: + case utils_1.AST_NODE_TYPES.ForInStatement: + // Stop traversing and don't report an error + return; + default: + // Stop traversing + current = undefined; + break; + } + } + report(node, getNodeName(node.id)); + }, + }; + }, +}); +//# sourceMappingURL=typedef.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.d.ts new file mode 100644 index 00000000..155e8625 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.d.ts @@ -0,0 +1,9 @@ +interface Config { + ignoreStatic: boolean; +} +export type Options = [Config]; +export type MessageIds = 'unbound' | 'unboundWithoutThisAnnotation'; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js new file mode 100644 index 00000000..7555505e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js @@ -0,0 +1,393 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const util_1 = require("../util"); +/** + * Static methods on these globals are either not `this`-aware or supported being + * called without `this`. + * + * - `Promise` is not in the list because it supports subclassing by using `this` + * - `Array` is in the list because although it supports subclassing, the `this` + * value defaults to `Array` when unbound + * + * This is now a language-design invariant: static methods are never `this`-aware + * because TC39 wants to make `array.map(Class.method)` work! + */ +const SUPPORTED_GLOBALS = [ + 'Number', + 'Object', + 'String', // eslint-disable-line @typescript-eslint/internal/prefer-ast-types-enum + 'RegExp', + 'Symbol', + 'Array', + 'Proxy', + 'Date', + 'Atomics', + 'Reflect', + 'console', + 'Math', + 'JSON', + 'Intl', +]; +const nativelyBoundMembers = new Set(SUPPORTED_GLOBALS.flatMap(namespace => { + if (!(namespace in global)) { + // node.js might not have namespaces like Intl depending on compilation options + // https://nodejs.org/api/intl.html#intl_options_for_building_node_js + return []; + } + const object = global[namespace]; + return Object.getOwnPropertyNames(object) + .filter(name => !name.startsWith('_') && + typeof object[name] === 'function') + .map(name => `${namespace}.${name}`); +})); +const SUPPORTED_GLOBAL_TYPES = [ + 'NumberConstructor', + 'ObjectConstructor', + 'StringConstructor', + 'SymbolConstructor', + 'ArrayConstructor', + 'Array', + 'ProxyConstructor', + 'Console', + 'DateConstructor', + 'Atomics', + 'Math', + 'JSON', +]; +/** + * Methods on instances of built-in classes that are defined by the ECMAScript + * spec as *bound* to their instance (i.e. they are safe to call without their + * receiver), but whose TypeScript declarations don't model that binding - they + * are declared as plain methods that would require a `this` value. + * + * For example, `Intl.Collator.prototype.compare` is defined as a bound getter + * function per the ECMA-402 spec: + * https://tc39.es/ecma402/#sec-intl.collator.prototype.compare + * ...but `lib.es5.d.ts` declares it as a regular method, so this rule would + * otherwise incorrectly flag usages such as `array.sort(collator.compare)`. + */ +const nativelyBoundInstanceMethods = new Set(['Collator.compare']); +const isNotImported = (symbol, currentSourceFile) => { + const { valueDeclaration } = symbol; + if (!valueDeclaration) { + // working around https://github.com/microsoft/TypeScript/issues/31294 + return false; + } + return (!!currentSourceFile && + currentSourceFile !== valueDeclaration.getSourceFile()); +}; +/** + * Returns `true` if `propertyName` is a member of a built-in class instance + * that is defined by the spec as bound to that instance (see + * `nativelyBoundInstanceMethods` above). + */ +function isSpecBoundBuiltinMethod(program, objectType, propertyName) { + const symbol = objectType.getSymbol(); + if (!symbol || !(0, util_1.isSymbolFromDefaultLibrary)(program, symbol)) { + return false; + } + return nativelyBoundInstanceMethods.has(`${symbol.getName()}.${propertyName}`); +} +const BASE_MESSAGE = [ + `A method that is not declared with \`this: void\` may cause unintentional scoping of \`this\` when separated from its object.`, + `Consider using an arrow function or explicitly \`.bind()\`ing the method to avoid calling the method with an unintended \`this\` value. `, +].join('\n'); +exports.default = (0, util_1.createRule)({ + name: 'unbound-method', + meta: { + type: 'problem', + docs: { + description: 'Enforce unbound methods are called with their expected scope', + recommended: 'recommended', + requiresTypeChecking: true, + }, + messages: { + unbound: BASE_MESSAGE, + unboundWithoutThisAnnotation: `${BASE_MESSAGE}\nIf a function does not access \`this\`, it can be annotated with \`this: void\`.`, + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreStatic: { + type: 'boolean', + description: 'Whether to skip checking whether `static` methods are correctly bound.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreStatic: false, + }, + ], + create(context, [{ ignoreStatic }]) { + const services = (0, util_1.getParserServices)(context); + const currentSourceFile = services.program.getSourceFile(context.filename); + function checkIfMethodAndReport(node, symbol) { + if (!symbol) { + return false; + } + const { dangerous, firstParamIsThis } = checkIfMethod(symbol, ignoreStatic); + if (dangerous) { + context.report({ + node, + messageId: firstParamIsThis === false + ? 'unboundWithoutThisAnnotation' + : 'unbound', + }); + return true; + } + return false; + } + function checkUnionConstituentsAndReport(reportNode, propertyName, type) { + for (const intersectionPart of tsutils + .unionConstituents(type) + .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) { + const reported = checkIfMethodAndReport(reportNode, intersectionPart.getProperty(propertyName)); + if (reported) { + return true; + } + } + return false; + } + function getAccessedPropertyNames(node) { + if (!node.computed) { + return node.property.type === utils_1.AST_NODE_TYPES.Identifier + ? [node.property.name] + : []; + } + return tsutils + .unionConstituents(services.getTypeAtLocation(node.property)) + .flatMap(part => { + return part.isStringLiteral() || part.isNumberLiteral() + ? [part.value.toString()] + : []; + }); + } + function isNativelyBound(object, property) { + // We can't rely entirely on the type-level checks made at the end of this + // function, because sometimes type declarations don't come from the + // default library, but come from, for example, "@types/node". And we can't + // tell if a method is unbound just by looking at its signature declared in + // the interface. + // + // See related discussion https://github.com/typescript-eslint/typescript-eslint/pull/8952#discussion_r1576543310 + if (object.type === utils_1.AST_NODE_TYPES.Identifier && + property.type === utils_1.AST_NODE_TYPES.Identifier) { + const objectSymbol = services.getSymbolAtLocation(object); + const notImported = objectSymbol != null && + isNotImported(objectSymbol, currentSourceFile); + if (notImported && + nativelyBoundMembers.has(`${object.name}.${property.name}`)) { + return true; + } + } + if (property.type === utils_1.AST_NODE_TYPES.Identifier) { + const objectType = services.getTypeAtLocation(object); + if (isSpecBoundBuiltinMethod(services.program, objectType, property.name)) { + return true; + } + } + // if `${object.name}.${property.name}` doesn't match any of + // the nativelyBoundMembers, then we fallback to type-level checks + return ((0, util_1.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(object), SUPPORTED_GLOBAL_TYPES) && + (0, util_1.isSymbolFromDefaultLibrary)(services.program, services.getTypeAtLocation(property).getSymbol())); + } + return { + MemberExpression(node) { + if (isSafeUse(node) || isNativelyBound(node.object, node.property)) { + return; + } + const propertyNames = getAccessedPropertyNames(node); + if (propertyNames.length === 0) { + return; + } + const objectType = services.getTypeAtLocation(node.object); + for (const propertyName of propertyNames) { + if (checkUnionConstituentsAndReport(node, propertyName, objectType)) { + break; + } + } + }, + ObjectPattern(node) { + if (isNodeInsideTypeDeclaration(node)) { + return; + } + let initNode = null; + if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) { + initNode = node.parent.init; + } + else if (node.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern || + node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression) { + initNode = node.parent.right; + } + for (const property of node.properties) { + if (property.type !== utils_1.AST_NODE_TYPES.Property || + property.key.type !== utils_1.AST_NODE_TYPES.Identifier) { + continue; + } + if (initNode) { + if (!isNativelyBound(initNode, property.key)) { + const reported = checkIfMethodAndReport(property.key, services + .getTypeAtLocation(initNode) + .getProperty(property.key.name)); + if (reported) { + continue; + } + // In assignment patterns, we should also check the type of + // Foo's nativelyBound method because initNode might be used as + // default value: + // function ({ nativelyBound }: Foo = NativeObject) {} + } + else if (node.parent.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) { + continue; + } + } + checkUnionConstituentsAndReport(property.key, property.key.name, services.getTypeAtLocation(node)); + } + }, + }; + }, +}); +function isNodeInsideTypeDeclaration(node) { + let parent = node; + while ((parent = parent.parent)) { + if ((parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration && parent.declare) || + parent.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition || + parent.type === utils_1.AST_NODE_TYPES.TSDeclareFunction || + parent.type === utils_1.AST_NODE_TYPES.TSFunctionType || + parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration || + parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration || + (parent.type === utils_1.AST_NODE_TYPES.VariableDeclaration && parent.declare)) { + return true; + } + } + return false; +} +function checkIfMethod(symbol, ignoreStatic) { + const { valueDeclaration } = symbol; + if (!valueDeclaration) { + // working around https://github.com/microsoft/TypeScript/issues/31294 + return { dangerous: false }; + } + switch (valueDeclaration.kind) { + case ts.SyntaxKind.PropertyDeclaration: + return { + dangerous: valueDeclaration.initializer?.kind === + ts.SyntaxKind.FunctionExpression, + }; + case ts.SyntaxKind.PropertyAssignment: { + const assignee = valueDeclaration.initializer; + if (assignee.kind !== ts.SyntaxKind.FunctionExpression) { + return { + dangerous: false, + }; + } + return checkMethod(assignee, ignoreStatic); + } + case ts.SyntaxKind.MethodDeclaration: + case ts.SyntaxKind.MethodSignature: { + return checkMethod(valueDeclaration, ignoreStatic); + } + } + return { dangerous: false }; +} +function checkMethod(valueDeclaration, ignoreStatic) { + const firstParam = valueDeclaration.parameters.at(0); + const firstParamIsThis = firstParam?.name.kind === ts.SyntaxKind.Identifier && + // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison + firstParam.name.escapedText === 'this'; + const thisArgIsVoid = firstParamIsThis && firstParam.type?.kind === ts.SyntaxKind.VoidKeyword; + return { + dangerous: !thisArgIsVoid && + !(ignoreStatic && + tsutils.includesModifier((0, util_1.getModifiers)(valueDeclaration), ts.SyntaxKind.StaticKeyword)), + firstParamIsThis, + }; +} +function isSafeUse(node) { + const parent = node.parent; + switch (parent?.type) { + case utils_1.AST_NODE_TYPES.IfStatement: + case utils_1.AST_NODE_TYPES.ForStatement: + case utils_1.AST_NODE_TYPES.MemberExpression: + case utils_1.AST_NODE_TYPES.SwitchStatement: + case utils_1.AST_NODE_TYPES.UpdateExpression: + case utils_1.AST_NODE_TYPES.WhileStatement: + return true; + case utils_1.AST_NODE_TYPES.CallExpression: + return parent.callee === node; + case utils_1.AST_NODE_TYPES.ConditionalExpression: + return parent.test === node; + case utils_1.AST_NODE_TYPES.TaggedTemplateExpression: + return parent.tag === node; + case utils_1.AST_NODE_TYPES.UnaryExpression: + // the first case is safe for obvious + // reasons. The second one is also fine + // since we're returning something falsy + return ['!', 'delete', 'typeof', 'void'].includes(parent.operator); + case utils_1.AST_NODE_TYPES.BinaryExpression: + return ['!=', '!==', '==', '===', 'instanceof'].includes(parent.operator); + case utils_1.AST_NODE_TYPES.AssignmentExpression: + return (parent.operator === '=' && + (node === parent.left || + (node.type === utils_1.AST_NODE_TYPES.MemberExpression && + node.object.type === utils_1.AST_NODE_TYPES.Super && + parent.left.type === utils_1.AST_NODE_TYPES.MemberExpression && + parent.left.object.type === utils_1.AST_NODE_TYPES.ThisExpression))); + case utils_1.AST_NODE_TYPES.ChainExpression: + case utils_1.AST_NODE_TYPES.TSNonNullExpression: + case utils_1.AST_NODE_TYPES.TSAsExpression: + case utils_1.AST_NODE_TYPES.TSTypeAssertion: + return isSafeUse(parent); + case utils_1.AST_NODE_TYPES.LogicalExpression: + if (parent.operator === '&&' && parent.left === node) { + // this is safe, as && will return the left if and only if it's falsy + return true; + } + // in all other cases, it's likely the logical expression will return the method ref + // so make sure the parent is a safe usage + return isSafeUse(parent); + } + return false; +} +//# sourceMappingURL=unbound-method.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts new file mode 100644 index 00000000..2ddb15c0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts @@ -0,0 +1,11 @@ +export type MessageIds = 'allParametersAreSame' | 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference'; +export type Options = [ + { + ignoreDifferentlyNamedParameters?: boolean; + ignoreOverloadsWithDifferentJSDoc?: boolean; + } +]; +declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js new file mode 100644 index 00000000..4668dad2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js @@ -0,0 +1,502 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const util_1 = require("../util"); +exports.default = (0, util_1.createRule)({ + name: 'unified-signatures', + meta: { + type: 'suggestion', + docs: { + description: 'Disallow two overloads that could be unified into one with a union or an optional/rest parameter', + // too opinionated to be recommended + recommended: 'strict', + }, + messages: { + allParametersAreSame: '{{failureStringStart}} with identical parameters.', + omittingRestParameter: '{{failureStringStart}} with a rest parameter.', + omittingSingleParameter: '{{failureStringStart}} with an optional parameter.', + singleParameterDifference: '{{failureStringStart}} taking `{{types}}`.', + }, + schema: [ + { + type: 'object', + additionalProperties: false, + properties: { + ignoreDifferentlyNamedParameters: { + type: 'boolean', + description: 'Whether two parameters with different names at the same index should be considered different even if their types are the same.', + }, + ignoreOverloadsWithDifferentJSDoc: { + type: 'boolean', + description: 'Whether two overloads with different JSDoc comments should be considered different even if their parameter and return types are the same.', + }, + }, + }, + ], + }, + defaultOptions: [ + { + ignoreDifferentlyNamedParameters: false, + ignoreOverloadsWithDifferentJSDoc: false, + }, + ], + create(context, [{ ignoreDifferentlyNamedParameters, ignoreOverloadsWithDifferentJSDoc }]) { + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + function failureStringStart(otherLine) { + // For only 2 overloads we don't need to specify which is the other one. + const overloads = otherLine == null + ? 'These overloads' + : `This overload and the one on line ${otherLine}`; + return `${overloads} can be combined into one signature`; + } + function addFailures(failures) { + for (const failure of failures) { + const { only2, unify } = failure; + switch (unify.kind) { + case 'single-parameter-difference': { + const { p0, p1 } = unify; + const lineOfOtherOverload = only2 ? undefined : p0.loc.start.line; + const typeAnnotation0 = getParameterTypeAnnotation(p0); + const typeAnnotation1 = getParameterTypeAnnotation(p1); + context.report({ + loc: p1.loc, + node: p1, + messageId: 'singleParameterDifference', + data: { + failureStringStart: failureStringStart(lineOfOtherOverload), + types: getUnifiedTypeText(typeAnnotation0, typeAnnotation1), + }, + }); + break; + } + case 'extra-parameter': { + const { extraParameter, otherSignature } = unify; + const lineOfOtherOverload = only2 + ? undefined + : otherSignature.loc.start.line; + context.report({ + loc: extraParameter.loc, + node: extraParameter, + messageId: extraParameter.type === utils_1.AST_NODE_TYPES.RestElement + ? 'omittingRestParameter' + : 'omittingSingleParameter', + data: { + failureStringStart: failureStringStart(lineOfOtherOverload), + }, + }); + break; + } + case 'all-parameters-are-same': { + const { signature0, signature1 } = unify; + const lineOfOtherOverload = only2 + ? undefined + : signature0.loc.start.line; + context.report({ + node: signature1, + messageId: 'allParametersAreSame', + data: { + failureStringStart: failureStringStart(lineOfOtherOverload), + }, + }); + break; + } + default: + unify; + } + } + } + function checkOverloads(signatures, typeParameters) { + const result = []; + const isTypeParameter = getIsTypeParameter(typeParameters); + for (const overloads of signatures) { + forEachPair(overloads, (a, b) => { + const signature0 = a.value ?? a; + const signature1 = b.value ?? b; + const unify = compareSignatures(signature0, signature1, isTypeParameter); + if (unify != null) { + result.push({ only2: overloads.length === 2, unify }); + } + }); + } + return result; + } + function compareSignatures(a, b, isTypeParameter) { + if (!signaturesCanBeUnified(a, b, isTypeParameter)) { + return undefined; + } + return a.params.length === b.params.length + ? signaturesHaveSameAmountOfParameters(a, b) + : signaturesDifferByOptionalOrRestParameter(a, b); + } + function signaturesCanBeUnified(a, b, isTypeParameter) { + // Must return the same type. + const aTypeParams = a.typeParameters != null ? a.typeParameters.params : undefined; + const bTypeParams = b.typeParameters != null ? b.typeParameters.params : undefined; + if (ignoreDifferentlyNamedParameters) { + const commonParamsLength = Math.min(a.params.length, b.params.length); + for (let i = 0; i < commonParamsLength; i += 1) { + if (a.params[i].type === b.params[i].type && + getStaticParameterName(a.params[i]) !== + getStaticParameterName(b.params[i])) { + return false; + } + } + } + if (ignoreOverloadsWithDifferentJSDoc) { + const aComment = getBlockCommentForNode(getCommentTargetNode(a)); + const bComment = getBlockCommentForNode(getCommentTargetNode(b)); + if (aComment?.value !== bComment?.value) { + return false; + } + } + return (typesAreEqual(a.returnType?.typeAnnotation, b.returnType?.typeAnnotation) && + // Must take the same type parameters. + // If one uses a type parameter (from outside) and the other doesn't, they shouldn't be joined. + (0, util_1.arraysAreEqual)(aTypeParams, bTypeParams, typeParametersAreEqual) && + signatureUsesTypeParameter(a, isTypeParameter) === + signatureUsesTypeParameter(b, isTypeParameter)); + } + /** + * Detect no difference, i.e. `a(x: number, y: string)` and `a(x: number, y: string)`, + * or one param difference, i.e. `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`. + */ + function signaturesHaveSameAmountOfParameters(signature0, signature1) { + const types1 = signature0.params; + const types2 = signature1.params; + const firstParam1 = types1[0]; + const firstParam2 = types2[0]; + // exempt signatures with `this: void` from the rule + if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) { + return undefined; + } + const index = getIndexOfFirstDifference(types1, types2, parametersAreEqual); + if (index == null) { + return { + kind: 'all-parameters-are-same', + signature0, + signature1, + }; + } + // If remaining arrays are equal, the signatures differ by just one parameter type + if (!(0, util_1.arraysAreEqual)(types1.slice(index + 1), types2.slice(index + 1), parametersAreEqual)) { + return undefined; + } + const a = types1[index]; + const b = types2[index]; + // Can unify `a?: string` and `b?: number`. Can't unify `...args: string[]` and `...args: number[]`. + // See https://github.com/Microsoft/TypeScript/issues/5077 + return parametersHaveEqualSigils(a, b) && + a.type !== utils_1.AST_NODE_TYPES.RestElement + ? { kind: 'single-parameter-difference', p0: a, p1: b } + : undefined; + } + function getParameterTypeAnnotation(parameter) { + return isTSParameterProperty(parameter) + ? parameter.parameter.typeAnnotation?.typeAnnotation + : parameter.typeAnnotation?.typeAnnotation; + } + function getUnifiedTypeText(type0, type1) { + // When a signature's parameter has no type annotation + if (type0 == null || type1 == null) { + return getUnionMemberText((0, util_1.nullThrows)(type0 ?? type1, 'Expected a type annotation for one of the parameters, but both were undefined')); + } + const members = [...getUnionMembers(type0), ...getUnionMembers(type1)]; + const uniqueMembers = []; + for (const member of members) { + if (!uniqueMembers.some(other => typesAreEqual(other, member))) { + uniqueMembers.push(member); + } + } + return uniqueMembers + .map(member => getUnionMemberText(member)) + .join(' | '); + } + function getUnionMembers(type) { + return type.type === utils_1.AST_NODE_TYPES.TSUnionType + ? type.types.flatMap(getUnionMembers) + : [type]; + } + function getUnionMemberText(type) { + const text = context.sourceCode.getText(type); + const needsParentheses = type.type === utils_1.AST_NODE_TYPES.TSConditionalType || + type.type === utils_1.AST_NODE_TYPES.TSConstructorType || + type.type === utils_1.AST_NODE_TYPES.TSFunctionType; + return needsParentheses ? `(${text})` : text; + } + function isThisParam(param) { + return param?.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this'; + } + function isThisVoidParam(param) { + return (isThisParam(param) && + param.typeAnnotation?.typeAnnotation.type === + utils_1.AST_NODE_TYPES.TSVoidKeyword); + } + /** + * Detect `a(): void` and `a(x: number): void`. + * Returns the parameter declaration (`x: number` in this example) that should be optional/rest, and overload it's a part of. + */ + function signaturesDifferByOptionalOrRestParameter(a, b) { + const sig1 = a.params; + const sig2 = b.params; + const minLength = Math.min(sig1.length, sig2.length); + const longer = sig1.length < sig2.length ? sig2 : sig1; + const shorter = sig1.length < sig2.length ? sig1 : sig2; + const shorterSig = sig1.length < sig2.length ? a : b; + const firstParam1 = sig1.at(0); + const firstParam2 = sig2.at(0); + // If one signature has explicit this type and another doesn't, they can't + // be unified. + if (isThisParam(firstParam1) !== isThisParam(firstParam2)) { + return undefined; + } + // exempt signatures with `this: void` from the rule + if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) { + return undefined; + } + // If one is has 2+ parameters more than the other, they must all be optional/rest. + // Differ by optional parameters: f() and f(x), f() and f(x, ?y, ...z) + // Not allowed: f() and f(x, y) + for (let i = minLength + 1; i < longer.length; i++) { + if (!parameterMayBeMissing(longer[i])) { + return undefined; + } + } + for (let i = 0; i < minLength; i++) { + if (!typesAreEqual(getParameterTypeAnnotation(sig1[i]), getParameterTypeAnnotation(sig2[i]))) { + return undefined; + } + } + if (minLength > 0 && + shorter[minLength - 1].type === utils_1.AST_NODE_TYPES.RestElement) { + return undefined; + } + return { + extraParameter: longer[longer.length - 1], + kind: 'extra-parameter', + otherSignature: shorterSig, + }; + } + /** Given type parameters, returns a function to test whether a type is one of those parameters. */ + function getIsTypeParameter(typeParameters) { + if (typeParameters == null) { + return () => false; + } + const set = new Set(); + for (const t of typeParameters.params) { + set.add(t.name.name); + } + return typeName => set.has(typeName); + } + /** True if any of the outer type parameters are used in a signature. */ + function signatureUsesTypeParameter(sig, isTypeParameter) { + return sig.params.some((p) => typeContainsTypeParameter(isTSParameterProperty(p) + ? p.parameter.typeAnnotation + : p.typeAnnotation)); + function typeContainsTypeParameter(type) { + if (!type) { + return false; + } + if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference) { + const typeName = type.typeName; + if (isIdentifier(typeName) && isTypeParameter(typeName.name)) { + return true; + } + } + return typeContainsTypeParameter(type.typeAnnotation ?? + type.elementType); + } + } + function isTSParameterProperty(node) { + return node.type === utils_1.AST_NODE_TYPES.TSParameterProperty; + } + function parametersAreEqual(a, b) { + return (parametersHaveEqualSigils(a, b) && + typesAreEqual(getParameterTypeAnnotation(a), getParameterTypeAnnotation(b))); + } + /** True for optional/rest parameters. */ + function parameterMayBeMissing(p) { + const optional = isTSParameterProperty(p) + ? p.parameter.optional + : p.optional; + return p.type === utils_1.AST_NODE_TYPES.RestElement || optional; + } + /** False if one is optional and the other isn't, or one is a rest parameter and the other isn't. */ + function parametersHaveEqualSigils(a, b) { + const optionalA = isTSParameterProperty(a) + ? a.parameter.optional + : a.optional; + const optionalB = isTSParameterProperty(b) + ? b.parameter.optional + : b.optional; + return ((a.type === utils_1.AST_NODE_TYPES.RestElement) === + (b.type === utils_1.AST_NODE_TYPES.RestElement) && optionalA === optionalB); + } + function typeParametersAreEqual(a, b) { + return (a.name.name === b.name.name && typesAreEqual(a.constraint, b.constraint)); + } + function typesAreEqual(a, b) { + return (a === b || + (a != null && + b != null && + context.sourceCode.getText(a) === context.sourceCode.getText(b))); + } + /* Returns the first index where `a` and `b` differ. */ + function getIndexOfFirstDifference(a, b, equal) { + for (let i = 0; i < a.length && i < b.length; i++) { + if (!equal(a[i], b[i])) { + return i; + } + } + return undefined; + } + /** Calls `action` for every pair of values in `values`. */ + function forEachPair(values, action) { + for (let i = 0; i < values.length; i++) { + for (let j = i + 1; j < values.length; j++) { + action(values[i], values[j]); + } + } + } + const scopes = []; + let currentScope = { + overloads: new Map(), + }; + function createScope(parent, typeParameters) { + if (currentScope) { + scopes.push(currentScope); + } + currentScope = { + overloads: new Map(), + parent, + typeParameters, + }; + } + function checkScope() { + const scope = (0, util_1.nullThrows)(currentScope, 'checkScope() called without a current scope'); + const failures = checkOverloads([...scope.overloads.values()], scope.typeParameters); + addFailures(failures); + currentScope = scopes.pop(); + } + /** + * @returns the first valid JSDoc comment annotating `node` + */ + function getBlockCommentForNode(node) { + return context.sourceCode + .getCommentsBefore(node) + .reverse() + .find(comment => comment.type === utils_1.AST_TOKEN_TYPES.Block); + } + function addOverload(signature, key, containingNode) { + key ??= getOverloadKey(signature); + if ((containingNode ?? signature).parent === currentScope?.parent) { + const overloads = currentScope.overloads.get(key); + if (overloads != null) { + overloads.push(signature); + } + else { + currentScope.overloads.set(key, [signature]); + } + } + } + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + return { + ClassDeclaration(node) { + createScope(node.body, node.typeParameters); + }, + Program: createScope, + TSInterfaceDeclaration(node) { + createScope(node.body, node.typeParameters); + }, + TSModuleBlock: createScope, + TSTypeLiteral: createScope, + // collect overloads + MethodDefinition(node) { + if (!node.value.body && !isGetterOrSetter(node)) { + addOverload(node); + } + }, + TSAbstractMethodDefinition(node) { + if (!node.value.body && !isGetterOrSetter(node)) { + addOverload(node); + } + }, + TSCallSignatureDeclaration: addOverload, + TSConstructSignatureDeclaration: addOverload, + TSDeclareFunction(node) { + const exportingNode = getExportingNode(node); + addOverload(node, node.id?.name ?? exportingNode?.type, exportingNode); + }, + TSMethodSignature(node) { + if (!isGetterOrSetter(node)) { + addOverload(node); + } + }, + // validate scopes + 'ClassDeclaration:exit': checkScope, + 'Program:exit': checkScope, + 'TSInterfaceDeclaration:exit': checkScope, + 'TSModuleBlock:exit': checkScope, + 'TSTypeLiteral:exit': checkScope, + }; + }, +}); +function getCommentTargetNode(node) { + if (node.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) { + return node.parent; + } + return getExportingNode(node) ?? node; +} +function getExportingNode(node) { + return node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration || + node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration + ? node.parent + : undefined; +} +function getOverloadKey(node) { + const info = getOverloadInfo(node); + return ((node.computed ? '0' : '1') + + (node.static ? '0' : '1') + + info); +} +function getOverloadInfo(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration: + return 'constructor'; + case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration: + return '()'; + default: { + const { key } = node; + if (isPrivateIdentifier(key)) { + return `private_identifier_${key.name}`; + } + if (isIdentifier(key)) { + return `identifier_${key.name}`; + } + return key.raw; + } + } +} +function getStaticParameterName(param) { + switch (param.type) { + case utils_1.AST_NODE_TYPES.Identifier: + return param.name; + case utils_1.AST_NODE_TYPES.RestElement: + return getStaticParameterName(param.argument); + default: + return undefined; + } +} +function isIdentifier(node) { + return node.type === utils_1.AST_NODE_TYPES.Identifier; +} +function isPrivateIdentifier(node) { + return node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier; +} +function isGetterOrSetter(node) { + return node.kind === 'get' || node.kind === 'set'; +} +//# sourceMappingURL=unified-signatures.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.d.ts new file mode 100644 index 00000000..9a955cd5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.d.ts @@ -0,0 +1,6 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export type MessageIds = 'addUnknownRestTypeAnnotationSuggestion' | 'addUnknownTypeAnnotationSuggestion' | 'useUnknown' | 'useUnknownArrayDestructuringPattern' | 'useUnknownObjectDestructuringPattern' | 'wrongRestTypeAnnotationSuggestion' | 'wrongTypeAnnotationSuggestion'; +declare const _default: TSESLint.RuleModule & { + name: string; +}; +export default _default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js new file mode 100644 index 00000000..2147c849 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js @@ -0,0 +1,262 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const util_1 = require("../util"); +const useUnknownMessageBase = 'Prefer the safe `: unknown` for a `{{method}}`{{append}} callback variable.'; +exports.default = (0, util_1.createRule)({ + name: 'use-unknown-in-catch-callback-variable', + meta: { + type: 'suggestion', + docs: { + description: 'Enforce typing arguments in Promise rejection callbacks as `unknown`', + recommended: 'strict', + requiresTypeChecking: true, + }, + hasSuggestions: true, + messages: { + addUnknownRestTypeAnnotationSuggestion: 'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.', + addUnknownTypeAnnotationSuggestion: 'Add an explicit `: unknown` type annotation to the rejection callback variable.', + useUnknown: useUnknownMessageBase, + useUnknownArrayDestructuringPattern: `${useUnknownMessageBase} The thrown error may not be iterable.`, + useUnknownObjectDestructuringPattern: `${useUnknownMessageBase} The thrown error may be nullable, or may not have the expected shape.`, + wrongRestTypeAnnotationSuggestion: 'Change existing type annotation to `: [unknown]`.', + wrongTypeAnnotationSuggestion: 'Change existing type annotation to `: unknown`.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context); + const checker = program.getTypeChecker(); + function isFlaggableHandlerType(type) { + for (const unionPart of tsutils.unionConstituents(type)) { + const callSignatures = tsutils.getCallSignaturesOfType(unionPart); + if (callSignatures.length === 0) { + // Ignore any non-function components to the type. Those are not this rule's problem. + continue; + } + for (const callSignature of callSignatures) { + const firstParam = callSignature.parameters.at(0); + if (!firstParam) { + // it's not an issue if there's no catch variable at all. + continue; + } + let firstParamType = checker.getTypeOfSymbol(firstParam); + const decl = firstParam.valueDeclaration; + if (decl != null && (0, util_1.isRestParameterDeclaration)(decl)) { + if (checker.isArrayType(firstParamType)) { + firstParamType = checker.getTypeArguments(firstParamType)[0]; + } + else if (checker.isTupleType(firstParamType)) { + firstParamType = checker.getTypeArguments(firstParamType)[0]; + } + else { + // a rest arg that's not an array or tuple should definitely be flagged. + return true; + } + } + if (!tsutils.isIntrinsicUnknownType(firstParamType)) { + return true; + } + } + } + return false; + } + function collectFlaggedNodes(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.LogicalExpression: + return [ + ...collectFlaggedNodes(node.left), + ...collectFlaggedNodes(node.right), + ]; + case utils_1.AST_NODE_TYPES.SequenceExpression: + return collectFlaggedNodes((0, util_1.nullThrows)(node.expressions.at(-1), 'sequence expression must have multiple expressions')); + case utils_1.AST_NODE_TYPES.ConditionalExpression: + return [ + ...collectFlaggedNodes(node.consequent), + ...collectFlaggedNodes(node.alternate), + ]; + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: + { + const argument = esTreeNodeToTSNodeMap.get(node); + const typeOfArgument = checker.getTypeAtLocation(argument); + if (isFlaggableHandlerType(typeOfArgument)) { + return [node]; + } + } + break; + default: + break; + } + return []; + } + /** + * Analyzes the syntax of the catch argument and makes a best effort to pinpoint + * why it's reporting, and to come up with a suggested fix if possible. + * + * This function is explicitly operating under the assumption that the + * rule _is reporting_, so it is not guaranteed to be sound to call otherwise. + */ + function refineReportIfPossible(argument) { + const catchVariableOuterWithIncorrectTypes = (0, util_1.nullThrows)(argument.params.at(0), 'There should have been at least one parameter for the rule to have flagged.'); + // Function expressions can't have parameter properties; those only exist in constructors. + const catchVariableOuter = catchVariableOuterWithIncorrectTypes; + const catchVariableInner = catchVariableOuter.type === utils_1.AST_NODE_TYPES.AssignmentPattern + ? catchVariableOuter.left + : catchVariableOuter; + switch (catchVariableInner.type) { + case utils_1.AST_NODE_TYPES.Identifier: { + const catchVariableTypeAnnotation = catchVariableInner.typeAnnotation; + if (catchVariableTypeAnnotation == null) { + return { + node: catchVariableOuter, + suggest: [ + { + messageId: 'addUnknownTypeAnnotationSuggestion', + fix: (fixer) => { + if (argument.type === + utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + (0, util_1.isParenlessArrowFunction)(argument, context.sourceCode)) { + return [ + fixer.insertTextBefore(catchVariableInner, '('), + fixer.insertTextAfter(catchVariableInner, ': unknown)'), + ]; + } + return [ + fixer.insertTextAfter(catchVariableInner, ': unknown'), + ]; + }, + }, + ], + }; + } + return { + node: catchVariableOuter, + suggest: [ + { + messageId: 'wrongTypeAnnotationSuggestion', + fix: (fixer) => fixer.replaceText(catchVariableTypeAnnotation, ': unknown'), + }, + ], + }; + } + case utils_1.AST_NODE_TYPES.ArrayPattern: { + return { + node: catchVariableOuter, + messageId: 'useUnknownArrayDestructuringPattern', + }; + } + case utils_1.AST_NODE_TYPES.ObjectPattern: { + return { + node: catchVariableOuter, + messageId: 'useUnknownObjectDestructuringPattern', + }; + } + case utils_1.AST_NODE_TYPES.RestElement: { + const catchVariableTypeAnnotation = catchVariableInner.typeAnnotation; + if (catchVariableTypeAnnotation == null) { + return { + node: catchVariableOuter, + suggest: [ + { + messageId: 'addUnknownRestTypeAnnotationSuggestion', + fix: (fixer) => fixer.insertTextAfter(catchVariableInner, ': [unknown]'), + }, + ], + }; + } + return { + node: catchVariableOuter, + suggest: [ + { + messageId: 'wrongRestTypeAnnotationSuggestion', + fix: (fixer) => fixer.replaceText(catchVariableTypeAnnotation, ': [unknown]'), + }, + ], + }; + } + } + } + return { + CallExpression({ arguments: args, callee }) { + if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return; + } + const staticMemberAccessKey = (0, util_1.getStaticMemberAccessValue)(callee, context); + if (!staticMemberAccessKey) { + return; + } + const promiseMethodInfo = [ + { append: '', argIndexToCheck: 0, method: 'catch' }, + { append: ' rejection', argIndexToCheck: 1, method: 'then' }, + ].find(({ method }) => staticMemberAccessKey === method); + if (!promiseMethodInfo) { + return; + } + // Need to be enough args to check + const { argIndexToCheck, ...data } = promiseMethodInfo; + if (args.length < argIndexToCheck + 1) { + return; + } + // Argument to check, and all arguments before it, must be "ordinary" arguments (i.e. no spread arguments) + // promise.catch(f), promise.catch(() => {}), promise.catch(, <>) + const argsToCheck = args.slice(0, argIndexToCheck + 1); + if (argsToCheck.some(({ type }) => type === utils_1.AST_NODE_TYPES.SpreadElement)) { + return; + } + if (!tsutils.isThenableType(checker, esTreeNodeToTSNodeMap.get(callee), checker.getTypeAtLocation(esTreeNodeToTSNodeMap.get(callee.object)))) { + return; + } + // the `some` check above has already excluded `SpreadElement`, so we are safe to assert the same + const argToCheck = argsToCheck[argIndexToCheck]; + for (const node of collectFlaggedNodes(argToCheck)) { + // We are now guaranteed to report, but we have a bit of work to do + // to determine exactly where, and whether we can fix it. + const overrides = refineReportIfPossible(node); + context.report({ + node, + messageId: 'useUnknown', + data, + ...overrides, + }); + } + }, + }; + }, +}); +//# sourceMappingURL=use-unknown-in-catch-callback-variable.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.d.ts new file mode 100644 index 00000000..f86cdf56 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.d.ts @@ -0,0 +1,15 @@ +import * as ts from 'typescript'; +/** + * Tracks checking the parameters of a single function signature. + * This allows rules to "consume" parameters and check for unsafe comparisons. + */ +export declare class FunctionSignature { + private readonly paramTypes; + private readonly restType; + private hasConsumedArguments; + private parameterTypeIndex; + private constructor(); + static create(checker: ts.TypeChecker, tsNode: ts.CallLikeExpression): FunctionSignature; + consumeRemainingArguments(): void; + getNextParameterType(): ts.Type | null; +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.js new file mode 100644 index 00000000..e5e930f2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.js @@ -0,0 +1,123 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FunctionSignature = void 0; +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const misc_1 = require("./misc"); +const { nullThrows } = utils_1.ESLintUtils; +var RestTypeKind; +(function (RestTypeKind) { + RestTypeKind[RestTypeKind["Array"] = 0] = "Array"; + RestTypeKind[RestTypeKind["Other"] = 1] = "Other"; + RestTypeKind[RestTypeKind["Tuple"] = 2] = "Tuple"; +})(RestTypeKind || (RestTypeKind = {})); +/** + * Tracks checking the parameters of a single function signature. + * This allows rules to "consume" parameters and check for unsafe comparisons. + */ +class FunctionSignature { + paramTypes; + restType; + hasConsumedArguments = false; + parameterTypeIndex = 0; + constructor(paramTypes, restType) { + this.paramTypes = paramTypes; + this.restType = restType; + } + static create(checker, tsNode) { + // getResolvedSignature only returns undefined for nodes outside the parse + // tree, and tsNode always comes from the AST node map. + const signature = nullThrows(checker.getResolvedSignature(tsNode), 'Expected the call-like node to resolve to a signature.'); + const paramTypes = []; + let restType = null; + const parameters = signature.getParameters(); + for (let index = 0; index < parameters.length; index += 1) { + const param = parameters[index]; + const declaration = param.getDeclarations()?.[0]; + const type = checker.getTypeOfSymbolAtLocation(param, tsNode); + const constrainedType = checker.getBaseConstraintOfType(type) ?? type; + if (declaration && (0, misc_1.isRestParameterDeclaration)(declaration)) { + if (checker.isTupleType(constrainedType)) { + restType = { + index, + kind: RestTypeKind.Tuple, + typeArguments: checker.getTypeArguments(constrainedType), + }; + } + else { + const elementType = checker.getIndexTypeOfType(constrainedType, ts.IndexKind.Number); + restType = elementType + ? { index, kind: RestTypeKind.Array, type: elementType } + : { index, kind: RestTypeKind.Other, type: constrainedType }; + } + break; + } + paramTypes.push(type); + } + return new FunctionSignature(paramTypes, restType); + } + consumeRemainingArguments() { + this.hasConsumedArguments = true; + } + getNextParameterType() { + const index = this.parameterTypeIndex; + this.parameterTypeIndex += 1; + if (index >= this.paramTypes.length || this.hasConsumedArguments) { + if (this.restType == null) { + return null; + } + switch (this.restType.kind) { + case RestTypeKind.Tuple: { + const { typeArguments } = this.restType; + if (this.hasConsumedArguments) { + return typeArguments[typeArguments.length - 1]; + } + const typeIndex = index - this.restType.index; + if (typeIndex >= typeArguments.length) { + return typeArguments[typeArguments.length - 1]; + } + return typeArguments[typeIndex]; + } + case RestTypeKind.Array: + case RestTypeKind.Other: + return this.restType.type; + } + } + return this.paramTypes[index]; + } +} +exports.FunctionSignature = FunctionSignature; +//# sourceMappingURL=FunctionSignature.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.d.ts new file mode 100644 index 00000000..20122ffd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.d.ts @@ -0,0 +1,16 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import * as ts from 'typescript'; +/** + * Inspect a call expression to see if it's a call to an assertion function. + * If it is, return the node of the argument that is asserted. + */ +export declare function findTruthinessAssertedArgument(services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): TSESTree.Expression | undefined; +/** + * Inspect a call expression to see if it's a call to an assertion function. + * If it is, return the node of the argument that is asserted and other useful info. + */ +export declare function findTypeGuardAssertedArgument(services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): { + argument: TSESTree.Expression; + asserts: boolean; + type: ts.Type; +} | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.js new file mode 100644 index 00000000..574269a5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.js @@ -0,0 +1,117 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.findTruthinessAssertedArgument = findTruthinessAssertedArgument; +exports.findTypeGuardAssertedArgument = findTypeGuardAssertedArgument; +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +/** + * Inspect a call expression to see if it's a call to an assertion function. + * If it is, return the node of the argument that is asserted. + */ +function findTruthinessAssertedArgument(services, node) { + // If the call looks like `assert(expr1, expr2, ...c, d, e, f)`, then we can + // only care if `expr1` or `expr2` is asserted, since anything that happens + // within or after a spread argument is out of scope to reason about. + const checkableArguments = []; + for (const argument of node.arguments) { + if (argument.type === utils_1.AST_NODE_TYPES.SpreadElement) { + break; + } + checkableArguments.push(argument); + } + // nothing to do + if (checkableArguments.length === 0) { + return undefined; + } + const checker = services.program.getTypeChecker(); + const signature = services.getResolvedSignature(node); + if (signature == null) { + return undefined; + } + const firstTypePredicateResult = checker.getTypePredicateOfSignature(signature); + if (firstTypePredicateResult == null) { + return undefined; + } + const { kind, parameterIndex, type } = firstTypePredicateResult; + if (!(kind === ts.TypePredicateKind.AssertsIdentifier && type == null)) { + return undefined; + } + return checkableArguments.at(parameterIndex); +} +/** + * Inspect a call expression to see if it's a call to an assertion function. + * If it is, return the node of the argument that is asserted and other useful info. + */ +function findTypeGuardAssertedArgument(services, node) { + // If the call looks like `assert(expr1, expr2, ...c, d, e, f)`, then we can + // only care if `expr1` or `expr2` is asserted, since anything that happens + // within or after a spread argument is out of scope to reason about. + const checkableArguments = []; + for (const argument of node.arguments) { + if (argument.type === utils_1.AST_NODE_TYPES.SpreadElement) { + break; + } + checkableArguments.push(argument); + } + // nothing to do + if (checkableArguments.length === 0) { + return undefined; + } + const checker = services.program.getTypeChecker(); + const callSignature = services.getResolvedSignature(node); + if (callSignature == null) { + return undefined; + } + const typePredicateInfo = checker.getTypePredicateOfSignature(callSignature); + if (typePredicateInfo == null) { + return undefined; + } + const { kind, parameterIndex, type } = typePredicateInfo; + if (!((kind === ts.TypePredicateKind.AssertsIdentifier || + kind === ts.TypePredicateKind.Identifier) && + type != null)) { + return undefined; + } + if (parameterIndex >= checkableArguments.length) { + return undefined; + } + return { + argument: checkableArguments[parameterIndex], + asserts: kind === ts.TypePredicateKind.AssertsIdentifier, + type, + }; +} +//# sourceMappingURL=assertionFunctionUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.d.ts new file mode 100644 index 00000000..1a31bb03 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.d.ts @@ -0,0 +1,17 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +import * as ts from 'typescript'; +export * from '@typescript-eslint/utils/ast-utils'; +/** + * Get the `loc` object of a given name in a `/*globals` comment directive. + * @param sourceCode The source code to convert index to loc. + * @param comment The `/*globals` comment directive which include the name. + * @param name The name to find. + * @returns The `loc` object. + */ +export declare function getNameLocationInGlobalDirectiveComment(sourceCode: TSESLint.SourceCode, comment: TSESTree.Comment, name: string): TSESTree.SourceLocation; +export declare function forEachReturnStatement(body: ts.Block, visitor: (stmt: ts.ReturnStatement) => T): T | undefined; +/** + * Rough equivalent to ts.forEachChild for ESTree nodes. + * It returns the first truthy value returned by the callback, if any. + */ +export declare function forEachChildESTree(node: TSESTree.Node, callback: (child: TSESTree.Node) => false | Result | null | undefined): Result | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.js new file mode 100644 index 00000000..c4b2ffae --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.js @@ -0,0 +1,144 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getNameLocationInGlobalDirectiveComment = getNameLocationInGlobalDirectiveComment; +exports.forEachReturnStatement = forEachReturnStatement; +exports.forEachChildESTree = forEachChildESTree; +const visitor_keys_1 = require("@typescript-eslint/visitor-keys"); +const ts = __importStar(require("typescript")); +const escapeRegExp_1 = require("./escapeRegExp"); +// deeply re-export, for convenience +__exportStar(require("@typescript-eslint/utils/ast-utils"), exports); +// The following is copied from `eslint`'s source code since it doesn't exist in eslint@5. +// https://github.com/eslint/eslint/blob/145aec1ab9052fbca96a44d04927c595951b1536/lib/rules/utils/ast-utils.js#L1751-L1779 +// Could be export { getNameLocationInGlobalDirectiveComment } from 'eslint/lib/rules/utils/ast-utils' +/** + * Get the `loc` object of a given name in a `/*globals` comment directive. + * @param sourceCode The source code to convert index to loc. + * @param comment The `/*globals` comment directive which include the name. + * @param name The name to find. + * @returns The `loc` object. + */ +function getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) { + const namePattern = new RegExp(`[\\s,]${(0, escapeRegExp_1.escapeRegExp)(name)}(?:$|[\\s,:])`, 'gu'); + // To ignore the first text "global". + namePattern.lastIndex = comment.value.indexOf('global') + 6; + // Search a given variable name. + const match = namePattern.exec(comment.value); + // Convert the index to loc. + const start = sourceCode.getLocFromIndex(comment.range[0] + '/*'.length + (match ? match.index + 1 : 0)); + const end = { + column: start.column + (match ? name.length : 1), + line: start.line, + }; + return { end, start }; +} +// Copied from typescript https://github.com/microsoft/TypeScript/blob/42b0e3c4630c129ca39ce0df9fff5f0d1b4dd348/src/compiler/utilities.ts#L1335 +// Warning: This has the same semantics as the forEach family of functions, +// in that traversal terminates in the event that 'visitor' supplies a truthy value. +function forEachReturnStatement(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case ts.SyntaxKind.ReturnStatement: + return visitor(node); + case ts.SyntaxKind.CaseBlock: + case ts.SyntaxKind.Block: + case ts.SyntaxKind.IfStatement: + case ts.SyntaxKind.DoStatement: + case ts.SyntaxKind.WhileStatement: + case ts.SyntaxKind.ForStatement: + case ts.SyntaxKind.ForInStatement: + case ts.SyntaxKind.ForOfStatement: + case ts.SyntaxKind.WithStatement: + case ts.SyntaxKind.SwitchStatement: + case ts.SyntaxKind.CaseClause: + case ts.SyntaxKind.DefaultClause: + case ts.SyntaxKind.LabeledStatement: + case ts.SyntaxKind.TryStatement: + case ts.SyntaxKind.CatchClause: + return ts.forEachChild(node, traverse); + } + return undefined; + } +} +function isESTreeNodeLike(node) { + return (typeof node === 'object' && + node != null && + 'type' in node && + // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access + typeof node.type === 'string'); +} +/** + * Rough equivalent to ts.forEachChild for ESTree nodes. + * It returns the first truthy value returned by the callback, if any. + */ +function forEachChildESTree(node, callback) { + function visit(currentNode) { + const result = callback(currentNode); + if (result) { + return result; + } + const currentKeys = visitor_keys_1.visitorKeys[currentNode.type]; + if (!currentKeys) { + return undefined; + } + for (const key of currentKeys) { + const currentProperty = currentNode[key]; + if (Array.isArray(currentProperty)) { + for (const child of currentProperty) { + if (isESTreeNodeLike(child)) { + const result = visit(child); + if (result) { + return result; + } + } + } + } + else if (isESTreeNodeLike(currentProperty)) { + const result = visit(currentProperty); + if (result) { + return result; + } + } + } + return undefined; + } + return visit(node); +} +//# sourceMappingURL=astUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.d.ts new file mode 100644 index 00000000..b58b058f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.d.ts @@ -0,0 +1,15 @@ +import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils'; +import type { InterfaceType, Type } from 'typescript'; +export declare function hasBaseTypes(type: Type): type is InterfaceType; +export declare function isNumberLike(type: Type): boolean; +export declare function isStringLike(type: Type): boolean; +/** + * Recursively checks if a type or any of its base types matches the provided + * matcher function. + * @param services Parser services with type information + * @param matcher Function to test if a type matches the desired criteria + * @param type The type to check + * @param seen Set of already visited types to prevent infinite recursion + * @returns `true` if the type or any of its base types match the matcher + */ +export declare function matchesTypeOrBaseType(services: ParserServicesWithTypeInformation, matcher: (type: Type) => boolean, type: Type, seen?: Set): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.js new file mode 100644 index 00000000..912556ec --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.js @@ -0,0 +1,92 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.hasBaseTypes = hasBaseTypes; +exports.isNumberLike = isNumberLike; +exports.isStringLike = isStringLike; +exports.matchesTypeOrBaseType = matchesTypeOrBaseType; +const ts_api_utils_1 = require("ts-api-utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +function getBaseTypesForType(checker, type) { + if (!tsutils.isObjectType(type)) { + return []; + } + const interfaceTarget = tsutils.isTypeReference(type) ? type.target : type; + const interfaceType = tsutils.isObjectFlagSet(interfaceTarget, ts.ObjectFlags.Interface | ts.ObjectFlags.Class) && interfaceTarget; + if (!interfaceType) { + return []; + } + return checker.getBaseTypes(interfaceType); +} +function hasBaseTypes(type) { + return ((0, ts_api_utils_1.isObjectType)(type) && + (0, ts_api_utils_1.isObjectFlagSet)(type, ts.ObjectFlags.Interface | ts.ObjectFlags.Class)); +} +function isNumberLike(type) { + return tsutils + .unionConstituents(type) + .every(unionPart => tsutils + .intersectionConstituents(unionPart) + .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.NumberLike))); +} +function isStringLike(type) { + return tsutils + .unionConstituents(type) + .every(unionPart => tsutils + .intersectionConstituents(unionPart) + .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.StringLike))); +} +/** + * Recursively checks if a type or any of its base types matches the provided + * matcher function. + * @param services Parser services with type information + * @param matcher Function to test if a type matches the desired criteria + * @param type The type to check + * @param seen Set of already visited types to prevent infinite recursion + * @returns `true` if the type or any of its base types match the matcher + */ +function matchesTypeOrBaseType(services, matcher, type, seen = new Set()) { + if (seen.has(type)) { + return false; + } + seen.add(type); + if (matcher(type)) { + return true; + } + const checker = services.program.getTypeChecker(); + return getBaseTypesForType(checker, type).some(base => matchesTypeOrBaseType(services, matcher, base, seen)); +} +//# sourceMappingURL=baseTypeUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.d.ts new file mode 100644 index 00000000..e0f7115b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.d.ts @@ -0,0 +1,52 @@ +import type { ScopeManager } from '@typescript-eslint/scope-manager'; +import type { TSESTree } from '@typescript-eslint/utils'; +import type { ClassNode, Key, MemberNode } from './types'; +export declare class Member { + /** + * The node that declares this member + */ + readonly node: MemberNode; + /** + * The resolved, unique key for this member. + */ + readonly key: Key; + /** + * The member name, as given in the source code. + */ + readonly name: string; + /** + * The node that represents the member name in the source code. + * Used for reporting errors. + */ + readonly nameNode: TSESTree.Node; + /** + * The number of writes to this member. + */ + writeCount: number; + /** + * The number of reads from this member. + */ + readCount: number; + private constructor(); + static create(node: MemberNode): Member | null; + isAccessor(): boolean; + isHashPrivate(): boolean; + isPrivate(): boolean; + isStatic(): boolean; + isUsed(): boolean; +} +export interface ClassScopeResult { + /** + * The classes name as given in the source code. + * If this is `null` then the class is an anonymous class. + */ + readonly className: string | null; + /** + * The class's members, keyed by their name + */ + readonly members: { + readonly instance: Map; + readonly static: Map; + }; +} +export declare function analyzeClassMemberUsage(program: TSESTree.Program, scopeManager: ScopeManager): ReadonlyMap; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.js new file mode 100644 index 00000000..dfd8ab81 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.js @@ -0,0 +1,567 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Member = void 0; +exports.analyzeClassMemberUsage = analyzeClassMemberUsage; +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const __1 = require(".."); +const extractComputedName_1 = require("./extractComputedName"); +const types_1 = require("./types"); +class Member { + /** + * The node that declares this member + */ + node; + /** + * The resolved, unique key for this member. + */ + key; + /** + * The member name, as given in the source code. + */ + name; + /** + * The node that represents the member name in the source code. + * Used for reporting errors. + */ + nameNode; + /** + * The number of writes to this member. + */ + writeCount = 0; + /** + * The number of reads from this member. + */ + readCount = 0; + constructor(node, key, name, nameNode) { + this.node = node; + this.key = key; + this.name = name; + this.nameNode = nameNode; + } + static create(node) { + const name = (0, extractComputedName_1.extractNameForMember)(node); + if (name == null) { + return null; + } + return new Member(node, name.key, name.codeName, name.nameNode); + } + isAccessor() { + if (this.node.type === utils_1.AST_NODE_TYPES.MethodDefinition || + this.node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) { + return this.node.kind === 'set' || this.node.kind === 'get'; + } + return (this.node.type === utils_1.AST_NODE_TYPES.AccessorProperty || + this.node.type === utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty); + } + isHashPrivate() { + return ('key' in this.node && + this.node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier); + } + isPrivate() { + return this.node.accessibility === 'private'; + } + isStatic() { + return this.node.static; + } + isUsed() { + return (this.readCount > 0 || + // any usage of an accessor is considered a usage as accessor can have side effects + (this.writeCount > 0 && this.isAccessor())); + } +} +exports.Member = Member; +function isWriteOnlyUsage(node, parent) { + if (parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression && + parent.type !== utils_1.AST_NODE_TYPES.ForInStatement && + parent.type !== utils_1.AST_NODE_TYPES.ForOfStatement && + parent.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) { + return false; + } + // If it's on the right then it's a read not a write + if (parent.left !== node) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + // For any other operator (such as '+=') we still consider it a read operation + parent.operator !== '=') { + // if the read operation is "discarded" in an empty statement, then it is write only. + return parent.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement; + } + return true; +} +function countReference(identifierParent, member) { + const identifierGrandparent = (0, __1.nullThrows)(identifierParent.parent, __1.NullThrowsReasons.MissingParent); + if (isWriteOnlyUsage(identifierParent, identifierGrandparent)) { + member.writeCount += 1; + return; + } + const identifierGreatGrandparent = identifierGrandparent.parent; + // A statement which only increments (`this.#x++;`) + if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.UpdateExpression && + identifierGreatGrandparent?.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + member.writeCount += 1; + return; + } + /* + * ({ x: this.#usedInDestructuring } = bar); + * + * But should treat the following as a read: + * ({ [this.#x]: a } = foo); + */ + if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.Property && + identifierGreatGrandparent?.type === utils_1.AST_NODE_TYPES.ObjectPattern && + identifierGrandparent.value === identifierParent) { + member.writeCount += 1; + return; + } + // [...this.#unusedInRestPattern] = bar; + if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.RestElement) { + member.writeCount += 1; + return; + } + // [this.#unusedInAssignmentPattern] = bar; + if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + member.writeCount += 1; + return; + } + member.readCount += 1; +} +class ThisScope extends scope_manager_1.Visitor { + /** + * True if the context is considered a static context and so `this` refers to + * the class and not an instance (eg a static method or a static block). + */ + isStaticThisContext; + /** + * The classes directly declared within this class -- for example a class declared within a method. + * This does not include grandchild classes. + */ + childScopes = []; + /** + * The scope manager instance used to resolve variables to improve discovery of usages. + */ + scopeManager; + /** + * The parent class scope if one exists. + */ + upper; + /** + * The context of the `this` reference in the current scope. + */ + thisContext; + constructor(scopeManager, upper, thisContext, isStaticThisContext) { + super({}); + this.scopeManager = scopeManager; + this.upper = upper; + this.isStaticThisContext = isStaticThisContext; + if (thisContext === 'self') { + if (!(this instanceof ClassScope)) { + throw new Error('Cannot use `self` unless it is in a ClassScope'); + } + this.thisContext = this; + } + else if (thisContext === 'none') { + this.thisContext = null; + } + else { + this.thisContext = thisContext; + } + } + findNearestScope(node) { + let currentScope; + let currentNode = node; + do { + currentScope = this.scopeManager.acquire(currentNode); + if (currentNode.parent == null) { + break; + } + currentNode = currentNode.parent; + } while (currentScope == null); + return currentScope; + } + findVariableInScope(node, name) { + let currentScope = this.findNearestScope(node); + let variable = null; + while (currentScope != null) { + variable = currentScope.set.get(name) ?? null; + if (variable != null) { + break; + } + currentScope = currentScope.upper; + } + return variable; + } + getObjectClass(node) { + switch (node.object.type) { + case utils_1.AST_NODE_TYPES.ThisExpression: { + if (this.thisContext == null) { + return null; + } + return { + thisContext: this.thisContext, + type: this.isStaticThisContext ? 'static' : 'instance', + }; + } + case utils_1.AST_NODE_TYPES.Identifier: { + const thisContext = this.findClassScopeWithName(node.object.name); + if (thisContext != null) { + return { thisContext, type: 'static' }; + } + // the following code does some very rudimentary scope analysis to handle some trivial cases + const variable = this.findVariableInScope(node, node.object.name); + if (variable == null || variable.defs.length === 0) { + return null; + } + const firstDef = variable.defs[0]; + switch (firstDef.node.type) { + // detect simple reassignment of `this` + // ``` + // class Foo { + // private prop: number; + // method(thing: Foo) { + // const self = this; + // return self.prop; + // } + // } + // ``` + case utils_1.AST_NODE_TYPES.VariableDeclarator: { + const value = firstDef.node.init; + if (value?.type !== utils_1.AST_NODE_TYPES.ThisExpression) { + return null; + } + if (variable.references.some(ref => ref.isWrite() && ref.init !== true)) { + // variable is assigned to multiple times so we can't be sure that it's still the same class + return null; + } + // we have a case like `const self = this` or `let self = this` that is not reassigned + // so we can safely assume that it's still the same class! + return { + thisContext: this.thisContext, + type: this.isStaticThisContext ? 'static' : 'instance', + }; + } + // Look for variables typed as the current class: + // ``` + // class Foo { + // private prop: number; + // method(thing: Foo) { + // // this references the private instance member but not via `this` so we can't see it + // thing.prop = 1; + // } + // } + // ``` + default: { + const typeAnnotation = (() => { + if ('typeAnnotation' in firstDef.name && + firstDef.name.typeAnnotation != null) { + return firstDef.name.typeAnnotation.typeAnnotation; + } + return null; + })(); + if (typeAnnotation == null) { + return null; + } + // Cases like `method(thing: Foo) { ... }` + if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference && + typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier) { + const typeName = typeAnnotation.typeName.name; + const typeScope = this.findClassScopeWithName(typeName); + if (typeScope != null) { + return { thisContext: typeScope, type: 'instance' }; + } + } + // Cases like `method(thing: typeof Foo) { ... }` + if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeQuery && + typeAnnotation.exprName.type === utils_1.AST_NODE_TYPES.Identifier) { + const exprName = typeAnnotation.exprName.name; + const exprScope = this.findClassScopeWithName(exprName); + if (exprScope != null) { + return { thisContext: exprScope, type: 'static' }; + } + } + } + } + return null; + } + case utils_1.AST_NODE_TYPES.MemberExpression: + // TODO - we could probably recurse here to do some more complex analysis and support like `foo.bar.baz` nested references + return null; + default: + return null; + } + } + visitClass(node) { + const classScope = new ClassScope(node, this, this.scopeManager); + this.childScopes.push(classScope); + classScope.visitChildren(node); + } + visitIntermediate(node) { + const intermediateScope = new IntermediateScope(this.scopeManager, this, node); + this.childScopes.push(intermediateScope); + intermediateScope.visitChildren(node); + } + /** + * Gets the nearest class scope with the given name. + */ + findClassScopeWithName(name) { + let currentScope = this; + while (currentScope != null) { + if (currentScope instanceof ClassScope && + currentScope.className === name) { + return currentScope; + } + currentScope = currentScope.upper; + } + return null; + } + ///////////////////// + // Visit selectors // + ///////////////////// + AssignmentExpression(node) { + this.visitChildren(node); + if (node.right.type === utils_1.AST_NODE_TYPES.ThisExpression && + node.left.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + this.handleThisDestructuring(node.left); + } + } + AssignmentPattern(node) { + this.visitChildren(node); + if (node.right.type === utils_1.AST_NODE_TYPES.ThisExpression && + node.left.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + this.handleThisDestructuring(node.left); + } + } + ClassDeclaration(node) { + this.visitClass(node); + } + ClassExpression(node) { + this.visitClass(node); + } + FunctionDeclaration(node) { + this.visitIntermediate(node); + } + FunctionExpression(node) { + this.visitIntermediate(node); + } + MemberExpression(node) { + this.visitChildren(node); + if (node.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + // will be handled by the PrivateIdentifier visitor + return; + } + const propertyName = (0, extractComputedName_1.extractNameForMemberExpression)(node); + if (propertyName == null) { + return; + } + const objectClassName = this.getObjectClass(node); + if (objectClassName == null) { + return; + } + if (objectClassName.thisContext == null) { + return; + } + const members = objectClassName.type === 'instance' + ? objectClassName.thisContext.members.instance + : objectClassName.thisContext.members.static; + const member = members.get(propertyName.key); + if (member == null) { + return; + } + countReference(node, member); + } + PrivateIdentifier(node) { + this.visitChildren(node); + if ((node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition || + node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) && + node.parent.key === node) { + // ignore the member definition + return; + } + // We can actually be pretty loose with our code here thanks to how private + // members are designed. + // + // 1) classes CANNOT have a static and instance private member with the + // same name, so we don't need to match up static access. + // 2) nested classes CANNOT access a private member of their parent class if + // the member has the same name as a private member of the nested class. + // + // together this means that we can just look for the member upwards until we + // find a match and we know that will be the correct match! + let currentScope = this; + const key = (0, types_1.privateKey)(node); + while (currentScope != null) { + if (currentScope.thisContext != null) { + const member = currentScope.thisContext.members.instance.get(key) ?? + currentScope.thisContext.members.static.get(key); + if (member != null) { + countReference(node.parent, member); + return; + } + } + currentScope = currentScope.upper; + } + } + StaticBlock(node) { + this.visitIntermediate(node); + } + VariableDeclarator(node) { + this.visitChildren(node); + if (node.init?.type === utils_1.AST_NODE_TYPES.ThisExpression && + node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) { + this.handleThisDestructuring(node.id); + } + } + /** + * Handles destructuring from `this` in ObjectPattern. + * Example: const { property } = this; + */ + handleThisDestructuring(pattern) { + if (this.thisContext == null) { + return; + } + for (const prop of pattern.properties) { + if (prop.type !== utils_1.AST_NODE_TYPES.Property) { + continue; + } + if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier || prop.computed) { + continue; + } + const memberKey = (0, types_1.publicKey)(prop.key.name); + const members = this.isStaticThisContext + ? this.thisContext.members.static + : this.thisContext.members.instance; + const member = members.get(memberKey); + if (member == null) { + continue; + } + countReference(prop.key, member); + } + } +} +/** + * Any other scope that is not a class scope + * + * When we visit a function declaration/expression the `this` reference is + * rebound so it no longer refers to the class. + * + * This also supports a function's `this` parameter. + */ +class IntermediateScope extends ThisScope { + constructor(scopeManager, upper, node) { + if (node.type === utils_1.AST_NODE_TYPES.Program) { + super(scopeManager, upper, 'none', false); + return; + } + if (node.type === utils_1.AST_NODE_TYPES.StaticBlock) { + if (upper == null || !(upper instanceof ClassScope)) { + throw new Error('Cannot have a static block without an upper ClassScope'); + } + super(scopeManager, upper, upper, true); + return; + } + // method definition + if ((node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition || + node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) && + node.parent.value === node) { + if (upper == null || !(upper instanceof ClassScope)) { + throw new Error('Cannot have a class method/property without an upper ClassScope'); + } + super(scopeManager, upper, upper, node.parent.static); + return; + } + // function with a `this` parameter + if (upper != null && + node.params.length > 0 && + node.params[0].type === utils_1.AST_NODE_TYPES.Identifier && + node.params[0].name === 'this') { + const thisType = node.params[0].typeAnnotation?.typeAnnotation; + if (thisType?.type === utils_1.AST_NODE_TYPES.TSTypeReference && + thisType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) { + const thisContext = upper.findClassScopeWithName(thisType.typeName.name); + if (thisContext != null) { + super(scopeManager, upper, thisContext, false); + return; + } + } + } + super(scopeManager, upper, 'none', false); + } +} +class ClassScope extends ThisScope { + className; + /** + * The class's members, keyed by their name + */ + members = { + instance: new Map(), + static: new Map(), + }; + /** + * The node that declares this class. + */ + theClass; + constructor(theClass, upper, scopeManager) { + super(scopeManager, upper, 'self', false); + this.theClass = theClass; + this.className = theClass.id?.name ?? null; + for (const memberNode of theClass.body.body) { + switch (memberNode.type) { + case utils_1.AST_NODE_TYPES.MethodDefinition: + if (memberNode.kind === 'constructor') { + for (const parameter of memberNode.value.params) { + if (parameter.type !== utils_1.AST_NODE_TYPES.TSParameterProperty) { + continue; + } + const member = Member.create(parameter); + if (member == null) { + continue; + } + this.members.instance.set(member.key, member); + } + // break instead of falling through because the constructor is not a "member" we track + break; + } + // intentional fallthrough + case utils_1.AST_NODE_TYPES.AccessorProperty: + case utils_1.AST_NODE_TYPES.PropertyDefinition: + case utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty: + case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition: + case utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition: { + const member = Member.create(memberNode); + if (member == null) { + continue; + } + if (member.isStatic()) { + this.members.static.set(member.key, member); + } + else { + this.members.instance.set(member.key, member); + } + break; + } + case utils_1.AST_NODE_TYPES.StaticBlock: + // static blocks declare no members + continue; + case utils_1.AST_NODE_TYPES.TSIndexSignature: + // index signatures are type signatures only and are fully computed + continue; + } + } + } +} +function analyzeClassMemberUsage(program, scopeManager) { + const rootScope = new IntermediateScope(scopeManager, null, program); + rootScope.visit(program); + return traverseScopes(rootScope); +} +function traverseScopes(currentScope, analysisResults = new Map()) { + if (currentScope instanceof ClassScope) { + analysisResults.set(currentScope.theClass, currentScope); + } + for (const childScope of currentScope.childScopes) { + traverseScopes(childScope, analysisResults); + } + return analysisResults; +} +//# sourceMappingURL=classScopeAnalyzer.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.d.ts new file mode 100644 index 00000000..94664cb0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.d.ts @@ -0,0 +1,17 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { Key, MemberNode } from './types'; +export interface ExtractedName { + key: Key; + codeName: string; + nameNode: TSESTree.Node; +} +/** + * Extracts the string name for a member. + * @returns `null` if the name cannot be extracted due to it being computed. + */ +export declare function extractNameForMember(node: MemberNode): ExtractedName | null; +/** + * Extracts the string property name for a member. + * @returns `null` if the name cannot be extracted due to it being a computed. + */ +export declare function extractNameForMemberExpression(node: TSESTree.MemberExpression): ExtractedName | null; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.js new file mode 100644 index 00000000..71278a6c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.js @@ -0,0 +1,71 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.extractNameForMember = extractNameForMember; +exports.extractNameForMemberExpression = extractNameForMemberExpression; +const utils_1 = require("@typescript-eslint/utils"); +const types_1 = require("./types"); +function extractComputedName(computedName) { + if (computedName.type === utils_1.AST_NODE_TYPES.Literal) { + const name = computedName.value?.toString() ?? 'null'; + return { + codeName: name, + key: (0, types_1.publicKey)(name), + nameNode: computedName, + }; + } + if (computedName.type === utils_1.AST_NODE_TYPES.TemplateLiteral && + computedName.expressions.length === 0) { + const name = computedName.quasis[0].value.raw; + return { + codeName: name, + key: (0, types_1.publicKey)(name), + nameNode: computedName, + }; + } + return null; +} +function extractNonComputedName(nonComputedName) { + const name = nonComputedName.name; + if (nonComputedName.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return { + codeName: `#${name}`, + key: (0, types_1.privateKey)(nonComputedName), + nameNode: nonComputedName, + }; + } + return { + codeName: name, + key: (0, types_1.publicKey)(name), + nameNode: nonComputedName, + }; +} +/** + * Extracts the string name for a member. + * @returns `null` if the name cannot be extracted due to it being computed. + */ +function extractNameForMember(node) { + if (node.type === utils_1.AST_NODE_TYPES.TSParameterProperty) { + const identifier = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier + ? node.parameter + : node.parameter.left; + return extractNonComputedName(identifier); + } + if (node.computed) { + return extractComputedName(node.key); + } + if (node.key.type === utils_1.AST_NODE_TYPES.Literal) { + return extractComputedName(node.key); + } + return extractNonComputedName(node.key); +} +/** + * Extracts the string property name for a member. + * @returns `null` if the name cannot be extracted due to it being a computed. + */ +function extractNameForMemberExpression(node) { + if (node.computed) { + return extractComputedName(node.property); + } + return extractNonComputedName(node.property); +} +//# sourceMappingURL=extractComputedName.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.d.ts new file mode 100644 index 00000000..e9abf782 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.d.ts @@ -0,0 +1,12 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export type ClassNode = TSESTree.ClassDeclaration | TSESTree.ClassExpression; +export type MemberNode = TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.TSParameterProperty; +export type PrivateKey = string & { + __brand: 'private-key'; +}; +export type PublicKey = string & { + __brand: 'public-key'; +}; +export type Key = PrivateKey | PublicKey; +export declare function publicKey(name: string): PublicKey; +export declare function privateKey(node: TSESTree.PrivateIdentifier): PrivateKey; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.js new file mode 100644 index 00000000..2698c9c3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.js @@ -0,0 +1,11 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.publicKey = publicKey; +exports.privateKey = privateKey; +function publicKey(name) { + return name; +} +function privateKey(node) { + return `#private@@${node.name}`; +} +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.d.ts new file mode 100644 index 00000000..a8a2942c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.d.ts @@ -0,0 +1,15 @@ +import type { ScopeVariable } from '@typescript-eslint/scope-manager'; +import { TSESLint } from '@typescript-eslint/utils'; +interface VariableAnalysis { + readonly unusedVariables: ReadonlySet; + readonly usedVariables: ReadonlySet; +} +/** + * Collects the set of unused variables for a given context. + * + * Due to complexity, this does not take into consideration: + * - variables within declaration files + * - variables within ambient module declarations + */ +export declare function collectVariables(context: Readonly>): VariableAnalysis; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.js new file mode 100644 index 00000000..23570a77 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.js @@ -0,0 +1,602 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.collectVariables = collectVariables; +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +const isTypeImport_1 = require("./isTypeImport"); +const referenceContainsTypePredicate_1 = require("./referenceContainsTypePredicate"); +const referenceContainsTypeQuery_1 = require("./referenceContainsTypeQuery"); +/** + * This class leverages an AST visitor to mark variables as used via the + * `eslintUsed` property. + */ +class UnusedVarsVisitor extends scope_manager_1.Visitor { + /** + * We keep a weak cache so that multiple rules can share the calculation + */ + static RESULTS_CACHE = new WeakMap(); + ClassDeclaration = this.visitClass; + ClassExpression = this.visitClass; + ForInStatement = this.visitForInForOf; + ForOfStatement = this.visitForInForOf; + //#region HELPERS + FunctionDeclaration = this.visitFunction; + FunctionExpression = this.visitFunction; + MethodDefinition = this.visitSetter; + Property = this.visitSetter; + TSCallSignatureDeclaration = this.visitFunctionTypeSignature; + TSConstructorType = this.visitFunctionTypeSignature; + TSConstructSignatureDeclaration = this.visitFunctionTypeSignature; + TSDeclareFunction = this.visitFunctionTypeSignature; + TSEmptyBodyFunctionExpression = this.visitFunctionTypeSignature; + //#endregion HELPERS + //#region VISITORS + // NOTE - This is a simple visitor - meaning it does not support selectors + TSFunctionType = this.visitFunctionTypeSignature; + TSMethodSignature = this.visitFunctionTypeSignature; + #scopeManager; + constructor(scopeManager) { + super({ + visitChildrenEvenIfSelectorExists: true, + }); + this.#scopeManager = scopeManager; + } + static collectUnusedVariables(program, scopeManager) { + const cached = this.RESULTS_CACHE.get(program); + if (cached) { + return cached; + } + const visitor = new this(scopeManager); + visitor.visit(program); + const unusedVars = visitor.collectUnusedVariables(visitor.getScope(program)); + this.RESULTS_CACHE.set(program, unusedVars); + return unusedVars; + } + Identifier(node) { + const scope = this.getScope(node); + if (scope.type === utils_1.TSESLint.Scope.ScopeType.function && + node.name === 'this' && + // this parameters should always be considered used as they're pseudo-parameters + 'params' in scope.block && + scope.block.params.includes(node)) { + this.markVariableAsUsed(node); + } + } + TSEnumDeclaration(node) { + // enum members create variables because they can be referenced within the enum, + // but they obviously aren't unused variables for the purposes of this rule. + const scope = this.getScope(node); + for (const variable of scope.variables) { + this.markVariableAsUsed(variable); + } + } + TSMappedType(node) { + // mapped types create a variable for their type name, but it's not necessary to reference it, + // so we shouldn't consider it as unused for the purpose of this rule. + this.markVariableAsUsed(node.key); + } + TSModuleDeclaration(node) { + // -- global augmentation can be in any file, and they do not need exports + if (node.kind === 'global') { + this.markVariableAsUsed('global', node.parent); + } + } + TSParameterProperty(node) { + let identifier; + switch (node.parameter.type) { + case utils_1.AST_NODE_TYPES.AssignmentPattern: + identifier = node.parameter.left; + break; + case utils_1.AST_NODE_TYPES.Identifier: + identifier = node.parameter; + break; + } + this.markVariableAsUsed(identifier); + } + collectUnusedVariables(scope, variables = { + unusedVariables: new Set(), + usedVariables: new Set(), + }) { + if ( + // skip function expression names + // this scope is created just to house the variable that allows a function + // expression to self-reference if it has a name defined + !scope.functionExpressionScope) { + for (const variable of scope.variables) { + // cases that we don't want to treat as used or unused + if ( + // implicit lib variables (from @typescript-eslint/scope-manager) + // these aren't variables that should be checked ever + variable instanceof scope_manager_1.ImplicitLibVariable) { + continue; + } + if ( + // variables marked with markVariableAsUsed() + variable.eslintUsed || + // basic exported variables + isExported(variable) || + // variables implicitly exported via a merged declaration + isMergeableExported(variable) || + // used variables + isUsedVariable(variable)) { + variables.usedVariables.add(variable); + } + else { + variables.unusedVariables.add(variable); + } + } + } + for (const childScope of scope.childScopes) { + this.collectUnusedVariables(childScope, variables); + } + return variables; + } + getScope(currentNode) { + // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope. + const inner = currentNode.type !== utils_1.AST_NODE_TYPES.Program; + let node = currentNode; + while (node) { + const scope = this.#scopeManager.acquire(node, inner); + if (scope) { + if (scope.type === scope_manager_1.ScopeType.functionExpressionName) { + return scope.childScopes[0]; + } + return scope; + } + node = node.parent; + } + return this.#scopeManager.scopes[0]; + } + markVariableAsUsed(variableOrIdentifierOrName, parent) { + if (typeof variableOrIdentifierOrName !== 'string' && + !('type' in variableOrIdentifierOrName)) { + variableOrIdentifierOrName.eslintUsed = true; + return; + } + let name; + let node; + if (typeof variableOrIdentifierOrName === 'string') { + name = variableOrIdentifierOrName; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + node = parent; + } + else { + name = variableOrIdentifierOrName.name; + node = variableOrIdentifierOrName; + } + let currentScope = this.getScope(node); + while (currentScope) { + const variable = currentScope.variables.find(scopeVar => scopeVar.name === name); + if (variable) { + variable.eslintUsed = true; + return; + } + currentScope = currentScope.upper; + } + } + visitClass(node) { + // skip a variable of class itself name in the class scope + const scope = this.getScope(node); + for (const variable of scope.variables) { + if (variable.identifiers[0] === scope.block.id) { + this.markVariableAsUsed(variable); + return; + } + } + } + visitForInForOf(node) { + /** + * (Brad Zacher): I hate that this has to exist. + * But it is required for compat with the base ESLint rule. + * + * In 2015, ESLint decided to add an exception for these two specific cases + * ``` + * for (var key in object) return; + * + * var key; + * for (key in object) return; + * ``` + * + * I disagree with it, but what are you going to do... + * + * https://github.com/eslint/eslint/issues/2342 + */ + let idOrVariable; + if (node.left.type === utils_1.AST_NODE_TYPES.VariableDeclaration) { + const variable = this.#scopeManager.getDeclaredVariables(node.left).at(0); + if (!variable) { + return; + } + idOrVariable = variable; + } + if (node.left.type === utils_1.AST_NODE_TYPES.Identifier) { + idOrVariable = node.left; + } + if (idOrVariable == null) { + return; + } + let body = node.body; + if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) { + if (node.body.body.length !== 1) { + return; + } + body = node.body.body[0]; + } + if (body.type !== utils_1.AST_NODE_TYPES.ReturnStatement) { + return; + } + this.markVariableAsUsed(idOrVariable); + } + visitFunction(node) { + const scope = this.getScope(node); + // skip implicit "arguments" variable + const variable = scope.set.get('arguments'); + if (variable?.defs.length === 0) { + this.markVariableAsUsed(variable); + } + } + visitFunctionTypeSignature(node) { + // function type signature params create variables because they can be referenced within the signature, + // but they obviously aren't unused variables for the purposes of this rule. + for (const param of node.params) { + this.visitPattern(param, name => { + this.markVariableAsUsed(name); + }); + } + } + visitSetter(node) { + if (node.kind === 'set') { + // ignore setter parameters because they're syntactically required to exist + for (const param of node.value.params) { + this.visitPattern(param, id => { + this.markVariableAsUsed(id); + }); + } + } + } +} +//#region private helpers +/** + * Checks the position of given nodes. + * @param inner A node which is expected as inside. + * @param outer A node which is expected as outside. + * @returns `true` if the `inner` node exists in the `outer` node. + */ +function isInside(inner, outer) { + return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1]; +} +/** + * Determine if an identifier is referencing an enclosing name. + * This only applies to declarations that create their own scope (modules, functions, classes) + * @param ref The reference to check. + * @param nodes The candidate function nodes. + * @returns True if it's a self-reference, false if not. + */ +function isSelfReference(ref, nodes) { + let scope = ref.from; + while (scope) { + if (nodes.has(scope.block)) { + return true; + } + scope = scope.upper; + } + return false; +} +const MERGEABLE_TYPES = new Set([ + utils_1.AST_NODE_TYPES.ClassDeclaration, + utils_1.AST_NODE_TYPES.FunctionDeclaration, + utils_1.AST_NODE_TYPES.TSInterfaceDeclaration, + utils_1.AST_NODE_TYPES.TSModuleDeclaration, + utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration, +]); +/** + * Determine if the variable is directly exported + * @param variable the variable to check + */ +function isMergeableExported(variable) { + // If all of the merged things are of the same type, TS will error if not all of them are exported - so we only need to find one + for (const def of variable.defs) { + // parameters can never be exported. + // their `node` prop points to the function decl, which can be exported + // so we need to special case them + if (def.type === utils_1.TSESLint.Scope.DefinitionType.Parameter) { + continue; + } + if ((MERGEABLE_TYPES.has(def.node.type) && + def.node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) || + def.node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) { + return true; + } + } + return false; +} +/** + * Determines if a given variable is being exported from a module. + * @param variable eslint-scope variable object. + * @returns True if the variable is exported, false if not. + */ +function isExported(variable) { + return variable.defs.some(definition => { + let node = definition.node; + if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) { + node = node.parent; + } + else if (definition.type === utils_1.TSESLint.Scope.DefinitionType.Parameter) { + return false; + } + return node.parent.type.startsWith('Export'); + }); +} +const LOGICAL_ASSIGNMENT_OPERATORS = new Set(['??=', '&&=', '||=']); +/** + * Determines if the variable is used. + * @param variable The variable to check. + * @returns True if the variable is used + */ +function isUsedVariable(variable) { + /** + * Gets a list of function definitions for a specified variable. + * @param variable eslint-scope variable object. + * @returns Function nodes. + */ + function getFunctionDefinitions(variable) { + const functionDefinitions = new Set(); + variable.defs.forEach(def => { + // FunctionDeclarations + if (def.type === utils_1.TSESLint.Scope.DefinitionType.FunctionName) { + functionDefinitions.add(def.node); + } + // FunctionExpressions + if (def.type === utils_1.TSESLint.Scope.DefinitionType.Variable && + (def.node.init?.type === utils_1.AST_NODE_TYPES.FunctionExpression || + def.node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) { + functionDefinitions.add(def.node.init); + } + }); + return functionDefinitions; + } + function getTypeDeclarations(variable) { + const nodes = new Set(); + variable.defs.forEach(def => { + if (def.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration || + def.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) { + nodes.add(def.node); + } + }); + return nodes; + } + function getModuleDeclarations(variable) { + const nodes = new Set(); + variable.defs.forEach(def => { + if (def.node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration) { + nodes.add(def.node); + } + }); + return nodes; + } + function getEnumDeclarations(variable) { + const nodes = new Set(); + variable.defs.forEach(def => { + if (def.node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration) { + nodes.add(def.node); + } + }); + return nodes; + } + /** + * Checks if the ref is contained within one of the given nodes + */ + function isInsideOneOf(ref, nodes) { + for (const node of nodes) { + if (isInside(ref.identifier, node)) { + return true; + } + } + return false; + } + /** + * Checks whether a given node is unused expression or not. + * @param node The node itself + * @returns The node is an unused expression. + */ + function isUnusedExpression(node) { + const parent = node.parent; + if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + return true; + } + if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression) { + const isLastExpression = parent.expressions[parent.expressions.length - 1] === node; + if (!isLastExpression) { + return true; + } + return isUnusedExpression(parent); + } + return false; + } + /** + * If a given reference is left-hand side of an assignment, this gets + * the right-hand side node of the assignment. + * + * In the following cases, this returns null. + * + * - The reference is not the LHS of an assignment expression. + * - The reference is inside of a loop. + * - The reference is inside of a function scope which is different from + * the declaration. + * @param ref A reference to check. + * @param prevRhsNode The previous RHS node. + * @returns The RHS node or null. + */ + function getRhsNode(ref, prevRhsNode) { + /** + * Checks whether the given node is in a loop or not. + * @param node The node to check. + * @returns `true` if the node is in a loop. + */ + function isInLoop(node) { + let currentNode = node; + while (currentNode) { + if (utils_1.ASTUtils.isFunction(currentNode)) { + break; + } + if (utils_1.ASTUtils.isLoop(currentNode)) { + return true; + } + currentNode = currentNode.parent; + } + return false; + } + const id = ref.identifier; + const parent = id.parent; + const refScope = ref.from.variableScope; + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const varScope = ref.resolved.scope.variableScope; + const canBeUsedLater = refScope !== varScope || isInLoop(id); + /* + * Inherits the previous node if this reference is in the node. + * This is for `a = a + a`-like code. + */ + if (prevRhsNode && isInside(id, prevRhsNode)) { + return prevRhsNode; + } + if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + isUnusedExpression(parent) && + id === parent.left && + !canBeUsedLater) { + return parent.right; + } + return null; + } + /** + * Checks whether a given reference is a read to update itself or not. + * @param ref A reference to check. + * @param rhsNode The RHS node of the previous assignment. + * @returns The reference is a read to update itself. + */ + function isReadForItself(ref, rhsNode) { + /** + * Checks whether a given Identifier node exists inside of a function node which can be used later. + * + * "can be used later" means: + * - the function is assigned to a variable. + * - the function is bound to a property and the object can be used later. + * - the function is bound as an argument of a function call. + * + * If a reference exists in a function which can be used later, the reference is read when the function is called. + * @param id An Identifier node to check. + * @param rhsNode The RHS node of the previous assignment. + * @returns `true` if the `id` node exists inside of a function node which can be used later. + */ + function isInsideOfStorableFunction(id, rhsNode) { + /** + * Finds a function node from ancestors of a node. + * @param node A start node to find. + * @returns A found function node. + */ + function getUpperFunction(node) { + let currentNode = node; + while (currentNode) { + if (utils_1.ASTUtils.isFunction(currentNode)) { + return currentNode; + } + currentNode = currentNode.parent; + } + return null; + } + /** + * Checks whether a given function node is stored to somewhere or not. + * If the function node is stored, the function can be used later. + * @param funcNode A function node to check. + * @param rhsNode The RHS node of the previous assignment. + * @returns `true` if under the following conditions: + * - the funcNode is assigned to a variable. + * - the funcNode is bound as an argument of a function call. + * - the function is bound to a property and the object satisfies above conditions. + */ + function isStorableFunction(funcNode, rhsNode) { + let node = funcNode; + let parent = funcNode.parent; + while (parent && isInside(parent, rhsNode)) { + switch (parent.type) { + case utils_1.AST_NODE_TYPES.SequenceExpression: + if (parent.expressions[parent.expressions.length - 1] !== node) { + return false; + } + break; + case utils_1.AST_NODE_TYPES.CallExpression: + case utils_1.AST_NODE_TYPES.NewExpression: + return parent.callee !== node; + case utils_1.AST_NODE_TYPES.AssignmentExpression: + case utils_1.AST_NODE_TYPES.TaggedTemplateExpression: + case utils_1.AST_NODE_TYPES.YieldExpression: + return true; + default: + if (parent.type.endsWith('Statement') || + parent.type.endsWith('Declaration')) { + /* + * If it encountered statements, this is a complex pattern. + * Since analyzing complex patterns is hard, this returns `true` to avoid false positive. + */ + return true; + } + } + node = parent; + parent = parent.parent; + } + return false; + } + const funcNode = getUpperFunction(id); + return (!!funcNode && + isInside(funcNode, rhsNode) && + isStorableFunction(funcNode, rhsNode)); + } + const id = ref.identifier; + const parent = id.parent; + return (ref.isRead() && // in RHS of an assignment for itself. e.g. `a = a + 1` + // self update. e.g. `a += 1`, `a++` + ((parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + !LOGICAL_ASSIGNMENT_OPERATORS.has(parent.operator) && + isUnusedExpression(parent) && + parent.left === id) || + (parent.type === utils_1.AST_NODE_TYPES.UpdateExpression && + isUnusedExpression(parent)) || + (!!rhsNode && + isInside(id, rhsNode) && + !isInsideOfStorableFunction(id, rhsNode)))); + } + const functionNodes = getFunctionDefinitions(variable); + const isFunctionDefinition = functionNodes.size > 0; + const typeDeclNodes = getTypeDeclarations(variable); + const isTypeDecl = typeDeclNodes.size > 0; + const moduleDeclNodes = getModuleDeclarations(variable); + const isModuleDecl = moduleDeclNodes.size > 0; + const enumDeclNodes = getEnumDeclarations(variable); + const isEnumDecl = enumDeclNodes.size > 0; + const isImportedAsType = variable.defs.every(isTypeImport_1.isTypeImport); + let rhsNode = null; + return variable.references.some(ref => { + const forItself = isReadForItself(ref, rhsNode); + rhsNode = getRhsNode(ref, rhsNode); + return (ref.isRead() && + !forItself && + !(!isImportedAsType && + ((0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier) || + (0, referenceContainsTypePredicate_1.referenceContainsTypePredicate)(ref.identifier))) && + !(isFunctionDefinition && isSelfReference(ref, functionNodes)) && + !(isTypeDecl && isInsideOneOf(ref, typeDeclNodes)) && + !(isModuleDecl && isSelfReference(ref, moduleDeclNodes)) && + !(isEnumDecl && isSelfReference(ref, enumDeclNodes))); + }); +} +//#endregion private helpers +/** + * Collects the set of unused variables for a given context. + * + * Due to complexity, this does not take into consideration: + * - variables within declaration files + * - variables within ambient module declarations + */ +function collectVariables(context) { + return UnusedVarsVisitor.collectUnusedVariables(context.sourceCode.ast, utils_1.ESLintUtils.nullThrows(context.sourceCode.scopeManager, 'Missing required scope manager')); +} +//# sourceMappingURL=collectUnusedVariables.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.d.ts new file mode 100644 index 00000000..13eb290d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.d.ts @@ -0,0 +1,5 @@ +import { ESLintUtils } from '@typescript-eslint/utils'; +import type { ESLintPluginDocs } from '../../rules'; +export declare const createRule: ({ meta, name, ...rule }: Readonly>) => ESLintUtils.RuleModule & { + name: string; +}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.js new file mode 100644 index 00000000..a0ee97b4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.js @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createRule = void 0; +const utils_1 = require("@typescript-eslint/utils"); +exports.createRule = utils_1.ESLintUtils.RuleCreator(name => `https://typescript-eslint.io/rules/${name}`); +//# sourceMappingURL=createRule.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.d.ts new file mode 100644 index 00000000..34a8c254 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.d.ts @@ -0,0 +1 @@ +export declare function escapeRegExp(string?: string): string; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.js new file mode 100644 index 00000000..3639aa16 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.escapeRegExp = escapeRegExp; +/** + * Lodash + * Released under MIT license + */ +const reRegExpChar = /[\\^$.*+?()[\]{}|]/g; +const reHasRegExpChar = RegExp(reRegExpChar.source); +function escapeRegExp(string = '') { + return string && reHasRegExpChar.test(string) + ? string.replaceAll(reRegExpChar, '\\$&') + : string; +} +//# sourceMappingURL=escapeRegExp.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.d.ts new file mode 100644 index 00000000..f830810b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.d.ts @@ -0,0 +1,47 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +export type FunctionExpression = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression; +export type FunctionNode = FunctionExpression | TSESTree.FunctionDeclaration; +export interface FunctionInfo { + node: T; + returns: TSESTree.ReturnStatement[]; +} +/** + * Checks if a function belongs to: + * ``` + * () => () => ... + * () => function () { ... } + * () => { return () => ... } + * () => { return function () { ... } } + * function fn() { return () => ... } + * function fn() { return function() { ... } } + * ``` + */ +export declare function doesImmediatelyReturnFunctionExpression({ node, returns, }: FunctionInfo): boolean; +interface Options { + allowDirectConstAssertionInArrowFunctions?: boolean; + allowExpressions?: boolean; + allowHigherOrderFunctions?: boolean; + allowTypedFunctionExpressions?: boolean; +} +/** + * True when the provided function expression is typed. + */ +export declare function isTypedFunctionExpression(node: FunctionExpression, options: Options): boolean; +/** + * Check whether the function expression return type is either typed or valid + * with the provided options. + */ +export declare function isValidFunctionExpressionReturnType(node: FunctionExpression, options: Options): boolean; +/** + * Checks if a function declaration/expression has a return type. + */ +export declare function checkFunctionReturnType({ node, returns }: FunctionInfo, options: Options, sourceCode: TSESLint.SourceCode, report: (loc: TSESTree.SourceLocation) => void): void; +/** + * Checks if a function declaration/expression has a return type. + */ +export declare function checkFunctionExpressionReturnType(info: FunctionInfo, options: Options, sourceCode: TSESLint.SourceCode, report: (loc: TSESTree.SourceLocation) => void): void; +/** + * Check whether any ancestor of the provided function has a valid return type. + */ +export declare function ancestorHasReturnType(node: FunctionNode): boolean; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.js new file mode 100644 index 00000000..6b92ba50 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/explicitReturnTypeUtils.js @@ -0,0 +1,239 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.doesImmediatelyReturnFunctionExpression = doesImmediatelyReturnFunctionExpression; +exports.isTypedFunctionExpression = isTypedFunctionExpression; +exports.isValidFunctionExpressionReturnType = isValidFunctionExpressionReturnType; +exports.checkFunctionReturnType = checkFunctionReturnType; +exports.checkFunctionExpressionReturnType = checkFunctionExpressionReturnType; +exports.ancestorHasReturnType = ancestorHasReturnType; +const utils_1 = require("@typescript-eslint/utils"); +const astUtils_1 = require("./astUtils"); +const getFunctionHeadLoc_1 = require("./getFunctionHeadLoc"); +/** + * Checks if a node is a variable declarator with a type annotation. + * ``` + * const x: Foo = ... + * ``` + */ +function isVariableDeclaratorWithTypeAnnotation(node) { + return (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && !!node.id.typeAnnotation); +} +/** + * Checks if a node is a class property with a type annotation. + * ``` + * public x: Foo = ... + * ``` + */ +function isPropertyDefinitionWithTypeAnnotation(node) { + return (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition && !!node.typeAnnotation); +} +/** + * Checks if a node belongs to: + * ``` + * foo(() => 1) + * ``` + */ +function isFunctionArgument(parent, callee) { + return (parent.type === utils_1.AST_NODE_TYPES.CallExpression && + // make sure this isn't an IIFE + parent.callee !== callee); +} +/** + * Checks if a node is type-constrained in JSX + * ``` + * {}} /> + * {() => {}} + * + * ``` + */ +function isTypedJSX(node) { + return (node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer || + node.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute); +} +function isTypedParent(parent, callee) { + return ((0, astUtils_1.isTypeAssertion)(parent) || + isVariableDeclaratorWithTypeAnnotation(parent) || + isDefaultFunctionParameterWithTypeAnnotation(parent) || + isPropertyDefinitionWithTypeAnnotation(parent) || + isFunctionArgument(parent, callee) || + isTypedJSX(parent)); +} +function isDefaultFunctionParameterWithTypeAnnotation(node) { + return (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern && + node.left.typeAnnotation != null); +} +/** + * Checks if a node belongs to: + * ``` + * new Foo(() => {}) + * ^^^^^^^^ + * ``` + */ +function isConstructorArgument(node) { + return node.type === utils_1.AST_NODE_TYPES.NewExpression; +} +/** + * Checks if a node is a property or a nested property of a typed object: + * ``` + * const x: Foo = { prop: () => {} } + * const x = { prop: () => {} } as Foo + * const x = { prop: () => {} } + * const x: Foo = { bar: { prop: () => {} } } + * ``` + */ +function isPropertyOfObjectWithType(property) { + if (property?.type !== utils_1.AST_NODE_TYPES.Property) { + return false; + } + const objectExpr = property.parent; + if (objectExpr.type !== utils_1.AST_NODE_TYPES.ObjectExpression) { + return false; + } + const parent = objectExpr.parent; + return isTypedParent(parent) || isPropertyOfObjectWithType(parent); +} +/** + * Checks if a function belongs to: + * ``` + * () => () => ... + * () => function () { ... } + * () => { return () => ... } + * () => { return function () { ... } } + * function fn() { return () => ... } + * function fn() { return function() { ... } } + * ``` + */ +function doesImmediatelyReturnFunctionExpression({ node, returns, }) { + if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + utils_1.ASTUtils.isFunction(node.body)) { + return true; + } + if (returns.length === 0) { + return false; + } + return returns.every(node => node.argument && utils_1.ASTUtils.isFunction(node.argument)); +} +/** + * Checks if a function belongs to: + * ``` + * ({ action: 'xxx' } as const) + * ``` + */ +function isConstAssertion(node) { + if ((0, astUtils_1.isTypeAssertion)(node)) { + const { typeAnnotation } = node; + if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) { + const { typeName } = typeAnnotation; + if (typeName.type === utils_1.AST_NODE_TYPES.Identifier && + typeName.name === 'const') { + return true; + } + } + } + return false; +} +/** + * True when the provided function expression is typed. + */ +function isTypedFunctionExpression(node, options) { + if (!options.allowTypedFunctionExpressions) { + return false; + } + return (isTypedParent(node.parent, node) || + isPropertyOfObjectWithType(node.parent) || + isConstructorArgument(node.parent)); +} +/** + * Check whether the function expression return type is either typed or valid + * with the provided options. + */ +function isValidFunctionExpressionReturnType(node, options) { + if (isTypedFunctionExpression(node, options)) { + return true; + } + if (options.allowExpressions && + node.parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator && + node.parent.type !== utils_1.AST_NODE_TYPES.MethodDefinition && + node.parent.type !== utils_1.AST_NODE_TYPES.ExportDefaultDeclaration && + node.parent.type !== utils_1.AST_NODE_TYPES.PropertyDefinition) { + return true; + } + // https://github.com/typescript-eslint/typescript-eslint/issues/653 + if (!options.allowDirectConstAssertionInArrowFunctions || + node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + return false; + } + let body = node.body; + while (body.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) { + body = body.expression; + } + return isConstAssertion(body); +} +/** + * Check that the function expression or declaration is valid. + */ +function isValidFunctionReturnType({ node, returns }, options) { + if (options.allowHigherOrderFunctions && + doesImmediatelyReturnFunctionExpression({ node, returns })) { + return true; + } + return (node.returnType != null || + (0, astUtils_1.isConstructor)(node.parent) || + (0, astUtils_1.isSetter)(node.parent)); +} +/** + * Checks if a function declaration/expression has a return type. + */ +function checkFunctionReturnType({ node, returns }, options, sourceCode, report) { + if (isValidFunctionReturnType({ node, returns }, options)) { + return; + } + report((0, getFunctionHeadLoc_1.getFunctionHeadLoc)(node, sourceCode)); +} +/** + * Checks if a function declaration/expression has a return type. + */ +function checkFunctionExpressionReturnType(info, options, sourceCode, report) { + if (isValidFunctionExpressionReturnType(info.node, options)) { + return; + } + checkFunctionReturnType(info, options, sourceCode, report); +} +/** + * Check whether any ancestor of the provided function has a valid return type. + */ +function ancestorHasReturnType(node) { + let ancestor = node.parent; + if (ancestor.type === utils_1.AST_NODE_TYPES.Property) { + ancestor = ancestor.value; + } + // if the ancestor is not a return, then this function was not returned at all, so we can exit early + const isReturnStatement = ancestor.type === utils_1.AST_NODE_TYPES.ReturnStatement; + const isBodylessArrow = ancestor.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + ancestor.body.type !== utils_1.AST_NODE_TYPES.BlockStatement; + if (!isReturnStatement && !isBodylessArrow) { + return false; + } + while (ancestor) { + switch (ancestor.type) { + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.FunctionDeclaration: + if (ancestor.returnType) { + return true; + } + break; + // const x: Foo = () => {}; + // Assume that a typed variable types the function expression + case utils_1.AST_NODE_TYPES.VariableDeclarator: + return !!ancestor.id.typeAnnotation; + case utils_1.AST_NODE_TYPES.PropertyDefinition: + return !!ancestor.typeAnnotation; + case utils_1.AST_NODE_TYPES.ExpressionStatement: + return false; + } + ancestor = ancestor.parent; + } + return false; +} +//# sourceMappingURL=explicitReturnTypeUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.d.ts new file mode 100644 index 00000000..c763a83a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.d.ts @@ -0,0 +1,4 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +export declare function getAwaitTokenRemovalRange(sourceCode: TSESLint.SourceCode, awaitToken: TSESTree.IdentifierToken & { + value: 'await'; +}): TSESTree.Range; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.js new file mode 100644 index 00000000..2eed2953 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getAwaitTokenRemovalRange.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getAwaitTokenRemovalRange = getAwaitTokenRemovalRange; +function getAwaitTokenRemovalRange(sourceCode, awaitToken) { + const startAt = awaitToken.range[0]; + let endAt = awaitToken.range[1]; + const nextToken = sourceCode.getTokenAfter(awaitToken, { + includeComments: true, + }); + /* istanbul ignore else */ if (nextToken) { + endAt = nextToken.range[0]; + } + return [startAt, endAt]; +} +//# sourceMappingURL=getAwaitTokenRemovalRange.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.d.ts new file mode 100644 index 00000000..35057240 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.d.ts @@ -0,0 +1,11 @@ +import type { TSESTree, ParserServicesWithTypeInformation } from '@typescript-eslint/utils'; +import type * as ts from 'typescript'; +/** + * Given a member of a class which extends another class or implements an interface, + * yields the corresponding member type for each of the base class/interfaces. + */ +export declare function getBaseTypesOfClassMember(services: ParserServicesWithTypeInformation, memberNode: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): Generator<{ + baseType: ts.Type; + baseMemberType: ts.Type; + heritageToken: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword; +}>; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.js new file mode 100644 index 00000000..61ff5121 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.js @@ -0,0 +1,32 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getBaseTypesOfClassMember = getBaseTypesOfClassMember; +/** + * Given a member of a class which extends another class or implements an interface, + * yields the corresponding member type for each of the base class/interfaces. + */ +function* getBaseTypesOfClassMember(services, memberNode) { + const memberTsNode = services.esTreeNodeToTSNodeMap.get(memberNode); + if (memberTsNode.name == null) { + return; + } + const checker = services.program.getTypeChecker(); + const memberSymbol = checker.getSymbolAtLocation(memberTsNode.name); + if (memberSymbol == null) { + return; + } + const classNode = memberTsNode.parent; + for (const clauseNode of classNode.heritageClauses ?? []) { + for (const baseTypeNode of clauseNode.types) { + const baseType = checker.getTypeAtLocation(baseTypeNode); + const baseMemberSymbol = checker.getPropertyOfType(baseType, memberSymbol.name); + if (baseMemberSymbol == null) { + continue; + } + const baseMemberType = checker.getTypeOfSymbolAtLocation(baseMemberSymbol, memberTsNode); + const heritageToken = clauseNode.token; + yield { baseMemberType, baseType, heritageToken }; + } + } +} +//# sourceMappingURL=getBaseTypesOfClassMember.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.d.ts new file mode 100644 index 00000000..f733ab09 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.d.ts @@ -0,0 +1,35 @@ +import type * as ts from 'typescript'; +export interface ConstraintTypeInfoUnconstrained { + constraintType: undefined; + isTypeParameter: true; +} +export interface ConstraintTypeInfoConstrained { + constraintType: ts.Type; + isTypeParameter: true; +} +export interface ConstraintTypeInfoNonGeneric { + constraintType: ts.Type; + isTypeParameter: false; +} +export type ConstraintTypeInfo = ConstraintTypeInfoConstrained | ConstraintTypeInfoNonGeneric | ConstraintTypeInfoUnconstrained; +/** + * Returns whether the type is a generic and what its constraint is. + * + * If the type is not a generic, `isTypeParameter` will be `false`, and + * `constraintType` will be the same as the input type. + * + * If the type is a generic, and it is constrained, `isTypeParameter` will be + * `true`, and `constraintType` will be the constraint type. + * + * If the type is a generic, but it is not constrained, `constraintType` will be + * `undefined` (rather than an `unknown` type), due to https://github.com/microsoft/TypeScript/issues/60475 + * + * Successor to {@link getConstrainedTypeAtLocation} due to https://github.com/typescript-eslint/typescript-eslint/issues/10438 + * + * This is considered internal since it is unstable for now and may have breaking changes at any time. + * Use at your own risk. + * + * @internal + * + */ +export declare function getConstraintInfo(checker: ts.TypeChecker, type: ts.Type): ConstraintTypeInfo; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.js new file mode 100644 index 00000000..b3e38768 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getConstraintInfo.js @@ -0,0 +1,71 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getConstraintInfo = getConstraintInfo; +const tsutils = __importStar(require("ts-api-utils")); +/** + * Returns whether the type is a generic and what its constraint is. + * + * If the type is not a generic, `isTypeParameter` will be `false`, and + * `constraintType` will be the same as the input type. + * + * If the type is a generic, and it is constrained, `isTypeParameter` will be + * `true`, and `constraintType` will be the constraint type. + * + * If the type is a generic, but it is not constrained, `constraintType` will be + * `undefined` (rather than an `unknown` type), due to https://github.com/microsoft/TypeScript/issues/60475 + * + * Successor to {@link getConstrainedTypeAtLocation} due to https://github.com/typescript-eslint/typescript-eslint/issues/10438 + * + * This is considered internal since it is unstable for now and may have breaking changes at any time. + * Use at your own risk. + * + * @internal + * + */ +function getConstraintInfo(checker, type) { + if (tsutils.isTypeParameter(type)) { + const constraintType = checker.getBaseConstraintOfType(type); + return { + constraintType, + isTypeParameter: true, + }; + } + return { + constraintType: type, + isTypeParameter: false, + }; +} +//# sourceMappingURL=getConstraintInfo.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.d.ts new file mode 100644 index 00000000..b2b490ec --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.d.ts @@ -0,0 +1,27 @@ +interface RuleMap { + 'arrow-parens': typeof import('eslint/lib/rules/arrow-parens'); + 'consistent-return': typeof import('eslint/lib/rules/consistent-return'); + 'dot-notation': typeof import('eslint/lib/rules/dot-notation'); + 'init-declarations': typeof import('eslint/lib/rules/init-declarations'); + 'max-params': typeof import('eslint/lib/rules/max-params'); + 'no-dupe-args': typeof import('eslint/lib/rules/no-dupe-args'); + 'no-dupe-class-members': typeof import('eslint/lib/rules/no-dupe-class-members'); + 'no-empty-function': typeof import('eslint/lib/rules/no-empty-function'); + 'no-implicit-globals': typeof import('eslint/lib/rules/no-implicit-globals'); + 'no-invalid-this': typeof import('eslint/lib/rules/no-invalid-this'); + 'no-loop-func': typeof import('eslint/lib/rules/no-loop-func'); + 'no-loss-of-precision': typeof import('eslint/lib/rules/no-loss-of-precision'); + 'no-magic-numbers': typeof import('eslint/lib/rules/no-magic-numbers'); + 'no-restricted-globals': typeof import('eslint/lib/rules/no-restricted-globals'); + 'no-restricted-imports': typeof import('eslint/lib/rules/no-restricted-imports'); + 'no-undef': typeof import('eslint/lib/rules/no-undef'); + 'no-unused-expressions': typeof import('eslint/lib/rules/no-unused-expressions'); + 'no-useless-constructor': typeof import('eslint/lib/rules/no-useless-constructor'); + 'prefer-const': typeof import('eslint/lib/rules/prefer-const'); + 'prefer-destructuring': typeof import('eslint/lib/rules/prefer-destructuring'); + strict: typeof import('eslint/lib/rules/strict'); +} +type RuleId = keyof RuleMap; +export declare const getESLintCoreRule: (ruleId: R) => RuleMap[R]; +export declare function maybeGetESLintCoreRule(ruleId: R): RuleMap[R] | null; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.js new file mode 100644 index 00000000..48023ccb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getESLintCoreRule.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getESLintCoreRule = void 0; +exports.maybeGetESLintCoreRule = maybeGetESLintCoreRule; +const utils_1 = require("@typescript-eslint/utils"); +const use_at_your_own_risk_1 = require("eslint/use-at-your-own-risk"); +const getESLintCoreRule = (ruleId) => utils_1.ESLintUtils.nullThrows(use_at_your_own_risk_1.builtinRules.get(ruleId), `ESLint's core rule '${ruleId}' not found.`); +exports.getESLintCoreRule = getESLintCoreRule; +function maybeGetESLintCoreRule(ruleId) { + try { + return (0, exports.getESLintCoreRule)(ruleId); + } + catch { + return null; + } +} +//# sourceMappingURL=getESLintCoreRule.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.d.ts new file mode 100644 index 00000000..b3f1008b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.d.ts @@ -0,0 +1,9 @@ +import type { TSESLint } from '@typescript-eslint/utils'; +export declare function getFixOrSuggest({ fixOrSuggest, suggestion, }: { + fixOrSuggest: 'fix' | 'none' | 'suggest'; + suggestion: TSESLint.SuggestionReportDescriptor; +}): { + fix: TSESLint.ReportFixFunction; +} | { + suggest: TSESLint.SuggestionReportDescriptor[]; +} | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.js new file mode 100644 index 00000000..b3ccd910 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.js @@ -0,0 +1,14 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getFixOrSuggest = getFixOrSuggest; +function getFixOrSuggest({ fixOrSuggest, suggestion, }) { + switch (fixOrSuggest) { + case 'fix': + return { fix: suggestion.fix }; + case 'none': + return undefined; + case 'suggest': + return { suggest: [suggestion] }; + } +} +//# sourceMappingURL=getFixOrSuggest.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.d.ts new file mode 100644 index 00000000..2746829f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.d.ts @@ -0,0 +1,17 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +/** + * Gets the location of the head of the given for statement variant for reporting. + * + * - `for (const foo in bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for (const foo of bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for await (const foo of bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for (let i = 0; i < 10; i++) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +export declare function getForStatementHeadLoc(sourceCode: TSESLint.SourceCode, node: TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement): TSESTree.SourceLocation; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.js new file mode 100644 index 00000000..fdc79f57 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getForStatementHeadLoc.js @@ -0,0 +1,27 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getForStatementHeadLoc = getForStatementHeadLoc; +const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils"); +/** + * Gets the location of the head of the given for statement variant for reporting. + * + * - `for (const foo in bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for (const foo of bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for await (const foo of bar) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * + * - `for (let i = 0; i < 10; i++) expressionOrBlock` + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +function getForStatementHeadLoc(sourceCode, node) { + const closingParens = (0, eslint_utils_1.nullThrows)(sourceCode.getTokenBefore(node.body, token => token.value === ')'), 'for statement must have a closing parenthesis.'); + return { + end: structuredClone(closingParens.loc.end), + start: structuredClone(node.loc.start), + }; +} +//# sourceMappingURL=getForStatementHeadLoc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.d.ts new file mode 100644 index 00000000..7aac75d5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.d.ts @@ -0,0 +1,101 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +type FunctionNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression; +/** + * Gets the location of the given function node for reporting. + * + * - `function foo() {}` + * ^^^^^^^^^^^^ + * - `(function foo() {})` + * ^^^^^^^^^^^^ + * - `(function() {})` + * ^^^^^^^^ + * - `function* foo() {}` + * ^^^^^^^^^^^^^ + * - `(function* foo() {})` + * ^^^^^^^^^^^^^ + * - `(function*() {})` + * ^^^^^^^^^ + * - `() => {}` + * ^^ + * - `async () => {}` + * ^^ + * - `({ foo: function foo() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ foo: function() {} })` + * ^^^^^^^^^^^^^ + * - `({ ['foo']: function() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function() {} })` + * ^^^^^^^^^^^^^^^ + * - `({ foo() {} })` + * ^^^ + * - `({ foo: function* foo() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ foo: function*() {} })` + * ^^^^^^^^^^^^^^ + * - `({ ['foo']: function*() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function*() {} })` + * ^^^^^^^^^^^^^^^^ + * - `({ *foo() {} })` + * ^^^^ + * - `({ foo: async function foo() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ foo: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^ + * - `({ ['foo']: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `({ async foo() {} })` + * ^^^^^^^^^ + * - `({ get foo() {} })` + * ^^^^^^^ + * - `({ set foo(a) {} })` + * ^^^^^^^ + * - `class A { constructor() {} }` + * ^^^^^^^^^^^ + * - `class A { foo() {} }` + * ^^^ + * - `class A { *foo() {} }` + * ^^^^ + * - `class A { async foo() {} }` + * ^^^^^^^^^ + * - `class A { ['foo']() {} }` + * ^^^^^^^ + * - `class A { *['foo']() {} }` + * ^^^^^^^^ + * - `class A { async ['foo']() {} }` + * ^^^^^^^^^^^^^ + * - `class A { [foo]() {} }` + * ^^^^^ + * - `class A { *[foo]() {} }` + * ^^^^^^ + * - `class A { async [foo]() {} }` + * ^^^^^^^^^^^ + * - `class A { get foo() {} }` + * ^^^^^^^ + * - `class A { set foo(a) {} }` + * ^^^^^^^ + * - `class A { static foo() {} }` + * ^^^^^^^^^^ + * - `class A { static *foo() {} }` + * ^^^^^^^^^^^ + * - `class A { static async foo() {} }` + * ^^^^^^^^^^^^^^^^ + * - `class A { static get foo() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static set foo(a) {} }` + * ^^^^^^^^^^^^^^ + * - `class A { foo = function() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static foo = function() {} }` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `class A { foo = (a, b) => {} }` + * ^^^^^^ + * @param node The function node to get. + * @param sourceCode The source code object to get tokens. + * @returns The location of the function node for reporting. + */ +export declare function getFunctionHeadLoc(node: FunctionNode, sourceCode: TSESLint.SourceCode): TSESTree.SourceLocation; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.js new file mode 100644 index 00000000..0fc05f87 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getFunctionHeadLoc.js @@ -0,0 +1,162 @@ +"use strict"; +// adapted from https://github.com/eslint/eslint/blob/5bdaae205c3a0089ea338b382df59e21d5b06436/lib/rules/utils/ast-utils.js#L1668-L1787 +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getFunctionHeadLoc = getFunctionHeadLoc; +const utils_1 = require("@typescript-eslint/utils"); +const astUtils_1 = require("./astUtils"); +/** + * Gets the `(` token of the given function node. + * @param node The function node to get. + * @param sourceCode The source code object to get tokens. + * @returns `(` token. + */ +function getOpeningParenOfParams(node, sourceCode) { + // If the node is an arrow function and doesn't have parens, this returns the identifier of the first param. + if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + node.params.length === 1) { + const argToken = utils_1.ESLintUtils.nullThrows(sourceCode.getFirstToken(node.params[0]), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('parameter', 'arrow function')); + const maybeParenToken = sourceCode.getTokenBefore(argToken); + return maybeParenToken && (0, astUtils_1.isOpeningParenToken)(maybeParenToken) + ? maybeParenToken + : argToken; + } + // Otherwise, returns paren. + return node.id != null + ? utils_1.ESLintUtils.nullThrows(sourceCode.getTokenAfter(node.id, astUtils_1.isOpeningParenToken), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('id', 'function')) + : utils_1.ESLintUtils.nullThrows(sourceCode.getFirstToken(node, astUtils_1.isOpeningParenToken), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('opening parenthesis', 'function')); +} +/** + * Gets the location of the given function node for reporting. + * + * - `function foo() {}` + * ^^^^^^^^^^^^ + * - `(function foo() {})` + * ^^^^^^^^^^^^ + * - `(function() {})` + * ^^^^^^^^ + * - `function* foo() {}` + * ^^^^^^^^^^^^^ + * - `(function* foo() {})` + * ^^^^^^^^^^^^^ + * - `(function*() {})` + * ^^^^^^^^^ + * - `() => {}` + * ^^ + * - `async () => {}` + * ^^ + * - `({ foo: function foo() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ foo: function() {} })` + * ^^^^^^^^^^^^^ + * - `({ ['foo']: function() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function() {} })` + * ^^^^^^^^^^^^^^^ + * - `({ foo() {} })` + * ^^^ + * - `({ foo: function* foo() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ foo: function*() {} })` + * ^^^^^^^^^^^^^^ + * - `({ ['foo']: function*() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function*() {} })` + * ^^^^^^^^^^^^^^^^ + * - `({ *foo() {} })` + * ^^^^ + * - `({ foo: async function foo() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ foo: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^ + * - `({ ['foo']: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `({ async foo() {} })` + * ^^^^^^^^^ + * - `({ get foo() {} })` + * ^^^^^^^ + * - `({ set foo(a) {} })` + * ^^^^^^^ + * - `class A { constructor() {} }` + * ^^^^^^^^^^^ + * - `class A { foo() {} }` + * ^^^ + * - `class A { *foo() {} }` + * ^^^^ + * - `class A { async foo() {} }` + * ^^^^^^^^^ + * - `class A { ['foo']() {} }` + * ^^^^^^^ + * - `class A { *['foo']() {} }` + * ^^^^^^^^ + * - `class A { async ['foo']() {} }` + * ^^^^^^^^^^^^^ + * - `class A { [foo]() {} }` + * ^^^^^ + * - `class A { *[foo]() {} }` + * ^^^^^^ + * - `class A { async [foo]() {} }` + * ^^^^^^^^^^^ + * - `class A { get foo() {} }` + * ^^^^^^^ + * - `class A { set foo(a) {} }` + * ^^^^^^^ + * - `class A { static foo() {} }` + * ^^^^^^^^^^ + * - `class A { static *foo() {} }` + * ^^^^^^^^^^^ + * - `class A { static async foo() {} }` + * ^^^^^^^^^^^^^^^^ + * - `class A { static get foo() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static set foo(a) {} }` + * ^^^^^^^^^^^^^^ + * - `class A { foo = function() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static foo = function() {} }` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `class A { foo = (a, b) => {} }` + * ^^^^^^ + * @param node The function node to get. + * @param sourceCode The source code object to get tokens. + * @returns The location of the function node for reporting. + */ +function getFunctionHeadLoc(node, sourceCode) { + const parent = node.parent; + let start; + let end; + if (parent.type === utils_1.AST_NODE_TYPES.MethodDefinition || + parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) { + // the decorator's range is included within the member + // however it's usually irrelevant to the member itself - so we don't want + // to highlight it ever. + if (parent.decorators.length > 0) { + const lastDecorator = parent.decorators[parent.decorators.length - 1]; + const firstTokenAfterDecorator = utils_1.ESLintUtils.nullThrows(sourceCode.getTokenAfter(lastDecorator), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('modifier or member name', 'class member')); + start = firstTokenAfterDecorator.loc.start; + } + else { + start = parent.loc.start; + } + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + else if (parent.type === utils_1.AST_NODE_TYPES.Property) { + start = parent.loc.start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) { + const arrowToken = utils_1.ESLintUtils.nullThrows(sourceCode.getTokenBefore(node.body, astUtils_1.isArrowToken), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('arrow token', 'arrow function')); + start = arrowToken.loc.start; + end = arrowToken.loc.end; + } + else { + start = node.loc.start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + return { + end: { ...end }, + start: { ...start }, + }; +} +//# sourceMappingURL=getFunctionHeadLoc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.d.ts new file mode 100644 index 00000000..5fa886f2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.d.ts @@ -0,0 +1,36 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +/** + * Generates report loc suitable for reporting on how a class member is + * declared, rather than how it's implemented. + * + * ```ts + * class A { + * abstract method(): void; + * ~~~~~~~~~~~~~~~ + * + * concreteMethod(): void { + * ~~~~~~~~~~~~~~ + * // code + * } + * + * abstract private property?: string; + * ~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * @decorator override concreteProperty = 'value'; + * ~~~~~~~~~~~~~~~~~~~~~~~~~ + * } + * ``` + */ +export declare function getMemberHeadLoc(sourceCode: Readonly, node: TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition): TSESTree.SourceLocation; +/** + * Generates report loc suitable for reporting on how a parameter property is + * declared. + * + * ```ts + * class A { + * constructor(private property: string = 'value') { + * ~~~~~~~~~~~~~~~~ + * } + * ``` + */ +export declare function getParameterPropertyHeadLoc(sourceCode: Readonly, node: TSESTree.TSParameterProperty, nodeName: string): TSESTree.SourceLocation; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.js new file mode 100644 index 00000000..5119d065 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getMemberHeadLoc.js @@ -0,0 +1,80 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getMemberHeadLoc = getMemberHeadLoc; +exports.getParameterPropertyHeadLoc = getParameterPropertyHeadLoc; +const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils"); +/** + * Generates report loc suitable for reporting on how a class member is + * declared, rather than how it's implemented. + * + * ```ts + * class A { + * abstract method(): void; + * ~~~~~~~~~~~~~~~ + * + * concreteMethod(): void { + * ~~~~~~~~~~~~~~ + * // code + * } + * + * abstract private property?: string; + * ~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * @decorator override concreteProperty = 'value'; + * ~~~~~~~~~~~~~~~~~~~~~~~~~ + * } + * ``` + */ +function getMemberHeadLoc(sourceCode, node) { + let start; + if (node.decorators.length === 0) { + start = node.loc.start; + } + else { + const lastDecorator = node.decorators[node.decorators.length - 1]; + const nextToken = (0, eslint_utils_1.nullThrows)(sourceCode.getTokenAfter(lastDecorator), eslint_utils_1.NullThrowsReasons.MissingToken('token', 'last decorator')); + start = nextToken.loc.start; + } + let end; + if (!node.computed) { + end = node.key.loc.end; + } + else { + const closingBracket = (0, eslint_utils_1.nullThrows)(sourceCode.getTokenAfter(node.key, token => token.value === ']'), eslint_utils_1.NullThrowsReasons.MissingToken(']', node.type)); + end = closingBracket.loc.end; + } + return { + end: structuredClone(end), + start: structuredClone(start), + }; +} +/** + * Generates report loc suitable for reporting on how a parameter property is + * declared. + * + * ```ts + * class A { + * constructor(private property: string = 'value') { + * ~~~~~~~~~~~~~~~~ + * } + * ``` + */ +function getParameterPropertyHeadLoc(sourceCode, node, nodeName) { + // Parameter properties have a weirdly different AST structure + // than other class members. + let start; + if (node.decorators.length === 0) { + start = structuredClone(node.loc.start); + } + else { + const lastDecorator = node.decorators[node.decorators.length - 1]; + const nextToken = (0, eslint_utils_1.nullThrows)(sourceCode.getTokenAfter(lastDecorator), eslint_utils_1.NullThrowsReasons.MissingToken('token', 'last decorator')); + start = structuredClone(nextToken.loc.start); + } + const end = sourceCode.getLocFromIndex(node.parameter.range[0] + nodeName.length); + return { + end, + start, + }; +} +//# sourceMappingURL=getMemberHeadLoc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.d.ts new file mode 100644 index 00000000..8c8e0962 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.d.ts @@ -0,0 +1,39 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import { SyntaxKind } from 'typescript'; +import type { ValueOf } from './types'; +export declare enum OperatorPrecedence { + Comma = 0, + Spread = 1, + Yield = 2, + Assignment = 3, + Conditional = 4, + Coalesce = 4,// NOTE: This is wrong + LogicalOR = 5, + LogicalAND = 6, + BitwiseOR = 7, + BitwiseXOR = 8, + BitwiseAND = 9, + Equality = 10, + Relational = 11, + Shift = 12, + Additive = 13, + Multiplicative = 14, + Exponentiation = 15, + Unary = 16, + Update = 17, + LeftHandSide = 18, + Member = 19, + Primary = 20, + Highest = 20, + Lowest = 0, + Invalid = -1 +} +/** + * Note that this does not take into account parenthesization. You should check + * for parenthesization separately if it's relevant to your usage. + */ +export declare function getOperatorPrecedenceForNode(node: TSESTree.Node): OperatorPrecedence; +type TSESTreeOperatorKind = ValueOf | ValueOf; +export declare function getOperatorPrecedence(nodeKind: SyntaxKind, operatorKind: SyntaxKind, hasArguments?: boolean): OperatorPrecedence; +export declare function getBinaryOperatorPrecedence(kind: SyntaxKind | TSESTreeOperatorKind): OperatorPrecedence; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.js new file mode 100644 index 00000000..630de34e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getOperatorPrecedence.js @@ -0,0 +1,422 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.OperatorPrecedence = void 0; +exports.getOperatorPrecedenceForNode = getOperatorPrecedenceForNode; +exports.getOperatorPrecedence = getOperatorPrecedence; +exports.getBinaryOperatorPrecedence = getBinaryOperatorPrecedence; +const utils_1 = require("@typescript-eslint/utils"); +const typescript_1 = require("typescript"); +var OperatorPrecedence; +(function (OperatorPrecedence) { + // Expression: + // AssignmentExpression + // Expression `,` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Comma"] = 0] = "Comma"; + // NOTE: `Spread` is higher than `Comma` due to how it is parsed in |ElementList| + // SpreadElement: + // `...` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Spread"] = 1] = "Spread"; + // AssignmentExpression: + // ConditionalExpression + // YieldExpression + // ArrowFunction + // AsyncArrowFunction + // LeftHandSideExpression `=` AssignmentExpression + // LeftHandSideExpression AssignmentOperator AssignmentExpression + // + // NOTE: AssignmentExpression is broken down into several precedences due to the requirements + // of the parenthesize rules. + // AssignmentExpression: YieldExpression + // YieldExpression: + // `yield` + // `yield` AssignmentExpression + // `yield` `*` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Yield"] = 2] = "Yield"; + // AssignmentExpression: LeftHandSideExpression `=` AssignmentExpression + // AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression + // AssignmentOperator: one of + // `*=` `/=` `%=` `+=` `-=` `<<=` `>>=` `>>>=` `&=` `^=` `|=` `**=` + OperatorPrecedence[OperatorPrecedence["Assignment"] = 3] = "Assignment"; + // NOTE: `Conditional` is considered higher than `Assignment` here, but in reality they have + // the same precedence. + // AssignmentExpression: ConditionalExpression + // ConditionalExpression: + // ShortCircuitExpression + // ShortCircuitExpression `?` AssignmentExpression `:` AssignmentExpression + // ShortCircuitExpression: + // LogicalORExpression + // CoalesceExpression + OperatorPrecedence[OperatorPrecedence["Conditional"] = 4] = "Conditional"; + // CoalesceExpression: + // CoalesceExpressionHead `??` BitwiseORExpression + // CoalesceExpressionHead: + // CoalesceExpression + // BitwiseORExpression + OperatorPrecedence[OperatorPrecedence["Coalesce"] = 4] = "Coalesce"; + // LogicalORExpression: + // LogicalANDExpression + // LogicalORExpression `||` LogicalANDExpression + OperatorPrecedence[OperatorPrecedence["LogicalOR"] = 5] = "LogicalOR"; + // LogicalANDExpression: + // BitwiseORExpression + // LogicalANDExpression `&&` BitwiseORExpression + OperatorPrecedence[OperatorPrecedence["LogicalAND"] = 6] = "LogicalAND"; + // BitwiseORExpression: + // BitwiseXORExpression + // BitwiseORExpression `^` BitwiseXORExpression + OperatorPrecedence[OperatorPrecedence["BitwiseOR"] = 7] = "BitwiseOR"; + // BitwiseXORExpression: + // BitwiseANDExpression + // BitwiseXORExpression `^` BitwiseANDExpression + OperatorPrecedence[OperatorPrecedence["BitwiseXOR"] = 8] = "BitwiseXOR"; + // BitwiseANDExpression: + // EqualityExpression + // BitwiseANDExpression `^` EqualityExpression + OperatorPrecedence[OperatorPrecedence["BitwiseAND"] = 9] = "BitwiseAND"; + // EqualityExpression: + // RelationalExpression + // EqualityExpression `==` RelationalExpression + // EqualityExpression `!=` RelationalExpression + // EqualityExpression `===` RelationalExpression + // EqualityExpression `!==` RelationalExpression + OperatorPrecedence[OperatorPrecedence["Equality"] = 10] = "Equality"; + // RelationalExpression: + // ShiftExpression + // RelationalExpression `<` ShiftExpression + // RelationalExpression `>` ShiftExpression + // RelationalExpression `<=` ShiftExpression + // RelationalExpression `>=` ShiftExpression + // RelationalExpression `instanceof` ShiftExpression + // RelationalExpression `in` ShiftExpression + // [+TypeScript] RelationalExpression `as` Type + OperatorPrecedence[OperatorPrecedence["Relational"] = 11] = "Relational"; + // ShiftExpression: + // AdditiveExpression + // ShiftExpression `<<` AdditiveExpression + // ShiftExpression `>>` AdditiveExpression + // ShiftExpression `>>>` AdditiveExpression + OperatorPrecedence[OperatorPrecedence["Shift"] = 12] = "Shift"; + // AdditiveExpression: + // MultiplicativeExpression + // AdditiveExpression `+` MultiplicativeExpression + // AdditiveExpression `-` MultiplicativeExpression + OperatorPrecedence[OperatorPrecedence["Additive"] = 13] = "Additive"; + // MultiplicativeExpression: + // ExponentiationExpression + // MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + // MultiplicativeOperator: one of `*`, `/`, `%` + OperatorPrecedence[OperatorPrecedence["Multiplicative"] = 14] = "Multiplicative"; + // ExponentiationExpression: + // UnaryExpression + // UpdateExpression `**` ExponentiationExpression + OperatorPrecedence[OperatorPrecedence["Exponentiation"] = 15] = "Exponentiation"; + // UnaryExpression: + // UpdateExpression + // `delete` UnaryExpression + // `void` UnaryExpression + // `typeof` UnaryExpression + // `+` UnaryExpression + // `-` UnaryExpression + // `~` UnaryExpression + // `!` UnaryExpression + // AwaitExpression + // UpdateExpression: // TODO: Do we need to investigate the precedence here? + // `++` UnaryExpression + // `--` UnaryExpression + OperatorPrecedence[OperatorPrecedence["Unary"] = 16] = "Unary"; + // UpdateExpression: + // LeftHandSideExpression + // LeftHandSideExpression `++` + // LeftHandSideExpression `--` + OperatorPrecedence[OperatorPrecedence["Update"] = 17] = "Update"; + // LeftHandSideExpression: + // NewExpression + // CallExpression + // NewExpression: + // MemberExpression + // `new` NewExpression + OperatorPrecedence[OperatorPrecedence["LeftHandSide"] = 18] = "LeftHandSide"; + // CallExpression: + // CoverCallExpressionAndAsyncArrowHead + // SuperCall + // ImportCall + // CallExpression Arguments + // CallExpression `[` Expression `]` + // CallExpression `.` IdentifierName + // CallExpression TemplateLiteral + // MemberExpression: + // PrimaryExpression + // MemberExpression `[` Expression `]` + // MemberExpression `.` IdentifierName + // MemberExpression TemplateLiteral + // SuperProperty + // MetaProperty + // `new` MemberExpression Arguments + OperatorPrecedence[OperatorPrecedence["Member"] = 19] = "Member"; + // TODO: JSXElement? + // PrimaryExpression: + // `this` + // IdentifierReference + // Literal + // ArrayLiteral + // ObjectLiteral + // FunctionExpression + // ClassExpression + // GeneratorExpression + // AsyncFunctionExpression + // AsyncGeneratorExpression + // RegularExpressionLiteral + // TemplateLiteral + // CoverParenthesizedExpressionAndArrowParameterList + OperatorPrecedence[OperatorPrecedence["Primary"] = 20] = "Primary"; + OperatorPrecedence[OperatorPrecedence["Highest"] = 20] = "Highest"; + OperatorPrecedence[OperatorPrecedence["Lowest"] = 0] = "Lowest"; + // -1 is lower than all other precedences. Returning it will cause binary expression + // parsing to stop. + OperatorPrecedence[OperatorPrecedence["Invalid"] = -1] = "Invalid"; +})(OperatorPrecedence || (exports.OperatorPrecedence = OperatorPrecedence = {})); +/** + * Note that this does not take into account parenthesization. You should check + * for parenthesization separately if it's relevant to your usage. + */ +function getOperatorPrecedenceForNode(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.SpreadElement: + case utils_1.AST_NODE_TYPES.RestElement: + return OperatorPrecedence.Spread; + case utils_1.AST_NODE_TYPES.YieldExpression: + case utils_1.AST_NODE_TYPES.ArrowFunctionExpression: + return OperatorPrecedence.Yield; + case utils_1.AST_NODE_TYPES.ConditionalExpression: + return OperatorPrecedence.Conditional; + case utils_1.AST_NODE_TYPES.SequenceExpression: + return OperatorPrecedence.Comma; + case utils_1.AST_NODE_TYPES.AssignmentExpression: + case utils_1.AST_NODE_TYPES.BinaryExpression: + case utils_1.AST_NODE_TYPES.LogicalExpression: + switch (node.operator) { + case '==': + case '+=': + case '-=': + case '**=': + case '*=': + case '/=': + case '%=': + case '<<=': + case '>>=': + case '>>>=': + case '&=': + case '^=': + case '|=': + case '||=': + case '&&=': + case '??=': + return OperatorPrecedence.Assignment; + default: + return getBinaryOperatorPrecedence(node.operator); + } + case utils_1.AST_NODE_TYPES.TSTypeAssertion: + case utils_1.AST_NODE_TYPES.TSNonNullExpression: + case utils_1.AST_NODE_TYPES.UnaryExpression: + case utils_1.AST_NODE_TYPES.AwaitExpression: + return OperatorPrecedence.Unary; + case utils_1.AST_NODE_TYPES.UpdateExpression: + // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? + if (node.prefix) { + return OperatorPrecedence.Unary; + } + return OperatorPrecedence.Update; + case utils_1.AST_NODE_TYPES.ChainExpression: + return getOperatorPrecedenceForNode(node.expression); + case utils_1.AST_NODE_TYPES.CallExpression: + return OperatorPrecedence.LeftHandSide; + case utils_1.AST_NODE_TYPES.NewExpression: + return node.arguments.length > 0 + ? OperatorPrecedence.Member + : OperatorPrecedence.LeftHandSide; + case utils_1.AST_NODE_TYPES.TaggedTemplateExpression: + case utils_1.AST_NODE_TYPES.MemberExpression: + case utils_1.AST_NODE_TYPES.MetaProperty: + return OperatorPrecedence.Member; + case utils_1.AST_NODE_TYPES.TSAsExpression: + return OperatorPrecedence.Relational; + case utils_1.AST_NODE_TYPES.ThisExpression: + case utils_1.AST_NODE_TYPES.Super: + case utils_1.AST_NODE_TYPES.Identifier: + case utils_1.AST_NODE_TYPES.PrivateIdentifier: + case utils_1.AST_NODE_TYPES.Literal: + case utils_1.AST_NODE_TYPES.ArrayExpression: + case utils_1.AST_NODE_TYPES.ObjectExpression: + case utils_1.AST_NODE_TYPES.FunctionExpression: + case utils_1.AST_NODE_TYPES.ClassExpression: + case utils_1.AST_NODE_TYPES.TemplateLiteral: + case utils_1.AST_NODE_TYPES.JSXElement: + case utils_1.AST_NODE_TYPES.JSXFragment: + // we don't have nodes for these cases + // case SyntaxKind.ParenthesizedExpression: + // case SyntaxKind.OmittedExpression: + return OperatorPrecedence.Primary; + default: + return OperatorPrecedence.Invalid; + } +} +function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { + switch (nodeKind) { + // A list of comma-separated expressions. This node is only created by transformations. + case typescript_1.SyntaxKind.CommaListExpression: + return OperatorPrecedence.Comma; + case typescript_1.SyntaxKind.SpreadElement: + return OperatorPrecedence.Spread; + case typescript_1.SyntaxKind.YieldExpression: + return OperatorPrecedence.Yield; + case typescript_1.SyntaxKind.ConditionalExpression: + return OperatorPrecedence.Conditional; + case typescript_1.SyntaxKind.BinaryExpression: + switch (operatorKind) { + case typescript_1.SyntaxKind.AmpersandAmpersandEqualsToken: + case typescript_1.SyntaxKind.AmpersandEqualsToken: + case typescript_1.SyntaxKind.AsteriskAsteriskEqualsToken: + case typescript_1.SyntaxKind.AsteriskEqualsToken: + case typescript_1.SyntaxKind.BarBarEqualsToken: + case typescript_1.SyntaxKind.BarEqualsToken: + case typescript_1.SyntaxKind.CaretEqualsToken: + case typescript_1.SyntaxKind.EqualsToken: + case typescript_1.SyntaxKind.GreaterThanGreaterThanEqualsToken: + case typescript_1.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: + case typescript_1.SyntaxKind.LessThanLessThanEqualsToken: + case typescript_1.SyntaxKind.MinusEqualsToken: + case typescript_1.SyntaxKind.PercentEqualsToken: + case typescript_1.SyntaxKind.PlusEqualsToken: + case typescript_1.SyntaxKind.QuestionQuestionEqualsToken: + case typescript_1.SyntaxKind.SlashEqualsToken: + return OperatorPrecedence.Assignment; + case typescript_1.SyntaxKind.CommaToken: + return OperatorPrecedence.Comma; + default: + return getBinaryOperatorPrecedence(operatorKind); + } + // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? + case typescript_1.SyntaxKind.TypeAssertionExpression: + case typescript_1.SyntaxKind.NonNullExpression: + case typescript_1.SyntaxKind.PrefixUnaryExpression: + case typescript_1.SyntaxKind.TypeOfExpression: + case typescript_1.SyntaxKind.VoidExpression: + case typescript_1.SyntaxKind.DeleteExpression: + case typescript_1.SyntaxKind.AwaitExpression: + return OperatorPrecedence.Unary; + case typescript_1.SyntaxKind.PostfixUnaryExpression: + return OperatorPrecedence.Update; + case typescript_1.SyntaxKind.CallExpression: + return OperatorPrecedence.LeftHandSide; + case typescript_1.SyntaxKind.NewExpression: + return hasArguments + ? OperatorPrecedence.Member + : OperatorPrecedence.LeftHandSide; + case typescript_1.SyntaxKind.TaggedTemplateExpression: + case typescript_1.SyntaxKind.PropertyAccessExpression: + case typescript_1.SyntaxKind.ElementAccessExpression: + case typescript_1.SyntaxKind.MetaProperty: + return OperatorPrecedence.Member; + case typescript_1.SyntaxKind.AsExpression: + case typescript_1.SyntaxKind.SatisfiesExpression: + return OperatorPrecedence.Relational; + case typescript_1.SyntaxKind.ThisKeyword: + case typescript_1.SyntaxKind.SuperKeyword: + case typescript_1.SyntaxKind.Identifier: + case typescript_1.SyntaxKind.PrivateIdentifier: + case typescript_1.SyntaxKind.NullKeyword: + case typescript_1.SyntaxKind.TrueKeyword: + case typescript_1.SyntaxKind.FalseKeyword: + case typescript_1.SyntaxKind.NumericLiteral: + case typescript_1.SyntaxKind.BigIntLiteral: + case typescript_1.SyntaxKind.StringLiteral: + case typescript_1.SyntaxKind.ArrayLiteralExpression: + case typescript_1.SyntaxKind.ObjectLiteralExpression: + case typescript_1.SyntaxKind.FunctionExpression: + case typescript_1.SyntaxKind.ArrowFunction: + case typescript_1.SyntaxKind.ClassExpression: + case typescript_1.SyntaxKind.RegularExpressionLiteral: + case typescript_1.SyntaxKind.NoSubstitutionTemplateLiteral: + case typescript_1.SyntaxKind.TemplateExpression: + case typescript_1.SyntaxKind.ParenthesizedExpression: + case typescript_1.SyntaxKind.OmittedExpression: + case typescript_1.SyntaxKind.JsxElement: + case typescript_1.SyntaxKind.JsxSelfClosingElement: + case typescript_1.SyntaxKind.JsxFragment: + return OperatorPrecedence.Primary; + default: + return OperatorPrecedence.Invalid; + } +} +function getBinaryOperatorPrecedence(kind) { + switch (kind) { + case '-': + case '+': + case typescript_1.SyntaxKind.MinusToken: + case typescript_1.SyntaxKind.PlusToken: + return OperatorPrecedence.Additive; + case '!=': + case '!==': + case '==': + case '===': + case typescript_1.SyntaxKind.EqualsEqualsEqualsToken: + case typescript_1.SyntaxKind.EqualsEqualsToken: + case typescript_1.SyntaxKind.ExclamationEqualsEqualsToken: + case typescript_1.SyntaxKind.ExclamationEqualsToken: + return OperatorPrecedence.Equality; + case '??': + case typescript_1.SyntaxKind.QuestionQuestionToken: + return OperatorPrecedence.Coalesce; + case '*': + case '/': + case '%': + case typescript_1.SyntaxKind.AsteriskToken: + case typescript_1.SyntaxKind.PercentToken: + case typescript_1.SyntaxKind.SlashToken: + return OperatorPrecedence.Multiplicative; + case '**': + case typescript_1.SyntaxKind.AsteriskAsteriskToken: + return OperatorPrecedence.Exponentiation; + case '&': + case typescript_1.SyntaxKind.AmpersandToken: + return OperatorPrecedence.BitwiseAND; + case '&&': + case typescript_1.SyntaxKind.AmpersandAmpersandToken: + return OperatorPrecedence.LogicalAND; + case '^': + case typescript_1.SyntaxKind.CaretToken: + return OperatorPrecedence.BitwiseXOR; + case '<': + case '<=': + case '>': + case '>=': + case 'in': + case 'instanceof': + case typescript_1.SyntaxKind.AsKeyword: + case typescript_1.SyntaxKind.GreaterThanEqualsToken: + case typescript_1.SyntaxKind.GreaterThanToken: + case typescript_1.SyntaxKind.InKeyword: + case typescript_1.SyntaxKind.InstanceOfKeyword: + case typescript_1.SyntaxKind.LessThanEqualsToken: + case typescript_1.SyntaxKind.LessThanToken: + // case 'as': -- we don't have a token for this + return OperatorPrecedence.Relational; + case '<<': + case '>>': + case '>>>': + case typescript_1.SyntaxKind.GreaterThanGreaterThanGreaterThanToken: + case typescript_1.SyntaxKind.GreaterThanGreaterThanToken: + case typescript_1.SyntaxKind.LessThanLessThanToken: + return OperatorPrecedence.Shift; + case '|': + case typescript_1.SyntaxKind.BarToken: + return OperatorPrecedence.BitwiseOR; + case '||': + case typescript_1.SyntaxKind.BarBarToken: + return OperatorPrecedence.LogicalOR; + } + // -1 is lower than all other precedences. Returning it will cause binary expression + // parsing to stop. + return -1; +} +//# sourceMappingURL=getOperatorPrecedence.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.d.ts new file mode 100644 index 00000000..9090e741 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function getParentFunctionNode(node: TSESTree.Node): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | null; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.js new file mode 100644 index 00000000..1deb998a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getParentFunctionNode.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getParentFunctionNode = getParentFunctionNode; +const utils_1 = require("@typescript-eslint/utils"); +function getParentFunctionNode(node) { + let current = node.parent; + while (current) { + if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || + current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration || + current.type === utils_1.AST_NODE_TYPES.FunctionExpression) { + return current; + } + current = current.parent; + } + // this shouldn't happen in correct code, but someone may attempt to parse bad code + // the parser won't error, so we shouldn't throw here + /* istanbul ignore next */ return null; +} +//# sourceMappingURL=getParentFunctionNode.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.d.ts new file mode 100644 index 00000000..b99ed2a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.d.ts @@ -0,0 +1,11 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +/** + * Returns the result of the string conversion applied to the evaluated value of the given expression node, + * if it can be determined statically. + * + * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only. + * In all other cases, this function returns `null`. + * @param node Expression node. + * @returns String value if it can be determined. Otherwise, `null`. + */ +export declare function getStaticStringValue(node: TSESTree.Node): string | null; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.js new file mode 100644 index 00000000..7be3b89e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStaticStringValue.js @@ -0,0 +1,45 @@ +"use strict"; +// adapted from https://github.com/eslint/eslint/blob/5bdaae205c3a0089ea338b382df59e21d5b06436/lib/rules/utils/ast-utils.js#L191-L230 +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getStaticStringValue = getStaticStringValue; +const utils_1 = require("@typescript-eslint/utils"); +const isNullLiteral_1 = require("./isNullLiteral"); +/** + * Returns the result of the string conversion applied to the evaluated value of the given expression node, + * if it can be determined statically. + * + * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only. + * In all other cases, this function returns `null`. + * @param node Expression node. + * @returns String value if it can be determined. Otherwise, `null`. + */ +function getStaticStringValue(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.Literal: + // eslint-disable-next-line eqeqeq, @typescript-eslint/internal/eqeq-nullish -- intentional strict comparison for literal value + if (node.value === null) { + if ((0, isNullLiteral_1.isNullLiteral)(node)) { + return String(node.value); // "null" + } + if ('regex' in node) { + return `/${node.regex.pattern}/${node.regex.flags}`; + } + if ('bigint' in node) { + return node.bigint; + } + // Otherwise, this is an unknown literal. The function will return null. + } + else { + return String(node.value); + } + break; + case utils_1.AST_NODE_TYPES.TemplateLiteral: + if (node.expressions.length === 0 && node.quasis.length === 1) { + return node.quasis[0].value.cooked; + } + break; + // no default + } + return null; +} +//# sourceMappingURL=getStaticStringValue.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.d.ts new file mode 100644 index 00000000..4671c266 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.d.ts @@ -0,0 +1 @@ +export declare function getStringLength(value: string): number; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.js new file mode 100644 index 00000000..07ea2e1c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getStringLength.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getStringLength = getStringLength; +let segmenter; +function isASCII(value) { + return /^[\u0020-\u007f]*$/u.test(value); +} +function getStringLength(value) { + if (isASCII(value)) { + return value.length; + } + segmenter ??= new Intl.Segmenter(); + return [...segmenter.segment(value)].length; +} +//# sourceMappingURL=getStringLength.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.d.ts new file mode 100644 index 00000000..70afed3f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.d.ts @@ -0,0 +1,3 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { SourceCode } from '@typescript-eslint/utils/ts-eslint'; +export declare function getTextWithParentheses(sourceCode: Readonly, node: TSESTree.Node): string; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.js new file mode 100644 index 00000000..48be26ef --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getTextWithParentheses.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getTextWithParentheses = getTextWithParentheses; +const _1 = require("."); +function getTextWithParentheses(sourceCode, node) { + // Capture parentheses before and after the node + let beforeCount = 0; + let afterCount = 0; + if ((0, _1.isParenthesized)(node, sourceCode)) { + const bodyOpeningParen = (0, _1.nullThrows)(sourceCode.getTokenBefore(node, _1.isOpeningParenToken), _1.NullThrowsReasons.MissingToken('(', 'node')); + const bodyClosingParen = (0, _1.nullThrows)(sourceCode.getTokenAfter(node, _1.isClosingParenToken), _1.NullThrowsReasons.MissingToken(')', 'node')); + beforeCount = node.range[0] - bodyOpeningParen.range[0]; + afterCount = bodyClosingParen.range[1] - node.range[1]; + } + return sourceCode.getText(node, beforeCount, afterCount); +} +//# sourceMappingURL=getTextWithParentheses.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.d.ts new file mode 100644 index 00000000..344dfc6e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function getThisExpression(node: TSESTree.Node): TSESTree.ThisExpression | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.js new file mode 100644 index 00000000..a132a598 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getThisExpression.js @@ -0,0 +1,25 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getThisExpression = getThisExpression; +const utils_1 = require("@typescript-eslint/utils"); +function getThisExpression(node) { + while (true) { + if (node.type === utils_1.AST_NODE_TYPES.CallExpression) { + node = node.callee; + } + else if (node.type === utils_1.AST_NODE_TYPES.ThisExpression) { + return node; + } + else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) { + node = node.object; + } + else if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) { + node = node.expression; + } + else { + break; + } + } + return; +} +//# sourceMappingURL=getThisExpression.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.d.ts new file mode 100644 index 00000000..41ea71a8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.d.ts @@ -0,0 +1,2 @@ +import type * as ts from 'typescript'; +export declare const getValueOfLiteralType: (type: ts.LiteralType) => bigint | number | string; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.js new file mode 100644 index 00000000..0c96475d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getValueOfLiteralType.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getValueOfLiteralType = void 0; +const valueIsPseudoBigInt = (value) => { + return typeof value === 'object'; +}; +const pseudoBigIntToBigInt = (value) => { + return BigInt((value.negative ? '-' : '') + value.base10Value); +}; +const getValueOfLiteralType = (type) => { + if (valueIsPseudoBigInt(type.value)) { + return pseudoBigIntToBigInt(type.value); + } + return type.value; +}; +exports.getValueOfLiteralType = getValueOfLiteralType; +//# sourceMappingURL=getValueOfLiteralType.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.d.ts new file mode 100644 index 00000000..961de2be --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.d.ts @@ -0,0 +1,2 @@ +import type { OperatorPrecedence } from './getOperatorPrecedence'; +export declare function getWrappedCode(text: string, nodePrecedence: OperatorPrecedence, parentPrecedence: OperatorPrecedence): string; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.js new file mode 100644 index 00000000..d6d05430 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappedCode.js @@ -0,0 +1,7 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getWrappedCode = getWrappedCode; +function getWrappedCode(text, nodePrecedence, parentPrecedence) { + return nodePrecedence > parentPrecedence ? text : `(${text})`; +} +//# sourceMappingURL=getWrappedCode.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts new file mode 100644 index 00000000..ad25b7bc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts @@ -0,0 +1,46 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +interface WrappingFixerParams { + /** + * Descendant of `node` we want to preserve. + * Use this to replace some code with another. + * By default it's the node we are modifying (so nothing is removed). + * You can pass multiple nodes as an array. + */ + innerNode?: TSESTree.Node | TSESTree.Node[]; + /** The node we want to modify. */ + node: TSESTree.Node; + /** Source code. */ + sourceCode: Readonly; + /** + * The function which gets the code of the `innerNode` and returns some code around it. + * Receives multiple arguments if there are multiple innerNodes. + * E.g. ``code => `${code} != null` `` + */ + wrap?: (...code: string[]) => string; +} +/** + * Wraps node with some code. Adds parentheses as necessary. + * @returns Fixer which adds the specified code and parens if necessary. + */ +export declare function getWrappingFixer(params: WrappingFixerParams): (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix; +/** + * If the node to be moved and the destination node require parentheses, include parentheses in the node to be moved. + * @param sourceCode Source code of current file + * @param nodeToMove Nodes that need to be moved + * @param destinationNode Final destination node with nodeToMove + * @returns If parentheses are required, code for the nodeToMove node is returned with parentheses at both ends of the code. + */ +export declare function getMovedNodeCode(params: { + destinationNode: TSESTree.Node; + nodeToMove: TSESTree.Node; + sourceCode: Readonly; +}): string; +/** + * Check if a node will always have the same precedence if its parent changes. + */ +export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean; +/** + * Check if a node's parent could have different precedence if the node changes. + */ +export declare function isWeakPrecedenceParent(node: TSESTree.Node): boolean; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.js new file mode 100644 index 00000000..7c5a3f37 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.js @@ -0,0 +1,185 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getWrappingFixer = getWrappingFixer; +exports.getMovedNodeCode = getMovedNodeCode; +exports.isStrongPrecedenceNode = isStrongPrecedenceNode; +exports.isWeakPrecedenceParent = isWeakPrecedenceParent; +const utils_1 = require("@typescript-eslint/utils"); +/** + * Wraps node with some code. Adds parentheses as necessary. + * @returns Fixer which adds the specified code and parens if necessary. + */ +function getWrappingFixer(params) { + const { node, innerNode = node, sourceCode, wrap } = params; + const innerNodes = Array.isArray(innerNode) ? innerNode : [innerNode]; + return (fixer) => { + const innerCodes = innerNodes.map(innerNode => { + let code = sourceCode.getText(innerNode); + /** + * Wrap our node in parens to prevent the following cases: + * - It has a weaker precedence than the code we are wrapping it in + * - It's gotten mistaken as block statement instead of object expression + */ + if (!isStrongPrecedenceNode(innerNode) || + isObjectExpressionInOneLineReturn(node, innerNode)) { + code = `(${code})`; + } + return code; + }); + if (!wrap) { + return fixer.replaceText(node, innerCodes.join('')); + } + // do the wrapping + let code = wrap(...innerCodes); + // check the outer expression's precedence + if (isWeakPrecedenceParent(node) && + // we wrapped the node in some expression which very likely has a different precedence than original wrapped node + // let's wrap the whole expression in parens just in case + !utils_1.ASTUtils.isParenthesized(node, sourceCode)) { + code = `(${code})`; + } + // check if we need to insert semicolon + if (/^[`([]/.test(code) && isMissingSemicolonBefore(node, sourceCode)) { + code = `;${code}`; + } + return fixer.replaceText(node, code); + }; +} +/** + * If the node to be moved and the destination node require parentheses, include parentheses in the node to be moved. + * @param sourceCode Source code of current file + * @param nodeToMove Nodes that need to be moved + * @param destinationNode Final destination node with nodeToMove + * @returns If parentheses are required, code for the nodeToMove node is returned with parentheses at both ends of the code. + */ +function getMovedNodeCode(params) { + const { destinationNode, nodeToMove: existingNode, sourceCode } = params; + const code = sourceCode.getText(existingNode); + if (isStrongPrecedenceNode(existingNode)) { + // Moved node never needs parens + return code; + } + if (!isWeakPrecedenceParent(destinationNode)) { + // Destination would never needs parens, regardless what node moves there + return code; + } + // Parens may be necessary + return `(${code})`; +} +/** + * Check if a node will always have the same precedence if its parent changes. + */ +function isStrongPrecedenceNode(innerNode) { + return (innerNode.type === utils_1.AST_NODE_TYPES.Literal || + innerNode.type === utils_1.AST_NODE_TYPES.Identifier || + innerNode.type === utils_1.AST_NODE_TYPES.TSTypeReference || + innerNode.type === utils_1.AST_NODE_TYPES.ArrayExpression || + innerNode.type === utils_1.AST_NODE_TYPES.ObjectExpression || + innerNode.type === utils_1.AST_NODE_TYPES.MemberExpression || + innerNode.type === utils_1.AST_NODE_TYPES.CallExpression || + innerNode.type === utils_1.AST_NODE_TYPES.NewExpression || + innerNode.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression || + innerNode.type === utils_1.AST_NODE_TYPES.TSInstantiationExpression); +} +/** + * Check if a node's parent could have different precedence if the node changes. + */ +function isWeakPrecedenceParent(node) { + const parent = node.parent; + if (!parent) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.UpdateExpression || + parent.type === utils_1.AST_NODE_TYPES.UnaryExpression || + parent.type === utils_1.AST_NODE_TYPES.BinaryExpression || + parent.type === utils_1.AST_NODE_TYPES.LogicalExpression || + parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression || + parent.type === utils_1.AST_NODE_TYPES.AwaitExpression) { + return true; + } + if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression && + parent.object === node) { + return true; + } + if ((parent.type === utils_1.AST_NODE_TYPES.CallExpression || + parent.type === utils_1.AST_NODE_TYPES.NewExpression) && + parent.callee === node) { + return true; + } + if (parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression && + parent.tag === node) { + return true; + } + return false; +} +/** + * Returns true if a node is at the beginning of expression statement and the statement above doesn't end with semicolon. + * Doesn't check if the node begins with `(`, `[` or `` ` ``. + */ +function isMissingSemicolonBefore(node, sourceCode) { + for (;;) { + // https://github.com/typescript-eslint/typescript-eslint/issues/6225 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const parent = node.parent; + if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + const block = parent.parent; + if (block.type === utils_1.AST_NODE_TYPES.Program || + block.type === utils_1.AST_NODE_TYPES.BlockStatement) { + // parent is an expression statement in a block + const statementIndex = block.body.indexOf(parent); + const previousStatement = block.body[statementIndex - 1]; + if (statementIndex > 0 && + utils_1.ESLintUtils.nullThrows(sourceCode.getLastToken(previousStatement), 'Mismatched semicolon and block').value !== ';') { + return true; + } + } + } + if (!isLeftHandSide(node)) { + return false; + } + node = parent; + } +} +/** + * Checks if a node is LHS of an operator. + */ +function isLeftHandSide(node) { + // https://github.com/typescript-eslint/typescript-eslint/issues/6225 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + const parent = node.parent; + // a++ + if (parent.type === utils_1.AST_NODE_TYPES.UpdateExpression) { + return true; + } + // a + b + if ((parent.type === utils_1.AST_NODE_TYPES.BinaryExpression || + parent.type === utils_1.AST_NODE_TYPES.LogicalExpression || + parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression) && + node === parent.left) { + return true; + } + // a ? b : c + if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + node === parent.test) { + return true; + } + // a(b) + if (parent.type === utils_1.AST_NODE_TYPES.CallExpression && node === parent.callee) { + return true; + } + // a`b` + if (parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression && + node === parent.tag) { + return true; + } + return false; +} +/** + * Checks if a node's parent is arrow function expression and a inner node is object expression + */ +function isObjectExpressionInOneLineReturn(node, innerNode) { + return (node.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + node.parent.body === node && + innerNode.type === utils_1.AST_NODE_TYPES.ObjectExpression); +} +//# sourceMappingURL=getWrappingFixer.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.d.ts new file mode 100644 index 00000000..00b44baf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.d.ts @@ -0,0 +1,6 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +/** + * @return `true` if the function or method node has overload signatures. + */ +export declare function hasOverloadSignatures(node: TSESTree.FunctionDeclaration | TSESTree.MethodDefinition, context: RuleContext): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.js new file mode 100644 index 00000000..0c919531 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/hasOverloadSignatures.js @@ -0,0 +1,48 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.hasOverloadSignatures = hasOverloadSignatures; +const utils_1 = require("@typescript-eslint/utils"); +const misc_1 = require("./misc"); +/** + * @return `true` if the function or method node has overload signatures. + */ +function hasOverloadSignatures(node, context) { + // `export default function () {}` + if (node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) { + return node.parent.parent.body.some(member => { + return (member.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration && + member.declaration.type === utils_1.AST_NODE_TYPES.TSDeclareFunction); + }); + } + // `export function f() {}` + if (node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) { + return node.parent.parent.body.some(member => { + return (member.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration && + member.declaration?.type === utils_1.AST_NODE_TYPES.TSDeclareFunction && + getFunctionDeclarationName(member.declaration, context) === + getFunctionDeclarationName(node, context)); + }); + } + // either: + // - `function f() {}` + // - `class T { foo() {} }` + const nodeKey = getFunctionDeclarationName(node, context); + return node.parent.body.some(member => { + return ((member.type === utils_1.AST_NODE_TYPES.TSDeclareFunction || + (member.type === utils_1.AST_NODE_TYPES.MethodDefinition && + member.value.body == null)) && + nodeKey === getFunctionDeclarationName(member, context)); + }); +} +function getFunctionDeclarationName(node, context) { + if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration || + node.type === utils_1.AST_NODE_TYPES.TSDeclareFunction) { + // For a `FunctionDeclaration` or `TSDeclareFunction` this may be `null` if + // and only if the parent is an `ExportDefaultDeclaration`. + // + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + return node.id.name; + } + return (0, misc_1.getStaticMemberAccessValue)(node, context); +} +//# sourceMappingURL=hasOverloadSignatures.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.d.ts new file mode 100644 index 00000000..58b9ebb1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.d.ts @@ -0,0 +1,45 @@ +import { ESLintUtils } from '@typescript-eslint/utils'; +export * from './astUtils'; +export * from './baseTypeUtils'; +export * from './collectUnusedVariables'; +export * from './createRule'; +export * from './FunctionSignature'; +export * from './getAwaitTokenRemovalRange'; +export * from './getBaseTypesOfClassMember'; +export * from './getFixOrSuggest'; +export * from './getFunctionHeadLoc'; +export * from './getOperatorPrecedence'; +export * from './getStaticStringValue'; +export * from './getStringLength'; +export * from './getTextWithParentheses'; +export * from './getThisExpression'; +export * from './getWrappingFixer'; +export * from './hasOverloadSignatures'; +export * from './isArrayMethodCallWithPredicate'; +export * from './isAssignee'; +export * from './isConditionalTest'; +export * from './isNodeEqual'; +export * from './isNullLiteral'; +export * from './isStartOfArrowFunctionBodyNeedingParentheses'; +export * from './isStartOfExpressionStatement'; +export * from './isStartOfExpressionStatementNeedingParentheses'; +export * from './isUndefinedIdentifier'; +export * from './misc'; +export * from './needsPrecedingSemiColon'; +export * from './objectIterators'; +export * from './needsToBeAwaited'; +export * from './scopeUtils'; +export * from './types'; +export * from './getConstraintInfo'; +export * from './getValueOfLiteralType'; +export * from './isHigherPrecedenceThanAwait'; +export * from './skipChainExpression'; +export * from './truthinessUtils'; +export * from './walkStatements'; +export * from '@typescript-eslint/type-utils'; +export declare const applyDefault: typeof ESLintUtils.applyDefault, deepMerge: typeof ESLintUtils.deepMerge, getParserServices: typeof ESLintUtils.getParserServices, isObjectNotArray: typeof ESLintUtils.isObjectNotArray, nullThrows: typeof ESLintUtils.nullThrows, NullThrowsReasons: { + readonly MissingParent: 'Expected node to have a parent.'; + readonly MissingToken: (token: string, thing: string) => string; +}; +export type InferMessageIdsTypeFromRule = ESLintUtils.InferMessageIdsTypeFromRule; +export type InferOptionsTypeFromRule = ESLintUtils.InferOptionsTypeFromRule; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.js new file mode 100644 index 00000000..42a738ff --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/index.js @@ -0,0 +1,59 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NullThrowsReasons = exports.nullThrows = exports.isObjectNotArray = exports.getParserServices = exports.deepMerge = exports.applyDefault = void 0; +const utils_1 = require("@typescript-eslint/utils"); +__exportStar(require("./astUtils"), exports); +__exportStar(require("./baseTypeUtils"), exports); +__exportStar(require("./collectUnusedVariables"), exports); +__exportStar(require("./createRule"), exports); +__exportStar(require("./FunctionSignature"), exports); +__exportStar(require("./getAwaitTokenRemovalRange"), exports); +__exportStar(require("./getBaseTypesOfClassMember"), exports); +__exportStar(require("./getFixOrSuggest"), exports); +__exportStar(require("./getFunctionHeadLoc"), exports); +__exportStar(require("./getOperatorPrecedence"), exports); +__exportStar(require("./getStaticStringValue"), exports); +__exportStar(require("./getStringLength"), exports); +__exportStar(require("./getTextWithParentheses"), exports); +__exportStar(require("./getThisExpression"), exports); +__exportStar(require("./getWrappingFixer"), exports); +__exportStar(require("./hasOverloadSignatures"), exports); +__exportStar(require("./isArrayMethodCallWithPredicate"), exports); +__exportStar(require("./isAssignee"), exports); +__exportStar(require("./isConditionalTest"), exports); +__exportStar(require("./isNodeEqual"), exports); +__exportStar(require("./isNullLiteral"), exports); +__exportStar(require("./isStartOfArrowFunctionBodyNeedingParentheses"), exports); +__exportStar(require("./isStartOfExpressionStatement"), exports); +__exportStar(require("./isStartOfExpressionStatementNeedingParentheses"), exports); +__exportStar(require("./isUndefinedIdentifier"), exports); +__exportStar(require("./misc"), exports); +__exportStar(require("./needsPrecedingSemiColon"), exports); +__exportStar(require("./objectIterators"), exports); +__exportStar(require("./needsToBeAwaited"), exports); +__exportStar(require("./scopeUtils"), exports); +__exportStar(require("./types"), exports); +__exportStar(require("./getConstraintInfo"), exports); +__exportStar(require("./getValueOfLiteralType"), exports); +__exportStar(require("./isHigherPrecedenceThanAwait"), exports); +__exportStar(require("./skipChainExpression"), exports); +__exportStar(require("./truthinessUtils"), exports); +__exportStar(require("./walkStatements"), exports); +// this is done for convenience - saves migrating all of the old rules +__exportStar(require("@typescript-eslint/type-utils"), exports); +({ applyDefault: exports.applyDefault, deepMerge: exports.deepMerge, getParserServices: exports.getParserServices, isObjectNotArray: exports.isObjectNotArray, nullThrows: exports.nullThrows, NullThrowsReasons: exports.NullThrowsReasons } = utils_1.ESLintUtils); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.d.ts new file mode 100644 index 00000000..9da8ac48 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.d.ts @@ -0,0 +1,3 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +export declare function isArrayMethodCallWithPredicate(context: RuleContext, services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.js new file mode 100644 index 00000000..fa2fc5cf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.js @@ -0,0 +1,65 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isArrayMethodCallWithPredicate = isArrayMethodCallWithPredicate; +const type_utils_1 = require("@typescript-eslint/type-utils"); +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const misc_1 = require("./misc"); +const ARRAY_PREDICATE_FUNCTIONS = new Set([ + 'every', + 'filter', + 'find', + 'findIndex', + 'findLast', + 'findLastIndex', + 'some', +]); +function isArrayMethodCallWithPredicate(context, services, node) { + if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return false; + } + const staticAccessValue = (0, misc_1.getStaticMemberAccessValue)(node.callee, context); + if (!ARRAY_PREDICATE_FUNCTIONS.has(staticAccessValue)) { + return false; + } + const checker = services.program.getTypeChecker(); + const type = (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object); + return tsutils + .unionConstituents(type) + .flatMap(part => tsutils.intersectionConstituents(part)) + .some(t => checker.isArrayType(t) || checker.isTupleType(t)); +} +//# sourceMappingURL=isArrayMethodCallWithPredicate.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.d.ts new file mode 100644 index 00000000..4f943e6d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isAssignee(node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.js new file mode 100644 index 00000000..3bcd1656 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isAssignee.js @@ -0,0 +1,51 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isAssignee = isAssignee; +const utils_1 = require("@typescript-eslint/utils"); +function isAssignee(node) { + const parent = node.parent; + if (!parent) { + return false; + } + // a[i] = 1, a[i] += 1, etc. + if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression && + parent.left === node) { + return true; + } + // delete a[i] + if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + parent.operator === 'delete' && + parent.argument === node) { + return true; + } + // a[i]++, --a[i], etc. + if (parent.type === utils_1.AST_NODE_TYPES.UpdateExpression && + parent.argument === node) { + return true; + } + // [a[i]] = [0] + if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) { + return true; + } + // [...a[i]] = [0] + if (parent.type === utils_1.AST_NODE_TYPES.RestElement) { + return true; + } + // ({ foo: a[i] }) = { foo: 0 } + if (parent.type === utils_1.AST_NODE_TYPES.Property && + parent.value === node && + parent.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression && + isAssignee(parent.parent)) { + return true; + } + // (a[i] as number)++, [...a[i]!] = [0], etc. + if ((parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression || + parent.type === utils_1.AST_NODE_TYPES.TSAsExpression || + parent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion || + parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) && + isAssignee(parent)) { + return true; + } + return false; +} +//# sourceMappingURL=isAssignee.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.d.ts new file mode 100644 index 00000000..85576137 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isConditionalTest(node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.js new file mode 100644 index 00000000..4c3dfa47 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isConditionalTest.js @@ -0,0 +1,35 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isConditionalTest = isConditionalTest; +const utils_1 = require("@typescript-eslint/utils"); +function isConditionalTest(node) { + const parent = node.parent; + if (parent == null) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.LogicalExpression) { + return isConditionalTest(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression && + (parent.consequent === node || parent.alternate === node)) { + return isConditionalTest(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.SequenceExpression && + parent.expressions.at(-1) === node) { + return isConditionalTest(parent); + } + if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && + parent.operator === '!') { + return isConditionalTest(parent); + } + if ((parent.type === utils_1.AST_NODE_TYPES.ConditionalExpression || + parent.type === utils_1.AST_NODE_TYPES.DoWhileStatement || + parent.type === utils_1.AST_NODE_TYPES.IfStatement || + parent.type === utils_1.AST_NODE_TYPES.ForStatement || + parent.type === utils_1.AST_NODE_TYPES.WhileStatement) && + parent.test === node) { + return true; + } + return false; +} +//# sourceMappingURL=isConditionalTest.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.d.ts new file mode 100644 index 00000000..817410a2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.d.ts @@ -0,0 +1,2 @@ +import * as ts from 'typescript'; +export declare function isHigherPrecedenceThanAwait(tsNode: ts.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.js new file mode 100644 index 00000000..6c78d542 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isHigherPrecedenceThanAwait.js @@ -0,0 +1,47 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isHigherPrecedenceThanAwait = isHigherPrecedenceThanAwait; +const ts = __importStar(require("typescript")); +const getOperatorPrecedence_1 = require("./getOperatorPrecedence"); +function isHigherPrecedenceThanAwait(tsNode) { + const operator = ts.isBinaryExpression(tsNode) + ? tsNode.operatorToken.kind + : ts.SyntaxKind.Unknown; + const nodePrecedence = (0, getOperatorPrecedence_1.getOperatorPrecedence)(tsNode.kind, operator); + const awaitPrecedence = (0, getOperatorPrecedence_1.getOperatorPrecedence)(ts.SyntaxKind.AwaitExpression, ts.SyntaxKind.Unknown); + return nodePrecedence > awaitPrecedence; +} +//# sourceMappingURL=isHigherPrecedenceThanAwait.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.d.ts new file mode 100644 index 00000000..5b46a7d1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.js new file mode 100644 index 00000000..8fc4711d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNodeEqual.js @@ -0,0 +1,26 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNodeEqual = isNodeEqual; +const utils_1 = require("@typescript-eslint/utils"); +function isNodeEqual(a, b) { + if (a.type !== b.type) { + return false; + } + if (a.type === utils_1.AST_NODE_TYPES.ThisExpression && + b.type === utils_1.AST_NODE_TYPES.ThisExpression) { + return true; + } + if (a.type === utils_1.AST_NODE_TYPES.Literal && b.type === utils_1.AST_NODE_TYPES.Literal) { + return a.value === b.value; + } + if (a.type === utils_1.AST_NODE_TYPES.Identifier && + b.type === utils_1.AST_NODE_TYPES.Identifier) { + return a.name === b.name; + } + if (a.type === utils_1.AST_NODE_TYPES.MemberExpression && + b.type === utils_1.AST_NODE_TYPES.MemberExpression) { + return (isNodeEqual(a.property, b.property) && isNodeEqual(a.object, b.object)); + } + return false; +} +//# sourceMappingURL=isNodeEqual.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.d.ts new file mode 100644 index 00000000..2d5aa85f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isNullLiteral(i: TSESTree.Node): i is TSESTree.NullLiteral; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.js new file mode 100644 index 00000000..bfac97cb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isNullLiteral.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNullLiteral = isNullLiteral; +const utils_1 = require("@typescript-eslint/utils"); +function isNullLiteral(i) { + return i.type === utils_1.AST_NODE_TYPES.Literal && i.value == null; +} +//# sourceMappingURL=isNullLiteral.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.d.ts new file mode 100644 index 00000000..590cc10d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.d.ts @@ -0,0 +1,3 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +export declare function isPromiseAggregatorMethod(context: RuleContext, services: ParserServicesWithTypeInformation, node: TSESTree.CallExpression): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.js new file mode 100644 index 00000000..58038521 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isPromiseAggregatorMethod.js @@ -0,0 +1,23 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isPromiseAggregatorMethod = isPromiseAggregatorMethod; +const type_utils_1 = require("@typescript-eslint/type-utils"); +const utils_1 = require("@typescript-eslint/utils"); +const misc_1 = require("./misc"); +const PROMISE_CONSTRUCTOR_ARRAY_METHODS = new Set([ + 'all', + 'allSettled', + 'race', + 'any', +]); +function isPromiseAggregatorMethod(context, services, node) { + if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) { + return false; + } + const staticAccessValue = (0, misc_1.getStaticMemberAccessValue)(node.callee, context); + if (!PROMISE_CONSTRUCTOR_ARRAY_METHODS.has(staticAccessValue)) { + return false; + } + return (0, type_utils_1.isPromiseConstructorLike)(services.program, (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object)); +} +//# sourceMappingURL=isPromiseAggregatorMethod.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.d.ts new file mode 100644 index 00000000..a95436ec --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.d.ts @@ -0,0 +1,2 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +export declare function isStartOfArrowFunctionBodyNeedingParentheses(node: TSESTree.Node, firstToken: TSESTree.Token, sourceCode: TSESLint.SourceCode): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.js new file mode 100644 index 00000000..c0c762c8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfArrowFunctionBodyNeedingParentheses.js @@ -0,0 +1,30 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isStartOfArrowFunctionBodyNeedingParentheses = isStartOfArrowFunctionBodyNeedingParentheses; +const utils_1 = require("@typescript-eslint/utils"); +const astUtils_1 = require("./astUtils"); +function isStartOfArrowFunctionBodyNeedingParentheses(node, firstToken, sourceCode) { + return ((0, astUtils_1.isOpeningBraceToken)(firstToken) && + isStartOfArrowFunctionBody(node, sourceCode)); +} +function isStartOfArrowFunctionBody(node, sourceCode) { + let current = node; + while (true) { + if ((0, astUtils_1.isParenthesized)(current, sourceCode)) { + return false; + } + const { parent } = current; + if (parent == null) { + return false; + } + if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression && + parent.body === current) { + return true; + } + if (parent.range[0] !== current.range[0]) { + return false; + } + current = parent; + } +} +//# sourceMappingURL=isStartOfArrowFunctionBodyNeedingParentheses.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.d.ts new file mode 100644 index 00000000..9dd35600 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.d.ts @@ -0,0 +1,7 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +/** + * Tests if a node appears at the beginning of an ancestor ExpressionStatement node. + * @param node The node to check. + * @returns Whether the node appears at the beginning of an ancestor ExpressionStatement node. + */ +export declare function isStartOfExpressionStatement(node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.js new file mode 100644 index 00000000..8c3d7b41 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatement.js @@ -0,0 +1,23 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isStartOfExpressionStatement = isStartOfExpressionStatement; +const utils_1 = require("@typescript-eslint/utils"); +// The following is copied from `eslint`'s source code. +// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/lib/rules/utils/ast-utils.js#L1026-L1041 +// Could be export { isStartOfExpressionStatement } from 'eslint/lib/rules/utils/ast-utils' +/** + * Tests if a node appears at the beginning of an ancestor ExpressionStatement node. + * @param node The node to check. + * @returns Whether the node appears at the beginning of an ancestor ExpressionStatement node. + */ +function isStartOfExpressionStatement(node) { + const start = node.range[0]; + let ancestor = node; + while ((ancestor = ancestor.parent) && ancestor.range[0] === start) { + if (ancestor.type === utils_1.AST_NODE_TYPES.ExpressionStatement) { + return true; + } + } + return false; +} +//# sourceMappingURL=isStartOfExpressionStatement.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.d.ts new file mode 100644 index 00000000..9a644416 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isStartOfExpressionStatementNeedingParentheses(node: TSESTree.Node, firstToken: TSESTree.Token): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.js new file mode 100644 index 00000000..aa7e7bf9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isStartOfExpressionStatementNeedingParentheses.js @@ -0,0 +1,9 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isStartOfExpressionStatementNeedingParentheses = isStartOfExpressionStatementNeedingParentheses; +const isStartOfExpressionStatement_1 = require("./isStartOfExpressionStatement"); +function isStartOfExpressionStatementNeedingParentheses(node, firstToken) { + return (['{', 'class', 'function'].includes(firstToken.value) && + (0, isStartOfExpressionStatement_1.isStartOfExpressionStatement)(node)); +} +//# sourceMappingURL=isStartOfExpressionStatementNeedingParentheses.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.d.ts new file mode 100644 index 00000000..9a5addcd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.d.ts @@ -0,0 +1,12 @@ +import type { Definition, ImportBindingDefinition } from '@typescript-eslint/scope-manager'; +/** + * Determine whether a variable definition is a type import. e.g.: + * + * ```ts + * import type { Foo } from 'foo'; + * import { type Bar } from 'bar'; + * ``` + * + * @param definition - The variable definition to check. + */ +export declare function isTypeImport(definition?: Definition): definition is ImportBindingDefinition; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.js new file mode 100644 index 00000000..6cc63dd7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isTypeImport.js @@ -0,0 +1,22 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isTypeImport = isTypeImport; +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const utils_1 = require("@typescript-eslint/utils"); +/** + * Determine whether a variable definition is a type import. e.g.: + * + * ```ts + * import type { Foo } from 'foo'; + * import { type Bar } from 'bar'; + * ``` + * + * @param definition - The variable definition to check. + */ +function isTypeImport(definition) { + return (definition?.type === scope_manager_1.DefinitionType.ImportBinding && + (definition.parent.importKind === 'type' || + (definition.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier && + definition.node.importKind === 'type'))); +} +//# sourceMappingURL=isTypeImport.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.d.ts new file mode 100644 index 00000000..eb4d9ecf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function isUndefinedIdentifier(i: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.js new file mode 100644 index 00000000..0bbd3186 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/isUndefinedIdentifier.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isUndefinedIdentifier = isUndefinedIdentifier; +const utils_1 = require("@typescript-eslint/utils"); +function isUndefinedIdentifier(i) { + return i.type === utils_1.AST_NODE_TYPES.Identifier && i.name === 'undefined'; +} +//# sourceMappingURL=isUndefinedIdentifier.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.d.ts new file mode 100644 index 00000000..b1d68d27 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.d.ts @@ -0,0 +1,115 @@ +/** + * @fileoverview Really small utility functions that didn't deserve their own files + */ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +import * as ts from 'typescript'; +/** + * Check if the context file name is *.d.ts or *.d.tsx + */ +export declare function isDefinitionFile(fileName: string): boolean; +/** + * Upper cases the first character or the string + */ +export declare function upperCaseFirst(str: string): string; +export declare function arrayGroupByToMap(array: T[], getKey: (item: T) => Key): Map; +/** Return true if both parameters are equal. */ +export type Equal = (a: T, b: T) => boolean; +export declare function arraysAreEqual(a: T[] | undefined, b: T[] | undefined, eq: (a: T, b: T) => boolean): boolean; +/** Returns the first non-`undefined` result. */ +export declare function findFirstResult(inputs: T[], getResult: (t: T) => U | undefined): U | undefined; +/** + * Gets a string representation of the name of the index signature. + */ +export declare function getNameFromIndexSignature(node: TSESTree.TSIndexSignature): string; +export declare enum MemberNameType { + Private = 1, + Quoted = 2, + Normal = 3, + Expression = 4 +} +/** + * Gets a string name representation of the name of the given MethodDefinition + * or PropertyDefinition node, with handling for computed property names. + */ +export declare function getNameFromMember(member: TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.TSMethodSignature | TSESTree.TSPropertySignature, sourceCode: TSESLint.SourceCode): { + name: string; + type: MemberNameType; +}; +export type ExcludeKeys, Keys extends keyof Obj> = { + [k in Exclude]: Obj[k]; +}; +export type RequireKeys, Keys extends keyof Obj> = { + [k in Keys]-?: Exclude; +} & ExcludeKeys; +export declare function getEnumNames(myEnum: Record): T[]; +/** + * Given an array of words, returns an English-friendly concatenation, separated with commas, with + * the `and` clause inserted before the last item. + * + * Example: ['foo', 'bar', 'baz' ] returns the string "foo, bar, and baz". + */ +export declare function formatWordList(words: string[]): string; +/** + * Iterates the array in reverse and returns the index of the first element it + * finds which passes the predicate function. + * + * @returns Returns the index of the element if it finds it or -1 otherwise. + */ +export declare function findLastIndex(members: T[], predicate: (member: T) => boolean | null | undefined): number; +export declare function typeNodeRequiresParentheses(node: TSESTree.TypeNode, text: string): boolean; +export declare function isRestParameterDeclaration(decl: ts.Declaration): boolean; +export declare function isParenlessArrowFunction(node: TSESTree.ArrowFunctionExpression, sourceCode: TSESLint.SourceCode): boolean; +export type NodeWithKey = TSESTree.AccessorProperty | TSESTree.MemberExpression | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition; +/** + * Gets a member being accessed or declared if its value can be determined statically, and + * resolves it to the string or symbol value that will be used as the actual member + * access key at runtime. Otherwise, returns `undefined`. + * + * ```ts + * x.member // returns 'member' + * ^^^^^^^^ + * + * x?.member // returns 'member' (optional chaining is treated the same) + * ^^^^^^^^^ + * + * x['value'] // returns 'value' + * ^^^^^^^^^^ + * + * x[Math.random()] // returns undefined (not a static value) + * ^^^^^^^^^^^^^^^^ + * + * arr[0] // returns '0' (NOT 0) + * ^^^^^^ + * + * arr[0n] // returns '0' (NOT 0n) + * ^^^^^^^ + * + * const s = Symbol.for('symbolName') + * x[s] // returns `Symbol.for('symbolName')` (since it's a static/global symbol) + * ^^^^ + * + * const us = Symbol('symbolName') + * x[us] // returns undefined (since it's a unique symbol, so not statically analyzable) + * ^^^^^ + * + * var object = { + * 1234: '4567', // returns '1234' (NOT 1234) + * ^^^^^^^^^^^^ + * method() { } // returns 'method' + * ^^^^^^^^^^^^ + * } + * + * class WithMembers { + * foo: string // returns 'foo' + * ^^^^^^^^^^^ + * } + * ``` + */ +export declare function getStaticMemberAccessValue(node: NodeWithKey, { sourceCode }: RuleContext): string | symbol | undefined; +/** + * Answers whether the member expression looks like + * `x.value`, `x['value']`, + * or even `const v = 'value'; x[v]` (or optional variants thereof). + */ +export declare const isStaticMemberAccessOfValue: (memberExpression: NodeWithKey, context: RuleContext, ...values: (string | symbol)[]) => boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.js new file mode 100644 index 00000000..4c92beee --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/misc.js @@ -0,0 +1,271 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isStaticMemberAccessOfValue = exports.MemberNameType = void 0; +exports.isDefinitionFile = isDefinitionFile; +exports.upperCaseFirst = upperCaseFirst; +exports.arrayGroupByToMap = arrayGroupByToMap; +exports.arraysAreEqual = arraysAreEqual; +exports.findFirstResult = findFirstResult; +exports.getNameFromIndexSignature = getNameFromIndexSignature; +exports.getNameFromMember = getNameFromMember; +exports.getEnumNames = getEnumNames; +exports.formatWordList = formatWordList; +exports.findLastIndex = findLastIndex; +exports.typeNodeRequiresParentheses = typeNodeRequiresParentheses; +exports.isRestParameterDeclaration = isRestParameterDeclaration; +exports.isParenlessArrowFunction = isParenlessArrowFunction; +exports.getStaticMemberAccessValue = getStaticMemberAccessValue; +const type_utils_1 = require("@typescript-eslint/type-utils"); +const utils_1 = require("@typescript-eslint/utils"); +const ts = __importStar(require("typescript")); +const astUtils_1 = require("./astUtils"); +const DEFINITION_EXTENSIONS = [ + ts.Extension.Dts, + ts.Extension.Dcts, + ts.Extension.Dmts, +]; +/** + * Check if the context file name is *.d.ts or *.d.tsx + */ +function isDefinitionFile(fileName) { + const lowerFileName = fileName.toLowerCase(); + for (const definitionExt of DEFINITION_EXTENSIONS) { + if (lowerFileName.endsWith(definitionExt)) { + return true; + } + } + return /\.d\.(ts|cts|mts|.*\.ts)$/.test(lowerFileName); +} +/** + * Upper cases the first character or the string + */ +function upperCaseFirst(str) { + return str[0].toUpperCase() + str.slice(1); +} +function arrayGroupByToMap(array, getKey) { + const groups = new Map(); + for (const item of array) { + const key = getKey(item); + const existing = groups.get(key); + if (existing) { + existing.push(item); + } + else { + groups.set(key, [item]); + } + } + return groups; +} +function arraysAreEqual(a, b, eq) { + return (a === b || + (a != null && a.length === b?.length && a.every((x, idx) => eq(x, b[idx])))); +} +/** Returns the first non-`undefined` result. */ +function findFirstResult(inputs, getResult) { + for (const element of inputs) { + const result = getResult(element); + // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish + if (result !== undefined) { + return result; + } + } + return undefined; +} +/** + * Gets a string representation of the name of the index signature. + */ +function getNameFromIndexSignature(node) { + const propName = node.parameters.find((parameter) => parameter.type === utils_1.AST_NODE_TYPES.Identifier); + return propName ? propName.name : '(index signature)'; +} +var MemberNameType; +(function (MemberNameType) { + MemberNameType[MemberNameType["Private"] = 1] = "Private"; + MemberNameType[MemberNameType["Quoted"] = 2] = "Quoted"; + MemberNameType[MemberNameType["Normal"] = 3] = "Normal"; + MemberNameType[MemberNameType["Expression"] = 4] = "Expression"; +})(MemberNameType || (exports.MemberNameType = MemberNameType = {})); +/** + * Gets a string name representation of the name of the given MethodDefinition + * or PropertyDefinition node, with handling for computed property names. + */ +function getNameFromMember(member, sourceCode) { + if (member.key.type === utils_1.AST_NODE_TYPES.Identifier) { + return { + name: member.key.name, + type: MemberNameType.Normal, + }; + } + if (member.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) { + return { + name: `#${member.key.name}`, + type: MemberNameType.Private, + }; + } + if (member.key.type === utils_1.AST_NODE_TYPES.Literal) { + const name = `${member.key.value}`; + if ((0, type_utils_1.requiresQuoting)(name)) { + return { + name: `"${name}"`, + type: MemberNameType.Quoted, + }; + } + return { + name, + type: MemberNameType.Normal, + }; + } + return { + name: sourceCode.text.slice(...member.key.range), + type: MemberNameType.Expression, + }; +} +function getEnumNames(myEnum) { + return Object.keys(myEnum).filter(x => isNaN(Number(x))); +} +/** + * Given an array of words, returns an English-friendly concatenation, separated with commas, with + * the `and` clause inserted before the last item. + * + * Example: ['foo', 'bar', 'baz' ] returns the string "foo, bar, and baz". + */ +function formatWordList(words) { + if (!words.length) { + return ''; + } + if (words.length === 1) { + return words[0]; + } + return [words.slice(0, -1).join(', '), words.slice(-1)[0]].join(' and '); +} +/** + * Iterates the array in reverse and returns the index of the first element it + * finds which passes the predicate function. + * + * @returns Returns the index of the element if it finds it or -1 otherwise. + */ +function findLastIndex(members, predicate) { + let idx = members.length - 1; + while (idx >= 0) { + const valid = predicate(members[idx]); + if (valid) { + return idx; + } + idx--; + } + return -1; +} +function typeNodeRequiresParentheses(node, text) { + return (node.type === utils_1.AST_NODE_TYPES.TSFunctionType || + node.type === utils_1.AST_NODE_TYPES.TSConstructorType || + node.type === utils_1.AST_NODE_TYPES.TSConditionalType || + (node.type === utils_1.AST_NODE_TYPES.TSUnionType && text.startsWith('|')) || + (node.type === utils_1.AST_NODE_TYPES.TSIntersectionType && text.startsWith('&'))); +} +function isRestParameterDeclaration(decl) { + return ts.isParameter(decl) && decl.dotDotDotToken != null; +} +function isParenlessArrowFunction(node, sourceCode) { + return (node.params.length === 1 && !(0, astUtils_1.isParenthesized)(node.params[0], sourceCode)); +} +/** + * Gets a member being accessed or declared if its value can be determined statically, and + * resolves it to the string or symbol value that will be used as the actual member + * access key at runtime. Otherwise, returns `undefined`. + * + * ```ts + * x.member // returns 'member' + * ^^^^^^^^ + * + * x?.member // returns 'member' (optional chaining is treated the same) + * ^^^^^^^^^ + * + * x['value'] // returns 'value' + * ^^^^^^^^^^ + * + * x[Math.random()] // returns undefined (not a static value) + * ^^^^^^^^^^^^^^^^ + * + * arr[0] // returns '0' (NOT 0) + * ^^^^^^ + * + * arr[0n] // returns '0' (NOT 0n) + * ^^^^^^^ + * + * const s = Symbol.for('symbolName') + * x[s] // returns `Symbol.for('symbolName')` (since it's a static/global symbol) + * ^^^^ + * + * const us = Symbol('symbolName') + * x[us] // returns undefined (since it's a unique symbol, so not statically analyzable) + * ^^^^^ + * + * var object = { + * 1234: '4567', // returns '1234' (NOT 1234) + * ^^^^^^^^^^^^ + * method() { } // returns 'method' + * ^^^^^^^^^^^^ + * } + * + * class WithMembers { + * foo: string // returns 'foo' + * ^^^^^^^^^^^ + * } + * ``` + */ +function getStaticMemberAccessValue(node, { sourceCode }) { + const key = node.type === utils_1.AST_NODE_TYPES.MemberExpression ? node.property : node.key; + const { type } = key; + if (!node.computed && + (type === utils_1.AST_NODE_TYPES.Identifier || + type === utils_1.AST_NODE_TYPES.PrivateIdentifier)) { + return key.name; + } + const result = (0, astUtils_1.getStaticValue)(key, sourceCode.getScope(node)); + if (!result) { + return undefined; + } + const { value } = result; + return typeof value === 'symbol' ? value : String(value); +} +/** + * Answers whether the member expression looks like + * `x.value`, `x['value']`, + * or even `const v = 'value'; x[v]` (or optional variants thereof). + */ +const isStaticMemberAccessOfValue = (memberExpression, context, ...values) => values.includes(getStaticMemberAccessValue(memberExpression, context)); +exports.isStaticMemberAccessOfValue = isStaticMemberAccessOfValue; +//# sourceMappingURL=misc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.d.ts new file mode 100644 index 00000000..eb3ebef2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.d.ts @@ -0,0 +1,11 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { SourceCode } from '@typescript-eslint/utils/ts-eslint'; +/** + * Determines whether an opening parenthesis `(`, bracket `[` or backtick ``` ` ``` needs to be preceded by a semicolon. + * This opening parenthesis or bracket should be at the start of an `ExpressionStatement`, a `MethodDefinition` or at + * the start of the body of an `ArrowFunctionExpression`. + * @param sourceCode The source code object. + * @param node A node at the position where an opening parenthesis or bracket will be inserted. + * @returns Whether a semicolon is required before the opening parenthesis or bracket. + */ +export declare function needsPrecedingSemicolon(sourceCode: SourceCode, node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.js new file mode 100644 index 00000000..4fb50f99 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsPrecedingSemiColon.js @@ -0,0 +1,98 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.needsPrecedingSemicolon = needsPrecedingSemicolon; +const utils_1 = require("@typescript-eslint/utils"); +const ast_utils_1 = require("@typescript-eslint/utils/ast-utils"); +// The following is adapted from `eslint`'s source code. +// https://github.com/eslint/eslint/blob/3a4eaf921543b1cd5d1df4ea9dec02fab396af2a/lib/rules/utils/ast-utils.js#L1043-L1132 +// Could be export { isStartOfExpressionStatement } from 'eslint/lib/rules/utils/ast-utils' +const BREAK_OR_CONTINUE = new Set([ + utils_1.AST_NODE_TYPES.BreakStatement, + utils_1.AST_NODE_TYPES.ContinueStatement, +]); +// Declaration types that must contain a string Literal node at the end. +const DECLARATIONS = new Set([ + utils_1.AST_NODE_TYPES.ExportAllDeclaration, + utils_1.AST_NODE_TYPES.ExportNamedDeclaration, + utils_1.AST_NODE_TYPES.ImportDeclaration, +]); +const IDENTIFIER_OR_KEYWORD = new Set([ + utils_1.AST_NODE_TYPES.Identifier, + utils_1.AST_TOKEN_TYPES.Keyword, +]); +// Keywords that can immediately precede an ExpressionStatement node, mapped to the their node types. +const NODE_TYPES_BY_KEYWORD = { + __proto__: null, + break: utils_1.AST_NODE_TYPES.BreakStatement, + continue: utils_1.AST_NODE_TYPES.ContinueStatement, + debugger: utils_1.AST_NODE_TYPES.DebuggerStatement, + do: utils_1.AST_NODE_TYPES.DoWhileStatement, + else: utils_1.AST_NODE_TYPES.IfStatement, + return: utils_1.AST_NODE_TYPES.ReturnStatement, + yield: utils_1.AST_NODE_TYPES.YieldExpression, +}; +/* + * Before an opening parenthesis, postfix `++` and `--` always trigger ASI; + * the tokens `:`, `;`, `{` and `=>` don't expect a semicolon, as that would count as an empty statement. + */ +const PUNCTUATORS = new Set(['--', ';', ':', '{', '++', '=>']); +/* + * Statements that can contain an `ExpressionStatement` after a closing parenthesis. + * DoWhileStatement is an exception in that it always triggers ASI after the closing parenthesis. + */ +const STATEMENTS = new Set([ + utils_1.AST_NODE_TYPES.DoWhileStatement, + utils_1.AST_NODE_TYPES.ForInStatement, + utils_1.AST_NODE_TYPES.ForOfStatement, + utils_1.AST_NODE_TYPES.ForStatement, + utils_1.AST_NODE_TYPES.IfStatement, + utils_1.AST_NODE_TYPES.WhileStatement, + utils_1.AST_NODE_TYPES.WithStatement, +]); +/** + * Determines whether an opening parenthesis `(`, bracket `[` or backtick ``` ` ``` needs to be preceded by a semicolon. + * This opening parenthesis or bracket should be at the start of an `ExpressionStatement`, a `MethodDefinition` or at + * the start of the body of an `ArrowFunctionExpression`. + * @param sourceCode The source code object. + * @param node A node at the position where an opening parenthesis or bracket will be inserted. + * @returns Whether a semicolon is required before the opening parenthesis or bracket. + */ +function needsPrecedingSemicolon(sourceCode, node) { + const prevToken = sourceCode.getTokenBefore(node); + if (!prevToken || + (prevToken.type === utils_1.AST_TOKEN_TYPES.Punctuator && + PUNCTUATORS.has(prevToken.value))) { + return false; + } + const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]); + if (!prevNode) { + return false; + } + if ((0, ast_utils_1.isClosingParenToken)(prevToken)) { + return !STATEMENTS.has(prevNode.type); + } + if ((0, ast_utils_1.isClosingBraceToken)(prevToken)) { + return ((prevNode.type === utils_1.AST_NODE_TYPES.BlockStatement && + prevNode.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression && + prevNode.parent.parent.type !== utils_1.AST_NODE_TYPES.MethodDefinition) || + (prevNode.type === utils_1.AST_NODE_TYPES.ClassBody && + prevNode.parent.type === utils_1.AST_NODE_TYPES.ClassExpression) || + prevNode.type === utils_1.AST_NODE_TYPES.ObjectExpression); + } + if (!prevNode.parent) { + return false; + } + if (IDENTIFIER_OR_KEYWORD.has(prevToken.type)) { + if (BREAK_OR_CONTINUE.has(prevNode.parent.type)) { + return false; + } + const keyword = prevToken.value; + const nodeType = NODE_TYPES_BY_KEYWORD[keyword]; + return prevNode.type !== nodeType; + } + if (prevToken.type === utils_1.AST_TOKEN_TYPES.String) { + return !DECLARATIONS.has(prevNode.parent.type); + } + return true; +} +//# sourceMappingURL=needsPrecedingSemiColon.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.d.ts new file mode 100644 index 00000000..2e97c6b6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.d.ts @@ -0,0 +1,7 @@ +import type * as ts from 'typescript'; +export declare enum Awaitable { + Always = 0, + Never = 1, + May = 2 +} +export declare function needsToBeAwaited(checker: ts.TypeChecker, node: ts.Node, type: ts.Type): Awaitable; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.js new file mode 100644 index 00000000..d2a89b02 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/needsToBeAwaited.js @@ -0,0 +1,64 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Awaitable = void 0; +exports.needsToBeAwaited = needsToBeAwaited; +const type_utils_1 = require("@typescript-eslint/type-utils"); +const tsutils = __importStar(require("ts-api-utils")); +const getConstraintInfo_1 = require("./getConstraintInfo"); +var Awaitable; +(function (Awaitable) { + Awaitable[Awaitable["Always"] = 0] = "Always"; + Awaitable[Awaitable["Never"] = 1] = "Never"; + Awaitable[Awaitable["May"] = 2] = "May"; +})(Awaitable || (exports.Awaitable = Awaitable = {})); +function needsToBeAwaited(checker, node, type) { + const { constraintType, isTypeParameter } = (0, getConstraintInfo_1.getConstraintInfo)(checker, type); + // unconstrained generic types should be treated as unknown + if (isTypeParameter && constraintType == null) { + return Awaitable.May; + } + // `any` and `unknown` types may need to be awaited + if ((0, type_utils_1.isTypeAnyType)(constraintType) || (0, type_utils_1.isTypeUnknownType)(constraintType)) { + return Awaitable.May; + } + // 'thenable' values should always be be awaited + if (tsutils.isThenableType(checker, node, constraintType)) { + return Awaitable.Always; + } + // anything else should not be awaited + return Awaitable.Never; +} +//# sourceMappingURL=needsToBeAwaited.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.d.ts new file mode 100644 index 00000000..96979cae --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.d.ts @@ -0,0 +1,3 @@ +export declare function objectForEachKey>(obj: T, callback: (key: keyof T) => void): void; +export declare function objectMapKey, Return>(obj: T, callback: (key: keyof T) => Return): Return[]; +export declare function objectReduceKey, Accumulator>(obj: T, callback: (acc: Accumulator, key: keyof T) => Accumulator, initial: Accumulator): Accumulator; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.js new file mode 100644 index 00000000..d10f56f9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/objectIterators.js @@ -0,0 +1,26 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.objectForEachKey = objectForEachKey; +exports.objectMapKey = objectMapKey; +exports.objectReduceKey = objectReduceKey; +function objectForEachKey(obj, callback) { + const keys = Object.keys(obj); + for (const key of keys) { + callback(key); + } +} +function objectMapKey(obj, callback) { + const values = []; + objectForEachKey(obj, key => { + values.push(callback(key)); + }); + return values; +} +function objectReduceKey(obj, callback, initial) { + let accumulator = initial; + objectForEachKey(obj, key => { + accumulator = callback(accumulator, key); + }); + return accumulator; +} +//# sourceMappingURL=objectIterators.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts new file mode 100644 index 00000000..aa6db943 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts @@ -0,0 +1,27 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'; +/** + * Parses a syntactically possible `Promise.then()` call. Does not check the + * type of the callee. + */ +export declare function parseThenCall(node: TSESTree.CallExpression, context: RuleContext): { + onFulfilled?: TSESTree.Expression | undefined; + onRejected?: TSESTree.Expression | undefined; + object: TSESTree.Expression; +} | undefined; +/** + * Parses a syntactically possible `Promise.catch()` call. Does not check the + * type of the callee. + */ +export declare function parseCatchCall(node: TSESTree.CallExpression, context: RuleContext): { + onRejected?: TSESTree.Expression | undefined; + object: TSESTree.Expression; +} | undefined; +/** + * Parses a syntactically possible `Promise.finally()` call. Does not check the + * type of the callee. + */ +export declare function parseFinallyCall(node: TSESTree.CallExpression, context: RuleContext): { + object: TSESTree.Expression; + onFinally?: TSESTree.Expression | undefined; +} | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.js new file mode 100644 index 00000000..54c5aba3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.js @@ -0,0 +1,99 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseThenCall = parseThenCall; +exports.parseCatchCall = parseCatchCall; +exports.parseFinallyCall = parseFinallyCall; +const utils_1 = require("@typescript-eslint/utils"); +const misc_1 = require("./misc"); +/** + * Parses a syntactically possible `Promise.then()` call. Does not check the + * type of the callee. + */ +function parseThenCall(node, context) { + if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) { + const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context); + if (methodName === 'then') { + if (node.arguments.length >= 1) { + if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) { + return { + object: node.callee.object, + }; + } + if (node.arguments.length >= 2) { + if (node.arguments[1].type === utils_1.AST_NODE_TYPES.SpreadElement) { + return { + object: node.callee.object, + onFulfilled: node.arguments[0], + }; + } + return { + object: node.callee.object, + onFulfilled: node.arguments[0], + onRejected: node.arguments[1], + }; + } + return { + object: node.callee.object, + onFulfilled: node.arguments[0], + }; + } + return { + object: node.callee.object, + }; + } + } + return undefined; +} +/** + * Parses a syntactically possible `Promise.catch()` call. Does not check the + * type of the callee. + */ +function parseCatchCall(node, context) { + if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) { + const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context); + if (methodName === 'catch') { + if (node.arguments.length >= 1) { + if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) { + return { + object: node.callee.object, + }; + } + return { + object: node.callee.object, + onRejected: node.arguments[0], + }; + } + return { + object: node.callee.object, + }; + } + } + return undefined; +} +/** + * Parses a syntactically possible `Promise.finally()` call. Does not check the + * type of the callee. + */ +function parseFinallyCall(node, context) { + if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) { + const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context); + if (methodName === 'finally') { + if (node.arguments.length >= 1) { + if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) { + return { + object: node.callee.object, + }; + } + return { + object: node.callee.object, + onFinally: node.arguments[0], + }; + } + return { + object: node.callee.object, + }; + } + } + return undefined; +} +//# sourceMappingURL=promiseUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.d.ts new file mode 100644 index 00000000..73a8df91 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.d.ts @@ -0,0 +1,2 @@ +import type { TSESLint, TSESTree } from '@typescript-eslint/utils'; +export declare function rangeToLoc(sourceCode: TSESLint.SourceCode, range: TSESLint.AST.Range): TSESTree.SourceLocation; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.js new file mode 100644 index 00000000..3f126be5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/rangeToLoc.js @@ -0,0 +1,10 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.rangeToLoc = rangeToLoc; +function rangeToLoc(sourceCode, range) { + return { + end: sourceCode.getLocFromIndex(range[1]), + start: sourceCode.getLocFromIndex(range[0]), + }; +} +//# sourceMappingURL=rangeToLoc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.d.ts new file mode 100644 index 00000000..978f6c87 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.d.ts @@ -0,0 +1,5 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +/** + * Recursively checks whether a given reference is used in a type predicate (e.g., `arg is string`) + */ +export declare function referenceContainsTypePredicate(node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.js new file mode 100644 index 00000000..64bddb4c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypePredicate.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.referenceContainsTypePredicate = referenceContainsTypePredicate; +const utils_1 = require("@typescript-eslint/utils"); +/** + * Recursively checks whether a given reference is used in a type predicate (e.g., `arg is string`) + */ +function referenceContainsTypePredicate(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSTypePredicate: + return true; + case utils_1.AST_NODE_TYPES.TSQualifiedName: + case utils_1.AST_NODE_TYPES.Identifier: + return referenceContainsTypePredicate(node.parent); + default: + return false; + } +} +//# sourceMappingURL=referenceContainsTypePredicate.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.d.ts new file mode 100644 index 00000000..75525949 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.d.ts @@ -0,0 +1,5 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +/** + * Recursively checks whether a given reference has a type query declaration among its parents + */ +export declare function referenceContainsTypeQuery(node: TSESTree.Node): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.js new file mode 100644 index 00000000..0ae36860 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/referenceContainsTypeQuery.js @@ -0,0 +1,20 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.referenceContainsTypeQuery = referenceContainsTypeQuery; +const utils_1 = require("@typescript-eslint/utils"); +/** + * Recursively checks whether a given reference has a type query declaration among its parents + */ +function referenceContainsTypeQuery(node) { + switch (node.type) { + case utils_1.AST_NODE_TYPES.TSTypeQuery: + return true; + case utils_1.AST_NODE_TYPES.TSQualifiedName: + case utils_1.AST_NODE_TYPES.Identifier: + return referenceContainsTypeQuery(node.parent); + default: + // if we find a different node, there's no chance that we're in a TSTypeQuery + return false; + } +} +//# sourceMappingURL=referenceContainsTypeQuery.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.d.ts new file mode 100644 index 00000000..e33aae17 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.d.ts @@ -0,0 +1,3 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type { SourceCode } from '@typescript-eslint/utils/ts-eslint'; +export declare function isReferenceToGlobalFunction(calleeName: string, node: TSESTree.Node, sourceCode: SourceCode): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.js new file mode 100644 index 00000000..18ff6c1d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/scopeUtils.js @@ -0,0 +1,11 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isReferenceToGlobalFunction = isReferenceToGlobalFunction; +function isReferenceToGlobalFunction(calleeName, node, sourceCode) { + const ref = sourceCode + .getScope(node) + .references.find(ref => ref.identifier.name === calleeName); + // ensure it's the "global" version + return !ref?.resolved?.defs.length; +} +//# sourceMappingURL=scopeUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.d.ts new file mode 100644 index 00000000..e2b4fe13 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.d.ts @@ -0,0 +1,2 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +export declare function skipChainExpression(node: T): T | TSESTree.ChainElement; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.js new file mode 100644 index 00000000..bd69a639 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/skipChainExpression.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.skipChainExpression = skipChainExpression; +const utils_1 = require("@typescript-eslint/utils"); +function skipChainExpression(node) { + return node.type === utils_1.AST_NODE_TYPES.ChainExpression ? node.expression : node; +} +//# sourceMappingURL=skipChainExpression.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.d.ts new file mode 100644 index 00000000..93f7c290 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.d.ts @@ -0,0 +1,3 @@ +import * as ts from 'typescript'; +export declare const isPossiblyFalsy: (type: ts.Type) => boolean; +export declare const isPossiblyTruthy: (type: ts.Type) => boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.js new file mode 100644 index 00000000..fe8931ef --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.js @@ -0,0 +1,61 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isPossiblyTruthy = exports.isPossiblyFalsy = void 0; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const getValueOfLiteralType_1 = require("./getValueOfLiteralType"); +// Truthiness utilities +const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) || + (type.isLiteral() && !!(0, getValueOfLiteralType_1.getValueOfLiteralType)(type)); +const isPossiblyFalsy = (type) => tsutils + .unionConstituents(type) + // Intersections like `string & {}` can also be possibly falsy, + // requiring us to look into the intersection. + .flatMap(type => tsutils.intersectionConstituents(type)) + // PossiblyFalsy flag includes literal values, so exclude ones that + // are definitely truthy + .filter(t => !isTruthyLiteral(t)) + .some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy)); +exports.isPossiblyFalsy = isPossiblyFalsy; +const isPossiblyTruthy = (type) => tsutils + .unionConstituents(type) + .map(type => tsutils.intersectionConstituents(type)) + .some(intersectionParts => +// It is possible to define intersections that are always falsy, +// like `"" & { __brand: string }`. +intersectionParts.every(type => !tsutils.isFalsyType(type))); +exports.isPossiblyTruthy = isPossiblyTruthy; +//# sourceMappingURL=truthinessUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.d.ts new file mode 100644 index 00000000..f75d67ce --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.d.ts @@ -0,0 +1,2 @@ +export type MakeRequired = Omit & Required>>; +export type ValueOf = T[keyof T]; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.js new file mode 100644 index 00000000..11e638d1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.d.ts new file mode 100644 index 00000000..fa8c6f02 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.d.ts @@ -0,0 +1,7 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +/** + * Yields all statement nodes in a block, including nested blocks. + * + * You can use it to find all return statements in a function body. + */ +export declare function walkStatements(body: readonly TSESTree.Statement[]): Generator; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.js b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.js new file mode 100644 index 00000000..660960af --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.js @@ -0,0 +1,57 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.walkStatements = walkStatements; +const utils_1 = require("@typescript-eslint/utils"); +/** + * Yields all statement nodes in a block, including nested blocks. + * + * You can use it to find all return statements in a function body. + */ +function* walkStatements(body) { + for (const statement of body) { + switch (statement.type) { + case utils_1.AST_NODE_TYPES.BlockStatement: { + yield* walkStatements(statement.body); + continue; + } + case utils_1.AST_NODE_TYPES.SwitchStatement: { + for (const switchCase of statement.cases) { + yield* walkStatements(switchCase.consequent); + } + continue; + } + case utils_1.AST_NODE_TYPES.IfStatement: { + yield* walkStatements([statement.consequent]); + if (statement.alternate) { + yield* walkStatements([statement.alternate]); + } + continue; + } + case utils_1.AST_NODE_TYPES.WhileStatement: + case utils_1.AST_NODE_TYPES.DoWhileStatement: + case utils_1.AST_NODE_TYPES.ForStatement: + case utils_1.AST_NODE_TYPES.ForInStatement: + case utils_1.AST_NODE_TYPES.ForOfStatement: + case utils_1.AST_NODE_TYPES.WithStatement: + case utils_1.AST_NODE_TYPES.LabeledStatement: { + yield* walkStatements([statement.body]); + continue; + } + case utils_1.AST_NODE_TYPES.TryStatement: { + yield* walkStatements([statement.block]); + if (statement.handler) { + yield* walkStatements([statement.handler.body]); + } + if (statement.finalizer) { + yield* walkStatements([statement.finalizer]); + } + continue; + } + default: { + yield statement; + continue; + } + } + } +} +//# sourceMappingURL=walkStatements.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/index.d.ts new file mode 100644 index 00000000..756a025e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/index.d.ts @@ -0,0 +1,13 @@ +import type { + ClassicConfig, + FlatConfig, +} from '@typescript-eslint/utils/ts-eslint'; + +import type rules from './rules'; + +declare const cjsExport: { + configs: Record; + meta: FlatConfig.PluginMeta; + rules: typeof rules; +}; +export = cjsExport; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsc b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsc new file mode 100755 index 00000000..c496de53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsc @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsserver b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsserver new file mode 100755 index 00000000..49048b89 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/node_modules/.bin/tsserver @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/package.json b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/package.json new file mode 100644 index 00000000..72ba3820 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/package.json @@ -0,0 +1,135 @@ +{ + "name": "@typescript-eslint/eslint-plugin", + "version": "8.70.1", + "description": "TypeScript plugin for ESLint", + "files": [ + "dist", + "!**/*.js.map", + "!**/*.tsbuildinfo", + "index.d.ts", + "raw-plugin.d.ts", + "rules.d.ts" + ], + "type": "commonjs", + "exports": { + ".": { + "types": "./index.d.ts", + "default": "./dist/index.js" + }, + "./package.json": "./package.json", + "./use-at-your-own-risk/rules": { + "types": "./rules.d.ts", + "default": "./dist/rules/index.js" + }, + "./use-at-your-own-risk/raw-plugin": { + "types": "./raw-plugin.d.ts", + "default": "./dist/raw-plugin.js" + } + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/typescript-eslint/typescript-eslint.git", + "directory": "packages/eslint-plugin" + }, + "bugs": { + "url": "https://github.com/typescript-eslint/typescript-eslint/issues" + }, + "homepage": "https://typescript-eslint.io/packages/eslint-plugin", + "license": "MIT", + "keywords": [ + "eslint", + "eslintplugin", + "eslint-plugin", + "typescript" + ], + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/type-utils": "8.70.1", + "@typescript-eslint/utils": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1", + "ignore": "^7.0.5", + "natural-compare": "^1.4.0", + "ts-api-utils": "^2.5.0" + }, + "devDependencies": { + "@types/json-schema": "^7.0.15", + "@types/mdast": "^4.0.4", + "@types/natural-compare": "^1.4.3", + "@types/react": "^18.3.21", + "@typescript-eslint/rule-schema-to-typescript-types": "8.70.1", + "@typescript-eslint/rule-tester": "8.70.1", + "@typescript/native": "npm:typescript@^7.0.2", + "@vitest/coverage-v8": "^4.0.18", + "ajv": "^6.12.6", + "eslint": "^10.0.0", + "json-schema": "^0.4.0", + "markdown-table": "^3.0.4", + "marked": "^15.0.12", + "mdast-util-from-markdown": "^2.0.2", + "mdast-util-mdx": "^3.0.0", + "micromark-extension-mdxjs": "^3.0.0", + "prettier": "3.9.5", + "rimraf": "^5.0.10", + "title-case": "^4.3.2", + "tsx": "^4.7.2", + "typescript": ">=4.8.4 <6.1.0", + "unist-util-visit": "^5.0.0", + "vitest": "^4.0.18" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^8.70.1", + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "nx": { + "name": "eslint-plugin", + "includedScripts": [ + "clean" + ], + "targets": { + "generate-breaking-changes": { + "command": "tsx tools/generate-breaking-changes.mts", + "dependsOn": [ + "type-utils:build" + ], + "options": { + "cwd": "{projectRoot}" + } + }, + "lint": { + "command": "eslint" + }, + "typecheck:tsgo": {}, + "attw-check": { + "cache": false, + "dependsOn": [ + "build" + ], + "command": "pnpm pack --out attw-check.tgz && attw attw-check.tgz --profile node16 --exclude-entrypoints use-at-your-own-risk/raw-plugin --exclude-entrypoints use-at-your-own-risk/rules --ignore-rules named-exports", + "options": { + "cwd": "{projectRoot}" + } + } + } + }, + "scripts": { + "build": "pnpm -w exec nx build", + "clean": "rimraf dist/ coverage/", + "format": "pnpm -w run format", + "generate-breaking-changes": "tsx tools/generate-breaking-changes.mts", + "generate-configs": "pnpm -w run generate-configs", + "lint": "pnpm -w exec nx lint", + "test": "pnpm -w exec nx test", + "typecheck": "pnpm -w exec nx typecheck", + "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo", + "attw-check": "pnpm -w exec nx attw-check" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/raw-plugin.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/raw-plugin.d.ts new file mode 100644 index 00000000..25a093ab --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/raw-plugin.d.ts @@ -0,0 +1,25 @@ +import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'; + +import type plugin from './index'; + +declare const cjsExport: { + flatConfigs: { + 'flat/all': FlatConfig.ConfigArray; + 'flat/base': FlatConfig.Config; + 'flat/disable-type-checked': FlatConfig.Config; + 'flat/eslint-recommended': FlatConfig.Config; + 'flat/recommended': FlatConfig.ConfigArray; + 'flat/recommended-type-checked': FlatConfig.ConfigArray; + 'flat/recommended-type-checked-only': FlatConfig.ConfigArray; + 'flat/strict': FlatConfig.ConfigArray; + 'flat/strict-type-checked': FlatConfig.ConfigArray; + 'flat/strict-type-checked-only': FlatConfig.ConfigArray; + 'flat/stylistic': FlatConfig.ConfigArray; + 'flat/stylistic-type-checked': FlatConfig.ConfigArray; + 'flat/stylistic-type-checked-only': FlatConfig.ConfigArray; + }; + parser: FlatConfig.Parser; + plugin: typeof plugin; +}; + +export = cjsExport; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/rules.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/rules.d.ts new file mode 100644 index 00000000..db19c5d6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/eslint-plugin/rules.d.ts @@ -0,0 +1,87 @@ +/* +We purposely don't generate types for our plugin because TL;DR: +1) there's no real reason that anyone should do a typed import of our rules, +2) it would require us to change our code so there aren't as many inferred types + +This type declaration exists as a hacky way to add a type to the export for our +internal packages that require it. + +*** Long reason *** + +When you turn on declaration files, TS requires all types to be "fully resolvable" +without changes to the code. +All of our lint rules `export default createRule(...)`, which means they all +implicitly reference the `TSESLint.Rule` type for the export. + +TS wants to transpile each rule file to this `.d.ts` file: + +```ts +import type { TSESLint } from '@typescript-eslint/utils'; +declare const _default: TSESLint.RuleModule; +export default _default; +``` + +Because we don't import `TSESLint` in most files, it means that TS would have to +insert a new import during the declaration emit to make this work. +However TS wants to avoid adding new imports to the file because a new module +could have type side-effects (like global augmentation) which could cause weird +type side-effects in the decl file that wouldn't exist in source TS file. + +So TS errors on most of our rules with the following error: +``` +The inferred type of 'default' cannot be named without a reference to +'../../../../node_modules/@typescript-eslint/utils/src/ts-eslint/Rule'. +This is likely not portable. A type annotation is necessary. ts(2742) +``` +*/ +/* eslint-disable no-restricted-syntax */ + +import type { + RuleModuleWithMetaDocs, + RuleRecommendation, + RuleRecommendationAcrossConfigs, +} from '@typescript-eslint/utils/ts-eslint'; + +interface ESLintPluginDocs { + /** + * Does the rule extend (or is it based off of) an ESLint code rule? + * Alternately accepts the name of the base rule, in case the rule has been renamed. + * This is only used for documentation purposes. + */ + extendsBaseRule?: boolean | string; + + /** + * If a string config name, which starting config this rule is enabled in. + * If an object, which settings it has enabled in each of those configs. + */ + recommended?: RuleRecommendation | RuleRecommendationAcrossConfigs; + + /** + * Does the rule require us to create a full TypeScript Program in order for it + * to type-check code. This is only used for documentation purposes. + */ + requiresTypeChecking?: boolean; +} + +type ESLintPluginRuleModule = RuleModuleWithMetaDocs< + string, + readonly unknown[], + ESLintPluginDocs +>; + +type TypeScriptESLintRules = Record< + string, + RuleModuleWithMetaDocs +>; + +declare const rules: TypeScriptESLintRules; + +declare namespace rules { + export type { + ESLintPluginDocs, + ESLintPluginRuleModule, + TypeScriptESLintRules, + }; +} + +export = rules; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/parser b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/parser new file mode 120000 index 00000000..86b398ca --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/parser @@ -0,0 +1 @@ +../../../@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/scope-manager b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/scope-manager new file mode 120000 index 00000000..4ca59d35 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/scope-manager @@ -0,0 +1 @@ +../../../@typescript-eslint+scope-manager@8.70.1/node_modules/@typescript-eslint/scope-manager \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/type-utils b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/type-utils new file mode 120000 index 00000000..da9ce68c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/type-utils @@ -0,0 +1 @@ +../../../@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/utils b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/utils new file mode 120000 index 00000000..bc1adc1b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/utils @@ -0,0 +1 @@ +../../../@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/visitor-keys b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/visitor-keys new file mode 120000 index 00000000..7142a334 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/@typescript-eslint/visitor-keys @@ -0,0 +1 @@ +../../../@typescript-eslint+visitor-keys@8.70.1/node_modules/@typescript-eslint/visitor-keys \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/eslint b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ignore b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ignore new file mode 120000 index 00000000..817c32d3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ignore @@ -0,0 +1 @@ +../../ignore@7.0.10/node_modules/ignore \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/natural-compare b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/natural-compare new file mode 120000 index 00000000..1d16aca8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/natural-compare @@ -0,0 +1 @@ +../../natural-compare@1.4.0/node_modules/natural-compare \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ts-api-utils b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ts-api-utils new file mode 120000 index 00000000..876bf58a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/ts-api-utils @@ -0,0 +1 @@ +../../ts-api-utils@2.5.0_typescript@6.0.3/node_modules/ts-api-utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/typescript b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/typescript new file mode 120000 index 00000000..b491b2a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+eslint-plugin@8.70.1_@typescript-eslint+parser@8.70.1_eslint@10.11.0_537f5d268ba95777736ff8dec60eadb4/node_modules/typescript @@ -0,0 +1 @@ +../../typescript@6.0.3/node_modules/typescript \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/LICENSE b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/LICENSE new file mode 100644 index 00000000..a1164108 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 typescript-eslint and other contributors + +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/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/README.md b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/README.md new file mode 100644 index 00000000..56ee655a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/README.md @@ -0,0 +1,12 @@ +# `@typescript-eslint/parser` + +> An ESLint parser which leverages TypeScript ESTree to allow for ESLint to lint TypeScript source code. + +[![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/parser.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/parser) +[![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/parser.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/parser) + +👉 See **https://typescript-eslint.io/packages/parser** for documentation on this package. + +> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code. + + diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.d.ts new file mode 100644 index 00000000..bd61733b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.d.ts @@ -0,0 +1,7 @@ +export { parse, parseForESLint, type ParserOptions } from './parser'; +export { clearCaches, createProgram, type ParserServices, type ParserServicesWithoutTypeInformation, type ParserServicesWithTypeInformation, withoutProjectParserOptions, } from '@typescript-eslint/typescript-estree'; +export declare const version: string; +export declare const meta: { + name: string; + version: string; +}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.js b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.js new file mode 100644 index 00000000..05b0fa32 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/index.js @@ -0,0 +1,65 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.meta = exports.version = exports.withoutProjectParserOptions = exports.createProgram = exports.clearCaches = exports.parseForESLint = exports.parse = void 0; +const ts = __importStar(require("typescript")); +// intentionally executing code before rest of the require()s. This will not work with ESM. +const [versionMajor, _versionMinor] = ts.versionMajorMinor + .split('.') + .map(Number); +if (versionMajor >= 7) { + // eslint-disable-next-line no-console + console.error([ + 'typescript-eslint does not support TS 7.0.', + 'Please see https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/#running-side-by-side-with-typescript-6.0 to run typescript-eslint using the TS 6 API.', + "See also https://github.com/typescript-eslint/typescript-eslint/issues/10940 for tracking typescript-eslint's support for TS >=7.1", + ].join('\n')); + throw new Error('typescript-eslint does not support TS 7.0.'); +} +var parser_1 = require("./parser"); +Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } }); +Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } }); +var typescript_estree_1 = require("@typescript-eslint/typescript-estree"); +Object.defineProperty(exports, "clearCaches", { enumerable: true, get: function () { return typescript_estree_1.clearCaches; } }); +Object.defineProperty(exports, "createProgram", { enumerable: true, get: function () { return typescript_estree_1.createProgram; } }); +Object.defineProperty(exports, "withoutProjectParserOptions", { enumerable: true, get: function () { return typescript_estree_1.withoutProjectParserOptions; } }); +// note - cannot migrate this to an import statement because it will make TSC copy the package.json to the dist folder +// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access +exports.version = require('../package.json').version; +exports.meta = { + name: 'typescript-eslint/parser', + version: exports.version, +}; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.d.ts new file mode 100644 index 00000000..3dd68c06 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.d.ts @@ -0,0 +1,22 @@ +import type { ScopeManager } from '@typescript-eslint/scope-manager'; +import type { ParserOptions, TSESTree } from '@typescript-eslint/types'; +import type { AST, ParserServices } from '@typescript-eslint/typescript-estree'; +import type { VisitorKeys } from '@typescript-eslint/visitor-keys'; +import type * as ts from 'typescript'; +interface ESLintProgram extends AST<{ + comment: true; + tokens: true; +}> { + comments: TSESTree.Comment[]; + range: [number, number]; + tokens: TSESTree.Token[]; +} +interface ParseForESLintResult { + ast: ESLintProgram; + scopeManager: ScopeManager; + services: ParserServices; + visitorKeys: VisitorKeys; +} +export declare function parse(code: string | ts.SourceFile, options?: ParserOptions): ParseForESLintResult['ast']; +export declare function parseForESLint(code: string | ts.SourceFile, parserOptions?: ParserOptions | null): ParseForESLintResult; +export type { ParserOptions } from '@typescript-eslint/types'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.js b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.js new file mode 100644 index 00000000..85cc4c38 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/dist/parser.js @@ -0,0 +1,150 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = parse; +exports.parseForESLint = parseForESLint; +const scope_manager_1 = require("@typescript-eslint/scope-manager"); +const typescript_estree_1 = require("@typescript-eslint/typescript-estree"); +const visitor_keys_1 = require("@typescript-eslint/visitor-keys"); +const debug_1 = __importDefault(require("debug")); +const typescript_1 = require("typescript"); +const log = (0, debug_1.default)('typescript-eslint:parser:parser'); +function validateBoolean(value, fallback = false) { + if (typeof value !== 'boolean') { + return fallback; + } + return value; +} +const LIB_FILENAME_REGEX = /lib\.(.+)\.d\.[cm]?ts$/; +function getLib(compilerOptions) { + if (compilerOptions.lib) { + return compilerOptions.lib + .map(lib => LIB_FILENAME_REGEX.exec(lib.toLowerCase())?.[1]) + .filter((lib) => !!lib); + } + const defaultTarget = typescript_estree_1.typescriptVersionIsAtLeast['6.0'] + ? typescript_1.ScriptTarget.LatestStandard + : typescript_1.ScriptTarget.ES5; // eslint-disable-line @typescript-eslint/no-deprecated -- Deprecated in TS 6 but we support TS < 6 + const target = compilerOptions.target ?? defaultTarget; + // https://github.com/microsoft/TypeScript/blob/35ff23d4b0cc715691323ebe54f523c16fe6e3a5/src/compiler/utilitiesPublic.ts#L312-L346 + switch (target) { + case typescript_1.ScriptTarget.ES2015: + return ['es6']; + case typescript_1.ScriptTarget.ES2016: + return ['es2016.full']; + case typescript_1.ScriptTarget.ES2017: + return ['es2017.full']; + case typescript_1.ScriptTarget.ES2018: + return ['es2018.full']; + case typescript_1.ScriptTarget.ES2019: + return ['es2019.full']; + case typescript_1.ScriptTarget.ES2020: + return ['es2020.full']; + case typescript_1.ScriptTarget.ES2021: + return ['es2021.full']; + case typescript_1.ScriptTarget.ES2022: + return ['es2022.full']; + case typescript_1.ScriptTarget.ES2023: + return ['es2023.full']; + case typescript_1.ScriptTarget.ES2024: + return ['es2024.full']; + case typescript_1.ScriptTarget.ES2025: + return ['es2025.full']; + case typescript_1.ScriptTarget.ESNext: + return ['esnext.full']; + default: + return ['lib']; + } +} +function parse(code, options) { + return parseForESLint(code, options).ast; +} +function parseForESLint(code, parserOptions) { + if (!parserOptions || typeof parserOptions !== 'object') { + parserOptions = {}; + } + else { + parserOptions = { ...parserOptions }; + } + // https://eslint.org/docs/user-guide/configuring#specifying-parser-options + // if sourceType is not provided by default eslint expect that it will be set to "script" + if (parserOptions.sourceType !== 'module' && + parserOptions.sourceType !== 'script') { + parserOptions.sourceType = 'script'; + } + if (typeof parserOptions.ecmaFeatures !== 'object') { + parserOptions.ecmaFeatures = {}; + } + if (parserOptions.onUnsupportedTypeScriptVersion != null && + // eslint-disable-next-line @typescript-eslint/no-deprecated -- read for backwards compatibility + parserOptions.warnOnUnsupportedTypeScriptVersion != null) { + throw new Error('Cannot use both the `onUnsupportedTypeScriptVersion` and the deprecated `warnOnUnsupportedTypeScriptVersion` options. Please use only `onUnsupportedTypeScriptVersion`.'); + } + const onUnsupportedTypeScriptVersion = parserOptions.onUnsupportedTypeScriptVersion ?? + // eslint-disable-next-line @typescript-eslint/no-deprecated -- read for backwards compatibility + (validateBoolean(parserOptions.warnOnUnsupportedTypeScriptVersion, true) + ? 'warn' + : 'ignore'); + const tsestreeOptions = { + jsx: validateBoolean(parserOptions.ecmaFeatures.jsx), + ...parserOptions, + onUnsupportedTypeScriptVersion, + // Override errorOnTypeScriptSyntacticAndSemanticIssues and set it to false to prevent use from user config + // https://github.com/typescript-eslint/typescript-eslint/issues/8681#issuecomment-2000411834 + errorOnTypeScriptSyntacticAndSemanticIssues: false, + // comment, loc, range, and tokens should always be set for ESLint usage + // https://github.com/typescript-eslint/typescript-eslint/issues/8347 + comment: true, + loc: true, + range: true, + tokens: true, + }; + const analyzeOptions = { + globalReturn: parserOptions.ecmaFeatures.globalReturn, + jsxFragmentName: parserOptions.jsxFragmentName, + jsxPragma: parserOptions.jsxPragma, + lib: parserOptions.lib, + sourceType: parserOptions.sourceType, + }; + const { ast, services } = (0, typescript_estree_1.parseAndGenerateServices)(code, tsestreeOptions); + ast.sourceType = parserOptions.sourceType; + if (services.program) { + // automatically apply the options configured for the program + const compilerOptions = services.program.getCompilerOptions(); + if (analyzeOptions.lib == null) { + analyzeOptions.lib = getLib(compilerOptions); + log('Resolved libs from program: %o', analyzeOptions.lib); + } + if ( + // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish + analyzeOptions.jsxPragma === undefined && + compilerOptions.jsxFactory != null) { + // in case the user has specified something like "preact.h" + const factory = compilerOptions.jsxFactory.split('.')[0].trim(); + analyzeOptions.jsxPragma = factory; + log('Resolved jsxPragma from program: %s', analyzeOptions.jsxPragma); + } + if ( + // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish + analyzeOptions.jsxFragmentName === undefined && + compilerOptions.jsxFragmentFactory != null) { + // in case the user has specified something like "preact.Fragment" + const fragFactory = compilerOptions.jsxFragmentFactory + .split('.')[0] + .trim(); + analyzeOptions.jsxFragmentName = fragFactory; + log('Resolved jsxFragmentName from program: %s', analyzeOptions.jsxFragmentName); + } + } + const scopeManager = (0, scope_manager_1.analyze)(ast, analyzeOptions); + // if not defined - override from the parserOptions + services.emitDecoratorMetadata ??= + parserOptions.emitDecoratorMetadata === true; + services.experimentalDecorators ??= + parserOptions.experimentalDecorators === true; + services.isolatedDeclarations ??= parserOptions.isolatedDeclarations === true; + return { ast, scopeManager, services, visitorKeys: visitor_keys_1.visitorKeys }; +} +//# sourceMappingURL=parser.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsc b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsc new file mode 100755 index 00000000..c496de53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsc @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsserver b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsserver new file mode 100755 index 00000000..49048b89 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/node_modules/.bin/tsserver @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/package.json b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/package.json new file mode 100644 index 00000000..cf133391 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/parser/package.json @@ -0,0 +1,87 @@ +{ + "name": "@typescript-eslint/parser", + "version": "8.70.1", + "description": "An ESLint custom parser which leverages TypeScript ESTree", + "files": [ + "dist", + "!**/*.js.map", + "!**/*.tsbuildinfo" + ], + "type": "commonjs", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/typescript-eslint/typescript-eslint.git", + "directory": "packages/parser" + }, + "bugs": { + "url": "https://github.com/typescript-eslint/typescript-eslint/issues" + }, + "homepage": "https://typescript-eslint.io/packages/parser", + "license": "MIT", + "keywords": [ + "ast", + "ecmascript", + "javascript", + "typescript", + "parser", + "syntax", + "eslint" + ], + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + }, + "dependencies": { + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1", + "@typescript-eslint/visitor-keys": "8.70.1", + "debug": "^4.4.3" + }, + "devDependencies": { + "@typescript/native": "npm:typescript@^7.0.2", + "@vitest/coverage-v8": "^4.0.18", + "eslint": "^10.0.0", + "glob": "^11.1.0", + "rimraf": "^5.0.10", + "typescript": ">=4.8.4 <6.1.0", + "vitest": "^4.0.18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "nx": { + "name": "parser", + "includedScripts": [ + "clean" + ], + "targets": { + "lint": { + "command": "eslint" + }, + "typecheck:tsgo": {}, + "attw-check": {} + } + }, + "scripts": { + "build": "pnpm exec nx build", + "clean": "rimraf dist/ coverage/", + "format": "pnpm -w run format", + "lint": "pnpm -w exec nx lint", + "test": "pnpm -w exec nx test", + "typecheck": "pnpm -w exec nx typecheck", + "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo", + "attw-check": "pnpm -w exec nx attw-check" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager new file mode 120000 index 00000000..4ca59d35 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager @@ -0,0 +1 @@ +../../../@typescript-eslint+scope-manager@8.70.1/node_modules/@typescript-eslint/scope-manager \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types new file mode 120000 index 00000000..66be4b7c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types @@ -0,0 +1 @@ +../../../@typescript-eslint+types@8.70.1/node_modules/@typescript-eslint/types \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree new file mode 120000 index 00000000..901511ee --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree @@ -0,0 +1 @@ +../../../@typescript-eslint+typescript-estree@8.70.1_typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/visitor-keys b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/visitor-keys new file mode 120000 index 00000000..7142a334 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/visitor-keys @@ -0,0 +1 @@ +../../../@typescript-eslint+visitor-keys@8.70.1/node_modules/@typescript-eslint/visitor-keys \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug new file mode 120000 index 00000000..6b438e1c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug @@ -0,0 +1 @@ +../../debug@4.4.3/node_modules/debug \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript new file mode 120000 index 00000000..b491b2a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+parser@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript @@ -0,0 +1 @@ +../../typescript@6.0.3/node_modules/typescript \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/LICENSE b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/LICENSE new file mode 100644 index 00000000..dabd464a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 typescript-eslint and other contributors + +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/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/README.md b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/README.md new file mode 100644 index 00000000..c5d32797 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/README.md @@ -0,0 +1,12 @@ +# `@typescript-eslint/type-utils` + +> Type utilities for working with TypeScript within ESLint rules. + +[![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils) +[![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils) + +The utilities in this package are separated from `@typescript-eslint/utils` so that that package does not require a dependency on `typescript`. + +> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code. + + diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.d.ts new file mode 100644 index 00000000..7f16cfe7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.d.ts @@ -0,0 +1,132 @@ +import type { TSESTree } from '@typescript-eslint/types'; +import type * as ts from 'typescript'; +/** + * Describes specific types or values declared in local files. + * See [TypeOrValueSpecifier > FileSpecifier](/packages/type-utils/type-or-value-specifier#filespecifier). + */ +export interface FileSpecifier { + from: 'file'; + /** + * Type or value name(s) to match on. + */ + name: string | string[]; + /** + * A specific file the types or values must be declared in. + */ + path?: string; +} +/** + * Describes specific types or values declared in TypeScript's built-in lib definitions. + * See [TypeOrValueSpecifier > LibSpecifier](/packages/type-utils/type-or-value-specifier#libspecifier). + */ +export interface LibSpecifier { + from: 'lib'; + /** + * Type or value name(s) to match on. + */ + name: string | string[]; +} +/** + * Describes specific types or values imported from packages. + * See [TypeOrValueSpecifier > PackageSpecifier](/packages/type-utils/type-or-value-specifier#packagespecifier). + */ +export interface PackageSpecifier { + from: 'package'; + /** + * Type or value name(s) to match on. + */ + name: string | string[]; + /** + * Package name the type or value must be declared in. + */ + package: string; +} +/** + * A centralized format for rule options to describe specific _types_ and/or _values_. + * See [TypeOrValueSpecifier](/packages/type-utils/type-or-value-specifier). + */ +export type TypeOrValueSpecifier = string | FileSpecifier | LibSpecifier | PackageSpecifier; +export declare const typeOrValueSpecifiersSchema: { + readonly items: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["file"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + readonly path: { + readonly type: 'string'; + }; + }; + readonly required: ["from", "name"]; + readonly type: 'object'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["lib"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + }; + readonly required: ["from", "name"]; + readonly type: 'object'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["package"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + readonly package: { + readonly type: 'string'; + }; + }; + readonly required: ["from", "name", "package"]; + readonly type: 'object'; + }]; + }; + readonly type: 'array'; +}; +export declare function typeMatchesSpecifier(type: ts.Type, specifier: TypeOrValueSpecifier, program: ts.Program): boolean; +export declare const typeMatchesSomeSpecifier: (type: ts.Type, specifiers: TypeOrValueSpecifier[] | undefined, program: ts.Program) => boolean; +export declare function valueMatchesSpecifier(node: TSESTree.Node, specifier: TypeOrValueSpecifier, program: ts.Program, type: ts.Type): boolean; +export declare const valueMatchesSomeSpecifier: (node: TSESTree.Node, specifiers: TypeOrValueSpecifier[] | undefined, program: ts.Program, type: ts.Type) => boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.js new file mode 100644 index 00000000..fbbeb115 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/TypeOrValueSpecifier.js @@ -0,0 +1,213 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.valueMatchesSomeSpecifier = exports.typeMatchesSomeSpecifier = exports.typeOrValueSpecifiersSchema = void 0; +exports.typeMatchesSpecifier = typeMatchesSpecifier; +exports.valueMatchesSpecifier = valueMatchesSpecifier; +const types_1 = require("@typescript-eslint/types"); +const tsutils = __importStar(require("ts-api-utils")); +const specifierNameMatches_1 = require("./typeOrValueSpecifiers/specifierNameMatches"); +const typeDeclaredInFile_1 = require("./typeOrValueSpecifiers/typeDeclaredInFile"); +const typeDeclaredInLib_1 = require("./typeOrValueSpecifiers/typeDeclaredInLib"); +const typeDeclaredInPackageDeclarationFile_1 = require("./typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile"); +exports.typeOrValueSpecifiersSchema = { + items: { + oneOf: [ + { + type: 'string', + }, + { + additionalProperties: false, + properties: { + from: { + enum: ['file'], + type: 'string', + }, + name: { + oneOf: [ + { + type: 'string', + }, + { + items: { + type: 'string', + }, + minItems: 1, + type: 'array', + uniqueItems: true, + }, + ], + }, + path: { + type: 'string', + }, + }, + required: ['from', 'name'], + type: 'object', + }, + { + additionalProperties: false, + properties: { + from: { + enum: ['lib'], + type: 'string', + }, + name: { + oneOf: [ + { + type: 'string', + }, + { + items: { + type: 'string', + }, + minItems: 1, + type: 'array', + uniqueItems: true, + }, + ], + }, + }, + required: ['from', 'name'], + type: 'object', + }, + { + additionalProperties: false, + properties: { + from: { + enum: ['package'], + type: 'string', + }, + name: { + oneOf: [ + { + type: 'string', + }, + { + items: { + type: 'string', + }, + minItems: 1, + type: 'array', + uniqueItems: true, + }, + ], + }, + package: { + type: 'string', + }, + }, + required: ['from', 'name', 'package'], + type: 'object', + }, + ], + }, + type: 'array', +}; +function typeMatchesSpecifier(type, specifier, program) { + if (tsutils.isUnionType(type)) { + return type.types.every(t => typeMatchesSpecifier(t, specifier, program)); + } + const wholeTypeMatches = (() => { + if (tsutils.isIntrinsicErrorType(type)) { + return false; + } + if (typeof specifier === 'string') { + return (0, specifierNameMatches_1.specifierNameMatches)(type, specifier); + } + if (!(0, specifierNameMatches_1.specifierNameMatches)(type, specifier.name)) { + return false; + } + const symbol = type.getSymbol() ?? type.aliasSymbol; + const declarations = symbol?.getDeclarations() ?? []; + const declarationFiles = declarations.map(declaration => declaration.getSourceFile()); + switch (specifier.from) { + case 'file': + return (0, typeDeclaredInFile_1.typeDeclaredInFile)(specifier.path, declarationFiles, program); + case 'lib': + return (0, typeDeclaredInLib_1.typeDeclaredInLib)(declarationFiles, program); + case 'package': + return (0, typeDeclaredInPackageDeclarationFile_1.typeDeclaredInPackageDeclarationFile)(specifier.package, declarations, declarationFiles, program); + } + })(); + if (wholeTypeMatches) { + return true; + } + if (tsutils.isIntersectionType(type) && + tsutils + .intersectionConstituents(type) + .some(part => typeMatchesSpecifier(part, specifier, program))) { + return true; + } + return false; +} +const typeMatchesSomeSpecifier = (type, specifiers = [], program) => specifiers.some(specifier => typeMatchesSpecifier(type, specifier, program)); +exports.typeMatchesSomeSpecifier = typeMatchesSomeSpecifier; +const getSpecifierNames = (specifierName) => { + return typeof specifierName === 'string' ? [specifierName] : specifierName; +}; +const getStaticName = (node) => { + if (node.type === types_1.AST_NODE_TYPES.Identifier || + node.type === types_1.AST_NODE_TYPES.JSXIdentifier || + node.type === types_1.AST_NODE_TYPES.PrivateIdentifier) { + return node.name; + } + if (node.type === types_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') { + return node.value; + } + return undefined; +}; +function valueMatchesSpecifier(node, specifier, program, type) { + const staticName = getStaticName(node); + if (!staticName) { + return false; + } + if (typeof specifier === 'string') { + return specifier === staticName; + } + if (!getSpecifierNames(specifier.name).includes(staticName)) { + return false; + } + if (specifier.from === 'package') { + const symbol = type.getSymbol() ?? type.aliasSymbol; + const declarations = symbol?.getDeclarations() ?? []; + const declarationFiles = declarations.map(declaration => declaration.getSourceFile()); + return (0, typeDeclaredInPackageDeclarationFile_1.typeDeclaredInPackageDeclarationFile)(specifier.package, declarations, declarationFiles, program); + } + return true; +} +const valueMatchesSomeSpecifier = (node, specifiers = [], program, type) => specifiers.some(specifier => valueMatchesSpecifier(node, specifier, program, type)); +exports.valueMatchesSomeSpecifier = valueMatchesSomeSpecifier; +//# sourceMappingURL=TypeOrValueSpecifier.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.d.ts new file mode 100644 index 00000000..2eba0d83 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.d.ts @@ -0,0 +1,53 @@ +import * as ts from 'typescript'; +/** + * @example + * ```ts + * class DerivedClass extends Promise {} + * DerivedClass.reject + * // ^ PromiseLike + * ``` + */ +export declare function isPromiseLike(program: ts.Program, type: ts.Type): boolean; +/** + * @example + * ```ts + * const value = Promise + * value.reject + * // ^ PromiseConstructorLike + * ``` + */ +export declare function isPromiseConstructorLike(program: ts.Program, type: ts.Type): boolean; +/** + * @example + * ```ts + * class Foo extends Error {} + * new Foo() + * // ^ ErrorLike + * ``` + */ +export declare function isErrorLike(program: ts.Program, type: ts.Type): boolean; +/** + * @example + * ```ts + * type T = Readonly + * // ^ ReadonlyErrorLike + * ``` + */ +export declare function isReadonlyErrorLike(program: ts.Program, type: ts.Type): boolean; +/** + * @example + * ```ts + * type T = Readonly<{ foo: 'bar' }> + * // ^ ReadonlyTypeLike + * ``` + */ +export declare function isReadonlyTypeLike(program: ts.Program, type: ts.Type, predicate?: (subType: { + aliasSymbol: ts.Symbol; + aliasTypeArguments: readonly ts.Type[]; +} & ts.Type) => boolean): boolean; +export declare function isBuiltinTypeAliasLike(program: ts.Program, type: ts.Type, predicate: (subType: { + aliasSymbol: ts.Symbol; + aliasTypeArguments: readonly ts.Type[]; +} & ts.Type) => boolean): boolean; +export declare function isBuiltinSymbolLike(program: ts.Program, type: ts.Type, symbolName: string | string[]): boolean; +export declare function isBuiltinSymbolLikeRecurser(program: ts.Program, type: ts.Type, predicate: (subType: ts.Type) => boolean | null): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.js new file mode 100644 index 00000000..bc424abf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/builtinSymbolLikes.js @@ -0,0 +1,166 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isPromiseLike = isPromiseLike; +exports.isPromiseConstructorLike = isPromiseConstructorLike; +exports.isErrorLike = isErrorLike; +exports.isReadonlyErrorLike = isReadonlyErrorLike; +exports.isReadonlyTypeLike = isReadonlyTypeLike; +exports.isBuiltinTypeAliasLike = isBuiltinTypeAliasLike; +exports.isBuiltinSymbolLike = isBuiltinSymbolLike; +exports.isBuiltinSymbolLikeRecurser = isBuiltinSymbolLikeRecurser; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const isSymbolFromDefaultLibrary_1 = require("./isSymbolFromDefaultLibrary"); +/** + * @example + * ```ts + * class DerivedClass extends Promise {} + * DerivedClass.reject + * // ^ PromiseLike + * ``` + */ +function isPromiseLike(program, type) { + return isBuiltinSymbolLike(program, type, 'Promise'); +} +/** + * @example + * ```ts + * const value = Promise + * value.reject + * // ^ PromiseConstructorLike + * ``` + */ +function isPromiseConstructorLike(program, type) { + return isBuiltinSymbolLike(program, type, 'PromiseConstructor'); +} +/** + * @example + * ```ts + * class Foo extends Error {} + * new Foo() + * // ^ ErrorLike + * ``` + */ +function isErrorLike(program, type) { + return isBuiltinSymbolLike(program, type, 'Error'); +} +/** + * @example + * ```ts + * type T = Readonly + * // ^ ReadonlyErrorLike + * ``` + */ +function isReadonlyErrorLike(program, type) { + return isReadonlyTypeLike(program, type, subtype => { + const [typeArgument] = subtype.aliasTypeArguments; + return (isErrorLike(program, typeArgument) || + isReadonlyErrorLike(program, typeArgument)); + }); +} +/** + * @example + * ```ts + * type T = Readonly<{ foo: 'bar' }> + * // ^ ReadonlyTypeLike + * ``` + */ +function isReadonlyTypeLike(program, type, predicate) { + return isBuiltinTypeAliasLike(program, type, subtype => { + return (subtype.aliasSymbol.getName() === 'Readonly' && !!predicate?.(subtype)); + }); +} +function isBuiltinTypeAliasLike(program, type, predicate) { + return isBuiltinSymbolLikeRecurser(program, type, subtype => { + const { aliasSymbol, aliasTypeArguments } = subtype; + if (!aliasSymbol || !aliasTypeArguments) { + return false; + } + if ((0, isSymbolFromDefaultLibrary_1.isSymbolFromDefaultLibrary)(program, aliasSymbol) && + predicate(subtype)) { + return true; + } + return null; + }); +} +function isBuiltinSymbolLike(program, type, symbolName) { + return isBuiltinSymbolLikeRecurser(program, type, subType => { + const symbol = subType.getSymbol(); + if (!symbol) { + return false; + } + const actualSymbolName = symbol.getName(); + if ((Array.isArray(symbolName) + ? symbolName.some(name => actualSymbolName === name) + : actualSymbolName === symbolName) && + (0, isSymbolFromDefaultLibrary_1.isSymbolFromDefaultLibrary)(program, symbol)) { + return true; + } + return null; + }); +} +function isBuiltinSymbolLikeRecurser(program, type, predicate) { + if (type.isIntersection()) { + return type.types.some(t => isBuiltinSymbolLikeRecurser(program, t, predicate)); + } + if (type.isUnion()) { + return type.types.every(t => isBuiltinSymbolLikeRecurser(program, t, predicate)); + } + if (tsutils.isTypeParameter(type)) { + const t = type.getConstraint(); + if (t) { + return isBuiltinSymbolLikeRecurser(program, t, predicate); + } + return false; + } + const predicateResult = predicate(type); + if (typeof predicateResult === 'boolean') { + return predicateResult; + } + const symbol = type.getSymbol(); + if (symbol && + tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Class | ts.SymbolFlags.Interface)) { + const checker = program.getTypeChecker(); + const declaredType = checker.getDeclaredTypeOfSymbol(symbol); + for (const baseType of checker.getBaseTypes(declaredType)) { + if (isBuiltinSymbolLikeRecurser(program, baseType, predicate)) { + return true; + } + } + } + return false; +} +//# sourceMappingURL=builtinSymbolLikes.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.d.ts new file mode 100644 index 00000000..30cd6dfd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.d.ts @@ -0,0 +1,9 @@ +import * as ts from 'typescript'; +/** + * @param type Type being checked by name. + * @param allowAny Whether to consider `any` and `unknown` to match. + * @param allowedNames Symbol names checking on the type. + * @param matchAnyInstead Whether to instead just check if any parts match, rather than all parts. + * @returns Whether the type is, extends, or contains the allowed names (or all matches the allowed names, if mustMatchAll is true). + */ +export declare function containsAllTypesByName(type: ts.Type, allowAny: boolean, allowedNames: Set, matchAnyInstead?: boolean): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.js new file mode 100644 index 00000000..00a56b63 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/containsAllTypesByName.js @@ -0,0 +1,70 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.containsAllTypesByName = containsAllTypesByName; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const typeFlagUtils_1 = require("./typeFlagUtils"); +/** + * @param type Type being checked by name. + * @param allowAny Whether to consider `any` and `unknown` to match. + * @param allowedNames Symbol names checking on the type. + * @param matchAnyInstead Whether to instead just check if any parts match, rather than all parts. + * @returns Whether the type is, extends, or contains the allowed names (or all matches the allowed names, if mustMatchAll is true). + */ +function containsAllTypesByName(type, allowAny, allowedNames, matchAnyInstead = false) { + if ((0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { + return !allowAny; + } + if (tsutils.isTypeReference(type)) { + type = type.target; + } + const symbol = type.getSymbol(); + if (symbol && allowedNames.has(symbol.name)) { + return true; + } + const predicate = (t) => containsAllTypesByName(t, allowAny, allowedNames, matchAnyInstead); + if (tsutils.isUnionOrIntersectionType(type)) { + return matchAnyInstead + ? type.types.some(predicate) + : type.types.every(predicate); + } + const bases = type.getBaseTypes(); + return (bases != null && + (matchAnyInstead + ? bases.some(predicate) + : bases.length > 0 && bases.every(predicate))); +} +//# sourceMappingURL=containsAllTypesByName.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.d.ts new file mode 100644 index 00000000..e7b09796 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.d.ts @@ -0,0 +1,12 @@ +import type * as ts from 'typescript'; +export declare enum AnyType { + Any = 0, + PromiseAny = 1, + AnyArray = 2, + Safe = 3 +} +/** + * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise`, + * otherwise it returns `AnyType.Safe`. + */ +export declare function discriminateAnyType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program, tsNode: ts.Node): AnyType; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.js new file mode 100644 index 00000000..cb993f65 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/discriminateAnyType.js @@ -0,0 +1,78 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AnyType = void 0; +exports.discriminateAnyType = discriminateAnyType; +const tsutils = __importStar(require("ts-api-utils")); +const predicates_1 = require("./predicates"); +var AnyType; +(function (AnyType) { + AnyType[AnyType["Any"] = 0] = "Any"; + AnyType[AnyType["PromiseAny"] = 1] = "PromiseAny"; + AnyType[AnyType["AnyArray"] = 2] = "AnyArray"; + AnyType[AnyType["Safe"] = 3] = "Safe"; +})(AnyType || (exports.AnyType = AnyType = {})); +/** + * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise`, + * otherwise it returns `AnyType.Safe`. + */ +function discriminateAnyType(type, checker, program, tsNode) { + return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set()); +} +function discriminateAnyTypeWorker(type, checker, program, tsNode, visited) { + if (visited.has(type)) { + return AnyType.Safe; + } + visited.add(type); + if ((0, predicates_1.isTypeAnyType)(type)) { + return AnyType.Any; + } + if ((0, predicates_1.isTypeAnyArrayType)(type, checker)) { + return AnyType.AnyArray; + } + for (const part of tsutils.typeConstituents(type)) { + if (tsutils.isThenableType(checker, tsNode, part)) { + const awaitedType = checker.getAwaitedType(part); + if (awaitedType) { + const awaitedAnyType = discriminateAnyTypeWorker(awaitedType, checker, program, tsNode, visited); + if (awaitedAnyType === AnyType.Any) { + return AnyType.PromiseAny; + } + } + } + } + return AnyType.Safe; +} +//# sourceMappingURL=discriminateAnyType.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.d.ts new file mode 100644 index 00000000..2c271763 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.d.ts @@ -0,0 +1,12 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/typescript-estree'; +import type * as ts from 'typescript'; +/** + * Resolves the given node's type. Will return the type's generic constraint, if it has one. + * + * Warning - if the type is generic and does _not_ have a constraint, the type will be + * returned as-is, rather than returning an `unknown` type. This can be checked + * for by checking for the type flag ts.TypeFlags.TypeParameter. + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/10438 + */ +export declare function getConstrainedTypeAtLocation(services: ParserServicesWithTypeInformation, node: TSESTree.Node): ts.Type; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.js new file mode 100644 index 00000000..d3370144 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getConstrainedTypeAtLocation.js @@ -0,0 +1,20 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getConstrainedTypeAtLocation = getConstrainedTypeAtLocation; +/** + * Resolves the given node's type. Will return the type's generic constraint, if it has one. + * + * Warning - if the type is generic and does _not_ have a constraint, the type will be + * returned as-is, rather than returning an `unknown` type. This can be checked + * for by checking for the type flag ts.TypeFlags.TypeParameter. + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/10438 + */ +function getConstrainedTypeAtLocation(services, node) { + const nodeType = services.getTypeAtLocation(node); + const constrained = services.program + .getTypeChecker() + .getBaseConstraintOfType(nodeType); + return constrained ?? nodeType; +} +//# sourceMappingURL=getConstrainedTypeAtLocation.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.d.ts new file mode 100644 index 00000000..a8222f13 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.d.ts @@ -0,0 +1,7 @@ +import * as ts from 'typescript'; +/** + * Returns the contextual type of a given node. + * Contextual type is the type of the target the node is going into. + * i.e. the type of a called function's parameter, or the defined type of a variable declaration + */ +export declare function getContextualType(checker: ts.TypeChecker, node: ts.Expression): ts.Type | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.js new file mode 100644 index 00000000..0097e037 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getContextualType.js @@ -0,0 +1,77 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getContextualType = getContextualType; +const ts = __importStar(require("typescript")); +/** + * Returns the contextual type of a given node. + * Contextual type is the type of the target the node is going into. + * i.e. the type of a called function's parameter, or the defined type of a variable declaration + */ +function getContextualType(checker, node) { + const parent = node.parent; + if (ts.isCallExpression(parent) || ts.isNewExpression(parent)) { + if (node === parent.expression) { + // is the callee, so has no contextual type + return; + } + } + else if (ts.isVariableDeclaration(parent) || + ts.isPropertyDeclaration(parent) || + ts.isParameter(parent)) { + return parent.type ? checker.getTypeFromTypeNode(parent.type) : undefined; + } + else if (ts.isJsxExpression(parent)) { + return checker.getContextualType(parent); + } + else if (ts.isIdentifier(node) && + (ts.isPropertyAssignment(parent) || + ts.isShorthandPropertyAssignment(parent))) { + return checker.getContextualType(node); + } + else if (ts.isBinaryExpression(parent) && + parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && + parent.right === node) { + // is RHS of assignment + return checker.getTypeAtLocation(parent.left); + } + else if (![ts.SyntaxKind.JsxExpression, ts.SyntaxKind.TemplateSpan].includes(parent.kind)) { + // parent is not something we know we can get the contextual type of + return; + } + // TODO - support return statement checking + return checker.getContextualType(node); +} +//# sourceMappingURL=getContextualType.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.d.ts new file mode 100644 index 00000000..f3849361 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.d.ts @@ -0,0 +1,6 @@ +import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/typescript-estree'; +import type * as ts from 'typescript'; +/** + * Gets the declaration for the given variable + */ +export declare function getDeclaration(services: ParserServicesWithTypeInformation, node: TSESTree.Node): ts.Declaration | null; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.js new file mode 100644 index 00000000..43d60b08 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getDeclaration.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getDeclaration = getDeclaration; +/** + * Gets the declaration for the given variable + */ +function getDeclaration(services, node) { + const symbol = services.getSymbolAtLocation(node); + if (!symbol) { + return null; + } + const declarations = symbol.getDeclarations(); + return declarations?.[0] ?? null; +} +//# sourceMappingURL=getDeclaration.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.d.ts new file mode 100644 index 00000000..2b0264ee --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.d.ts @@ -0,0 +1,6 @@ +import * as ts from 'typescript'; +/** + * @deprecated + * Gets the source file for a given node + */ +export declare function getSourceFileOfNode(node: ts.Node): ts.SourceFile; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.js new file mode 100644 index 00000000..fbb0e7e7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getSourceFileOfNode.js @@ -0,0 +1,48 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getSourceFileOfNode = getSourceFileOfNode; +const ts = __importStar(require("typescript")); +/** + * @deprecated + * Gets the source file for a given node + */ +function getSourceFileOfNode(node) { + while (node.kind !== ts.SyntaxKind.SourceFile) { + node = node.parent; + } + return node; +} +//# sourceMappingURL=getSourceFileOfNode.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.d.ts new file mode 100644 index 00000000..342d345b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.d.ts @@ -0,0 +1,7 @@ +import * as ts from 'typescript'; +/** + * Get the type name of a given type. + * @param typeChecker The context sensitive TypeScript TypeChecker. + * @param type The type to get the name of. + */ +export declare function getTypeName(typeChecker: ts.TypeChecker, type: ts.Type): string; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.js new file mode 100644 index 00000000..7c4de756 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/getTypeName.js @@ -0,0 +1,85 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getTypeName = getTypeName; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +/** + * Get the type name of a given type. + * @param typeChecker The context sensitive TypeScript TypeChecker. + * @param type The type to get the name of. + */ +function getTypeName(typeChecker, type) { + // It handles `string` and string literal types as string. + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.StringLike)) { + return 'string'; + } + // If the type is a type parameter which extends primitive string types, + // but it was not recognized as a string like. So check the constraint + // type of the type parameter. + if (tsutils.isTypeFlagSet(type, ts.TypeFlags.TypeParameter)) { + // `type.getConstraint()` method doesn't return the constraint type of + // the type parameter for some reason. So this gets the constraint type + // via AST. + const symbol = type.getSymbol(); + const decls = symbol?.getDeclarations(); + const typeParamDecl = decls?.[0]; + if (typeParamDecl != null && + ts.isTypeParameterDeclaration(typeParamDecl) && + typeParamDecl.constraint != null) { + return getTypeName(typeChecker, typeChecker.getTypeFromTypeNode(typeParamDecl.constraint)); + } + } + // If the type is a union and all types in the union are string like, + // return `string`. For example: + // - `"a" | "b"` is string. + // - `string | string[]` is not string. + if (type.isUnion() && + type.types + .map(value => getTypeName(typeChecker, value)) + .every(t => t === 'string')) { + return 'string'; + } + // If the type is an intersection and a type in the intersection is string + // like, return `string`. For example: `string & {__htmlEscaped: void}` + if (type.isIntersection() && + type.types + .map(value => getTypeName(typeChecker, value)) + .some(t => t === 'string')) { + return 'string'; + } + return typeChecker.typeToString(type); +} +//# sourceMappingURL=getTypeName.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.d.ts new file mode 100644 index 00000000..af09b7be --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.d.ts @@ -0,0 +1,18 @@ +export * from './builtinSymbolLikes'; +export * from './containsAllTypesByName'; +export * from './getConstrainedTypeAtLocation'; +export * from './getContextualType'; +export * from './getDeclaration'; +export * from './getSourceFileOfNode'; +export * from './getTypeName'; +export * from './isSymbolFromDefaultLibrary'; +export * from './isTypeBrandedLiteralLike'; +export * from './isTypeReadonly'; +export * from './isUnsafeAssignment'; +export * from './predicates'; +export * from './propertyTypes'; +export * from './requiresQuoting'; +export * from './typeFlagUtils'; +export * from './TypeOrValueSpecifier'; +export * from './discriminateAnyType'; +export { getDecorators, getModifiers, typescriptVersionIsAtLeast, } from '@typescript-eslint/typescript-estree'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.js new file mode 100644 index 00000000..0cd8176d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/index.js @@ -0,0 +1,39 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.typescriptVersionIsAtLeast = exports.getModifiers = exports.getDecorators = void 0; +__exportStar(require("./builtinSymbolLikes"), exports); +__exportStar(require("./containsAllTypesByName"), exports); +__exportStar(require("./getConstrainedTypeAtLocation"), exports); +__exportStar(require("./getContextualType"), exports); +__exportStar(require("./getDeclaration"), exports); +__exportStar(require("./getSourceFileOfNode"), exports); +__exportStar(require("./getTypeName"), exports); +__exportStar(require("./isSymbolFromDefaultLibrary"), exports); +__exportStar(require("./isTypeBrandedLiteralLike"), exports); +__exportStar(require("./isTypeReadonly"), exports); +__exportStar(require("./isUnsafeAssignment"), exports); +__exportStar(require("./predicates"), exports); +__exportStar(require("./propertyTypes"), exports); +__exportStar(require("./requiresQuoting"), exports); +__exportStar(require("./typeFlagUtils"), exports); +__exportStar(require("./TypeOrValueSpecifier"), exports); +__exportStar(require("./discriminateAnyType"), exports); +var typescript_estree_1 = require("@typescript-eslint/typescript-estree"); +Object.defineProperty(exports, "getDecorators", { enumerable: true, get: function () { return typescript_estree_1.getDecorators; } }); +Object.defineProperty(exports, "getModifiers", { enumerable: true, get: function () { return typescript_estree_1.getModifiers; } }); +Object.defineProperty(exports, "typescriptVersionIsAtLeast", { enumerable: true, get: function () { return typescript_estree_1.typescriptVersionIsAtLeast; } }); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.d.ts new file mode 100644 index 00000000..9ec4f244 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.d.ts @@ -0,0 +1,2 @@ +import type * as ts from 'typescript'; +export declare function isSymbolFromDefaultLibrary(program: ts.Program, symbol: ts.Symbol | undefined): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.js new file mode 100644 index 00000000..7a074105 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isSymbolFromDefaultLibrary.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isSymbolFromDefaultLibrary = isSymbolFromDefaultLibrary; +function isSymbolFromDefaultLibrary(program, symbol) { + if (!symbol) { + return false; + } + const declarations = symbol.getDeclarations() ?? []; + for (const declaration of declarations) { + const sourceFile = declaration.getSourceFile(); + if (program.isSourceFileDefaultLibrary(sourceFile)) { + return true; + } + } + return false; +} +//# sourceMappingURL=isSymbolFromDefaultLibrary.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.d.ts new file mode 100644 index 00000000..2f619a9b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.d.ts @@ -0,0 +1,2 @@ +import * as ts from 'typescript'; +export declare function isTypeBrandedLiteralLike(type: ts.Type): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.js new file mode 100644 index 00000000..33b6dfeb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeBrandedLiteralLike.js @@ -0,0 +1,75 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isTypeBrandedLiteralLike = isTypeBrandedLiteralLike; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +function isLiteralOrTaggablePrimitiveLike(type) { + return (type.isLiteral() || + tsutils.isTypeFlagSet(type, ts.TypeFlags.BigInt | + ts.TypeFlags.Number | + ts.TypeFlags.String | + ts.TypeFlags.TemplateLiteral)); +} +function isObjectLiteralLike(type) { + return (!type.getCallSignatures().length && + !type.getConstructSignatures().length && + tsutils.isObjectType(type)); +} +function isTypeBrandedLiteral(type) { + if (!type.isIntersection()) { + return false; + } + let hadObjectLike = false; + let hadPrimitiveLike = false; + for (const constituent of type.types) { + if (isObjectLiteralLike(constituent)) { + hadPrimitiveLike = true; + } + else if (isLiteralOrTaggablePrimitiveLike(constituent)) { + hadObjectLike = true; + } + else { + return false; + } + } + return hadPrimitiveLike && hadObjectLike; +} +function isTypeBrandedLiteralLike(type) { + return type.isUnion() + ? type.types.every(isTypeBrandedLiteral) + : isTypeBrandedLiteral(type); +} +//# sourceMappingURL=isTypeBrandedLiteralLike.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.d.ts new file mode 100644 index 00000000..144b5117 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.d.ts @@ -0,0 +1,100 @@ +import * as ts from 'typescript'; +import type { TypeOrValueSpecifier } from './TypeOrValueSpecifier'; +export interface ReadonlynessOptions { + readonly allow?: TypeOrValueSpecifier[]; + readonly treatMethodsAsReadonly?: boolean; +} +export declare const readonlynessOptionsSchema: { + additionalProperties: false; + properties: { + allow: { + readonly items: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["file"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + readonly path: { + readonly type: 'string'; + }; + }; + readonly required: ["from", "name"]; + readonly type: 'object'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["lib"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + }; + readonly required: ["from", "name"]; + readonly type: 'object'; + }, { + readonly additionalProperties: false; + readonly properties: { + readonly from: { + readonly enum: ["package"]; + readonly type: 'string'; + }; + readonly name: { + readonly oneOf: [{ + readonly type: 'string'; + }, { + readonly items: { + readonly type: 'string'; + }; + readonly minItems: 1; + readonly type: 'array'; + readonly uniqueItems: true; + }]; + }; + readonly package: { + readonly type: 'string'; + }; + }; + readonly required: ["from", "name", "package"]; + readonly type: 'object'; + }]; + }; + readonly type: 'array'; + }; + treatMethodsAsReadonly: { + type: "boolean"; + }; + }; + type: "object"; +}; +export declare const readonlynessOptionsDefaults: ReadonlynessOptions; +/** + * Checks if the given type is readonly + */ +export declare function isTypeReadonly(program: ts.Program, type: ts.Type, options?: ReadonlynessOptions): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.js new file mode 100644 index 00000000..55ce1470 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isTypeReadonly.js @@ -0,0 +1,256 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.readonlynessOptionsDefaults = exports.readonlynessOptionsSchema = void 0; +exports.isTypeReadonly = isTypeReadonly; +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const propertyTypes_1 = require("./propertyTypes"); +const TypeOrValueSpecifier_1 = require("./TypeOrValueSpecifier"); +var Readonlyness; +(function (Readonlyness) { + /** the type cannot be handled by the function */ + Readonlyness[Readonlyness["UnknownType"] = 1] = "UnknownType"; + /** the type is mutable */ + Readonlyness[Readonlyness["Mutable"] = 2] = "Mutable"; + /** the type is readonly */ + Readonlyness[Readonlyness["Readonly"] = 3] = "Readonly"; +})(Readonlyness || (Readonlyness = {})); +exports.readonlynessOptionsSchema = { + additionalProperties: false, + properties: { + allow: TypeOrValueSpecifier_1.typeOrValueSpecifiersSchema, + treatMethodsAsReadonly: { + type: 'boolean', + }, + }, + type: 'object', +}; +exports.readonlynessOptionsDefaults = { + allow: [], + treatMethodsAsReadonly: false, +}; +function hasSymbol(node) { + return Object.hasOwn(node, 'symbol'); +} +function isTypeReadonlyArrayOrTuple(program, type, options, seenTypes) { + const checker = program.getTypeChecker(); + function checkTypeArguments(arrayType) { + const typeArguments = checker.getTypeArguments(arrayType); + // this shouldn't happen in reality as: + // - tuples require at least 1 type argument + // - ReadonlyArray requires at least 1 type argument + /* istanbul ignore if */ if (typeArguments.length === 0) { + return Readonlyness.Readonly; + } + // validate the element types are also readonly + if (typeArguments.some(typeArg => isTypeReadonlyRecurser(program, typeArg, options, seenTypes) === + Readonlyness.Mutable)) { + return Readonlyness.Mutable; + } + return Readonlyness.Readonly; + } + if (checker.isArrayType(type)) { + const symbol = utils_1.ESLintUtils.nullThrows(type.getSymbol(), utils_1.ESLintUtils.NullThrowsReasons.MissingToken('symbol', 'array type')); + const escapedName = symbol.getEscapedName(); + // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison + if (escapedName === 'Array') { + return Readonlyness.Mutable; + } + return checkTypeArguments(type); + } + if (checker.isTupleType(type)) { + if (!type.target.readonly) { + return Readonlyness.Mutable; + } + return checkTypeArguments(type); + } + return Readonlyness.UnknownType; +} +function isTypeReadonlyObject(program, type, options, seenTypes) { + const checker = program.getTypeChecker(); + function checkIndexSignature(kind) { + const indexInfo = checker.getIndexInfoOfType(type, kind); + if (indexInfo) { + if (!indexInfo.isReadonly) { + return Readonlyness.Mutable; + } + if (indexInfo.type === type || seenTypes.has(indexInfo.type)) { + return Readonlyness.Readonly; + } + return isTypeReadonlyRecurser(program, indexInfo.type, options, seenTypes); + } + return Readonlyness.UnknownType; + } + const properties = type.getProperties(); + if (properties.length) { + // ensure the properties are marked as readonly + for (const property of properties) { + if (options.treatMethodsAsReadonly) { + if (property.valueDeclaration != null && + hasSymbol(property.valueDeclaration) && + tsutils.isSymbolFlagSet(property.valueDeclaration.symbol, ts.SymbolFlags.Method)) { + continue; + } + const declarations = property.getDeclarations(); + const lastDeclaration = declarations != null && declarations.length > 0 + ? declarations[declarations.length - 1] + : undefined; + if (lastDeclaration != null && + hasSymbol(lastDeclaration) && + tsutils.isSymbolFlagSet(lastDeclaration.symbol, ts.SymbolFlags.Method)) { + continue; + } + } + if (tsutils.isPropertyReadonlyInType(type, property.getEscapedName(), checker)) { + continue; + } + const name = ts.getNameOfDeclaration(property.valueDeclaration); + if (name && ts.isPrivateIdentifier(name)) { + continue; + } + return Readonlyness.Mutable; + } + // all properties were readonly + // now ensure that all of the values are readonly also. + // do this after checking property readonly-ness as a perf optimization, + // as we might be able to bail out early due to a mutable property before + // doing this deep, potentially expensive check. + for (const property of properties) { + const propertyType = utils_1.ESLintUtils.nullThrows((0, propertyTypes_1.getTypeOfPropertyOfType)(checker, type, property), utils_1.ESLintUtils.NullThrowsReasons.MissingToken(`property "${property.name}"`, 'type')); + // handle recursive types. + // we only need this simple check, because a mutable recursive type will break via the above prop readonly check + if (seenTypes.has(propertyType)) { + continue; + } + if (isTypeReadonlyRecurser(program, propertyType, options, seenTypes) === + Readonlyness.Mutable) { + return Readonlyness.Mutable; + } + } + } + const isStringIndexSigReadonly = checkIndexSignature(ts.IndexKind.String); + if (isStringIndexSigReadonly === Readonlyness.Mutable) { + return isStringIndexSigReadonly; + } + const isNumberIndexSigReadonly = checkIndexSignature(ts.IndexKind.Number); + if (isNumberIndexSigReadonly === Readonlyness.Mutable) { + return isNumberIndexSigReadonly; + } + return Readonlyness.Readonly; +} +// a helper function to ensure the seenTypes map is always passed down, except by the external caller +function isTypeReadonlyRecurser(program, type, options, seenTypes) { + const checker = program.getTypeChecker(); + seenTypes.add(type); + // If the type has an alias symbol, check it against the allow list first + if (type.aliasSymbol && options.allow) { + const aliasSymbol = type.aliasSymbol; + const aliasMatches = options.allow.some(specifier => { + const specifierName = typeof specifier === 'string' ? specifier : specifier.name; + const names = Array.isArray(specifierName) + ? specifierName + : [specifierName]; + return names.includes(aliasSymbol.getName()); + }); + if (aliasMatches) { + return Readonlyness.Readonly; + } + } + if ((0, TypeOrValueSpecifier_1.typeMatchesSomeSpecifier)(type, options.allow, program)) { + return Readonlyness.Readonly; + } + if (tsutils.isUnionType(type)) { + // all types in the union must be readonly + const result = tsutils + .unionConstituents(type) + .every(t => seenTypes.has(t) || + isTypeReadonlyRecurser(program, t, options, seenTypes) === + Readonlyness.Readonly); + const readonlyness = result ? Readonlyness.Readonly : Readonlyness.Mutable; + return readonlyness; + } + if (tsutils.isIntersectionType(type)) { + // Special case for handling arrays/tuples (as readonly arrays/tuples always have mutable methods). + if (type.types.some(t => checker.isArrayType(t) || checker.isTupleType(t))) { + const allReadonlyParts = type.types.every(t => seenTypes.has(t) || + isTypeReadonlyRecurser(program, t, options, seenTypes) === + Readonlyness.Readonly); + return allReadonlyParts ? Readonlyness.Readonly : Readonlyness.Mutable; + } + // Normal case. + const isReadonlyObject = isTypeReadonlyObject(program, type, options, seenTypes); + if (isReadonlyObject !== Readonlyness.UnknownType) { + return isReadonlyObject; + } + } + if (tsutils.isConditionalType(type)) { + const result = [type.root.node.trueType, type.root.node.falseType] + .map(checker.getTypeFromTypeNode) + .every(t => seenTypes.has(t) || + isTypeReadonlyRecurser(program, t, options, seenTypes) === + Readonlyness.Readonly); + const readonlyness = result ? Readonlyness.Readonly : Readonlyness.Mutable; + return readonlyness; + } + // all non-object, non-intersection types are readonly. + // this should only be primitive types + if (!tsutils.isObjectType(type)) { + return Readonlyness.Readonly; + } + // pure function types are readonly + if (type.getCallSignatures().length > 0 && + type.getProperties().length === 0) { + return Readonlyness.Readonly; + } + const isReadonlyArray = isTypeReadonlyArrayOrTuple(program, type, options, seenTypes); + if (isReadonlyArray !== Readonlyness.UnknownType) { + return isReadonlyArray; + } + const isReadonlyObject = isTypeReadonlyObject(program, type, options, seenTypes); + /* istanbul ignore else */ if (isReadonlyObject !== Readonlyness.UnknownType) { + return isReadonlyObject; + } + throw new Error('Unhandled type'); +} +/** + * Checks if the given type is readonly + */ +function isTypeReadonly(program, type, options = exports.readonlynessOptionsDefaults) { + return (isTypeReadonlyRecurser(program, type, options, new Set()) === + Readonlyness.Readonly); +} +//# sourceMappingURL=isTypeReadonly.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.d.ts new file mode 100644 index 00000000..0dd5a4c9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.d.ts @@ -0,0 +1,16 @@ +import type { TSESTree } from '@typescript-eslint/utils'; +import type * as ts from 'typescript'; +/** + * Does a simple check to see if there is an any being assigned to a non-any type. + * + * This also checks generic positions to ensure there's no unsafe sub-assignments. + * Note: in the case of generic positions, it makes the assumption that the two types are the same. + * + * @example See tests for examples + * + * @returns false if it's safe, or an object with the two types if it's unsafe + */ +export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, checker: ts.TypeChecker, senderNode: TSESTree.Node | null): false | { + receiver: ts.Type; + sender: ts.Type; +}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.js new file mode 100644 index 00000000..e5979ead --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/isUnsafeAssignment.js @@ -0,0 +1,115 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isUnsafeAssignment = isUnsafeAssignment; +const utils_1 = require("@typescript-eslint/utils"); +const tsutils = __importStar(require("ts-api-utils")); +const predicates_1 = require("./predicates"); +/** + * Does a simple check to see if there is an any being assigned to a non-any type. + * + * This also checks generic positions to ensure there's no unsafe sub-assignments. + * Note: in the case of generic positions, it makes the assumption that the two types are the same. + * + * @example See tests for examples + * + * @returns false if it's safe, or an object with the two types if it's unsafe + */ +function isUnsafeAssignment(type, receiver, checker, senderNode) { + return isUnsafeAssignmentWorker(type, receiver, checker, senderNode, new Map()); +} +function isUnsafeAssignmentWorker(type, receiver, checker, senderNode, visited) { + if ((0, predicates_1.isTypeAnyType)(type)) { + // Allow assignment of any ==> unknown. + if ((0, predicates_1.isTypeUnknownType)(receiver)) { + return false; + } + if (!(0, predicates_1.isTypeAnyType)(receiver)) { + return { receiver, sender: type }; + } + } + const typeAlreadyVisited = visited.get(type); + if (typeAlreadyVisited) { + if (typeAlreadyVisited.has(receiver)) { + return false; + } + typeAlreadyVisited.add(receiver); + } + else { + visited.set(type, new Set([receiver])); + } + if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) { + // TODO - figure out how to handle cases like this, + // where the types are assignable, but not the same type + /* + function foo(): ReadonlySet { return new Set(); } + + // and + + type Test = { prop: T } + type Test2 = { prop: string } + declare const a: Test; + const b: Test2 = a; + */ + if (type.target !== receiver.target) { + // if the type references are different, assume safe, as we won't know how to compare the two types + // the generic positions might not be equivalent for both types + return false; + } + if (senderNode?.type === utils_1.AST_NODE_TYPES.NewExpression && + senderNode.callee.type === utils_1.AST_NODE_TYPES.Identifier && + senderNode.callee.name === 'Map' && + senderNode.arguments.length === 0 && + senderNode.typeArguments == null) { + // special case to handle `new Map()` + // unfortunately Map's default empty constructor is typed to return `Map` :( + // https://github.com/typescript-eslint/typescript-eslint/issues/2109#issuecomment-634144396 + return false; + } + const typeArguments = type.typeArguments ?? []; + const receiverTypeArguments = receiver.typeArguments ?? []; + for (let i = 0; i < typeArguments.length; i += 1) { + const arg = typeArguments[i]; + const receiverArg = receiverTypeArguments[i]; + const unsafe = isUnsafeAssignmentWorker(arg, receiverArg, checker, senderNode, visited); + if (unsafe) { + return { receiver, sender: type }; + } + } + return false; + } + return false; +} +//# sourceMappingURL=isUnsafeAssignment.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.d.ts new file mode 100644 index 00000000..fc71fada --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.d.ts @@ -0,0 +1,37 @@ +import * as ts from 'typescript'; +/** + * Checks if the given type is (or accepts) nullable + */ +export declare function isNullableType(type: ts.Type): boolean; +/** + * Checks if the given type is either an array type, + * or a union made up solely of array types. + */ +export declare function isTypeArrayTypeOrUnionOfArrayTypes(type: ts.Type, checker: ts.TypeChecker): boolean; +/** + * @returns true if the type is `never` + */ +export declare function isTypeNeverType(type: ts.Type): boolean; +/** + * @returns true if the type is `unknown` + */ +export declare function isTypeUnknownType(type: ts.Type): boolean; +export declare function isTypeReferenceType(type: ts.Type): type is ts.TypeReference; +/** + * @returns true if the type is `any` + */ +export declare function isTypeAnyType(type: ts.Type): boolean; +/** + * @returns true if the type is `any[]` + */ +export declare function isTypeAnyArrayType(type: ts.Type, checker: ts.TypeChecker): boolean; +/** + * @returns true if the type is `unknown[]` + */ +export declare function isTypeUnknownArrayType(type: ts.Type, checker: ts.TypeChecker): boolean; +/** + * @returns Whether a type is an instance of the parent type, including for the parent's base types. + */ +export declare function typeIsOrHasBaseType(type: ts.Type, parentType: ts.Type): boolean; +export declare function isTypeBigIntLiteralType(type: ts.Type): type is ts.BigIntLiteralType; +export declare function isTypeTemplateLiteralType(type: ts.Type): type is ts.TemplateLiteralType; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.js new file mode 100644 index 00000000..00e35a35 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/predicates.js @@ -0,0 +1,158 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNullableType = isNullableType; +exports.isTypeArrayTypeOrUnionOfArrayTypes = isTypeArrayTypeOrUnionOfArrayTypes; +exports.isTypeNeverType = isTypeNeverType; +exports.isTypeUnknownType = isTypeUnknownType; +exports.isTypeReferenceType = isTypeReferenceType; +exports.isTypeAnyType = isTypeAnyType; +exports.isTypeAnyArrayType = isTypeAnyArrayType; +exports.isTypeUnknownArrayType = isTypeUnknownArrayType; +exports.typeIsOrHasBaseType = typeIsOrHasBaseType; +exports.isTypeBigIntLiteralType = isTypeBigIntLiteralType; +exports.isTypeTemplateLiteralType = isTypeTemplateLiteralType; +const debug_1 = __importDefault(require("debug")); +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const typeFlagUtils_1 = require("./typeFlagUtils"); +const log = (0, debug_1.default)('typescript-eslint:type-utils:predicates'); +/** + * Checks if the given type is (or accepts) nullable + */ +function isNullableType(type) { + return (0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.Any | + ts.TypeFlags.Unknown | + ts.TypeFlags.Null | + ts.TypeFlags.Undefined | + ts.TypeFlags.Void); +} +/** + * Checks if the given type is either an array type, + * or a union made up solely of array types. + */ +function isTypeArrayTypeOrUnionOfArrayTypes(type, checker) { + for (const t of tsutils.unionConstituents(type)) { + if (!checker.isArrayType(t)) { + return false; + } + } + return true; +} +/** + * @returns true if the type is `never` + */ +function isTypeNeverType(type) { + return (0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.Never); +} +/** + * @returns true if the type is `unknown` + */ +function isTypeUnknownType(type) { + return (0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.Unknown); +} +// https://github.com/microsoft/TypeScript/blob/42aa18bf442c4df147e30deaf27261a41cbdc617/src/compiler/types.ts#L5157 +const Nullable = ts.TypeFlags.Undefined | ts.TypeFlags.Null; +// https://github.com/microsoft/TypeScript/blob/42aa18bf442c4df147e30deaf27261a41cbdc617/src/compiler/types.ts#L5187 +const ObjectFlagsType = ts.TypeFlags.Any | + Nullable | + ts.TypeFlags.Never | + ts.TypeFlags.Object | + ts.TypeFlags.Union | + ts.TypeFlags.Intersection; +function isTypeReferenceType(type) { + if ((type.flags & ObjectFlagsType) === 0) { + return false; + } + const objectTypeFlags = type.objectFlags; + return (objectTypeFlags & ts.ObjectFlags.Reference) !== 0; +} +/** + * @returns true if the type is `any` + */ +function isTypeAnyType(type) { + if ((0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.Any)) { + if (type.intrinsicName === 'error') { + log('Found an "error" any type'); + } + return true; + } + return false; +} +/** + * @returns true if the type is `any[]` + */ +function isTypeAnyArrayType(type, checker) { + return (checker.isArrayType(type) && + isTypeAnyType(checker.getTypeArguments(type)[0])); +} +/** + * @returns true if the type is `unknown[]` + */ +function isTypeUnknownArrayType(type, checker) { + return (checker.isArrayType(type) && + isTypeUnknownType(checker.getTypeArguments(type)[0])); +} +/** + * @returns Whether a type is an instance of the parent type, including for the parent's base types. + */ +function typeIsOrHasBaseType(type, parentType) { + const parentSymbol = parentType.getSymbol(); + if (!type.getSymbol() || !parentSymbol) { + return false; + } + const typeAndBaseTypes = [type]; + const ancestorTypes = type.getBaseTypes(); + if (ancestorTypes) { + typeAndBaseTypes.push(...ancestorTypes); + } + for (const baseType of typeAndBaseTypes) { + const baseSymbol = baseType.getSymbol(); + if (baseSymbol?.name === parentSymbol.name) { + return true; + } + } + return false; +} +function isTypeBigIntLiteralType(type) { + return (0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.BigIntLiteral); +} +function isTypeTemplateLiteralType(type) { + return (0, typeFlagUtils_1.isTypeFlagSet)(type, ts.TypeFlags.TemplateLiteral); +} +//# sourceMappingURL=predicates.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.d.ts new file mode 100644 index 00000000..d76768bc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.d.ts @@ -0,0 +1,3 @@ +import type * as ts from 'typescript'; +export declare function getTypeOfPropertyOfName(checker: ts.TypeChecker, type: ts.Type, name: string, escapedName?: ts.__String): ts.Type | undefined; +export declare function getTypeOfPropertyOfType(checker: ts.TypeChecker, type: ts.Type, property: ts.Symbol): ts.Type | undefined; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.js new file mode 100644 index 00000000..042af450 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/propertyTypes.js @@ -0,0 +1,36 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getTypeOfPropertyOfName = getTypeOfPropertyOfName; +exports.getTypeOfPropertyOfType = getTypeOfPropertyOfType; +function getTypeOfPropertyOfName(checker, type, name, escapedName) { + // Most names are directly usable in the checker and aren't different from escaped names + if (!escapedName || !isSymbol(escapedName)) { + return checker.getTypeOfPropertyOfType(type, name); + } + // Symbolic names may differ in their escaped name compared to their human-readable name + // https://github.com/typescript-eslint/typescript-eslint/issues/2143 + const escapedProperty = type + .getProperties() + .find(property => property.escapedName === escapedName); + return escapedProperty + ? checker.getDeclaredTypeOfSymbol(escapedProperty) + : undefined; +} +function getTypeOfPropertyOfType(checker, type, property) { + return getTypeOfPropertyOfName(checker, type, property.getName(), property.getEscapedName()); +} +// Symbolic names need to be specially handled because TS api is not sufficient for these cases. +// Source based on: +// https://github.com/microsoft/TypeScript/blob/0043abe982aae0d35f8df59f9715be6ada758ff7/src/compiler/utilities.ts#L3388-L3402 +function isSymbol(escapedName) { + return isKnownSymbol(escapedName) || isPrivateIdentifierSymbol(escapedName); +} +// case for escapedName: "__@foo@10", name: "__@foo@10" +function isKnownSymbol(escapedName) { + return escapedName.startsWith('__@'); +} +// case for escapedName: "__#1@#foo", name: "#foo" +function isPrivateIdentifierSymbol(escapedName) { + return escapedName.startsWith('__#'); +} +//# sourceMappingURL=propertyTypes.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.d.ts new file mode 100644 index 00000000..e72f0990 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.d.ts @@ -0,0 +1,3 @@ +import * as ts from 'typescript'; +/*** Indicates whether identifiers require the use of quotation marks when accessing property definitions and dot notation. */ +export declare function requiresQuoting(name: string, target?: ts.ScriptTarget): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.js new file mode 100644 index 00000000..03e37ce2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/requiresQuoting.js @@ -0,0 +1,53 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.requiresQuoting = requiresQuoting; +const ts = __importStar(require("typescript")); +/*** Indicates whether identifiers require the use of quotation marks when accessing property definitions and dot notation. */ +function requiresQuoting(name, target = ts.ScriptTarget.ESNext) { + if (name.length === 0) { + return true; + } + if (!ts.isIdentifierStart(name.charCodeAt(0), target)) { + return true; + } + for (let i = 1; i < name.length; i += 1) { + if (!ts.isIdentifierPart(name.charCodeAt(i), target)) { + return true; + } + } + return false; +} +//# sourceMappingURL=requiresQuoting.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.d.ts new file mode 100644 index 00000000..2cb433e6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.d.ts @@ -0,0 +1,17 @@ +import * as ts from 'typescript'; +/** + * Gets all of the type flags in a type, iterating through unions automatically. + */ +export declare function getTypeFlags(type: ts.Type): ts.TypeFlags; +/** + * @param flagsToCheck The composition of one or more `ts.TypeFlags`. + * @param isReceiver Whether the type is a receiving type (e.g. the type of a + * called function's parameter). + * @remarks + * Note that if the type is a union, this function will decompose it into the + * parts and get the flags of every union constituent. If this is not desired, + * use the `isTypeFlag` function from tsutils. + */ +export declare function isTypeFlagSet(type: ts.Type, flagsToCheck: ts.TypeFlags, +/** @deprecated This params is not used and will be removed in the future.*/ +isReceiver?: boolean): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.js new file mode 100644 index 00000000..888d7431 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeFlagUtils.js @@ -0,0 +1,71 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getTypeFlags = getTypeFlags; +exports.isTypeFlagSet = isTypeFlagSet; +const tsutils = __importStar(require("ts-api-utils")); +const ts = __importStar(require("typescript")); +const ANY_OR_UNKNOWN = ts.TypeFlags.Any | ts.TypeFlags.Unknown; +/** + * Gets all of the type flags in a type, iterating through unions automatically. + */ +function getTypeFlags(type) { + // @ts-expect-error Since typescript 5.0, this is invalid, but uses 0 as the default value of TypeFlags. + let flags = 0; + for (const t of tsutils.unionConstituents(type)) { + flags |= t.flags; + } + return flags; +} +/** + * @param flagsToCheck The composition of one or more `ts.TypeFlags`. + * @param isReceiver Whether the type is a receiving type (e.g. the type of a + * called function's parameter). + * @remarks + * Note that if the type is a union, this function will decompose it into the + * parts and get the flags of every union constituent. If this is not desired, + * use the `isTypeFlag` function from tsutils. + */ +function isTypeFlagSet(type, flagsToCheck, +/** @deprecated This params is not used and will be removed in the future.*/ +isReceiver) { + const flags = getTypeFlags(type); + // eslint-disable-next-line @typescript-eslint/no-deprecated -- not used + if (isReceiver && flags & ANY_OR_UNKNOWN) { + return true; + } + return (flags & flagsToCheck) !== 0; +} +//# sourceMappingURL=typeFlagUtils.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.d.ts new file mode 100644 index 00000000..933a8aa2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.d.ts @@ -0,0 +1,2 @@ +import type * as ts from 'typescript'; +export declare function specifierNameMatches(type: ts.Type, names: string | string[]): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.js new file mode 100644 index 00000000..0d305a25 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/specifierNameMatches.js @@ -0,0 +1,17 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.specifierNameMatches = specifierNameMatches; +function specifierNameMatches(type, names) { + if (typeof names === 'string') { + names = [names]; + } + const symbol = type.aliasSymbol ?? type.getSymbol(); + const candidateNames = symbol + ? [symbol.escapedName, type.intrinsicName] + : [type.intrinsicName]; + if (names.some(item => candidateNames.includes(item))) { + return true; + } + return false; +} +//# sourceMappingURL=specifierNameMatches.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.d.ts new file mode 100644 index 00000000..b78c4031 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.d.ts @@ -0,0 +1,2 @@ +import type * as ts from 'typescript'; +export declare function typeDeclaredInFile(relativePath: string | undefined, declarationFiles: ts.SourceFile[], program: ts.Program): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.js new file mode 100644 index 00000000..c1f85a9c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInFile.js @@ -0,0 +1,17 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.typeDeclaredInFile = typeDeclaredInFile; +const typescript_estree_1 = require("@typescript-eslint/typescript-estree"); +const node_path_1 = __importDefault(require("node:path")); +function typeDeclaredInFile(relativePath, declarationFiles, program) { + if (relativePath == null) { + const cwd = (0, typescript_estree_1.getCanonicalFileName)(program.getCurrentDirectory()); + return declarationFiles.some(declaration => (0, typescript_estree_1.getCanonicalFileName)(declaration.fileName).startsWith(cwd)); + } + const absolutePath = (0, typescript_estree_1.getCanonicalFileName)(node_path_1.default.join(program.getCurrentDirectory(), relativePath)); + return declarationFiles.some(declaration => (0, typescript_estree_1.getCanonicalFileName)(declaration.fileName) === absolutePath); +} +//# sourceMappingURL=typeDeclaredInFile.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.d.ts new file mode 100644 index 00000000..c470f92b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.d.ts @@ -0,0 +1,2 @@ +import type * as ts from 'typescript'; +export declare function typeDeclaredInLib(declarationFiles: ts.SourceFile[], program: ts.Program): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.js new file mode 100644 index 00000000..9feb9d9e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInLib.js @@ -0,0 +1,12 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.typeDeclaredInLib = typeDeclaredInLib; +function typeDeclaredInLib(declarationFiles, program) { + // Assertion: The type is not an error type. + // Intrinsic type (i.e. string, number, boolean, etc) - Treat it as if it's from lib. + if (declarationFiles.length === 0) { + return true; + } + return declarationFiles.some(declaration => program.isSourceFileDefaultLibrary(declaration)); +} +//# sourceMappingURL=typeDeclaredInLib.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.d.ts new file mode 100644 index 00000000..556d1500 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.d.ts @@ -0,0 +1,2 @@ +import * as ts from 'typescript'; +export declare function typeDeclaredInPackageDeclarationFile(packageName: string, declarations: ts.Node[], declarationFiles: ts.SourceFile[], program: ts.Program): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.js b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.js new file mode 100644 index 00000000..148396b2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/dist/typeOrValueSpecifiers/typeDeclaredInPackageDeclarationFile.js @@ -0,0 +1,83 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.typeDeclaredInPackageDeclarationFile = typeDeclaredInPackageDeclarationFile; +const ts = __importStar(require("typescript")); +function findParentModuleDeclaration(node) { + switch (node.kind) { + case ts.SyntaxKind.ModuleDeclaration: + // "namespace x {...}" should be ignored here + if (node.flags & ts.NodeFlags.Namespace) { + break; + } + return ts.isStringLiteral(node.name) + ? node + : undefined; + case ts.SyntaxKind.SourceFile: + return undefined; + } + return findParentModuleDeclaration(node.parent); +} +function typeDeclaredInDeclareModule(packageName, declarations) { + return declarations.some(declaration => findParentModuleDeclaration(declaration)?.name.text === packageName); +} +/** + * Whether `packagePath` is `packageName` itself or something inside it, comparing + * whole path components: `semver` covers `semver` and `semver/classes/semver.d.ts`, + * but not `semver-compare` or `my-semver`. + */ +function pathIsInPackage(packagePath, packageName) { + return (packagePath === packageName || packagePath.startsWith(`${packageName}/`)); +} +function typeDeclaredInDeclarationFile(packageName, declarationFiles, program) { + // Handle scoped packages: if the name starts with @, remove it and replace / with __ + const typesPackageName = packageName.replace(/^@([^/]+)\//, '$1__'); + return declarationFiles.some(declaration => { + // A package id name is a path within the package, such as + // `typescript/lib/typescript.d.ts` or `@types/semver/classes/semver.d.ts`. + const packageIdName = program.sourceFileToPackageName.get(declaration.path); + if (packageIdName == null) { + return false; + } + return ((pathIsInPackage(packageIdName, packageName) || + pathIsInPackage(packageIdName.replace(/^@types\//, ''), typesPackageName)) && + program.isSourceFileFromExternalLibrary(declaration)); + }); +} +function typeDeclaredInPackageDeclarationFile(packageName, declarations, declarationFiles, program) { + return (typeDeclaredInDeclareModule(packageName, declarations) || + typeDeclaredInDeclarationFile(packageName, declarationFiles, program)); +} +//# sourceMappingURL=typeDeclaredInPackageDeclarationFile.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsc b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsc new file mode 100755 index 00000000..c496de53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsc @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsserver b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsserver new file mode 100755 index 00000000..49048b89 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/node_modules/.bin/tsserver @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/package.json b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/package.json new file mode 100644 index 00000000..14f28c43 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/type-utils/package.json @@ -0,0 +1,85 @@ +{ + "name": "@typescript-eslint/type-utils", + "version": "8.70.1", + "description": "Type utilities for working with TypeScript + ESLint together", + "files": [ + "dist", + "!**/*.js.map", + "!**/*.tsbuildinfo" + ], + "type": "commonjs", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "./package.json": "./package.json" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/typescript-eslint/typescript-eslint.git", + "directory": "packages/type-utils" + }, + "bugs": { + "url": "https://github.com/typescript-eslint/typescript-eslint/issues" + }, + "homepage": "https://typescript-eslint.io", + "license": "MIT", + "keywords": [ + "eslint", + "typescript", + "estree" + ], + "dependencies": { + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1", + "@typescript-eslint/utils": "8.70.1", + "debug": "^4.4.3", + "ts-api-utils": "^2.5.0" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + }, + "devDependencies": { + "@types/babel__code-frame": "^7.0.6", + "@typescript-eslint/parser": "8.70.1", + "@typescript/native": "npm:typescript@^7.0.2", + "@vitest/coverage-v8": "^4.0.18", + "ajv": "^6.12.6", + "eslint": "^10.0.0", + "rimraf": "^5.0.10", + "typescript": ">=4.8.4 <6.1.0", + "vitest": "^4.0.18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "nx": { + "name": "type-utils", + "includedScripts": [ + "clean" + ], + "targets": { + "lint": { + "command": "eslint" + }, + "typecheck:tsgo": {}, + "attw-check": {} + } + }, + "scripts": { + "build": "pnpm exec nx build", + "clean": "rimraf dist/ coverage/", + "format": "pnpm -w run format", + "lint": "pnpm -w exec nx lint", + "test": "pnpm -w exec nx test", + "typecheck": "pnpm -w exec nx typecheck", + "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo", + "attw-check": "pnpm -w exec nx attw-check" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types new file mode 120000 index 00000000..66be4b7c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types @@ -0,0 +1 @@ +../../../@typescript-eslint+types@8.70.1/node_modules/@typescript-eslint/types \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree new file mode 120000 index 00000000..901511ee --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree @@ -0,0 +1 @@ +../../../@typescript-eslint+typescript-estree@8.70.1_typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils new file mode 120000 index 00000000..bc1adc1b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils @@ -0,0 +1 @@ +../../../@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug new file mode 120000 index 00000000..6b438e1c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/debug @@ -0,0 +1 @@ +../../debug@4.4.3/node_modules/debug \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/ts-api-utils b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/ts-api-utils new file mode 120000 index 00000000..876bf58a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/ts-api-utils @@ -0,0 +1 @@ +../../ts-api-utils@2.5.0_typescript@6.0.3/node_modules/ts-api-utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript new file mode 120000 index 00000000..b491b2a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+type-utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript @@ -0,0 +1 @@ +../../typescript@6.0.3/node_modules/typescript \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@eslint-community/eslint-utils b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@eslint-community/eslint-utils new file mode 120000 index 00000000..404b9e3e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@eslint-community/eslint-utils @@ -0,0 +1 @@ +../../../@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager new file mode 120000 index 00000000..4ca59d35 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/scope-manager @@ -0,0 +1 @@ +../../../@typescript-eslint+scope-manager@8.70.1/node_modules/@typescript-eslint/scope-manager \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types new file mode 120000 index 00000000..66be4b7c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/types @@ -0,0 +1 @@ +../../../@typescript-eslint+types@8.70.1/node_modules/@typescript-eslint/types \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree new file mode 120000 index 00000000..901511ee --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree @@ -0,0 +1 @@ +../../../@typescript-eslint+typescript-estree@8.70.1_typescript@6.0.3/node_modules/@typescript-eslint/typescript-estree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/LICENSE b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/LICENSE new file mode 100644 index 00000000..a1164108 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 typescript-eslint and other contributors + +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/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/README.md b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/README.md new file mode 100644 index 00000000..7ba75009 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/README.md @@ -0,0 +1,12 @@ +# `@typescript-eslint/utils` + +> Utilities for working with TypeScript + ESLint together. + +[![NPM Version](https://img.shields.io/npm/v/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils) +[![NPM Downloads](https://img.shields.io/npm/dm/@typescript-eslint/utils.svg?style=flat-square)](https://www.npmjs.com/package/@typescript-eslint/utils) + +👉 See **https://typescript-eslint.io/packages/utils** for documentation on this package. + +> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code. + + diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.d.ts new file mode 100644 index 00000000..504d0195 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.d.ts @@ -0,0 +1,47 @@ +interface PatternMatcher { + /** + * Replace all matched parts by a given replacer. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-symbol-replace} + * @example + * const { PatternMatcher } = require("eslint-utils") + * const matcher = new PatternMatcher(/\\p{Script=Greek}/g) + * + * module.exports = { + * meta: {}, + * create(context) { + * return { + * "Literal[regex]"(node) { + * const replacedPattern = node.regex.pattern.replace( + * matcher, + * "[\\u0370-\\u0373\\u0375-\\u0377\\u037A-\\u037D\\u037F\\u0384\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03E1\\u03F0-\\u03FF\\u1D26-\\u1D2A\\u1D5D-\\u1D61\\u1D66-\\u1D6A\\u1DBF\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FC4\\u1FC6-\\u1FD3\\u1FD6-\\u1FDB\\u1FDD-\\u1FEF\\u1FF2-\\u1FF4\\u1FF6-\\u1FFE\\u2126\\uAB65]|\\uD800[\\uDD40-\\uDD8E\\uDDA0]|\\uD834[\\uDE00-\\uDE45]" + * ) + * }, + * } + * }, + * } + */ + [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string; + /** + * Iterate all matched parts in a given string. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-execall} + */ + execAll(str: string): IterableIterator; + /** + * Check whether this pattern matches a given string or not. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#matcher-test} + */ + test(str: string): boolean; +} +/** + * The class to find a pattern in strings as handling escape sequences. + * It ignores the found pattern if it's escaped with `\`. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#patternmatcher-class} + */ +export declare const PatternMatcher: new (pattern: RegExp, options?: { + escaped?: boolean; +}) => PatternMatcher; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.js new file mode 100644 index 00000000..54ece2a2 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/PatternMatcher.js @@ -0,0 +1,45 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PatternMatcher = void 0; +const eslintUtils = __importStar(require("@eslint-community/eslint-utils")); +/** + * The class to find a pattern in strings as handling escape sequences. + * It ignores the found pattern if it's escaped with `\`. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#patternmatcher-class} + */ +exports.PatternMatcher = eslintUtils.PatternMatcher; +//# sourceMappingURL=PatternMatcher.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts new file mode 100644 index 00000000..a0a5dd47 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts @@ -0,0 +1,71 @@ +import type * as TSESLint from '../../ts-eslint'; +import type { TSESTree } from '../../ts-estree'; +declare const ReferenceTrackerREAD: symbol; +declare const ReferenceTrackerCALL: symbol; +declare const ReferenceTrackerCONSTRUCT: symbol; +declare const ReferenceTrackerESM: symbol; +interface ReferenceTracker { + /** + * Iterate the references that the given `traceMap` determined. + * This method starts to search from `require()` expression. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iteratecjsreferences} + */ + iterateCjsReferences(traceMap: ReferenceTracker.TraceMap): IterableIterator>; + /** + * Iterate the references that the given `traceMap` determined. + * This method starts to search from `import`/`export` declarations. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iterateesmreferences} + */ + iterateEsmReferences(traceMap: ReferenceTracker.TraceMap): IterableIterator>; + /** + * Iterate the references that the given `traceMap` determined. + * This method starts to search from global variables. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#tracker-iterateglobalreferences} + */ + iterateGlobalReferences(traceMap: ReferenceTracker.TraceMap): IterableIterator>; +} +interface ReferenceTrackerStatic { + readonly CALL: typeof ReferenceTrackerCALL; + readonly CONSTRUCT: typeof ReferenceTrackerCONSTRUCT; + readonly ESM: typeof ReferenceTrackerESM; + new (globalScope: TSESLint.Scope.Scope, options?: { + /** + * The name list of Global Object. Optional. Default is `["global", "globalThis", "self", "window"]`. + */ + globalObjectNames?: readonly string[]; + /** + * The mode which determines how the `tracker.iterateEsmReferences()` method scans CommonJS modules. + * If this is `"strict"`, the method binds CommonJS modules to the default export. Otherwise, the method binds + * CommonJS modules to both the default export and named exports. Optional. Default is `"strict"`. + */ + mode?: 'legacy' | 'strict'; + }): ReferenceTracker; + readonly READ: typeof ReferenceTrackerREAD; +} +declare namespace ReferenceTracker { + type READ = ReferenceTrackerStatic['READ']; + type CALL = ReferenceTrackerStatic['CALL']; + type CONSTRUCT = ReferenceTrackerStatic['CONSTRUCT']; + type ESM = ReferenceTrackerStatic['ESM']; + type ReferenceType = symbol; + type TraceMap = Record>; + interface TraceMapElement { + [key: string]: TraceMapElement; + } + interface FoundReference { + info: T; + node: TSESTree.Node; + path: readonly string[]; + type: ReferenceType; + } +} +/** + * The tracker for references. This provides reference tracking for global variables, CommonJS modules, and ES modules. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class} + */ +export declare const ReferenceTracker: ReferenceTrackerStatic; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.js new file mode 100644 index 00000000..7c04146b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/ReferenceTracker.js @@ -0,0 +1,49 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ReferenceTracker = void 0; +/* eslint-disable @typescript-eslint/no-namespace */ +const eslintUtils = __importStar(require("@eslint-community/eslint-utils")); +const ReferenceTrackerREAD = eslintUtils.ReferenceTracker.READ; +const ReferenceTrackerCALL = eslintUtils.ReferenceTracker.CALL; +const ReferenceTrackerCONSTRUCT = eslintUtils.ReferenceTracker.CONSTRUCT; +const ReferenceTrackerESM = eslintUtils.ReferenceTracker.ESM; +/** + * The tracker for references. This provides reference tracking for global variables, CommonJS modules, and ES modules. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#referencetracker-class} + */ +exports.ReferenceTracker = eslintUtils.ReferenceTracker; +//# sourceMappingURL=ReferenceTracker.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.d.ts new file mode 100644 index 00000000..67f87924 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.d.ts @@ -0,0 +1,83 @@ +import type * as TSESLint from '../../ts-eslint'; +import type { TSESTree } from '../../ts-estree'; +/** + * Get the proper location of a given function node to report. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation} + */ +export declare const getFunctionHeadLocation: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode: TSESLint.SourceCode) => TSESTree.SourceLocation; +/** + * Get the name and kind of a given function node. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind} + */ +export declare const getFunctionNameWithKind: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode?: TSESLint.SourceCode) => string; +/** + * Get the property name of a given property node. + * If the node is a computed property, this tries to compute the property name by the getStringIfConstant function. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname} + * @returns The property name of the node. If the property name is not constant then it returns `null`. + */ +export declare const getPropertyName: (node: TSESTree.MemberExpression | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition, initialScope?: TSESLint.Scope.Scope) => string | null; +/** + * Get the value of a given node if it can decide the value statically. + * If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the + * given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have + * not been modified. + * For example, it considers `Symbol.iterator`, `Symbol.for('k')`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static, but `Symbol('k')` is not static. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue} + * @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the + * static value of the node, it returns `null`. + */ +export declare const getStaticValue: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => { + value: unknown; +} | null; +/** + * Get the string value of a given node. + * This function is a tiny wrapper of the getStaticValue function. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant} + */ +export declare const getStringIfConstant: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => string | null; +/** + * Check whether a given node has any side effect or not. + * The side effect means that it may modify a certain variable or object member. This function considers the node which + * contains the following types as the node which has side effects: + * - `AssignmentExpression` + * - `AwaitExpression` + * - `CallExpression` + * - `ImportExpression` + * - `NewExpression` + * - `UnaryExpression([operator = "delete"])` + * - `UpdateExpression` + * - `YieldExpression` + * - When `options.considerGetters` is `true`: + * - `MemberExpression` + * - When `options.considerImplicitTypeConversion` is `true`: + * - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])` + * - `MemberExpression([computed = true])` + * - `MethodDefinition([computed = true])` + * - `Property([computed = true])` + * - `UnaryExpression([operator = "-" | "+" | "!" | "~"])` + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect} + */ +export declare const hasSideEffect: (node: TSESTree.Node, sourceCode: TSESLint.SourceCode, options?: { + considerGetters?: boolean; + considerImplicitTypeConversion?: boolean; +}) => boolean; +export declare const isParenthesized: { + (times: number, node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean; + /** + * Check whether a given node is parenthesized or not. + * This function detects it correctly even if it's parenthesized by specific syntax. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#isparenthesized} + * @returns `true` if the node is parenthesized. + * If `times` was given, it returns `true` only if the node is parenthesized the `times` times. + * For example, `isParenthesized(2, node, sourceCode)` returns true for `((foo))`, but not for `(foo)`. + */ + (node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean; +}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.js new file mode 100644 index 00000000..e0e1a35a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/astUtilities.js @@ -0,0 +1,102 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isParenthesized = exports.hasSideEffect = exports.getStringIfConstant = exports.getStaticValue = exports.getPropertyName = exports.getFunctionNameWithKind = exports.getFunctionHeadLocation = void 0; +const eslintUtils = __importStar(require("@eslint-community/eslint-utils")); +/** + * Get the proper location of a given function node to report. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation} + */ +exports.getFunctionHeadLocation = eslintUtils.getFunctionHeadLocation; +/** + * Get the name and kind of a given function node. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind} + */ +exports.getFunctionNameWithKind = eslintUtils.getFunctionNameWithKind; +/** + * Get the property name of a given property node. + * If the node is a computed property, this tries to compute the property name by the getStringIfConstant function. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname} + * @returns The property name of the node. If the property name is not constant then it returns `null`. + */ +exports.getPropertyName = eslintUtils.getPropertyName; +/** + * Get the value of a given node if it can decide the value statically. + * If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the + * given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have + * not been modified. + * For example, it considers `Symbol.iterator`, `Symbol.for('k')`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static, but `Symbol('k')` is not static. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue} + * @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the + * static value of the node, it returns `null`. + */ +exports.getStaticValue = eslintUtils.getStaticValue; +/** + * Get the string value of a given node. + * This function is a tiny wrapper of the getStaticValue function. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant} + */ +exports.getStringIfConstant = eslintUtils.getStringIfConstant; +/** + * Check whether a given node has any side effect or not. + * The side effect means that it may modify a certain variable or object member. This function considers the node which + * contains the following types as the node which has side effects: + * - `AssignmentExpression` + * - `AwaitExpression` + * - `CallExpression` + * - `ImportExpression` + * - `NewExpression` + * - `UnaryExpression([operator = "delete"])` + * - `UpdateExpression` + * - `YieldExpression` + * - When `options.considerGetters` is `true`: + * - `MemberExpression` + * - When `options.considerImplicitTypeConversion` is `true`: + * - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])` + * - `MemberExpression([computed = true])` + * - `MethodDefinition([computed = true])` + * - `Property([computed = true])` + * - `UnaryExpression([operator = "-" | "+" | "!" | "~"])` + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect} + */ +exports.hasSideEffect = eslintUtils.hasSideEffect; +exports.isParenthesized = eslintUtils.isParenthesized; +//# sourceMappingURL=astUtilities.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.d.ts new file mode 100644 index 00000000..4a41363d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.d.ts @@ -0,0 +1,5 @@ +export * from './astUtilities'; +export * from './PatternMatcher'; +export * from './predicates'; +export * from './ReferenceTracker'; +export * from './scopeAnalysis'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.js new file mode 100644 index 00000000..6e0fbf72 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/index.js @@ -0,0 +1,22 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./astUtilities"), exports); +__exportStar(require("./PatternMatcher"), exports); +__exportStar(require("./predicates"), exports); +__exportStar(require("./ReferenceTracker"), exports); +__exportStar(require("./scopeAnalysis"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.d.ts new file mode 100644 index 00000000..3da016e1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.d.ts @@ -0,0 +1,31 @@ +import type { TSESTree } from '../../ts-estree'; +type IsSpecificTokenFunction = (token: TSESTree.Token) => token is SpecificToken; +type IsNotSpecificTokenFunction = (token: TSESTree.Token) => token is Exclude; +type PunctuatorTokenWithValue = { + value: Value; +} & TSESTree.PunctuatorToken; +type IsPunctuatorTokenWithValueFunction = IsSpecificTokenFunction>; +type IsNotPunctuatorTokenWithValueFunction = IsNotSpecificTokenFunction>; +export declare const isArrowToken: IsPunctuatorTokenWithValueFunction<'=>'>; +export declare const isNotArrowToken: IsNotPunctuatorTokenWithValueFunction<'=>'>; +export declare const isClosingBraceToken: IsPunctuatorTokenWithValueFunction<'}'>; +export declare const isNotClosingBraceToken: IsNotPunctuatorTokenWithValueFunction<'}'>; +export declare const isClosingBracketToken: IsPunctuatorTokenWithValueFunction<']'>; +export declare const isNotClosingBracketToken: IsNotPunctuatorTokenWithValueFunction<']'>; +export declare const isClosingParenToken: IsPunctuatorTokenWithValueFunction<')'>; +export declare const isNotClosingParenToken: IsNotPunctuatorTokenWithValueFunction<')'>; +export declare const isColonToken: IsPunctuatorTokenWithValueFunction<':'>; +export declare const isNotColonToken: IsNotPunctuatorTokenWithValueFunction<':'>; +export declare const isCommaToken: IsPunctuatorTokenWithValueFunction<','>; +export declare const isNotCommaToken: IsNotPunctuatorTokenWithValueFunction<','>; +export declare const isCommentToken: IsSpecificTokenFunction; +export declare const isNotCommentToken: IsNotSpecificTokenFunction; +export declare const isOpeningBraceToken: IsPunctuatorTokenWithValueFunction<'{'>; +export declare const isNotOpeningBraceToken: IsNotPunctuatorTokenWithValueFunction<'{'>; +export declare const isOpeningBracketToken: IsPunctuatorTokenWithValueFunction<'['>; +export declare const isNotOpeningBracketToken: IsNotPunctuatorTokenWithValueFunction<'['>; +export declare const isOpeningParenToken: IsPunctuatorTokenWithValueFunction<'('>; +export declare const isNotOpeningParenToken: IsNotPunctuatorTokenWithValueFunction<'('>; +export declare const isSemicolonToken: IsPunctuatorTokenWithValueFunction<';'>; +export declare const isNotSemicolonToken: IsNotPunctuatorTokenWithValueFunction<';'>; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.js new file mode 100644 index 00000000..beeb2cae --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/predicates.js @@ -0,0 +1,60 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNotSemicolonToken = exports.isSemicolonToken = exports.isNotOpeningParenToken = exports.isOpeningParenToken = exports.isNotOpeningBracketToken = exports.isOpeningBracketToken = exports.isNotOpeningBraceToken = exports.isOpeningBraceToken = exports.isNotCommentToken = exports.isCommentToken = exports.isNotCommaToken = exports.isCommaToken = exports.isNotColonToken = exports.isColonToken = exports.isNotClosingParenToken = exports.isClosingParenToken = exports.isNotClosingBracketToken = exports.isClosingBracketToken = exports.isNotClosingBraceToken = exports.isClosingBraceToken = exports.isNotArrowToken = exports.isArrowToken = void 0; +const eslintUtils = __importStar(require("@eslint-community/eslint-utils")); +exports.isArrowToken = eslintUtils.isArrowToken; +exports.isNotArrowToken = eslintUtils.isNotArrowToken; +exports.isClosingBraceToken = eslintUtils.isClosingBraceToken; +exports.isNotClosingBraceToken = eslintUtils.isNotClosingBraceToken; +exports.isClosingBracketToken = eslintUtils.isClosingBracketToken; +exports.isNotClosingBracketToken = eslintUtils.isNotClosingBracketToken; +exports.isClosingParenToken = eslintUtils.isClosingParenToken; +exports.isNotClosingParenToken = eslintUtils.isNotClosingParenToken; +exports.isColonToken = eslintUtils.isColonToken; +exports.isNotColonToken = eslintUtils.isNotColonToken; +exports.isCommaToken = eslintUtils.isCommaToken; +exports.isNotCommaToken = eslintUtils.isNotCommaToken; +exports.isCommentToken = eslintUtils.isCommentToken; +exports.isNotCommentToken = eslintUtils.isNotCommentToken; +exports.isOpeningBraceToken = eslintUtils.isOpeningBraceToken; +exports.isNotOpeningBraceToken = eslintUtils.isNotOpeningBraceToken; +exports.isOpeningBracketToken = eslintUtils.isOpeningBracketToken; +exports.isNotOpeningBracketToken = eslintUtils.isNotOpeningBracketToken; +exports.isOpeningParenToken = eslintUtils.isOpeningParenToken; +exports.isNotOpeningParenToken = eslintUtils.isNotOpeningParenToken; +exports.isSemicolonToken = eslintUtils.isSemicolonToken; +exports.isNotSemicolonToken = eslintUtils.isNotSemicolonToken; +//# sourceMappingURL=predicates.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts new file mode 100644 index 00000000..8d6348e0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts @@ -0,0 +1,16 @@ +import type * as TSESLint from '../../ts-eslint'; +import type { TSESTree } from '../../ts-estree'; +/** + * Get the variable of a given name. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#findvariable} + */ +export declare const findVariable: (initialScope: TSESLint.Scope.Scope, nameOrNode: string | TSESTree.Identifier) => TSESLint.Scope.Variable | null; +/** + * Get the innermost scope which contains a given node. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#getinnermostscope} + * @returns The innermost scope which contains the given node. + * If such scope doesn't exist then it returns the 1st argument `initialScope`. + */ +export declare const getInnermostScope: (initialScope: TSESLint.Scope.Scope, node: TSESTree.Node) => TSESLint.Scope.Scope; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.js new file mode 100644 index 00000000..80f64897 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/eslint-utils/scopeAnalysis.js @@ -0,0 +1,52 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getInnermostScope = exports.findVariable = void 0; +const eslintUtils = __importStar(require("@eslint-community/eslint-utils")); +/** + * Get the variable of a given name. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#findvariable} + */ +exports.findVariable = eslintUtils.findVariable; +/** + * Get the innermost scope which contains a given node. + * + * @see {@link https://eslint-community.github.io/eslint-utils/api/scope-utils.html#getinnermostscope} + * @returns The innermost scope which contains the given node. + * If such scope doesn't exist then it returns the 1st argument `initialScope`. + */ +exports.getInnermostScope = eslintUtils.getInnermostScope; +//# sourceMappingURL=scopeAnalysis.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.d.ts new file mode 100644 index 00000000..9df9cdd8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.d.ts @@ -0,0 +1,18 @@ +import type { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree } from '../ts-estree'; +export declare const isNodeOfType: (nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract; +export declare const isNodeOfTypes: (nodeTypes: NodeTypes) => (node: TSESTree.Node | null | undefined) => node is Extract; +export declare const isNodeOfTypeWithConditions: , Conditions extends Partial>(nodeType: NodeType, conditions: Conditions) => ((node: TSESTree.Node | null | undefined) => node is Conditions & ExtractedNode); +export declare const isTokenOfTypeWithConditions: , Conditions extends Partial<{ + type: TokenType; +} & TSESTree.Token>>(tokenType: TokenType, conditions: Conditions) => ((token: TSESTree.Token | null | undefined) => token is Conditions & ExtractedToken); +export declare const isNotTokenOfTypeWithConditions: , Conditions extends Partial>(tokenType: TokenType, conditions: Conditions) => ((token: TSESTree.Token | null | undefined) => token is Exclude); diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js new file mode 100644 index 00000000..4d6bb469 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js @@ -0,0 +1,22 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isNotTokenOfTypeWithConditions = exports.isTokenOfTypeWithConditions = exports.isNodeOfTypeWithConditions = exports.isNodeOfTypes = exports.isNodeOfType = void 0; +const isNodeOfType = (nodeType) => (node) => node?.type === nodeType; +exports.isNodeOfType = isNodeOfType; +const isNodeOfTypes = (nodeTypes) => (node) => !!node && nodeTypes.includes(node.type); +exports.isNodeOfTypes = isNodeOfTypes; +const isNodeOfTypeWithConditions = (nodeType, conditions) => { + const entries = Object.entries(conditions); + return (node) => node?.type === nodeType && + entries.every(([key, value]) => node[key] === value); +}; +exports.isNodeOfTypeWithConditions = isNodeOfTypeWithConditions; +const isTokenOfTypeWithConditions = (tokenType, conditions) => { + const entries = Object.entries(conditions); + return (token) => token?.type === tokenType && + entries.every(([key, value]) => token[key] === value); +}; +exports.isTokenOfTypeWithConditions = isTokenOfTypeWithConditions; +const isNotTokenOfTypeWithConditions = (tokenType, conditions) => (token) => !(0, exports.isTokenOfTypeWithConditions)(tokenType, conditions)(token); +exports.isNotTokenOfTypeWithConditions = isNotTokenOfTypeWithConditions; +//# sourceMappingURL=helpers.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.d.ts new file mode 100644 index 00000000..66e528aa --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.d.ts @@ -0,0 +1,4 @@ +export * from './eslint-utils'; +export * from './helpers'; +export * from './misc'; +export * from './predicates'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js new file mode 100644 index 00000000..6c5b6600 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js @@ -0,0 +1,21 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./eslint-utils"), exports); +__exportStar(require("./helpers"), exports); +__exportStar(require("./misc"), exports); +__exportStar(require("./predicates"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.d.ts new file mode 100644 index 00000000..48a6a56d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.d.ts @@ -0,0 +1,10 @@ +import type { TSESTree } from '../ts-estree'; +/** + * A regular expression to match line terminators. + * @see https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-LineTerminator + */ +export declare const LINEBREAK_MATCHER: RegExp; +/** + * Determines whether two adjacent tokens are on the same line + */ +export declare function isTokenOnSameLine(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js new file mode 100644 index 00000000..9aa2286a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js @@ -0,0 +1,16 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.LINEBREAK_MATCHER = void 0; +exports.isTokenOnSameLine = isTokenOnSameLine; +/** + * A regular expression to match line terminators. + * @see https://tc39.es/ecma262/multipage/ecmascript-language-lexical-grammar.html#prod-LineTerminator + */ +exports.LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/; +/** + * Determines whether two adjacent tokens are on the same line + */ +function isTokenOnSameLine(left, right) { + return left.loc.end.line === right.loc.start.line; +} +//# sourceMappingURL=misc.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.d.ts new file mode 100644 index 00000000..a05ceff8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.d.ts @@ -0,0 +1,68 @@ +import type { TSESTree } from '../ts-estree'; +export declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is { + value: "?."; +} & TSESTree.PunctuatorToken; +export declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BlockComment | TSESTree.BooleanToken | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.LineComment | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PrivateIdentifierToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken; +export declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is { + value: "!"; +} & TSESTree.PunctuatorToken; +export declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BlockComment | TSESTree.BooleanToken | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.LineComment | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PrivateIdentifierToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken; +/** + * Returns true if and only if the node represents: foo?.() or foo.bar?.() + */ +export declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is { + optional: boolean; +} & TSESTree.CallExpression; +/** + * Returns true if and only if the node represents logical OR + */ +export declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is Partial & TSESTree.LogicalExpression; +/** + * Checks if a node is a type assertion: + * ``` + * x as foo + * x + * ``` + */ +export declare const isTypeAssertion: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSTypeAssertion; +export declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) => node is TSESTree.UsingInForOfDeclarator | TSESTree.UsingInNormalContextDeclarator | TSESTree.VariableDeclaratorDefiniteAssignment | TSESTree.VariableDeclaratorMaybeInit | TSESTree.VariableDeclaratorNoInit; +export declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpressionWithBlockBody | TSESTree.ArrowFunctionExpressionWithExpressionBody | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression; +export declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSDeclareFunctionNoDeclare | TSESTree.TSDeclareFunctionWithDeclare | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName; +export declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpressionWithBlockBody | TSESTree.ArrowFunctionExpressionWithExpressionBody | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSDeclareFunctionNoDeclare | TSESTree.TSDeclareFunctionWithDeclare | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName; +export declare const isTSFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSFunctionType; +export declare const isTSConstructorType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSConstructorType; +export declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.FunctionExpression | TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSAbstractMethodDefinitionComputedName | TSESTree.TSAbstractMethodDefinitionNonComputedName | TSESTree.TSAbstractPropertyDefinitionComputedName | TSESTree.TSAbstractPropertyDefinitionNonComputedName | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSIndexSignature | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName; +/** + * Checks if a node is a constructor method. + */ +export declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (Partial & TSESTree.MethodDefinitionComputedName) | (Partial & TSESTree.MethodDefinitionNonComputedName); +/** + * Checks if a node is a setter method. + */ +export declare function isSetter(node: TSESTree.Node | undefined): node is { + kind: 'set'; +} & (TSESTree.MethodDefinition | TSESTree.Property); +export declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier; +/** + * Checks if a node represents an `await …` expression. + */ +export declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.AwaitExpression; +/** + * Checks if a possible token is the `await` keyword. + */ +export declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is { + value: "await"; +} & TSESTree.IdentifierToken; +/** + * Checks if a possible token is the `type` keyword. + */ +export declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is { + value: "type"; +} & TSESTree.IdentifierToken; +/** + * Checks if a possible token is the `import` keyword. + */ +export declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is { + value: "import"; +} & TSESTree.KeywordToken; +export declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js new file mode 100644 index 00000000..5cefcba1 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js @@ -0,0 +1,109 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isLoop = exports.isImportKeyword = exports.isTypeKeyword = exports.isAwaitKeyword = exports.isAwaitExpression = exports.isIdentifier = exports.isConstructor = exports.isClassOrTypeElement = exports.isTSConstructorType = exports.isTSFunctionType = exports.isFunctionOrFunctionType = exports.isFunctionType = exports.isFunction = exports.isVariableDeclarator = exports.isTypeAssertion = exports.isLogicalOrOperator = exports.isOptionalCallExpression = exports.isNotNonNullAssertionPunctuator = exports.isNonNullAssertionPunctuator = exports.isNotOptionalChainPunctuator = exports.isOptionalChainPunctuator = void 0; +exports.isSetter = isSetter; +const ts_estree_1 = require("../ts-estree"); +const helpers_1 = require("./helpers"); +exports.isOptionalChainPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' }); +exports.isNotOptionalChainPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' }); +exports.isNonNullAssertionPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' }); +exports.isNotNonNullAssertionPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' }); +/** + * Returns true if and only if the node represents: foo?.() or foo.bar?.() + */ +exports.isOptionalCallExpression = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.CallExpression, +// this flag means the call expression itself is option +// i.e. it is foo.bar?.() and not foo?.bar() +{ optional: true }); +/** + * Returns true if and only if the node represents logical OR + */ +exports.isLogicalOrOperator = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.LogicalExpression, { operator: '||' }); +/** + * Checks if a node is a type assertion: + * ``` + * x as foo + * x + * ``` + */ +exports.isTypeAssertion = (0, helpers_1.isNodeOfTypes)([ + ts_estree_1.AST_NODE_TYPES.TSAsExpression, + ts_estree_1.AST_NODE_TYPES.TSTypeAssertion, +]); +exports.isVariableDeclarator = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.VariableDeclarator); +const functionTypes = [ + ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression, + ts_estree_1.AST_NODE_TYPES.FunctionDeclaration, + ts_estree_1.AST_NODE_TYPES.FunctionExpression, +]; +exports.isFunction = (0, helpers_1.isNodeOfTypes)(functionTypes); +const functionTypeTypes = [ + ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration, + ts_estree_1.AST_NODE_TYPES.TSConstructorType, + ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration, + ts_estree_1.AST_NODE_TYPES.TSDeclareFunction, + ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression, + ts_estree_1.AST_NODE_TYPES.TSFunctionType, + ts_estree_1.AST_NODE_TYPES.TSMethodSignature, +]; +exports.isFunctionType = (0, helpers_1.isNodeOfTypes)(functionTypeTypes); +exports.isFunctionOrFunctionType = (0, helpers_1.isNodeOfTypes)([ + ...functionTypes, + ...functionTypeTypes, +]); +exports.isTSFunctionType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSFunctionType); +exports.isTSConstructorType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSConstructorType); +exports.isClassOrTypeElement = (0, helpers_1.isNodeOfTypes)([ + // ClassElement + ts_estree_1.AST_NODE_TYPES.PropertyDefinition, + ts_estree_1.AST_NODE_TYPES.FunctionExpression, + ts_estree_1.AST_NODE_TYPES.MethodDefinition, + ts_estree_1.AST_NODE_TYPES.TSAbstractPropertyDefinition, + ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition, + ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression, + ts_estree_1.AST_NODE_TYPES.TSIndexSignature, + // TypeElement + ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration, + ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration, + // AST_NODE_TYPES.TSIndexSignature, + ts_estree_1.AST_NODE_TYPES.TSMethodSignature, + ts_estree_1.AST_NODE_TYPES.TSPropertySignature, +]); +/** + * Checks if a node is a constructor method. + */ +exports.isConstructor = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.MethodDefinition, { kind: 'constructor' }); +/** + * Checks if a node is a setter method. + */ +function isSetter(node) { + return (!!node && + (node.type === ts_estree_1.AST_NODE_TYPES.MethodDefinition || + node.type === ts_estree_1.AST_NODE_TYPES.Property) && + node.kind === 'set'); +} +exports.isIdentifier = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.Identifier); +/** + * Checks if a node represents an `await …` expression. + */ +exports.isAwaitExpression = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.AwaitExpression); +/** + * Checks if a possible token is the `await` keyword. + */ +exports.isAwaitKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: 'await' }); +/** + * Checks if a possible token is the `type` keyword. + */ +exports.isTypeKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: 'type' }); +/** + * Checks if a possible token is the `import` keyword. + */ +exports.isImportKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Keyword, { value: 'import' }); +exports.isLoop = (0, helpers_1.isNodeOfTypes)([ + ts_estree_1.AST_NODE_TYPES.DoWhileStatement, + ts_estree_1.AST_NODE_TYPES.ForStatement, + ts_estree_1.AST_NODE_TYPES.ForInStatement, + ts_estree_1.AST_NODE_TYPES.ForOfStatement, + ts_estree_1.AST_NODE_TYPES.WhileStatement, +]); +//# sourceMappingURL=predicates.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.d.ts new file mode 100644 index 00000000..093a2d90 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.d.ts @@ -0,0 +1,9 @@ +import type { RuleCreateFunction, RuleModule } from '../ts-eslint'; +/** + * Uses type inference to fetch the Options type from the given RuleModule + */ +export type InferOptionsTypeFromRule = T extends RuleModule ? Options : T extends RuleCreateFunction ? Options : unknown; +/** + * Uses type inference to fetch the MessageIds type from the given RuleModule + */ +export type InferMessageIdsTypeFromRule = T extends RuleModule ? MessageIds : T extends RuleCreateFunction ? MessageIds : unknown; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js new file mode 100644 index 00000000..9305805b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=InferTypesFromRule.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.d.ts new file mode 100644 index 00000000..e6a75e2b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.d.ts @@ -0,0 +1,32 @@ +import type { RuleContext, RuleListener, RuleMetaData, RuleMetaDataDocs, RuleModule } from '../ts-eslint/Rule'; +export type NamedCreateRuleMetaDocs = Omit; +export type NamedCreateRuleMeta = { + docs: PluginDocs & RuleMetaDataDocs; +} & Omit, 'docs'>; +export interface RuleCreateAndOptions { + create: (context: Readonly>, optionsWithDefault: Readonly) => RuleListener; + /** @deprecated Use meta.defaultOptions instead */ + defaultOptions?: Readonly; +} +export interface RuleWithMeta extends RuleCreateAndOptions { + meta: RuleMetaData; + name?: string; +} +export interface RuleWithMetaAndName extends RuleCreateAndOptions { + meta: NamedCreateRuleMeta; + name: string; +} +type RuleModuleWithName = RuleModule & { + name: string; +}; +/** + * Creates reusable function to create rules with default options and docs URLs. + * + * @param urlCreator Creates a documentation URL for a given rule name. + * @returns Function to create a rule with the docs URL format. + */ +export declare function RuleCreator(urlCreator: (ruleName: string) => string): ({ meta, name, ...rule }: Readonly>) => RuleModuleWithName; +export declare namespace RuleCreator { + var withoutDocs: (args: Readonly>) => RuleModule; +} +export { type RuleListener, type RuleModule } from '../ts-eslint/Rule'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js new file mode 100644 index 00000000..98dca2e7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RuleCreator = RuleCreator; +const applyDefault_1 = require("./applyDefault"); +/** + * Creates reusable function to create rules with default options and docs URLs. + * + * @param urlCreator Creates a documentation URL for a given rule name. + * @returns Function to create a rule with the docs URL format. + */ +function RuleCreator(urlCreator) { + // This function will get much easier to call when this is merged https://github.com/Microsoft/TypeScript/pull/26349 + // TODO - when the above PR lands; add type checking for the context.report `data` property + return function createNamedRule({ meta, name, ...rule }) { + const ruleWithDocs = createRule({ + meta: { + ...meta, + docs: { + ...meta.docs, + url: urlCreator(name), + }, + }, + name, + ...rule, + }); + return ruleWithDocs; + }; +} +function createRule({ create, +// Keep accepting deprecated defaultOptions for backward compatibility. +// eslint-disable-next-line @typescript-eslint/no-deprecated +defaultOptions, meta, name, }) { + const resolvedDefaultOptions = (meta.defaultOptions ?? + defaultOptions ?? + []); + return { + create(context) { + const optionsWithDefault = (0, applyDefault_1.applyDefault)(resolvedDefaultOptions, context.options); + return create(context, optionsWithDefault); + }, + defaultOptions, + meta, + name, + }; +} +/** + * Creates a well-typed TSESLint custom ESLint rule without a docs URL. + * + * @returns Well-typed TSESLint custom ESLint rule. + * @remarks It is generally better to provide a docs URL function to RuleCreator. + */ +RuleCreator.withoutDocs = function withoutDocs(args) { + return createRule(args); +}; +//# sourceMappingURL=RuleCreator.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.d.ts new file mode 100644 index 00000000..72deb69b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.d.ts @@ -0,0 +1,8 @@ +/** + * Pure function - doesn't mutate either parameter! + * Uses the default options and overrides with the options provided by the user + * @param defaultOptions the defaults + * @param userOptions the user opts + * @returns the options with defaults + */ +export declare function applyDefault(defaultOptions: Readonly, userOptions: Readonly | null): Default; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js new file mode 100644 index 00000000..1cb9d70a --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js @@ -0,0 +1,34 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.applyDefault = applyDefault; +const deepMerge_1 = require("./deepMerge"); +/** + * Pure function - doesn't mutate either parameter! + * Uses the default options and overrides with the options provided by the user + * @param defaultOptions the defaults + * @param userOptions the user opts + * @returns the options with defaults + */ +function applyDefault(defaultOptions, userOptions) { + // clone defaults + const options = structuredClone(defaultOptions); + if (userOptions == null) { + return options; + } + // For avoiding the type error + // `This expression is not callable. Type 'unknown' has no call signatures.ts(2349)` + options.forEach((opt, i) => { + // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish + if (userOptions[i] !== undefined) { + const userOpt = userOptions[i]; + if ((0, deepMerge_1.isObjectNotArray)(userOpt) && (0, deepMerge_1.isObjectNotArray)(opt)) { + options[i] = (0, deepMerge_1.deepMerge)(opt, userOpt); + } + else { + options[i] = userOpt; + } + } + }); + return options; +} +//# sourceMappingURL=applyDefault.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.d.ts new file mode 100644 index 00000000..b5d31ffb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.d.ts @@ -0,0 +1,14 @@ +export type ObjectLike = Record; +/** + * Check if the variable contains an object strictly rejecting arrays + * @returns `true` if obj is an object + */ +export declare function isObjectNotArray(obj: unknown): obj is ObjectLike; +/** + * Pure function - doesn't mutate either parameter! + * Merges two objects together deeply, overwriting the properties in first with the properties in second + * @param first The first object + * @param second The second object + * @returns a new object + */ +export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js new file mode 100644 index 00000000..51a50890 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js @@ -0,0 +1,47 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isObjectNotArray = isObjectNotArray; +exports.deepMerge = deepMerge; +/** + * Check if the variable contains an object strictly rejecting arrays + * @returns `true` if obj is an object + */ +function isObjectNotArray(obj) { + return typeof obj === 'object' && obj != null && !Array.isArray(obj); +} +/** + * Pure function - doesn't mutate either parameter! + * Merges two objects together deeply, overwriting the properties in first with the properties in second + * @param first The first object + * @param second The second object + * @returns a new object + */ +function deepMerge(first = {}, second = {}) { + // get the unique set of keys across both objects + const keys = new Set([...Object.keys(first), ...Object.keys(second)]); + return Object.fromEntries([...keys].map(key => { + const firstHasKey = key in first; + const secondHasKey = key in second; + const firstValue = first[key]; + const secondValue = second[key]; + let value; + if (firstHasKey && secondHasKey) { + if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) { + // object type + value = deepMerge(firstValue, secondValue); + } + else { + // value type + value = secondValue; + } + } + else if (firstHasKey) { + value = firstValue; + } + else { + value = secondValue; + } + return [key, value]; + })); +} +//# sourceMappingURL=deepMerge.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.d.ts new file mode 100644 index 00000000..a6a91ff6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.d.ts @@ -0,0 +1,22 @@ +import type * as TSESLint from '../ts-eslint'; +import type { ParserServices, ParserServicesWithTypeInformation } from '../ts-estree'; +/** + * Try to retrieve type-aware parser service from context. + * This **_will_** throw if it is not available. + */ +export declare function getParserServices(context: Readonly>): ParserServicesWithTypeInformation; +/** + * Try to retrieve type-aware parser service from context. + * This **_will_** throw if it is not available. + */ +export declare function getParserServices(context: Readonly>, allowWithoutFullTypeInformation: false): ParserServicesWithTypeInformation; +/** + * Try to retrieve type-aware parser service from context. + * This **_will not_** throw if it is not available. + */ +export declare function getParserServices(context: Readonly>, allowWithoutFullTypeInformation: true): ParserServices; +/** + * Try to retrieve type-aware parser service from context. + * This may or may not throw if it is not available, depending on if `allowWithoutFullTypeInformation` is `true` + */ +export declare function getParserServices(context: Readonly>, allowWithoutFullTypeInformation: boolean): ParserServices; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js new file mode 100644 index 00000000..baa49572 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js @@ -0,0 +1,42 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getParserServices = getParserServices; +const parserSeemsToBeTSESLint_1 = require("./parserSeemsToBeTSESLint"); +const ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information."; +const ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.'; +function getParserServices(context, allowWithoutFullTypeInformation = false) { + const parser = + // eslint-disable-next-line @typescript-eslint/no-deprecated -- For compatibility with ESLint 8 + context.parserPath || context.languageOptions.parser?.meta?.name; + // This check is unnecessary if the user is using the latest version of our parser. + // + // However the world isn't perfect: + // - Users often use old parser versions. + // Old versions of the parser would not return any parserServices unless parserOptions.project was set. + // - Users sometimes use parsers that aren't @typescript-eslint/parser + // Other parsers won't return the parser services we expect (if they return any at all). + // + // This check allows us to handle bad user setups whilst providing a nice user-facing + // error message explaining the problem. + if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null || + context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) { + throwError(parser); + } + // if a rule requires full type information, then hard fail if it doesn't exist + // this forces the user to supply parserOptions.project + if (context.sourceCode.parserServices.program == null && + !allowWithoutFullTypeInformation) { + throwError(parser); + } + return context.sourceCode.parserServices; +} +/* eslint-enable @typescript-eslint/unified-signatures */ +function throwError(parser) { + const messages = [ + ERROR_MESSAGE_REQUIRES_PARSER_SERVICES, + `Parser: ${parser || '(unknown)'}`, + !(0, parserSeemsToBeTSESLint_1.parserSeemsToBeTSESLint)(parser) && ERROR_MESSAGE_UNKNOWN_PARSER, + ].filter(Boolean); + throw new Error(messages.join('\n')); +} +//# sourceMappingURL=getParserServices.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.d.ts new file mode 100644 index 00000000..632b6e05 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.d.ts @@ -0,0 +1,6 @@ +export * from './applyDefault'; +export * from './deepMerge'; +export * from './getParserServices'; +export * from './InferTypesFromRule'; +export * from './nullThrows'; +export * from './RuleCreator'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js new file mode 100644 index 00000000..e3895dd4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js @@ -0,0 +1,23 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./applyDefault"), exports); +__exportStar(require("./deepMerge"), exports); +__exportStar(require("./getParserServices"), exports); +__exportStar(require("./InferTypesFromRule"), exports); +__exportStar(require("./nullThrows"), exports); +__exportStar(require("./RuleCreator"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.d.ts new file mode 100644 index 00000000..1786dd78 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.d.ts @@ -0,0 +1,12 @@ +/** + * A set of common reasons for calling nullThrows + */ +export declare const NullThrowsReasons: { + readonly MissingParent: 'Expected node to have a parent.'; + readonly MissingToken: (token: string, thing: string) => string; +}; +/** + * Assert that a value must not be null or undefined. + * This is a nice explicit alternative to the non-null assertion operator. + */ +export declare function nullThrows(value: T, message: string): NonNullable; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js new file mode 100644 index 00000000..a534dd67 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js @@ -0,0 +1,22 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NullThrowsReasons = void 0; +exports.nullThrows = nullThrows; +/** + * A set of common reasons for calling nullThrows + */ +exports.NullThrowsReasons = { + MissingParent: 'Expected node to have a parent.', + MissingToken: (token, thing) => `Expected to find a ${token} for the ${thing}.`, +}; +/** + * Assert that a value must not be null or undefined. + * This is a nice explicit alternative to the non-null assertion operator. + */ +function nullThrows(value, message) { + if (value == null) { + throw new Error(`Non-null Assertion Failed: ${message}`); + } + return value; +} +//# sourceMappingURL=nullThrows.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.d.ts new file mode 100644 index 00000000..16b5d8be --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.d.ts @@ -0,0 +1 @@ +export declare function parserSeemsToBeTSESLint(parser: string | undefined): boolean; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js new file mode 100644 index 00000000..01a05902 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js @@ -0,0 +1,7 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parserSeemsToBeTSESLint = parserSeemsToBeTSESLint; +function parserSeemsToBeTSESLint(parser) { + return !!parser && /(?:typescript-eslint|\.\.)[\w/\\]*parser/.test(parser); +} +//# sourceMappingURL=parserSeemsToBeTSESLint.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.d.ts new file mode 100644 index 00000000..f7301058 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.d.ts @@ -0,0 +1,6 @@ +export * as ASTUtils from './ast-utils'; +export * as ESLintUtils from './eslint-utils'; +export * as JSONSchema from './json-schema'; +export * as TSESLint from './ts-eslint'; +export * from './ts-estree'; +export * as TSUtils from './ts-utils'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.js new file mode 100644 index 00000000..0ed4f85c --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/index.js @@ -0,0 +1,46 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TSUtils = exports.TSESLint = exports.JSONSchema = exports.ESLintUtils = exports.ASTUtils = void 0; +exports.ASTUtils = __importStar(require("./ast-utils")); +exports.ESLintUtils = __importStar(require("./eslint-utils")); +exports.JSONSchema = __importStar(require("./json-schema")); +exports.TSESLint = __importStar(require("./ts-eslint")); +__exportStar(require("./ts-estree"), exports); +exports.TSUtils = __importStar(require("./ts-utils")); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.d.ts new file mode 100644 index 00000000..a266e7c6 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.d.ts @@ -0,0 +1,387 @@ +/** + * This is a fork of https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13f63c2eb8d7479caf01ab8d72f9e3683368a8f5/types/json-schema/index.d.ts + * We intentionally fork this because: + * - ESLint ***ONLY*** supports JSONSchema v4 + * - We want to provide stricter types + */ +/** + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1 + */ +export type JSONSchema4TypeName = 'any' | 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string'; +/** + * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5 + */ +export type JSONSchema4Type = boolean | number | string | null; +export type JSONSchema4TypeExtended = JSONSchema4Array | JSONSchema4Object | JSONSchema4Type; +export interface JSONSchema4Object { + [key: string]: JSONSchema4TypeExtended; +} +export interface JSONSchema4Array extends Array { +} +/** + * Meta schema + * + * Recommended values: + * - 'http://json-schema.org/schema#' + * - 'http://json-schema.org/hyper-schema#' + * - 'http://json-schema.org/draft-04/schema#' + * - 'http://json-schema.org/draft-04/hyper-schema#' + * - 'http://json-schema.org/draft-03/schema#' + * - 'http://json-schema.org/draft-03/hyper-schema#' + * + * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5 + */ +export type JSONSchema4Version = string; +/** + * JSON Schema V4 + * @see https://tools.ietf.org/html/draft-zyp-json-schema-04 + */ +export type JSONSchema4 = JSONSchema4AllOfSchema | JSONSchema4AnyOfSchema | JSONSchema4AnySchema | JSONSchema4ArraySchema | JSONSchema4BooleanSchema | JSONSchema4MultiSchema | JSONSchema4NullSchema | JSONSchema4NumberSchema | JSONSchema4ObjectSchema | JSONSchema4OneOfSchema | JSONSchema4RefSchema | JSONSchema4StringSchema; +interface JSONSchema4Base { + /** + * Reusable definitions that can be referenced via `$ref` + */ + $defs?: Record | undefined; + /** + * Path to a schema defined in `definitions`/`$defs` that will form the base + * for this schema. + * + * If you are defining an "array" schema (`schema: [ ... ]`) for your rule + * then you should prefix this with `items/0` so that the validator can find + * your definitions. + * + * eg: `'#/items/0/definitions/myDef'` + * + * Otherwise if you are defining an "object" schema (`schema: { ... }`) for + * your rule you can directly reference your definitions + * + * eg: `'#/definitions/myDef'` + */ + $ref?: string | undefined; + $schema?: JSONSchema4Version | undefined; + /** + * (AND) Must be valid against all of the sub-schemas + */ + allOf?: JSONSchema4[] | undefined; + /** + * (OR) Must be valid against any of the sub-schemas + */ + anyOf?: JSONSchema4[] | undefined; + /** + * The default value for the item if not present + */ + default?: JSONSchema4TypeExtended | undefined; + /** + * Reusable definitions that can be referenced via `$ref` + */ + definitions?: Record | undefined; + /** + * This attribute is a string that provides a full description of the of + * purpose the instance property. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22 + */ + description?: string | undefined; + /** + * The value of this property MUST be another schema which will provide + * a base schema which the current schema will inherit from. The + * inheritance rules are such that any instance that is valid according + * to the current schema MUST be valid according to the referenced + * schema. This MAY also be an array, in which case, the instance MUST + * be valid for all the schemas in the array. A schema that extends + * another schema MAY define additional attributes, constrain existing + * attributes, or add other constraints. + * + * Conceptually, the behavior of extends can be seen as validating an + * instance against all constraints in the extending schema as well as + * the extended schema(s). + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26 + */ + extends?: string | string[] | undefined; + id?: string | undefined; + /** + * (NOT) Must not be valid against the given schema + */ + not?: JSONSchema4 | undefined; + /** + * (XOR) Must be valid against exactly one of the sub-schemas + */ + oneOf?: JSONSchema4[] | undefined; + /** + * This attribute indicates if the instance must have a value, and not + * be undefined. This is false by default, making the instance + * optional. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7 + */ + required?: boolean | string[] | undefined; + /** + * This attribute is a string that provides a short description of the + * instance property. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21 + */ + title?: string | undefined; + /** + * A single type, or a union of simple types + */ + type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined; +} +export interface JSONSchema4RefSchema extends JSONSchema4Base { + $ref: string; + type?: undefined; +} +export interface JSONSchema4AllOfSchema extends JSONSchema4Base { + allOf: JSONSchema4[]; + type?: undefined; +} +export interface JSONSchema4AnyOfSchema extends JSONSchema4Base { + anyOf: JSONSchema4[]; + type?: undefined; +} +export interface JSONSchema4OneOfSchema extends JSONSchema4Base { + oneOf: JSONSchema4[]; + type?: undefined; +} +export interface JSONSchema4MultiSchema extends Omit, Omit, Omit, Omit, Omit, Omit, Omit { + /** + * This provides an enumeration of all possible values that are valid + * for the instance property. This MUST be an array, and each item in + * the array represents a possible value for the instance value. If + * this attribute is defined, the instance value MUST be one of the + * values in the array in order for the schema to be valid. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 + */ + enum?: JSONSchema4Type[]; + type: JSONSchema4TypeName[]; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/object.html + */ +export interface JSONSchema4ObjectSchema extends JSONSchema4Base { + /** + * This attribute defines a schema for all properties that are not + * explicitly defined in an object type definition. If specified, the + * value MUST be a schema or a boolean. If false is provided, no + * additional properties are allowed beyond the properties defined in + * the schema. The default value is an empty schema which allows any + * value for additional properties. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4 + */ + additionalProperties?: boolean | JSONSchema4 | undefined; + /** + * The `dependencies` keyword conditionally applies a sub-schema when a given + * property is present. This schema is applied in the same way `allOf` applies + * schemas. Nothing is merged or extended. Both schemas apply independently. + */ + dependencies?: Record | undefined; + /** + * The maximum number of properties allowed for record-style schemas + */ + maxProperties?: number | undefined; + /** + * The minimum number of properties required for record-style schemas + */ + minProperties?: number | undefined; + /** + * This attribute is an object that defines the schema for a set of + * property names of an object instance. The name of each property of + * this attribute's object is a regular expression pattern in the ECMA + * 262/Perl 5 format, while the value is a schema. If the pattern + * matches the name of a property on the instance object, the value of + * the instance's property MUST be valid against the pattern name's + * schema value. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3 + */ + patternProperties?: Record | undefined; + /** + * This attribute is an object with property definitions that define the + * valid values of instance object property values. When the instance + * value is an object, the property values of the instance object MUST + * conform to the property definitions in this object. In this object, + * each property definition's value MUST be a schema, and the property's + * name MUST be the name of the instance property that it defines. The + * instance property value MUST be valid according to the schema from + * the property definition. Properties are considered unordered, the + * order of the instance properties MAY be in any order. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2 + */ + properties?: Record | undefined; + type: 'object'; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/array.html + */ +export interface JSONSchema4ArraySchema extends JSONSchema4Base { + /** + * May only be defined when "items" is defined, and is a tuple of JSONSchemas. + * + * This provides a definition for additional items in an array instance + * when tuple definitions of the items is provided. This can be false + * to indicate additional items in the array are not allowed, or it can + * be a schema that defines the schema of the additional items. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6 + */ + additionalItems?: boolean | JSONSchema4 | undefined; + /** + * This attribute defines the allowed items in an instance array, and + * MUST be a schema or an array of schemas. The default value is an + * empty schema which allows any value for items in the instance array. + * + * When this attribute value is a schema and the instance value is an + * array, then all the items in the array MUST be valid according to the + * schema. + * + * When this attribute value is an array of schemas and the instance + * value is an array, each position in the instance array MUST conform + * to the schema in the corresponding position for this array. This + * called tuple typing. When tuple typing is used, additional items are + * allowed, disallowed, or constrained by the "additionalItems" + * (Section 5.6) attribute using the same rules as + * "additionalProperties" (Section 5.4) for objects. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5 + */ + items?: JSONSchema4 | JSONSchema4[] | undefined; + /** + * Defines the maximum length of an array + */ + maxItems?: number | undefined; + /** + * Defines the minimum length of an array + */ + minItems?: number | undefined; + type: 'array'; + /** + * Enforces that all items in the array are unique + */ + uniqueItems?: boolean | undefined; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/string.html + */ +export interface JSONSchema4StringSchema extends JSONSchema4Base { + enum?: string[] | undefined; + /** + * The `format` keyword allows for basic semantic identification of certain + * kinds of string values that are commonly used. + * + * For example, because JSON doesn’t have a “DateTime” type, dates need to be + * encoded as strings. `format` allows the schema author to indicate that the + * string value should be interpreted as a date. + * + * ajv v6 provides a few built-in formats - all other strings will cause AJV + * to throw during schema compilation + */ + format?: 'date' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'json-pointer' | 'json-pointer-uri-fragment' | 'regex' | 'relative-json-pointer' | 'time' | 'uri' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | undefined; + /** + * The maximum allowed length for the string + */ + maxLength?: number | undefined; + /** + * The minimum allowed length for the string + */ + minLength?: number | undefined; + /** + * The `pattern` keyword is used to restrict a string to a particular regular + * expression. The regular expression syntax is the one defined in JavaScript + * (ECMA 262 specifically) with Unicode support. + * + * When defining the regular expressions, it’s important to note that the + * string is considered valid if the expression matches anywhere within the + * string. For example, the regular expression "p" will match any string with + * a p in it, such as "apple" not just a string that is simply "p". Therefore, + * it is usually less confusing, as a matter of course, to surround the + * regular expression in ^...$, for example, "^p$", unless there is a good + * reason not to do so. + */ + pattern?: string | undefined; + type: 'string'; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/numeric.html + */ +export interface JSONSchema4NumberSchema extends JSONSchema4Base { + /** + * This provides an enumeration of all possible values that are valid + * for the instance property. This MUST be an array, and each item in + * the array represents a possible value for the instance value. If + * this attribute is defined, the instance value MUST be one of the + * values in the array in order for the schema to be valid. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 + */ + enum?: number[] | undefined; + /** + * The exclusive minimum allowed value for the number + * - `true` = `x < maximum` + * - `false` = `x <= maximum` + * + * Default is `false` + */ + exclusiveMaximum?: boolean | undefined; + /** + * Indicates whether or not `minimum` is the inclusive or exclusive minimum + * - `true` = `x > minimum` + * - `false` = `x ≥ minimum` + * + * Default is `false` + */ + exclusiveMinimum?: boolean | undefined; + /** + * The maximum allowed value for the number + */ + maximum?: number | undefined; + /** + * The minimum allowed value for the number + */ + minimum?: number | undefined; + /** + * Numbers can be restricted to a multiple of a given number, using the + * `multipleOf` keyword. It may be set to any positive number. + */ + multipleOf?: number | undefined; + type: 'integer' | 'number'; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/boolean.html + */ +export interface JSONSchema4BooleanSchema extends JSONSchema4Base { + /** + * This provides an enumeration of all possible values that are valid + * for the instance property. This MUST be an array, and each item in + * the array represents a possible value for the instance value. If + * this attribute is defined, the instance value MUST be one of the + * values in the array in order for the schema to be valid. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 + */ + enum?: boolean[] | undefined; + type: 'boolean'; +} +/** + * @see https://json-schema.org/understanding-json-schema/reference/null.html + */ +export interface JSONSchema4NullSchema extends JSONSchema4Base { + /** + * This provides an enumeration of all possible values that are valid + * for the instance property. This MUST be an array, and each item in + * the array represents a possible value for the instance value. If + * this attribute is defined, the instance value MUST be one of the + * values in the array in order for the schema to be valid. + * + * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 + */ + enum?: null[] | undefined; + type: 'null'; +} +export interface JSONSchema4AnySchema extends JSONSchema4Base { + type: 'any'; +} +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.js new file mode 100644 index 00000000..8597348f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/json-schema.js @@ -0,0 +1,9 @@ +"use strict"; +/** + * This is a fork of https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13f63c2eb8d7479caf01ab8d72f9e3683368a8f5/types/json-schema/index.d.ts + * We intentionally fork this because: + * - ESLint ***ONLY*** supports JSONSchema v4 + * - We want to provide stricter types + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=json-schema.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.d.ts new file mode 100644 index 00000000..18f6b388 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.d.ts @@ -0,0 +1,8 @@ +import type { AST_TOKEN_TYPES, TSESTree } from '../ts-estree'; +declare namespace AST { + type TokenType = AST_TOKEN_TYPES; + type Token = TSESTree.Token; + type SourceLocation = TSESTree.SourceLocation; + type Range = TSESTree.Range; +} +export type { AST }; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.js new file mode 100644 index 00000000..a52223f3 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.js @@ -0,0 +1,4 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace, no-restricted-syntax */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=AST.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.d.ts new file mode 100644 index 00000000..a255825f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.d.ts @@ -0,0 +1,291 @@ +import type { Parser as ParserType } from './Parser'; +import type * as ParserOptionsTypes from './ParserOptions'; +import type { Processor as ProcessorType } from './Processor'; +import type { LooseRuleDefinition, SharedConfigurationSettings } from './Rule'; +/** @internal */ +export declare namespace SharedConfig { + type Severity = 0 | 1 | 2; + type SeverityString = 'error' | 'off' | 'warn'; + type RuleLevel = Severity | SeverityString; + type RuleLevelAndOptions = [RuleLevel, ...unknown[]]; + type RuleEntry = RuleLevel | RuleLevelAndOptions; + type RulesRecord = Partial>; + type GlobalVariableOptionBase = 'off' | /** @deprecated use `'readonly'` */ 'readable' | 'readonly' | 'writable' | /** @deprecated use `'writable'` */ 'writeable'; + type GlobalVariableOptionBoolean = /** @deprecated use `'readonly'` */ false | /** @deprecated use `'writable'` */ true; + type GlobalVariableOption = GlobalVariableOptionBase | GlobalVariableOptionBoolean; + interface GlobalsConfig { + [name: string]: GlobalVariableOption; + } + interface EnvironmentConfig { + [name: string]: boolean; + } + type ParserOptions = ParserOptionsTypes.ParserOptions; + interface PluginMeta { + /** + * The meta.name property should match the npm package name for your plugin. + */ + name: string; + /** + * If you followed the classic style to name your package + * (e.g. `eslint-plugin-X`, `@X/eslint-plugin`, or `@X/eslint-plugin-Y`), + * then this should match the classic namespace inferred for your package + * (e.g. `X`, `@X`, or `@X/Y`, respectively). + */ + namespace?: string; + /** + * The meta.version property should match the npm package version for your plugin. + */ + version: string; + } +} +export declare namespace ClassicConfig { + export type EnvironmentConfig = SharedConfig.EnvironmentConfig; + export type GlobalsConfig = SharedConfig.GlobalsConfig; + export type GlobalVariableOption = SharedConfig.GlobalVariableOption; + export type GlobalVariableOptionBase = SharedConfig.GlobalVariableOptionBase; + export type ParserOptions = SharedConfig.ParserOptions; + export type RuleEntry = SharedConfig.RuleEntry; + export type RuleLevel = SharedConfig.RuleLevel; + export type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; + export type RulesRecord = SharedConfig.RulesRecord; + export type Severity = SharedConfig.Severity; + export type SeverityString = SharedConfig.SeverityString; + interface BaseConfig { + $schema?: string; + /** + * The environment settings. + */ + env?: EnvironmentConfig; + /** + * The path to other config files or the package name of shareable configs. + */ + extends?: string | string[]; + /** + * The global variable settings. + */ + globals?: GlobalsConfig; + /** + * The flag that disables comment directives. + */ + noInlineConfig?: boolean; + /** + * The override settings per kind of files. + */ + overrides?: ConfigOverride[]; + /** + * The path to a parser or the package name of a parser. + */ + parser?: string | null; + /** + * The parser options. + */ + parserOptions?: ParserOptions; + /** + * The plugin specifiers. + */ + plugins?: string[]; + /** + * The processor specifier. + */ + processor?: string; + /** + * The flag to report unused `eslint-disable` comments. + */ + reportUnusedDisableDirectives?: boolean; + /** + * The rule settings. + */ + rules?: RulesRecord; + /** + * The shared settings. + */ + settings?: SharedConfigurationSettings; + } + export interface ConfigOverride extends BaseConfig { + excludedFiles?: string | string[]; + files: string | string[]; + } + export interface Config extends BaseConfig { + /** + * The glob patterns that ignore to lint. + */ + ignorePatterns?: string | string[]; + /** + * The root flag. + */ + root?: boolean; + } + export {}; +} +export declare namespace FlatConfig { + type EcmaVersion = ParserOptionsTypes.EcmaVersion; + type GlobalsConfig = SharedConfig.GlobalsConfig; + type Parser = ParserType.LooseParserModule; + type ParserOptions = SharedConfig.ParserOptions; + type PluginMeta = SharedConfig.PluginMeta; + type Processor = ProcessorType.LooseProcessorModule; + type RuleEntry = SharedConfig.RuleEntry; + type RuleLevel = SharedConfig.RuleLevel; + type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; + type Rules = SharedConfig.RulesRecord; + type Settings = SharedConfigurationSettings; + type Severity = SharedConfig.Severity; + type SeverityString = SharedConfig.SeverityString; + type SourceType = 'commonjs' | ParserOptionsTypes.SourceType; + interface SharedConfigs { + [key: string]: Config | ConfigArray; + } + interface Plugin { + /** + * Shared configurations bundled with the plugin. + * Users will reference these directly in their config (i.e. `plugin.configs.recommended`). + */ + configs?: SharedConfigs; + /** + * Metadata about your plugin for easier debugging and more effective caching of plugins. + */ + meta?: { + [K in keyof PluginMeta]?: PluginMeta[K] | undefined; + }; + /** + * The definition of plugin processors. + * Users can stringly reference the processor using the key in their config (i.e., `"pluginName/processorName"`). + */ + processors?: Partial> | undefined; + /** + * The definition of plugin rules. + * The key must be the name of the rule that users will use + * Users can stringly reference the rule using the key they registered the plugin under combined with the rule name. + * i.e. for the user config `plugins: { foo: pluginReference }` - the reference would be `"foo/ruleName"`. + */ + rules?: Record | undefined; + } + interface Plugins { + /** + * We intentionally omit the `configs` key from this object because it avoids + * type conflicts with old plugins that haven't updated their configs to flat configs yet. + * It's valid to reference these old plugins because ESLint won't access the + * `.config` property of a plugin when evaluating a flat config. + */ + [pluginAlias: string]: Omit; + } + interface LinterOptions { + /** + * A Boolean value indicating if inline configuration is allowed. + */ + noInlineConfig?: boolean; + /** + * A severity string indicating if and how unused disable and enable + * directives should be tracked and reported. For legacy compatibility, `true` + * is equivalent to `"warn"` and `false` is equivalent to `"off"`. + * @default "warn" + */ + reportUnusedDisableDirectives?: boolean | SharedConfig.Severity | SharedConfig.SeverityString; + /** + * A severity string indicating if and how unused inline directives + * should be tracked and reported. + * + * since ESLint 9.19.0 + * @default "off" + */ + reportUnusedInlineConfigs?: SharedConfig.Severity | SharedConfig.SeverityString; + } + interface LanguageOptions { + /** + * The version of ECMAScript to support. + * May be any year (i.e., `2022`) or version (i.e., `5`). + * Set to `"latest"` for the most recent supported version. + * @default "latest" + */ + ecmaVersion?: EcmaVersion | undefined; + /** + * An object specifying additional objects that should be added to the global scope during linting. + */ + globals?: GlobalsConfig | undefined; + /** + * An object containing a `parse()` method or a `parseForESLint()` method. + * @default + * ``` + * // https://github.com/eslint/espree + * require('espree') + * ``` + */ + parser?: Parser | undefined; + /** + * An object specifying additional options that are passed directly to the parser. + * The available options are parser-dependent. + */ + parserOptions?: ParserOptions | undefined; + /** + * The type of JavaScript source code. + * Possible values are `"script"` for traditional script files, `"module"` for ECMAScript modules (ESM), and `"commonjs"` for CommonJS files. + * @default + * ``` + * // for `.js` and `.mjs` files + * "module" + * // for `.cjs` files + * "commonjs" + * ``` + */ + sourceType?: SourceType | undefined; + } + interface Config { + /** + * The base path for files and ignores. + * + * Note that this is not permitted inside an `extends` array. + * + * Since ESLint 9.30.0 + */ + basePath?: string; + /** + * An array of glob patterns indicating the files that the configuration object should apply to. + * If not specified, the configuration object applies to all files matched by any other configuration object. + */ + files?: (string | string[])[]; + /** + * An array of glob patterns indicating the files that the configuration object should not apply to. + * If not specified, the configuration object applies to all files matched by files. + */ + ignores?: string[]; + /** + * Language specifier in the form `namespace/language-name` where `namespace` is a plugin name set in the `plugins` field. + */ + language?: string; + /** + * An object containing settings related to how JavaScript is configured for linting. + */ + languageOptions?: LanguageOptions; + /** + * An object containing settings related to the linting process. + */ + linterOptions?: LinterOptions; + /** + * An string to identify the configuration object. Used in error messages and inspection tools. + */ + name?: string; + /** + * An object containing a name-value mapping of plugin names to plugin objects. + * When `files` is specified, these plugins are only available to the matching files. + */ + plugins?: Plugins; + /** + * Either an object containing `preprocess()` and `postprocess()` methods or + * a string indicating the name of a processor inside of a plugin + * (i.e., `"pluginName/processorName"`). + */ + processor?: string | Processor; + /** + * An object containing the configured rules. + * When `files` or `ignores` are specified, these rule configurations are only available to the matching files. + */ + rules?: Rules; + /** + * An object containing name-value pairs of information that should be available to all rules. + */ + settings?: Settings; + } + type ConfigArray = Config[]; + type ConfigPromise = Promise; + type ConfigFile = ConfigArray | ConfigPromise; +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.js new file mode 100644 index 00000000..3894b265 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.js @@ -0,0 +1,4 @@ +"use strict"; +/* eslint-disable @typescript-eslint/consistent-indexed-object-style, @typescript-eslint/no-namespace */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Config.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.d.ts new file mode 100644 index 00000000..0b43dba7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.d.ts @@ -0,0 +1,7 @@ +export { FlatESLint } from './eslint/FlatESLint'; +export { FlatESLint as ESLint } from './eslint/FlatESLint'; +export { +/** + * @deprecated - use ESLint instead + */ +LegacyESLint, } from './eslint/LegacyESLint'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.js new file mode 100644 index 00000000..414b5bd4 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ESLint.js @@ -0,0 +1,14 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.LegacyESLint = exports.ESLint = exports.FlatESLint = void 0; +var FlatESLint_1 = require("./eslint/FlatESLint"); +Object.defineProperty(exports, "FlatESLint", { enumerable: true, get: function () { return FlatESLint_1.FlatESLint; } }); +var FlatESLint_2 = require("./eslint/FlatESLint"); +Object.defineProperty(exports, "ESLint", { enumerable: true, get: function () { return FlatESLint_2.FlatESLint; } }); +var LegacyESLint_1 = require("./eslint/LegacyESLint"); +// TODO(typescript-eslint@v9) - remove this in the next major release +/** + * @deprecated - use ESLint instead + */ +Object.defineProperty(exports, "LegacyESLint", { enumerable: true, get: function () { return LegacyESLint_1.LegacyESLint; } }); +//# sourceMappingURL=ESLint.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.d.ts new file mode 100644 index 00000000..12b34b8f --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.d.ts @@ -0,0 +1,255 @@ +import type { ClassicConfig, FlatConfig, SharedConfig } from './Config'; +import type { Parser } from './Parser'; +import type { Processor as ProcessorType } from './Processor'; +import type { AnyRuleCreateFunction, AnyRuleModule, RuleCreateFunction, RuleFix, RuleModule } from './Rule'; +import type { SourceCode } from './SourceCode'; +export type MinimalRuleModule = Partial, 'create'>> & Pick, 'create'>; +declare class LinterBase { + /** + * The version from package.json. + */ + readonly version: string; + /** + * Initialize the Linter. + * @param config the config object + */ + constructor(config?: Linter.LinterOptions); + /** + * Define a new parser module + * @param parserId Name of the parser + * @param parserModule The parser object + */ + defineParser(parserId: string, parserModule: Parser.LooseParserModule): void; + /** + * Defines a new linting rule. + * @param ruleId A unique rule identifier + * @param ruleModule Function from context to object mapping AST node types to event handlers + */ + defineRule(ruleId: string, ruleModule: MinimalRuleModule | RuleCreateFunction): void; + /** + * Defines many new linting rules. + * @param rulesToDefine map from unique rule identifier to rule + */ + defineRules(rulesToDefine: Record | RuleCreateFunction>): void; + /** + * Gets an object with all loaded rules. + * @returns All loaded rules + */ + getRules(): Map>; + /** + * Gets the `SourceCode` object representing the parsed source. + * @returns The `SourceCode` object. + */ + getSourceCode(): SourceCode; + /** + * Verifies the text against the rules specified by the second argument. + * @param textOrSourceCode The text to parse or a SourceCode object. + * @param config An ESLintConfig instance to configure everything. + * @param filenameOrOptions The optional filename of the file being checked. + * If this is not set, the filename will default to '' in the rule context. + * If this is an object, then it has "filename", "allowInlineConfig", and some properties. + * @returns The results as an array of messages or an empty array if no messages. + */ + verify(textOrSourceCode: string | SourceCode, config: Linter.ConfigType, filenameOrOptions?: string | Linter.VerifyOptions): Linter.LintMessage[]; + /** + * The version from package.json. + */ + static readonly version: string; + /** + * Performs multiple autofix passes over the text until as many fixes as possible have been applied. + * @param code The source text to apply fixes to. + * @param config The ESLint config object to use. + * @param options The ESLint options object to use. + * @returns The result of the fix operation as returned from the SourceCodeFixer. + */ + verifyAndFix(code: string, config: Linter.ConfigType, options: Linter.FixOptions): Linter.FixReport; +} +declare namespace Linter { + interface LinterOptions { + /** + * Which config format to use. + * @default 'flat' + */ + configType?: ConfigTypeSpecifier; + /** + * path to a directory that should be considered as the current working directory. + */ + cwd?: string; + } + type ConfigTypeSpecifier = 'eslintrc' | 'flat'; + type EnvironmentConfig = SharedConfig.EnvironmentConfig; + type GlobalsConfig = SharedConfig.GlobalsConfig; + type GlobalVariableOption = SharedConfig.GlobalVariableOption; + type GlobalVariableOptionBase = SharedConfig.GlobalVariableOptionBase; + type ParserOptions = SharedConfig.ParserOptions; + type PluginMeta = SharedConfig.PluginMeta; + type RuleEntry = SharedConfig.RuleEntry; + type RuleLevel = SharedConfig.RuleLevel; + type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; + type RulesRecord = SharedConfig.RulesRecord; + type Severity = SharedConfig.Severity; + type SeverityString = SharedConfig.SeverityString; + /** @deprecated use {@link Linter.ConfigType} instead */ + type Config = ClassicConfig.Config; + type ConfigType = ClassicConfig.Config | FlatConfig.Config | FlatConfig.ConfigArray; + /** @deprecated use {@link ClassicConfig.ConfigOverride} instead */ + type ConfigOverride = ClassicConfig.ConfigOverride; + interface VerifyOptions { + /** + * Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied. + * Useful if you want to validate JS without comments overriding rules. + */ + allowInlineConfig?: boolean; + /** + * if `true` then the linter doesn't make `fix` properties into the lint result. + */ + disableFixes?: boolean; + /** + * the filename of the source code. + */ + filename?: string; + /** + * the predicate function that selects adopt code blocks. + */ + filterCodeBlock?: (filename: string, text: string) => boolean; + /** + * postprocessor for report messages. + * If provided, this should accept an array of the message lists + * for each code block returned from the preprocessor, apply a mapping to + * the messages as appropriate, and return a one-dimensional array of + * messages. + */ + postprocess?: ProcessorType.PostProcess; + /** + * preprocessor for source text. + * If provided, this should accept a string of source text, and return an array of code blocks to lint. + */ + preprocess?: ProcessorType.PreProcess; + /** + * Adds reported errors for unused `eslint-disable` directives. + */ + reportUnusedDisableDirectives?: boolean | SeverityString; + } + interface FixOptions extends VerifyOptions { + /** + * Determines whether fixes should be applied. + */ + fix?: boolean; + } + interface LintSuggestion { + desc: string; + fix: RuleFix; + messageId?: string; + } + interface LintMessage { + /** + * The 1-based column number. + */ + column: number; + /** + * The 1-based column number of the end location. + */ + endColumn?: number; + /** + * The 1-based line number of the end location. + */ + endLine?: number; + /** + * If `true` then this is a fatal error. + */ + fatal?: true; + /** + * Information for autofix. + */ + fix?: RuleFix; + /** + * The 1-based line number. + */ + line: number; + /** + * The error message. + */ + message: string; + messageId?: string; + /** + * @deprecated `nodeType` is deprecated and will be removed in the next major version. + */ + nodeType?: string; + /** + * The ID of the rule which makes this message. + */ + ruleId: string | null; + /** + * The severity of this message. + */ + severity: Severity; + source: string | null; + /** + * Information for suggestions + */ + suggestions?: LintSuggestion[]; + } + interface FixReport { + /** + * True, if the code was fixed + */ + fixed: boolean; + /** + * Collection of all messages for the given code + */ + messages: LintMessage[]; + /** + * Fixed code text (might be the same as input if no fixes were applied). + */ + output: string; + } + /** @deprecated use {@link Parser.ParserModule} */ + type ParserModule = Parser.LooseParserModule; + /** @deprecated use {@link Parser.ParseResult} */ + type ESLintParseResult = Parser.ParseResult; + /** @deprecated use {@link ProcessorType.ProcessorModule} */ + type Processor = ProcessorType.ProcessorModule; + interface Environment { + /** + * The definition of global variables. + */ + globals?: GlobalsConfig; + /** + * The parser options that will be enabled under this environment. + */ + parserOptions?: ParserOptions; + } + type LegacyPluginRules = Record; + type PluginRules = Record; + interface Plugin { + /** + * The definition of plugin configs. + */ + configs?: Record; + /** + * The definition of plugin environments. + */ + environments?: Record; + /** + * Metadata about your plugin for easier debugging and more effective caching of plugins. + */ + meta?: PluginMeta; + /** + * The definition of plugin processors. + */ + processors?: Record; + /** + * The definition of plugin rules. + */ + rules?: LegacyPluginRules; + } +} +declare const Linter_base: typeof LinterBase; +/** + * The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it + * simply parses and reports on the code. In particular, the Linter object does not process configuration objects + * or files. + */ +declare class Linter extends Linter_base { +} +export { Linter }; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.js new file mode 100644 index 00000000..d9536ea8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.js @@ -0,0 +1,14 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace, no-restricted-syntax */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Linter = void 0; +const eslint_1 = require("eslint"); +/** + * The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it + * simply parses and reports on the code. In particular, the Linter object does not process configuration objects + * or files. + */ +class Linter extends eslint_1.Linter { +} +exports.Linter = Linter; +//# sourceMappingURL=Linter.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.d.ts new file mode 100644 index 00000000..9638ff10 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.d.ts @@ -0,0 +1,94 @@ +import type { ParserServices, TSESTree } from '../ts-estree'; +import type { ParserOptions } from './ParserOptions'; +import type { Scope } from './Scope'; +export declare namespace Parser { + interface ParserMeta { + /** + * The unique name of the parser. + */ + name: string; + /** + * The a string identifying the version of the parser. + */ + version?: string; + } + /** + * A loose definition of the ParserModule type for use with configs + * This type intended to relax validation of configs so that parsers that have + * different AST types or scope managers can still be passed to configs + * + * @see {@link LooseRuleDefinition}, {@link LooseProcessorModule} + */ + type LooseParserModule = { + /** + * Information about the parser to uniquely identify it when serializing. + */ + meta?: { + [K in keyof ParserMeta]?: ParserMeta[K] | undefined; + }; + /** + * Parses the given text into an AST + */ + parseForESLint(text: string, options?: unknown): { + [k in keyof ParseResult]: unknown; + }; + } | { + /** + * Information about the parser to uniquely identify it when serializing. + */ + meta?: { + [K in keyof ParserMeta]?: ParserMeta[K] | undefined; + }; + /** + * Parses the given text into an ESTree AST + */ + parse(text: string, options?: unknown): unknown; + }; + type ParserModule = { + /** + * Information about the parser to uniquely identify it when serializing. + */ + meta?: ParserMeta; + /** + * Parses the given text into an AST + */ + parseForESLint(text: string, options?: ParserOptions): ParseResult; + } | { + /** + * Information about the parser to uniquely identify it when serializing. + */ + meta?: ParserMeta; + /** + * Parses the given text into an ESTree AST + */ + parse(text: string, options?: ParserOptions): TSESTree.Program; + }; + interface ParseResult { + /** + * The ESTree AST + */ + ast: TSESTree.Program; + /** + * A `ScopeManager` object. + * Custom parsers can use customized scope analysis for experimental/enhancement syntaxes. + * The default is the `ScopeManager` object which is created by `eslint-scope`. + */ + scopeManager?: Scope.ScopeManager; + /** + * Any parser-dependent services (such as type checkers for nodes). + * The value of the services property is available to rules as `context.sourceCode.parserServices`. + * The default is an empty object. + */ + services?: ParserServices; + /** + * An object to customize AST traversal. + * The keys of the object are the type of AST nodes. + * Each value is an array of the property names which should be traversed. + * The default is `KEYS` of `eslint-visitor-keys`. + */ + visitorKeys?: VisitorKeys; + } + interface VisitorKeys { + [nodeType: string]: readonly string[]; + } +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.js new file mode 100644 index 00000000..10cd9ec7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.js @@ -0,0 +1,4 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Parser.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.d.ts new file mode 100644 index 00000000..a2fdf43d --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.d.ts @@ -0,0 +1 @@ +export type { DebugLevel, EcmaVersion, ParserOptions, SourceType, } from '@typescript-eslint/types'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.js new file mode 100644 index 00000000..40b03dd5 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/ParserOptions.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=ParserOptions.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.d.ts new file mode 100644 index 00000000..d976dacc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.d.ts @@ -0,0 +1,63 @@ +import type { Linter } from './Linter'; +export declare namespace Processor { + interface ProcessorMeta { + /** + * The unique name of the processor. + */ + name: string; + /** + * The a string identifying the version of the processor. + */ + version?: string; + } + type PreProcess = (text: string, filename: string) => (string | { + filename: string; + text: string; + })[]; + type PostProcess = (messagesList: Linter.LintMessage[][], filename: string) => Linter.LintMessage[]; + interface ProcessorModule { + /** + * Information about the processor to uniquely identify it when serializing. + */ + meta?: ProcessorMeta; + /** + * The function to merge messages. + */ + postprocess?: PostProcess; + /** + * The function to extract code blocks. + */ + preprocess?: PreProcess; + /** + * If `true` then it means the processor supports autofix. + */ + supportsAutofix?: boolean; + } + /** + * A loose definition of the ParserModule type for use with configs + * This type intended to relax validation of configs so that parsers that have + * different AST types or scope managers can still be passed to configs + * + * @see {@link LooseRuleDefinition}, {@link LooseParserModule} + */ + interface LooseProcessorModule { + /** + * Information about the processor to uniquely identify it when serializing. + */ + meta?: { + [K in keyof ProcessorMeta]?: ProcessorMeta[K] | undefined; + }; + /** + * The function to merge messages. + */ + postprocess?: (messagesList: any, filename: string) => any; + /** + * The function to extract code blocks. + */ + preprocess?: (text: string, filename: string) => any; + /** + * If `true` then it means the processor supports autofix. + */ + supportsAutofix?: boolean | undefined; + } +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.js new file mode 100644 index 00000000..4dc798a7 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.js @@ -0,0 +1,4 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Processor.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.d.ts new file mode 100644 index 00000000..ddb1330b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.d.ts @@ -0,0 +1,631 @@ +import type { JSONSchema4 } from '../json-schema'; +import type { ParserServices, TSESTree } from '../ts-estree'; +import type { AST } from './AST'; +import type { FlatConfig } from './Config'; +import type { Linter } from './Linter'; +import type { Scope } from './Scope'; +import type { SourceCode } from './SourceCode'; +export type RuleRecommendation = 'recommended' | 'strict' | 'stylistic'; +export interface RuleRecommendationAcrossConfigs { + recommended?: true; + strict: Partial; +} +export interface RuleMetaDataDocs { + /** + * Concise description of the rule. + */ + description: string; + /** + * The URL of the rule's docs. + */ + url?: string; + /** + * Mark this rule as feature-frozen. + */ + frozen?: boolean; + /** + * The dialects of the languages that the rule is intended to lint. + * @example + * ["JavaScript", "TypeScript"] + * + * since ESLint 10.2.0 + */ + dialects?: string[] | undefined; +} +export interface ExternalSpecifier { + /** + * Name of the referenced plugin / rule. + */ + name?: string; + /** + * URL pointing to documentation for the plugin / rule. + */ + url?: string; +} +export interface ReplacedByInfo { + /** + * General message presented to the user, e.g. how to replace the rule + */ + message?: string; + /** + * URL to more information about this replacement in general + */ + url?: string; + /** + * Name should be "eslint" if the replacement is an ESLint core rule. Omit + * the property if the replacement is in the same plugin. + */ + plugin?: ExternalSpecifier; + /** + * Name and documentation of the replacement rule + */ + rule?: ExternalSpecifier; +} +export interface DeprecatedInfo { + /** + * General message presented to the user, e.g. for the key rule why the rule + * is deprecated or for info how to replace the rule. + */ + message?: string; + /** + * URL to more information about this deprecation in general. + */ + url?: string; + /** + * An empty array explicitly states that there is no replacement. + */ + replacedBy?: ReplacedByInfo[]; + /** + * The package version since when the rule is deprecated (should use full + * semver without a leading "v"). + */ + deprecatedSince?: string; + /** + * The estimated version when the rule is removed (probably the next major + * version). null means the rule is "frozen" (will be available but will not + * be changed). + */ + availableUntil?: string | null; +} +export interface RuleMetaData { + /** + * True if the rule is deprecated, false otherwise + */ + deprecated?: boolean | DeprecatedInfo; + /** + * Documentation for the rule + */ + docs?: PluginDocs & RuleMetaDataDocs; + /** + * The fixer category. Omit if there is no fixer + */ + fixable?: 'code' | 'whitespace'; + /** + * Specifies whether rules can return suggestions. Omit if there is no suggestions + */ + hasSuggestions?: boolean; + /** + * Languages supported by this rule in the format `"plugin/language"`. + * Use `"*"` for any language or `"plugin/*"` for any language from a specific plugin. + * @example + * ["js/js", "markdown/gfm", "json/jsonc", "css/css"] + * + * since ESLint 10.2.0 + */ + languages?: string[] | undefined; + /** + * A map of messages which the rule can report. + * The key is the messageId, and the string is the parameterized error string. + * See: https://eslint.org/docs/developer-guide/working-with-rules#messageids + */ + messages: Record; + /** + * The name of the rule this rule was replaced by, if it was deprecated. + * + * @deprecated since eslint 9.21.0, in favor of `RuleMetaData#deprecated.replacedBy` + */ + replacedBy?: readonly string[]; + /** + * The options schema. Supply an empty array if there are no options. + */ + schema: JSONSchema4 | readonly JSONSchema4[]; + /** + * The type of rule. + * - `"problem"` means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve. + * - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed. + * - `"layout"` means the rule cares primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes. These rules work on parts of the code that aren’t specified in the AST. + */ + type: 'layout' | 'problem' | 'suggestion'; + /** + * Specifies default options for the rule. If present, any user-provided options in their config will be merged on top of them recursively. + * This merging will be applied directly to `context.options`. + * If you want backwards-compatible support for earlier ESLint version, consider using the top-level `defaultOptions` instead. + * + * since ESLint 9.15.0 + */ + defaultOptions?: Options; +} +export interface RuleMetaDataWithDocs extends RuleMetaData { + /** + * Documentation for the rule + */ + docs: PluginDocs & RuleMetaDataDocs; +} +export interface RuleFix { + range: Readonly; + text: string; +} +export interface RuleFixer { + insertTextAfter(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix; + insertTextAfterRange(range: Readonly, text: string): RuleFix; + insertTextBefore(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix; + insertTextBeforeRange(range: Readonly, text: string): RuleFix; + remove(nodeOrToken: TSESTree.Node | TSESTree.Token): RuleFix; + removeRange(range: Readonly): RuleFix; + replaceText(nodeOrToken: TSESTree.Node | TSESTree.Token, text: string): RuleFix; + replaceTextRange(range: Readonly, text: string): RuleFix; +} +export interface SuggestionReportDescriptor extends Omit, 'fix'> { + readonly fix: ReportFixFunction; +} +export type ReportFixFunction = (fixer: RuleFixer) => IterableIterator | readonly RuleFix[] | RuleFix | null; +export type ReportSuggestionArray = SuggestionReportDescriptor[]; +export type ReportDescriptorMessageData = Readonly>; +interface ReportDescriptorBase { + /** + * The parameters for the message string associated with `messageId`. + */ + readonly data?: ReportDescriptorMessageData; + /** + * The fixer function. + */ + readonly fix?: ReportFixFunction | null; + /** + * The messageId which is being reported. + */ + readonly messageId: MessageIds; +} +interface ReportDescriptorWithSuggestion extends ReportDescriptorBase { + /** + * 6.7's Suggestions API + */ + readonly suggest?: Readonly> | null; +} +interface ReportDescriptorNodeOptionalLoc { + /** + * An override of the location of the report + */ + readonly loc?: Readonly | Readonly; + /** + * The Node or AST Token which the report is being attached to + */ + readonly node: TSESTree.Node | TSESTree.Token; +} +interface ReportDescriptorLocOnly { + /** + * An override of the location of the report + */ + loc: Readonly | Readonly; +} +export type ReportDescriptor = (ReportDescriptorLocOnly | ReportDescriptorNodeOptionalLoc) & ReportDescriptorWithSuggestion; +/** + * Plugins can add their settings using declaration + * merging against this interface. + */ +export interface SharedConfigurationSettings { + [name: string]: unknown; +} +export interface RuleContext { + /** + * The rule ID. + */ + id: string; + /** + * The language options configured for this run + */ + languageOptions: FlatConfig.LanguageOptions & { + parserOptions: FlatConfig.ParserOptions; + }; + /** + * An array of the configured options for this rule. + * This array does not include the rule severity. + */ + options: Options; + /** + * The parser options configured for this run + * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10. + */ + parserOptions: Linter.ParserOptions; + /** + * The name of the parser from configuration, if in eslintrc (legacy) config. + * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10. + */ + parserPath: string | undefined; + /** + * An object containing parser-provided services for rules + * + * @deprecated in favor of `SourceCode#parserServices` + */ + parserServices?: ParserServices; + /** + * The shared settings from configuration. + * We do not have any shared settings in this plugin. + */ + settings: SharedConfigurationSettings; + /** + * Returns an array of the ancestors of the currently-traversed node, starting at + * the root of the AST and continuing through the direct parent of the current node. + * This array does not include the currently-traversed node itself. + * + * @deprecated in favor of `SourceCode#getAncestors` + */ + getAncestors(): TSESTree.Node[]; + /** + * Returns a list of variables declared by the given node. + * This information can be used to track references to variables. + * + * @deprecated in favor of `SourceCode#getDeclaredVariables` + */ + getDeclaredVariables(node: TSESTree.Node): readonly Scope.Variable[]; + /** + * Returns the current working directory passed to Linter. + * It is a path to a directory that should be considered as the current working directory. + * @deprecated in favor of `RuleContext#cwd` + */ + getCwd(): string; + /** + * The current working directory passed to Linter. + * It is a path to a directory that should be considered as the current working directory. + */ + cwd: string; + /** + * Returns the filename associated with the source. + * + * @deprecated in favor of `RuleContext#filename` + */ + getFilename(): string; + /** + * The filename associated with the source. + */ + filename: string; + /** + * Returns the full path of the file on disk without any code block information (unlike `getFilename()`). + * @deprecated in favor of `RuleContext#physicalFilename` + */ + getPhysicalFilename(): string; + /** + * The full path of the file on disk without any code block information (unlike `filename`). + */ + physicalFilename: string; + /** + * Returns the scope of the currently-traversed node. + * This information can be used track references to variables. + * + * @deprecated in favor of `SourceCode#getScope` + */ + getScope(): Scope.Scope; + /** + * Returns a SourceCode object that you can use to work with the source that + * was passed to ESLint. + * + * @deprecated in favor of `RuleContext#sourceCode` + */ + getSourceCode(): Readonly; + /** + * A SourceCode object that you can use to work with the source that + * was passed to ESLint. + */ + sourceCode: Readonly; + /** + * Marks a variable with the given name in the current scope as used. + * This affects the no-unused-vars rule. + * + * @deprecated in favor of `SourceCode#markVariableAsUsed` + */ + markVariableAsUsed(name: string): boolean; + /** + * Reports a problem in the code. + */ + report(descriptor: ReportDescriptor): void; +} +/** + * Part of the code path analysis feature of ESLint: + * https://eslint.org/docs/latest/extend/code-path-analysis + * + * These are used in the `onCodePath*` methods. (Note that the `node` parameter + * of these methods is intentionally omitted.) + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/6993 + */ +export interface CodePath { + /** Code paths of functions this code path contains. */ + childCodePaths: CodePath[]; + /** + * Segments of the current traversal position. + * + * @deprecated + */ + currentSegments: CodePathSegment[]; + /** The final segments which includes both returned and thrown. */ + finalSegments: CodePathSegment[]; + /** + * A unique string. Respective rules can use `id` to save additional + * information for each code path. + */ + id: string; + initialSegment: CodePathSegment; + /** The final segments which includes only returned. */ + returnedSegments: CodePathSegment[]; + /** The final segments which includes only thrown. */ + thrownSegments: CodePathSegment[]; + /** The code path of the upper function/global scope. */ + upper: CodePath | null; +} +/** + * Part of the code path analysis feature of ESLint: + * https://eslint.org/docs/latest/extend/code-path-analysis + * + * These are used in the `onCodePath*` methods. (Note that the `node` parameter + * of these methods is intentionally omitted.) + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/6993 + */ +export interface CodePathSegment { + /** + * A unique string. Respective rules can use `id` to save additional + * information for each segment. + */ + id: string; + /** + * The next segments. If forking, there are two or more. If final, there is + * nothing. + */ + nextSegments: CodePathSegment[]; + /** + * The previous segments. If merging, there are two or more. If initial, there + * is nothing. + */ + prevSegments: CodePathSegment[]; + /** + * A flag which shows whether it is reachable. This becomes `false` when + * preceded by `return`, `throw`, `break`, or `continue`. + */ + reachable: boolean; +} +/** + * Part of the code path analysis feature of ESLint: + * https://eslint.org/docs/latest/extend/code-path-analysis + * + * This type is unused in the `typescript-eslint` codebase since putting it on + * the `nodeSelector` for `RuleListener` would break the existing definition. + * However, it is exported here for the purposes of manual type-assertion. + * + * @see https://github.com/typescript-eslint/typescript-eslint/issues/6993 + */ +export type CodePathFunction = ((codePath: CodePath, node: TSESTree.Node) => void) | ((fromSegment: CodePathSegment, toSegment: CodePathSegment, node: TSESTree.Node) => void) | ((segment: CodePathSegment, node: TSESTree.Node) => void); +export type RuleFunction = (node: T) => void; +interface RuleListenerBaseSelectors { + AccessorProperty?: RuleFunction; + ArrayExpression?: RuleFunction; + ArrayPattern?: RuleFunction; + ArrowFunctionExpression?: RuleFunction; + AssignmentExpression?: RuleFunction; + AssignmentPattern?: RuleFunction; + AwaitExpression?: RuleFunction; + BinaryExpression?: RuleFunction; + BlockStatement?: RuleFunction; + BreakStatement?: RuleFunction; + CallExpression?: RuleFunction; + CatchClause?: RuleFunction; + ChainExpression?: RuleFunction; + ClassBody?: RuleFunction; + ClassDeclaration?: RuleFunction; + ClassExpression?: RuleFunction; + ConditionalExpression?: RuleFunction; + ContinueStatement?: RuleFunction; + DebuggerStatement?: RuleFunction; + Decorator?: RuleFunction; + DoWhileStatement?: RuleFunction; + EmptyStatement?: RuleFunction; + ExportAllDeclaration?: RuleFunction; + ExportDefaultDeclaration?: RuleFunction; + ExportNamedDeclaration?: RuleFunction; + ExportSpecifier?: RuleFunction; + ExpressionStatement?: RuleFunction; + ForInStatement?: RuleFunction; + ForOfStatement?: RuleFunction; + ForStatement?: RuleFunction; + FunctionDeclaration?: RuleFunction; + FunctionExpression?: RuleFunction; + Identifier?: RuleFunction; + IfStatement?: RuleFunction; + ImportAttribute?: RuleFunction; + ImportDeclaration?: RuleFunction; + ImportDefaultSpecifier?: RuleFunction; + ImportExpression?: RuleFunction; + ImportNamespaceSpecifier?: RuleFunction; + ImportSpecifier?: RuleFunction; + JSXAttribute?: RuleFunction; + JSXClosingElement?: RuleFunction; + JSXClosingFragment?: RuleFunction; + JSXElement?: RuleFunction; + JSXEmptyExpression?: RuleFunction; + JSXExpressionContainer?: RuleFunction; + JSXFragment?: RuleFunction; + JSXIdentifier?: RuleFunction; + JSXMemberExpression?: RuleFunction; + JSXNamespacedName?: RuleFunction; + JSXOpeningElement?: RuleFunction; + JSXOpeningFragment?: RuleFunction; + JSXSpreadAttribute?: RuleFunction; + JSXSpreadChild?: RuleFunction; + JSXText?: RuleFunction; + LabeledStatement?: RuleFunction; + Literal?: RuleFunction; + LogicalExpression?: RuleFunction; + MemberExpression?: RuleFunction; + MetaProperty?: RuleFunction; + MethodDefinition?: RuleFunction; + NewExpression?: RuleFunction; + ObjectExpression?: RuleFunction; + ObjectPattern?: RuleFunction; + PrivateIdentifier?: RuleFunction; + Program?: RuleFunction; + Property?: RuleFunction; + PropertyDefinition?: RuleFunction; + RestElement?: RuleFunction; + ReturnStatement?: RuleFunction; + SequenceExpression?: RuleFunction; + SpreadElement?: RuleFunction; + StaticBlock?: RuleFunction; + Super?: RuleFunction; + SwitchCase?: RuleFunction; + SwitchStatement?: RuleFunction; + TaggedTemplateExpression?: RuleFunction; + TemplateElement?: RuleFunction; + TemplateLiteral?: RuleFunction; + ThisExpression?: RuleFunction; + ThrowStatement?: RuleFunction; + TryStatement?: RuleFunction; + TSAbstractAccessorProperty?: RuleFunction; + TSAbstractKeyword?: RuleFunction; + TSAbstractMethodDefinition?: RuleFunction; + TSAbstractPropertyDefinition?: RuleFunction; + TSAnyKeyword?: RuleFunction; + TSArrayType?: RuleFunction; + TSAsExpression?: RuleFunction; + TSAsyncKeyword?: RuleFunction; + TSBigIntKeyword?: RuleFunction; + TSBooleanKeyword?: RuleFunction; + TSCallSignatureDeclaration?: RuleFunction; + TSClassImplements?: RuleFunction; + TSConditionalType?: RuleFunction; + TSConstructorType?: RuleFunction; + TSConstructSignatureDeclaration?: RuleFunction; + TSDeclareFunction?: RuleFunction; + TSDeclareKeyword?: RuleFunction; + TSEmptyBodyFunctionExpression?: RuleFunction; + TSEnumBody?: RuleFunction; + TSEnumDeclaration?: RuleFunction; + TSEnumMember?: RuleFunction; + TSExportAssignment?: RuleFunction; + TSExportKeyword?: RuleFunction; + TSExternalModuleReference?: RuleFunction; + TSFunctionType?: RuleFunction; + TSImportEqualsDeclaration?: RuleFunction; + TSImportType?: RuleFunction; + TSIndexedAccessType?: RuleFunction; + TSIndexSignature?: RuleFunction; + TSInferType?: RuleFunction; + TSInstantiationExpression?: RuleFunction; + TSInterfaceBody?: RuleFunction; + TSInterfaceDeclaration?: RuleFunction; + TSInterfaceHeritage?: RuleFunction; + TSIntersectionType?: RuleFunction; + TSIntrinsicKeyword?: RuleFunction; + TSLiteralType?: RuleFunction; + TSMappedType?: RuleFunction; + TSMethodSignature?: RuleFunction; + TSModuleBlock?: RuleFunction; + TSModuleDeclaration?: RuleFunction; + TSNamedTupleMember?: RuleFunction; + TSNamespaceExportDeclaration?: RuleFunction; + TSNeverKeyword?: RuleFunction; + TSNonNullExpression?: RuleFunction; + TSNullKeyword?: RuleFunction; + TSNumberKeyword?: RuleFunction; + TSObjectKeyword?: RuleFunction; + TSOptionalType?: RuleFunction; + TSParameterProperty?: RuleFunction; + TSPrivateKeyword?: RuleFunction; + TSPropertySignature?: RuleFunction; + TSProtectedKeyword?: RuleFunction; + TSPublicKeyword?: RuleFunction; + TSQualifiedName?: RuleFunction; + TSReadonlyKeyword?: RuleFunction; + TSRestType?: RuleFunction; + TSSatisfiesExpression?: RuleFunction; + TSStaticKeyword?: RuleFunction; + TSStringKeyword?: RuleFunction; + TSSymbolKeyword?: RuleFunction; + TSTemplateLiteralType?: RuleFunction; + TSThisType?: RuleFunction; + TSTupleType?: RuleFunction; + TSTypeAliasDeclaration?: RuleFunction; + TSTypeAnnotation?: RuleFunction; + TSTypeAssertion?: RuleFunction; + TSTypeLiteral?: RuleFunction; + TSTypeOperator?: RuleFunction; + TSTypeParameter?: RuleFunction; + TSTypeParameterDeclaration?: RuleFunction; + TSTypeParameterInstantiation?: RuleFunction; + TSTypePredicate?: RuleFunction; + TSTypeQuery?: RuleFunction; + TSTypeReference?: RuleFunction; + TSUndefinedKeyword?: RuleFunction; + TSUnionType?: RuleFunction; + TSUnknownKeyword?: RuleFunction; + TSVoidKeyword?: RuleFunction; + UnaryExpression?: RuleFunction; + UpdateExpression?: RuleFunction; + VariableDeclaration?: RuleFunction; + VariableDeclarator?: RuleFunction; + WhileStatement?: RuleFunction; + WithStatement?: RuleFunction; + YieldExpression?: RuleFunction; +} +type RuleListenerExitSelectors = { + [K in keyof RuleListenerBaseSelectors as `${K}:exit`]: RuleListenerBaseSelectors[K]; +}; +type RuleListenerCatchAllBaseCase = Record; +export interface RuleListenerExtension { +} +export type RuleListener = RuleListenerBaseSelectors & RuleListenerCatchAllBaseCase & RuleListenerExitSelectors; +export interface RuleModule { + /** + * Function which returns an object with methods that ESLint calls to “visit” + * nodes while traversing the abstract syntax tree. + */ + create(context: Readonly>): ExtendedRuleListener; + /** + * @deprecated Use meta.defaultOptions instead + * Default options the rule will be run with + */ + defaultOptions?: Options; + /** + * Metadata about the rule + */ + meta: RuleMetaData; + /** + * Rule name + */ + name?: string; +} +export type AnyRuleModule = RuleModule; +export interface RuleModuleWithMetaDocs extends RuleModule { + /** + * Metadata about the rule + */ + meta: RuleMetaDataWithDocs; +} +export type AnyRuleModuleWithMetaDocs = RuleModuleWithMetaDocs; +/** + * A loose definition of the RuleModule type for use with configs. This type is + * intended to relax validation of types so that we can have basic validation + * without being overly strict about nitty gritty details matching. + * + * For example the plugin might be declared using an old version of our types or + * they might use the DefinitelyTyped eslint types. Ultimately we don't need + * super strict validation in a config - a loose shape match is "good enough" to + * help validate the config is correct. + * + * @see {@link LooseParserModule}, {@link LooseProcessorModule} + */ +export type LooseRuleDefinition = LooseRuleCreateFunction | { + create: LooseRuleCreateFunction; + meta?: object | undefined; +}; +export type LooseRuleCreateFunction = (context: any) => Record; +export type RuleCreateFunction = (context: Readonly>) => RuleListener; +export type AnyRuleCreateFunction = RuleCreateFunction; +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.js new file mode 100644 index 00000000..8113a7eb --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Rule.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.d.ts new file mode 100644 index 00000000..c9aa22bd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.d.ts @@ -0,0 +1,183 @@ +import type { AST_NODE_TYPES, AST_TOKEN_TYPES } from '../ts-estree'; +import type { ClassicConfig } from './Config'; +import type { Linter } from './Linter'; +import type { ParserOptions } from './ParserOptions'; +import type { ReportDescriptorMessageData, RuleCreateFunction, RuleModule, SharedConfigurationSettings } from './Rule'; +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface ValidTestCase { + /** + * Code for the test case. + */ + readonly code: string; + /** + * Environments for the test case. + */ + readonly env?: Readonly; + /** + * The fake filename for the test case. Useful for rules that make assertion about filenames. + */ + readonly filename?: string; + /** + * The additional global variables. + */ + readonly globals?: Readonly; + /** + * Name for the test case. + */ + readonly name?: string; + /** + * Run this case exclusively for debugging in supported test frameworks. + */ + readonly only?: boolean; + /** + * Options for the test case. + */ + readonly options?: Readonly; + /** + * The absolute path for the parser. + */ + readonly parser?: string; + /** + * Options for the parser. + */ + readonly parserOptions?: Readonly; + /** + * Settings for the test case. + */ + readonly settings?: Readonly; +} +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface SuggestionOutput { + /** + * The data used to fill the message template. + */ + readonly data?: ReportDescriptorMessageData; + /** + * Reported message ID. + */ + readonly messageId: MessageIds; + /** + * NOTE: Suggestions will be applied as a stand-alone change, without triggering multi-pass fixes. + * Each individual error has its own suggestion, so you have to show the correct, _isolated_ output for each suggestion. + */ + readonly output: string; +} +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface InvalidTestCase extends ValidTestCase { + /** + * Expected errors. + */ + readonly errors: readonly TestCaseError[]; + /** + * The expected code after autofixes are applied. If set to `null`, the test runner will assert that no autofix is suggested. + */ + readonly output?: string | string[] | null; +} +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface TestCaseError { + /** + * The 1-based column number of the reported start location. + */ + readonly column?: number; + /** + * The data used to fill the message template. + */ + readonly data?: ReportDescriptorMessageData; + /** + * The 1-based column number of the reported end location. + */ + readonly endColumn?: number; + /** + * The 1-based line number of the reported end location. + */ + readonly endLine?: number; + /** + * The 1-based line number of the reported start location. + */ + readonly line?: number; + /** + * Reported message ID. + */ + readonly messageId: MessageIds; + /** + * Reported suggestions. + */ + readonly suggestions?: readonly SuggestionOutput[] | null; + /** + * The type of the reported AST node. + */ + readonly type?: AST_NODE_TYPES | AST_TOKEN_TYPES; +} +/** + * @param text a string describing the rule + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export type RuleTesterTestFrameworkFunction = (text: string, callback: () => void) => void; +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface RunTests { + readonly invalid: readonly InvalidTestCase[]; + readonly valid: readonly (string | ValidTestCase)[]; +} +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export interface RuleTesterConfig extends ClassicConfig.Config { + readonly parser: string; + readonly parserOptions?: Readonly; +} +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +declare class RuleTesterBase { + /** + * Creates a new instance of RuleTester. + * @param testerConfig extra configuration for the tester + */ + constructor(testerConfig?: RuleTesterConfig); + /** + * Adds a new rule test to execute. + * @param ruleName The name of the rule to run. + * @param rule The rule to test. + * @param tests The collection of tests to run. + */ + run(ruleName: string, rule: RuleModule, tests: RunTests): void; + /** + * If you supply a value to this property, the rule tester will call this instead of using the version defined on + * the global namespace. + */ + static get describe(): RuleTesterTestFrameworkFunction; + static set describe(value: RuleTesterTestFrameworkFunction | undefined); + /** + * If you supply a value to this property, the rule tester will call this instead of using the version defined on + * the global namespace. + */ + static get it(): RuleTesterTestFrameworkFunction; + static set it(value: RuleTesterTestFrameworkFunction | undefined); + /** + * If you supply a value to this property, the rule tester will call this instead of using the version defined on + * the global namespace. + */ + static get itOnly(): RuleTesterTestFrameworkFunction; + static set itOnly(value: RuleTesterTestFrameworkFunction | undefined); + /** + * Define a rule for one particular run of tests. + */ + defineRule(name: string, rule: RuleCreateFunction | RuleModule): void; +} +declare const RuleTester_base: typeof RuleTesterBase; +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +export declare class RuleTester extends RuleTester_base { +} +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.js new file mode 100644 index 00000000..7b53577b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/RuleTester.js @@ -0,0 +1,12 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RuleTester = void 0; +/* eslint-disable @typescript-eslint/no-deprecated */ +const eslint_1 = require("eslint"); +/** + * @deprecated Use `@typescript-eslint/rule-tester` instead. + */ +class RuleTester extends eslint_1.RuleTester { +} +exports.RuleTester = RuleTester; +//# sourceMappingURL=RuleTester.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.d.ts new file mode 100644 index 00000000..b6fd8654 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.d.ts @@ -0,0 +1,42 @@ +import * as scopeManager from '@typescript-eslint/scope-manager'; +export declare namespace Scope { + type ScopeManager = scopeManager.ScopeManager; + type Reference = scopeManager.Reference; + type Variable = scopeManager.ScopeVariable; + type Scope = scopeManager.Scope; + const ScopeType: typeof scopeManager.ScopeType; + type DefinitionType = scopeManager.Definition; + type Definition = scopeManager.Definition; + const DefinitionType: typeof scopeManager.DefinitionType; + namespace Definitions { + type CatchClauseDefinition = scopeManager.CatchClauseDefinition; + type ClassNameDefinition = scopeManager.ClassNameDefinition; + type FunctionNameDefinition = scopeManager.FunctionNameDefinition; + type ImplicitGlobalVariableDefinition = scopeManager.ImplicitGlobalVariableDefinition; + type ImportBindingDefinition = scopeManager.ImportBindingDefinition; + type ParameterDefinition = scopeManager.ParameterDefinition; + type TSEnumMemberDefinition = scopeManager.TSEnumMemberDefinition; + type TSEnumNameDefinition = scopeManager.TSEnumNameDefinition; + type TSModuleNameDefinition = scopeManager.TSModuleNameDefinition; + type TypeDefinition = scopeManager.TypeDefinition; + type VariableDefinition = scopeManager.VariableDefinition; + } + namespace Scopes { + type BlockScope = scopeManager.BlockScope; + type CatchScope = scopeManager.CatchScope; + type ClassScope = scopeManager.ClassScope; + type ConditionalTypeScope = scopeManager.ConditionalTypeScope; + type ForScope = scopeManager.ForScope; + type FunctionExpressionNameScope = scopeManager.FunctionExpressionNameScope; + type FunctionScope = scopeManager.FunctionScope; + type FunctionTypeScope = scopeManager.FunctionTypeScope; + type GlobalScope = scopeManager.GlobalScope; + type MappedTypeScope = scopeManager.MappedTypeScope; + type ModuleScope = scopeManager.ModuleScope; + type SwitchScope = scopeManager.SwitchScope; + type TSEnumScope = scopeManager.TSEnumScope; + type TSModuleScope = scopeManager.TSModuleScope; + type TypeScope = scopeManager.TypeScope; + type WithScope = scopeManager.WithScope; + } +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.js new file mode 100644 index 00000000..d9218400 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.js @@ -0,0 +1,44 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Scope = void 0; +const scopeManager = __importStar(require("@typescript-eslint/scope-manager")); +var Scope; +(function (Scope) { + Scope.ScopeType = scopeManager.ScopeType; + Scope.DefinitionType = scopeManager.DefinitionType; +})(Scope || (exports.Scope = Scope = {})); +//# sourceMappingURL=Scope.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.d.ts new file mode 100644 index 00000000..1b29f097 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.d.ts @@ -0,0 +1,354 @@ +import type { ParserServices, TSESTree } from '../ts-estree'; +import type { Parser } from './Parser'; +import type { Scope } from './Scope'; +declare class TokenStore { + /** + * Checks whether any comments exist or not between the given 2 nodes. + * @param left The node to check. + * @param right The node to check. + * @returns `true` if one or more comments exist. + */ + commentsExistBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean; + /** + * Gets all comment tokens directly after the given node or token. + * @param nodeOrToken The AST node or token to check for adjacent comment tokens. + * @returns An array of comments in occurrence order. + */ + getCommentsAfter(nodeOrToken: TSESTree.Node | TSESTree.Token): TSESTree.Comment[]; + /** + * Gets all comment tokens directly before the given node or token. + * @param nodeOrToken The AST node or token to check for adjacent comment tokens. + * @returns An array of comments in occurrence order. + */ + getCommentsBefore(nodeOrToken: TSESTree.Node | TSESTree.Token): TSESTree.Comment[]; + /** + * Gets all comment tokens inside the given node. + * @param node The AST node to get the comments for. + * @returns An array of comments in occurrence order. + */ + getCommentsInside(node: TSESTree.Node): TSESTree.Comment[]; + /** + * Gets the first token of the given node. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns An object representing the token. + */ + getFirstToken(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the first token between two non-overlapping nodes. + * @param left Node before the desired token range. + * @param right Node after the desired token range. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns An object representing the token. + */ + getFirstTokenBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the first `count` tokens of the given node. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + */ + getFirstTokens(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the first `count` tokens between two non-overlapping nodes. + * @param left Node before the desired token range. + * @param right Node after the desired token range. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + * @returns Tokens between left and right. + */ + getFirstTokensBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the last token of the given node. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns An object representing the token. + */ + getLastToken(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the last token between two non-overlapping nodes. + * @param left Node before the desired token range. + * @param right Node after the desired token range. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns An object representing the token. + */ + getLastTokenBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the last `count` tokens of the given node. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + */ + getLastTokens(node: TSESTree.Node, options?: T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the last `count` tokens between two non-overlapping nodes. + * @param left Node before the desired token range. + * @param right Node after the desired token range. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + * @returns Tokens between left and right. + */ + getLastTokensBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the token that follows a given node or token. + * @param node The AST node or token. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns An object representing the token. + */ + getTokenAfter(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the token that precedes a given node or token. + * @param node The AST node or token. + * @param options The option object + * @returns An object representing the token. + */ + getTokenBefore(node: TSESTree.Node | TSESTree.Token, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets the token starting at the specified index. + * @param offset Index of the start of the token's range. + * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @returns The token starting at index, or null if no such token. + */ + getTokenByRangeStart(offset: number, options?: T): SourceCode.ReturnTypeFromOptions | null; + /** + * Gets all tokens that are related to the given node. + * @param node The AST node. + * @param beforeCount The number of tokens before the node to retrieve. + * @param afterCount The number of tokens after the node to retrieve. + * @returns Array of objects representing tokens. + */ + getTokens(node: TSESTree.Node, beforeCount?: number, afterCount?: number): TSESTree.Token[]; + /** + * Gets all tokens that are related to the given node. + * @param node The AST node. + * @param options The option object. If this is a function then it's `options.filter`. + * @returns Array of objects representing tokens. + */ + getTokens(node: TSESTree.Node, options: T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the `count` tokens that follows a given node or token. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + */ + getTokensAfter(node: TSESTree.Node | TSESTree.Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets the `count` tokens that precedes a given node or token. + * @param node The AST node. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + */ + getTokensBefore(node: TSESTree.Node | TSESTree.Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; + /** + * Gets all of the tokens between two non-overlapping nodes. + * @param left Node before the desired token range. + * @param right Node after the desired token range. + * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + * @returns Tokens between left and right. + */ + getTokensBetween(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; +} +declare class SourceCodeBase extends TokenStore { + /** + * Represents parsed source code. + * @param ast The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. + */ + constructor(text: string, ast: SourceCode.Program); + /** + * Represents parsed source code. + * @param config The config object. + */ + constructor(config: SourceCode.SourceCodeConfig); + /** + * The parsed AST for the source code. + */ + ast: SourceCode.Program; + applyInlineConfig(): void; + applyLanguageOptions(): void; + finalize(): void; + /** + * Retrieves an array containing all comments in the source code. + * @returns An array of comment nodes. + */ + getAllComments(): TSESTree.Comment[]; + /** + * Converts a (line, column) pair into a range index. + * @param location A line/column location + * @returns The range index of the location in the file. + */ + getIndexFromLoc(location: TSESTree.Position): number; + /** + * Gets the entire source text split into an array of lines. + * @returns The source text as an array of lines. + */ + getLines(): string[]; + /** + * Converts a source text index into a (line, column) pair. + * @param index The index of a character in a file + * @returns A {line, column} location object with a 0-indexed column + */ + getLocFromIndex(index: number): TSESTree.Position; + /** + * Gets the deepest node containing a range index. + * @param index Range index of the desired node. + * @returns The node if found or `null` if not found. + */ + getNodeByRangeIndex(index: number): TSESTree.Node | null; + /** + * Gets the source code for the given node. + * @param node The AST node to get the text for. + * @param beforeCount The number of characters before the node to retrieve. + * @param afterCount The number of characters after the node to retrieve. + * @returns The text representing the AST node. + */ + getText(node?: TSESTree.Node | TSESTree.Token, beforeCount?: number, afterCount?: number): string; + /** + * The flag to indicate that the source code has Unicode BOM. + */ + hasBOM: boolean; + /** + * Determines if two nodes or tokens have at least one whitespace character + * between them. Order does not matter. Returns false if the given nodes or + * tokens overlap. + * @param first The first node or token to check between. + * @param second The second node or token to check between. + * @returns True if there is a whitespace character between any of the tokens found between the two given nodes or tokens. + */ + isSpaceBetween(first: TSESTree.Node | TSESTree.Token, second: TSESTree.Node | TSESTree.Token): boolean; + /** + * Determines if two nodes or tokens have at least one whitespace character + * between them. Order does not matter. Returns false if the given nodes or + * tokens overlap. + * For backward compatibility, this method returns true if there are + * `JSXText` tokens that contain whitespace between the two. + * @param first The first node or token to check between. + * @param second The second node or token to check between. + * @returns {boolean} True if there is a whitespace character between + * any of the tokens found between the two given nodes or tokens. + * @deprecated in favor of isSpaceBetween + */ + isSpaceBetweenTokens(first: TSESTree.Token, second: TSESTree.Token): boolean; + /** + * Returns the scope of the given node. + * This information can be used track references to variables. + */ + getScope(node: TSESTree.Node): Scope.Scope; + /** + * Returns an array of the ancestors of the given node, starting at + * the root of the AST and continuing through the direct parent of the current node. + * This array does not include the currently-traversed node itself. + */ + getAncestors(node: TSESTree.Node): TSESTree.Node[]; + /** + * Returns a list of variables declared by the given node. + * This information can be used to track references to variables. + */ + getDeclaredVariables(node: TSESTree.Node): readonly Scope.Variable[]; + /** + * Marks a variable with the given name in the current scope as used. + * This affects the no-unused-vars rule. + */ + markVariableAsUsed(name: string, node: TSESTree.Node): boolean; + /** + * The source code split into lines according to ECMA-262 specification. + * This is done to avoid each rule needing to do so separately. + */ + lines: string[]; + /** + * The indexes in `text` that each line starts + */ + lineStartIndices: number[]; + /** + * The parser services of this source code. + */ + parserServices?: Partial; + /** + * The scope of this source code. + */ + scopeManager: Scope.ScopeManager | null; + /** + * The original text source code. BOM was stripped from this text. + */ + text: string; + /** + * All of the tokens and comments in the AST. + * + * TODO: rename to 'tokens' + */ + tokensAndComments: TSESTree.Token[]; + /** + * The visitor keys to traverse AST. + */ + visitorKeys: SourceCode.VisitorKeys; + /** + * Split the source code into multiple lines based on the line delimiters. + * @param text Source code as a string. + * @returns Array of source code lines. + */ + static splitLines(text: string): string[]; +} +declare namespace SourceCode { + interface Program extends TSESTree.Program { + comments: TSESTree.Comment[]; + tokens: TSESTree.Token[]; + } + interface SourceCodeConfig { + /** + * The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. + */ + ast: Program; + /** + * The parser services. + */ + parserServices: ParserServices | null; + /** + * The scope of this source code. + */ + scopeManager: Scope.ScopeManager | null; + /** + * The source code text. + */ + text: string; + /** + * The visitor keys to traverse AST. + */ + visitorKeys: VisitorKeys | null; + } + type VisitorKeys = Parser.VisitorKeys; + type FilterPredicate = (token: TSESTree.Token) => boolean; + type GetFilterPredicate = Filter extends ((token: TSESTree.Token) => token is infer U extends TSESTree.Token) ? U : Default; + type GetFilterPredicateFromOptions = Options extends { + filter?: FilterPredicate; + } ? GetFilterPredicate : GetFilterPredicate; + type ReturnTypeFromOptions = T extends { + includeComments: true; + } ? GetFilterPredicateFromOptions : GetFilterPredicateFromOptions>; + type CursorWithSkipOptions = number | FilterPredicate | { + /** + * The predicate function to choose tokens. + */ + filter?: FilterPredicate; + /** + * The flag to iterate comments as well. + */ + includeComments?: boolean; + /** + * The count of tokens the cursor skips. + */ + skip?: number; + }; + type CursorWithCountOptions = number | FilterPredicate | { + /** + * The maximum count of tokens the cursor iterates. + */ + count?: number; + /** + * The predicate function to choose tokens. + */ + filter?: FilterPredicate; + /** + * The flag to iterate comments as well. + */ + includeComments?: boolean; + }; +} +declare const SourceCode_base: typeof SourceCodeBase; +declare class SourceCode extends SourceCode_base { +} +export { SourceCode }; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.js new file mode 100644 index 00000000..777905e0 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.js @@ -0,0 +1,9 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace, no-restricted-syntax */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SourceCode = void 0; +const eslint_1 = require("eslint"); +class SourceCode extends eslint_1.SourceCode { +} +exports.SourceCode = SourceCode; +//# sourceMappingURL=SourceCode.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.d.ts new file mode 100644 index 00000000..3fd2f3fd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.d.ts @@ -0,0 +1,381 @@ +import type { Linter } from '../Linter'; +import type { RuleMetaData } from '../Rule'; +export declare class ESLintBase> { + /** + * Creates a new instance of the main ESLint API. + * @param options The options for this instance. + */ + constructor(options?: Options); + /** + * This method calculates the configuration for a given file, which can be useful for debugging purposes. + * - It resolves and merges extends and overrides settings into the top level configuration. + * - It resolves the parser setting to absolute paths. + * - It normalizes the plugins setting to align short names. (e.g., eslint-plugin-foo → foo) + * - It adds the processor setting if a legacy file extension processor is matched. + * - It doesn't interpret the env setting to the globals and parserOptions settings, so the result object contains + * the env setting as is. + * @param filePath The path to the file whose configuration you would like to calculate. Directory paths are forbidden + * because ESLint cannot handle the overrides setting. + * @returns The promise that will be fulfilled with a configuration object. + */ + calculateConfigForFile(filePath: string): Promise; + getRulesMetaForResults(results: LintResult[]): Record>>; + /** + * This method checks if a given file is ignored by your configuration. + * @param filePath The path to the file you want to check. + * @returns The promise that will be fulfilled with whether the file is ignored or not. If the file is ignored, then + * it will return true. + */ + isPathIgnored(filePath: string): Promise; + /** + * This method lints the files that match the glob patterns and then returns the results. + * @param patterns The lint target files. This can contain any of file paths, directory paths, and glob patterns. + * @returns The promise that will be fulfilled with an array of LintResult objects. + */ + lintFiles(patterns: string | string[]): Promise; + /** + * This method lints the given source code text and then returns the results. + * + * By default, this method uses the configuration that applies to files in the current working directory (the cwd + * constructor option). If you want to use a different configuration, pass options.filePath, and ESLint will load the + * same configuration that eslint.lintFiles() would use for a file at options.filePath. + * + * If the options.filePath value is configured to be ignored, this method returns an empty array. If the + * options.warnIgnored option is set along with the options.filePath option, this method returns a LintResult object. + * In that case, the result may contain a warning that indicates the file was ignored. + * @param code The source code text to check. + * @returns The promise that will be fulfilled with an array of LintResult objects. This is an array (despite there + * being only one lint result) in order to keep the interfaces between this and the eslint.lintFiles() + * method similar. + */ + lintText(code: string, options?: LintTextOptions): Promise; + /** + * This method loads a formatter. Formatters convert lint results to a human- or machine-readable string. + * @param name TThe path to the file you want to check. + * The following values are allowed: + * - undefined. In this case, loads the "stylish" built-in formatter. + * - A name of built-in formatters. + * - A name of third-party formatters. For examples: + * -- `foo` will load eslint-formatter-foo. + * -- `@foo` will load `@foo/eslint-formatter`. + * -- `@foo/bar` will load `@foo/eslint-formatter-bar`. + * - A path to the file that defines a formatter. The path must contain one or more path separators (/) in order to distinguish if it's a path or not. For example, start with ./. + * @returns The promise that will be fulfilled with a Formatter object. + */ + loadFormatter(name?: string): Promise; + /** + * This method copies the given results and removes warnings. The returned value contains only errors. + * @param results The LintResult objects to filter. + * @returns The filtered LintResult objects. + */ + static getErrorResults(results: LintResult): LintResult; + /** + * This method writes code modified by ESLint's autofix feature into its respective file. If any of the modified + * files don't exist, this method does nothing. + * @param results The LintResult objects to write. + * @returns The promise that will be fulfilled after all files are written. + */ + static outputFixes(results: LintResult[]): Promise; + /** + * The version text. + */ + static readonly version: string; + /** + * The type of configuration used by this class. + */ + static readonly configType: Linter.ConfigTypeSpecifier; +} +export interface ESLintOptions { + /** + * If false is present, ESLint suppresses comment directives in source code. + * If this option is false, it overrides the noInlineConfig setting in your configurations. + * @default true + */ + allowInlineConfig?: boolean; + /** + * Configuration object, extended by all configurations used with this instance. + * You can use this option to define the default settings that will be used if your configuration files don't + * configure it. + * @default null + */ + baseConfig?: Config | null; + /** + * If `true` is present, the `eslint.lintFiles()` method caches lint results and uses it if each target file is not + * changed. Please mind that ESLint doesn't clear the cache when you upgrade ESLint plugins. In that case, you have + * to remove the cache file manually. The `eslint.lintText()` method doesn't use caches even if you pass the + * options.filePath to the method. + * @default false + */ + cache?: boolean; + /** + * The eslint.lintFiles() method writes caches into this file. + * @default '.eslintcache' + */ + cacheLocation?: string; + /** + * Strategy for the cache to use for detecting changed files. + * @default 'metadata' + */ + cacheStrategy?: 'content' | 'metadata'; + /** + * The working directory. This must be an absolute path. + * @default process.cwd() + */ + cwd?: string; + /** + * Unless set to false, the `eslint.lintFiles()` method will throw an error when no target files are found. + * @default true + */ + errorOnUnmatchedPattern?: boolean; + /** + * If `true` is present, the `eslint.lintFiles()` and `eslint.lintText()` methods work in autofix mode. + * If a predicate function is present, the methods pass each lint message to the function, then use only the + * lint messages for which the function returned true. + * @default false + */ + fix?: boolean | ((message: LintMessage) => boolean); + /** + * The types of the rules that the `eslint.lintFiles()` and `eslint.lintText()` methods use for autofix. + * @default null + */ + fixTypes?: ('directive' | 'problem' | 'suggestion')[] | null; + /** + * If false is present, the `eslint.lintFiles()` method doesn't interpret glob patterns. + * @default true + */ + globInputPaths?: boolean; + /** + * Configuration object, overrides all configurations used with this instance. + * You can use this option to define the settings that will be used even if your configuration files configure it. + * @default null + */ + overrideConfig?: Config | null; + /** + * When set to true, missing patterns cause the linting operation to short circuit and not report any failures. + * @default false + */ + passOnNoPatterns?: boolean; + /** + * The plugin implementations that ESLint uses for the plugins setting of your configuration. + * This is a map-like object. Those keys are plugin IDs and each value is implementation. + * @default null + */ + plugins?: Record | null; +} +export interface DeprecatedRuleInfo { + /** + * The rule IDs that replace this deprecated rule. + */ + replacedBy: string[]; + /** + * The rule ID. + */ + ruleId: string; +} +/** + * The LintResult value is the information of the linting result of each file. + */ +export interface LintResult { + /** + * The number of errors. This includes fixable errors. + */ + errorCount: number; + /** + * The number of fatal errors. + */ + fatalErrorCount: number; + /** + * The absolute path to the file of this result. This is the string "" if the file path is unknown (when you + * didn't pass the options.filePath option to the eslint.lintText() method). + */ + filePath: string; + /** + * The number of errors that can be fixed automatically by the fix constructor option. + */ + fixableErrorCount: number; + /** + * The number of warnings that can be fixed automatically by the fix constructor option. + */ + fixableWarningCount: number; + /** + * The array of LintMessage objects. + */ + messages: LintMessage[]; + /** + * The source code of the file that was linted, with as many fixes applied as possible. + */ + output?: string; + /** + * The original source code text. This property is undefined if any messages didn't exist or the output + * property exists. + */ + source?: string; + /** + * Timing information of the lint run. + * This exists if and only if the `--stats` CLI flag was added or the `stats: true` + * option was passed to the ESLint class + * @since 9.0.0 + */ + stats?: LintStats; + /** + * The array of SuppressedLintMessage objects. + */ + suppressedMessages: SuppressedLintMessage[]; + /** + * The information about the deprecated rules that were used to check this file. + */ + usedDeprecatedRules: DeprecatedRuleInfo[]; + /** + * The number of warnings. This includes fixable warnings. + */ + warningCount: number; +} +export interface LintStats { + /** + * The number of times ESLint has applied at least one fix after linting. + */ + fixPasses: number; + /** + * The times spent on (parsing, fixing, linting) a file, where the linting refers to the timing information for each rule. + */ + times: { + passes: LintStatsTimePass[]; + }; +} +export interface LintStatsTimePass { + /** + * The total time that is spent on applying fixes to the code. + */ + fix: LintStatsFixTime; + /** + * The total time that is spent when parsing a file. + */ + parse: LintStatsParseTime; + /** + * The total time that is spent on a rule. + */ + rules?: Record; + /** + * The cumulative total + */ + total: number; +} +export interface LintStatsParseTime { + total: number; +} +export interface LintStatsRuleTime { + total: number; +} +export interface LintStatsFixTime { + total: number; +} +export interface LintTextOptions { + /** + * The path to the file of the source code text. If omitted, the result.filePath becomes the string "". + */ + filePath?: string; + /** + * If true is present and the options.filePath is a file ESLint should ignore, this method returns a lint result + * contains a warning message. + */ + warnIgnored?: boolean; +} +/** + * The LintMessage value is the information of each linting error. + */ +export interface LintMessage { + /** + * The 1-based column number of the begin point of this message. + */ + column: number | undefined; + /** + * The 1-based column number of the end point of this message. This property is undefined if this message + * is not a range. + */ + endColumn: number | undefined; + /** + * The 1-based line number of the end point of this message. This property is undefined if this + * message is not a range. + */ + endLine: number | undefined; + /** + * `true` if this is a fatal error unrelated to a rule, like a parsing error. + */ + fatal?: boolean | undefined; + /** + * The EditInfo object of autofix. This property is undefined if this message is not fixable. + */ + fix: EditInfo | undefined; + /** + * The 1-based line number of the begin point of this message. + */ + line: number | undefined; + /** + * The error message + */ + message: string; + /** + * The rule name that generates this lint message. If this message is generated by the ESLint core rather than + * rules, this is null. + */ + ruleId: string | null; + /** + * The severity of this message. 1 means warning and 2 means error. + */ + severity: 1 | 2; + /** + * The list of suggestions. Each suggestion is the pair of a description and an EditInfo object to fix code. API + * users such as editor integrations can choose one of them to fix the problem of this message. This property is + * undefined if this message doesn't have any suggestions. + */ + suggestions: { + desc: string; + fix: EditInfo; + }[] | undefined; +} +/** + * The SuppressedLintMessage value is the information of each suppressed linting error. + */ +export interface SuppressedLintMessage extends LintMessage { + /** + * The list of suppressions. + */ + suppressions?: { + /** + * The free text description added after the `--` in the comment + */ + justification: string; + /** + * Right now, this is always `directive` + */ + kind: string; + }[]; +} +/** + * The EditInfo value is information to edit text. + * + * This edit information means replacing the range of the range property by the text property value. It's like + * sourceCodeText.slice(0, edit.range[0]) + edit.text + sourceCodeText.slice(edit.range[1]). Therefore, it's an add + * if the range[0] and range[1] property values are the same value, and it's removal if the text property value is + * empty string. + */ +export interface EditInfo { + /** + * The pair of 0-based indices in source code text to remove. + */ + range: [number, number]; + /** + * The text to add. + */ + text: string; +} +/** + * The Formatter value is the object to convert the LintResult objects to text. + */ +export interface Formatter { + /** + * The method to convert the LintResult objects to text. + * Promise return supported since 8.4.0 + */ + format(results: LintResult[]): string | Promise; +} diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.js new file mode 100644 index 00000000..09d9a311 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/ESLintShared.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=ESLintShared.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.d.ts new file mode 100644 index 00000000..c5382c78 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.d.ts @@ -0,0 +1,87 @@ +import type { FlatConfig } from '../Config'; +import type * as Shared from './ESLintShared'; +declare class FlatESLintBase extends Shared.ESLintBase { + static readonly configType: 'flat'; + /** + * Returns a configuration object for the given file based on the CLI options. + * This is the same logic used by the ESLint CLI executable to determine + * configuration for each file it processes. + * @param filePath The path of the file to retrieve a config object for. + * @returns A configuration object for the file or `undefined` if there is no configuration data for the object. + */ + calculateConfigForFile(filePath: string): Promise; + /** + * Finds the config file being used by this instance based on the options + * passed to the constructor. + * @returns The path to the config file being used or `undefined` if no config file is being used. + */ + findConfigFile(): Promise; +} +declare const FlatESLint_base: typeof FlatESLintBase; +/** + * The ESLint class is the primary class to use in Node.js applications. + * This class depends on the Node.js fs module and the file system, so you cannot use it in browsers. + * + * If you want to lint code on browsers, use the Linter class instead. + */ +export declare class FlatESLint extends FlatESLint_base { +} +export declare namespace FlatESLint { + interface ESLintOptions extends Shared.ESLintOptions { + /** + * If false is present, the eslint.lintFiles() method doesn't respect `ignorePatterns` ignorePatterns in your configuration. + * @default true + */ + ignore?: boolean; + /** + * Ignore file patterns to use in addition to config ignores. These patterns are relative to cwd. + * @default null + */ + ignorePatterns?: string[] | null; + /** + * The path to a configuration file. Overrides all configurations used with this instance. + * The options.overrideConfig option is applied after this option is applied. + * + * - When falsy, searches for default config file. + * - When `true`, does not do any config file lookup. + * - When a string, considered to be a config file name. + * + * @default false + */ + overrideConfigFile?: boolean | string; + /** + * A predicate function that filters rules to be run. + * This function is called with an object containing `ruleId` and `severity`, and returns `true` if the rule should be run. + * @default () => true + */ + ruleFilter?: RuleFilter; + /** + * When set to true, additional statistics are added to the lint results. + * @see {@link https://eslint.org/docs/latest/extend/stats} + * @default false + */ + stats?: boolean; + /** + * Show warnings when the file list includes ignored files. + * @default true + */ + warnIgnored?: boolean; + } + type DeprecatedRuleInfo = Shared.DeprecatedRuleInfo; + type EditInfo = Shared.EditInfo; + type Formatter = Shared.Formatter; + type LintMessage = Shared.LintMessage; + type LintResult = Shared.LintResult; + type LintStats = Shared.LintStats; + type LintStatsFixTime = Shared.LintStatsFixTime; + type LintStatsParseTime = Shared.LintStatsParseTime; + type LintStatsRuleTime = Shared.LintStatsRuleTime; + type LintStatsTimePass = Shared.LintStatsTimePass; + type LintTextOptions = Shared.LintTextOptions; + type SuppressedLintMessage = Shared.SuppressedLintMessage; + type RuleFilter = (rule: { + ruleId: string; + severity: number; + }) => boolean; +} +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.js new file mode 100644 index 00000000..233d1e72 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/FlatESLint.js @@ -0,0 +1,20 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FlatESLint = void 0; +/* eslint-disable @typescript-eslint/no-namespace */ +const eslint_1 = require("eslint"); +const use_at_your_own_risk_1 = __importDefault(require("eslint/use-at-your-own-risk")); +/** + * The ESLint class is the primary class to use in Node.js applications. + * This class depends on the Node.js fs module and the file system, so you cannot use it in browsers. + * + * If you want to lint code on browsers, use the Linter class instead. + */ +class FlatESLint extends (use_at_your_own_risk_1.default.FlatESLint ?? + eslint_1.ESLint) { +} +exports.FlatESLint = FlatESLint; +//# sourceMappingURL=FlatESLint.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.d.ts new file mode 100644 index 00000000..782e5ad9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.d.ts @@ -0,0 +1,72 @@ +import type { ClassicConfig } from '../Config'; +import type { Linter } from '../Linter'; +import type * as Shared from './ESLintShared'; +declare class LegacyESLintBase extends Shared.ESLintBase { + static readonly configType: 'eslintrc'; +} +declare const LegacyESLint_base: typeof LegacyESLintBase; +/** + * The ESLint class is the primary class to use in Node.js applications. + * This class depends on the Node.js fs module and the file system, so you cannot use it in browsers. + * + * If you want to lint code on browsers, use the Linter class instead. + */ +export declare class LegacyESLint extends LegacyESLint_base { +} +export declare namespace LegacyESLint { + interface ESLintOptions extends Shared.ESLintOptions { + /** + * If you pass directory paths to the eslint.lintFiles() method, ESLint checks the files in those directories that + * have the given extensions. For example, when passing the src/ directory and extensions is [".js", ".ts"], ESLint + * will lint *.js and *.ts files in src/. If extensions is null, ESLint checks *.js files and files that match + * overrides[].files patterns in your configuration. + * Note: This option only applies when you pass directory paths to the eslint.lintFiles() method. + * If you pass glob patterns, ESLint will lint all files matching the glob pattern regardless of extension. + */ + extensions?: string[] | null; + /** + * If false is present, the eslint.lintFiles() method doesn't respect `.eslintignore` files in your configuration. + * @default true + */ + ignore?: boolean; + /** + * The path to a file ESLint uses instead of `$CWD/.eslintignore`. + * If a path is present and the file doesn't exist, this constructor will throw an error. + */ + ignorePath?: string; + /** + * The path to a configuration file, overrides all configurations used with this instance. + * The options.overrideConfig option is applied after this option is applied. + */ + overrideConfigFile?: string | null; + /** + * The severity to report unused eslint-disable directives. + * If this option is a severity, it overrides the reportUnusedDisableDirectives setting in your configurations. + */ + reportUnusedDisableDirectives?: Linter.SeverityString | null; + /** + * The path to a directory where plugins should be resolved from. + * If null is present, ESLint loads plugins from the location of the configuration file that contains the plugin + * setting. + * If a path is present, ESLint loads all plugins from there. + */ + resolvePluginsRelativeTo?: string | null; + /** + * An array of paths to directories to load custom rules from. + */ + rulePaths?: string[]; + /** + * If false is present, ESLint doesn't load configuration files (.eslintrc.* files). + * Only the configuration of the constructor options is valid. + */ + useEslintrc?: boolean; + } + type DeprecatedRuleInfo = Shared.DeprecatedRuleInfo; + type EditInfo = Shared.EditInfo; + type Formatter = Shared.Formatter; + type LintMessage = Shared.LintMessage; + type LintResult = Omit; + type LintTextOptions = Shared.LintTextOptions; + type SuppressedLintMessage = Shared.SuppressedLintMessage; +} +export {}; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.js new file mode 100644 index 00000000..7cae0551 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/eslint/LegacyESLint.js @@ -0,0 +1,37 @@ +"use strict"; +/* eslint-disable @typescript-eslint/no-namespace */ +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.LegacyESLint = void 0; +const eslint_1 = require("eslint"); +const use_at_your_own_risk_1 = __importDefault(require("eslint/use-at-your-own-risk")); +function throwMissingLegacyESLintError() { + throw new Error('LegacyESLint is not available with the current version of ESLint.'); +} +/* eslint-disable-next-line @typescript-eslint/no-extraneous-class */ +class MissingLegacyESLint { + static configType = 'eslintrc'; + static version = eslint_1.ESLint.version; + constructor() { + throwMissingLegacyESLintError(); + } + static getErrorResults() { + throwMissingLegacyESLintError(); + } + static outputFixes() { + throwMissingLegacyESLintError(); + } +} +/** + * The ESLint class is the primary class to use in Node.js applications. + * This class depends on the Node.js fs module and the file system, so you cannot use it in browsers. + * + * If you want to lint code on browsers, use the Linter class instead. + */ +class LegacyESLint extends (use_at_your_own_risk_1.default.LegacyESLint ?? + MissingLegacyESLint) { +} +exports.LegacyESLint = LegacyESLint; +//# sourceMappingURL=LegacyESLint.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.d.ts new file mode 100644 index 00000000..217b46dc --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.d.ts @@ -0,0 +1,11 @@ +export * from './AST'; +export * from './Config'; +export * from './ESLint'; +export * from './Linter'; +export * from './Parser'; +export * from './ParserOptions'; +export * from './Processor'; +export * from './Rule'; +export * from './RuleTester'; +export * from './Scope'; +export * from './SourceCode'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.js new file mode 100644 index 00000000..85b7e5cf --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-eslint/index.js @@ -0,0 +1,28 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./AST"), exports); +__exportStar(require("./Config"), exports); +__exportStar(require("./ESLint"), exports); +__exportStar(require("./Linter"), exports); +__exportStar(require("./Parser"), exports); +__exportStar(require("./ParserOptions"), exports); +__exportStar(require("./Processor"), exports); +__exportStar(require("./Rule"), exports); +__exportStar(require("./RuleTester"), exports); +__exportStar(require("./Scope"), exports); +__exportStar(require("./SourceCode"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.d.ts new file mode 100644 index 00000000..341d90ec --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.d.ts @@ -0,0 +1,3 @@ +export { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree, } from '@typescript-eslint/types'; +export type { NodeWithParent } from '@typescript-eslint/types'; +export type { ParserServices, ParserServicesWithoutTypeInformation, ParserServicesWithTypeInformation, } from '@typescript-eslint/typescript-estree'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.js new file mode 100644 index 00000000..8f59d133 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-estree.js @@ -0,0 +1,10 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TSESTree = exports.AST_TOKEN_TYPES = exports.AST_NODE_TYPES = void 0; +// for convenience's sake - export the types directly from here so consumers +// don't need to reference/install both packages in their code +var types_1 = require("@typescript-eslint/types"); +Object.defineProperty(exports, "AST_NODE_TYPES", { enumerable: true, get: function () { return types_1.AST_NODE_TYPES; } }); +Object.defineProperty(exports, "AST_TOKEN_TYPES", { enumerable: true, get: function () { return types_1.AST_TOKEN_TYPES; } }); +Object.defineProperty(exports, "TSESTree", { enumerable: true, get: function () { return types_1.TSESTree; } }); +//# sourceMappingURL=ts-estree.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.d.ts new file mode 100644 index 00000000..2dc7d962 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.d.ts @@ -0,0 +1,9 @@ +/** + * We could use NoInfer typescript built-in utility + * introduced in typescript 5.4, however at the moment of creation + * the supported ts versions are >=4.8.4 <5.7.0 + * so for the moment we have to stick to this polyfill. + * + * @see https://github.com/millsp/ts-toolbelt/blob/master/sources/Function/NoInfer.ts + */ +export type NoInfer = [A][A extends unknown ? 0 : never]; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.js new file mode 100644 index 00000000..af801291 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/NoInfer.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=NoInfer.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.d.ts new file mode 100644 index 00000000..58ea1fcd --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.d.ts @@ -0,0 +1,2 @@ +export * from './isArray'; +export * from './NoInfer'; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.js new file mode 100644 index 00000000..cb645cda --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/index.js @@ -0,0 +1,19 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./isArray"), exports); +__exportStar(require("./NoInfer"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.d.ts b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.d.ts new file mode 100644 index 00000000..b32b9ce8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.d.ts @@ -0,0 +1 @@ +export declare function isArray(arg: unknown): arg is readonly unknown[]; diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.js b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.js new file mode 100644 index 00000000..92a7237e --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/ts-utils/isArray.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isArray = isArray; +// https://github.com/microsoft/TypeScript/issues/17002 +function isArray(arg) { + return Array.isArray(arg); +} +//# sourceMappingURL=isArray.js.map \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/eslint b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/eslint new file mode 100755 index 00000000..ef5a3be8 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules:$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js" "$@" +fi +# cmd-shim-target=../../../../../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsc b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsc new file mode 100755 index 00000000..c496de53 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsc @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsc diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsserver b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsserver new file mode 100755 index 00000000..49048b89 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/node_modules/.bin/tsserver @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/node_modules:$basedir_abs/../../../../../../typescript@6.0.3/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +else + exec node "$basedir_abs/../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver" "$@" +fi +# cmd-shim-target=../../../../../../typescript@6.0.3/node_modules/typescript/bin/tsserver diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/package.json b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/package.json new file mode 100644 index 00000000..fd9d913b --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/package.json @@ -0,0 +1,115 @@ +{ + "name": "@typescript-eslint/utils", + "version": "8.70.1", + "description": "Utilities for working with TypeScript + ESLint together", + "files": [ + "dist", + "!**/*.js.map", + "!**/*.tsbuildinfo" + ], + "type": "commonjs", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "./ast-utils": { + "types": "./dist/ast-utils/index.d.ts", + "default": "./dist/ast-utils/index.js" + }, + "./eslint-utils": { + "types": "./dist/eslint-utils/index.d.ts", + "default": "./dist/eslint-utils/index.js" + }, + "./json-schema": { + "types": "./dist/json-schema.d.ts", + "default": "./dist/json-schema.js" + }, + "./ts-eslint": { + "types": "./dist/ts-eslint/index.d.ts", + "default": "./dist/ts-eslint/index.js" + }, + "./package.json": "./package.json" + }, + "types": "./dist/index.d.ts", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/typescript-eslint/typescript-eslint.git", + "directory": "packages/utils" + }, + "bugs": { + "url": "https://github.com/typescript-eslint/typescript-eslint/issues" + }, + "homepage": "https://typescript-eslint.io/packages/utils", + "license": "MIT", + "keywords": [ + "eslint", + "typescript", + "estree" + ], + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.70.1", + "@typescript-eslint/types": "8.70.1", + "@typescript-eslint/typescript-estree": "8.70.1" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + }, + "devDependencies": { + "@typescript/native": "npm:typescript@^7.0.2", + "@vitest/coverage-v8": "^4.0.18", + "eslint": "^10.0.0", + "rimraf": "^5.0.10", + "typescript": ">=4.8.4 <6.1.0", + "vitest": "^4.0.18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "nx": { + "name": "utils", + "includedScripts": [ + "clean" + ], + "targets": { + "lint": { + "command": "eslint" + }, + "typecheck": { + "outputs": [ + "{workspaceRoot}/dist", + "{projectRoot}/dist" + ] + }, + "typecheck:tsgo": { + "outputs": [ + "{workspaceRoot}/dist", + "{projectRoot}/dist" + ] + }, + "test": { + "dependsOn": [ + "^build", + "typecheck" + ] + }, + "attw-check": {} + } + }, + "scripts": { + "build": "pnpm exec nx build", + "clean": "rimraf dist/ coverage/", + "format": "pnpm -w run format", + "lint": "pnpm -w exec nx lint", + "test": "pnpm -w exec nx test", + "typecheck": "pnpm -w exec nx typecheck", + "typecheck:tsgo": "pnpm -w exec nx typecheck:tsgo", + "attw-check": "pnpm -w exec nx attw-check" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint new file mode 120000 index 00000000..1da0f551 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/eslint @@ -0,0 +1 @@ +../../eslint@10.11.0_jiti@2.7.0/node_modules/eslint \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript new file mode 120000 index 00000000..b491b2a9 --- /dev/null +++ b/backend/node_modules/.pnpm/@typescript-eslint+utils@8.70.1_eslint@10.11.0_jiti@2.7.0__typescript@6.0.3/node_modules/typescript @@ -0,0 +1 @@ +../../typescript@6.0.3/node_modules/typescript \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@jridgewell/trace-mapping b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@jridgewell/trace-mapping new file mode 120000 index 00000000..163702c4 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@jridgewell/trace-mapping @@ -0,0 +1 @@ +../../../@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/LICENSE b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/LICENSE new file mode 100644 index 00000000..0e5771dd --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors + +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/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/README.md b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/README.md new file mode 100644 index 00000000..dae8292f --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/README.md @@ -0,0 +1,7 @@ +# @vitest/mocker + +[![NPM version](https://img.shields.io/npm/v/@vitest/mocker?color=a1b858&label=)](https://npmx.dev/package/@vitest/mocker) + +Vitest's module mocker implementation. + +[GitHub](https://github.com/vitest-dev/vitest/blob/main/packages/mocker/) | [Documentation](https://github.com/vitest-dev/vitest/blob/main/packages/mocker/EXPORTS.md) diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.d.ts new file mode 100644 index 00000000..04fa25ee --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.d.ts @@ -0,0 +1,2 @@ + +export { }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.js new file mode 100644 index 00000000..5e80823e --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/auto-register.js @@ -0,0 +1,10 @@ +import { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js'; +import { registerModuleMocker } from './register.js'; +import './chunk-mocker.js'; +import './chunk-helpers.js'; +import './index.js'; +import './chunk-registry.js'; +import './chunk-pathe.M-eThtNZ.js'; +import '@vitest/spy'; + +registerModuleMocker(() => new ModuleMockerServerInterceptor()); diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.d.ts new file mode 100644 index 00000000..23daf27b --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.d.ts @@ -0,0 +1,13 @@ +import MagicString from 'magic-string'; + +interface AutomockOptions { + /** + * @default "__vitest_mocker__" + */ + globalThisAccessor?: string; + id?: string; +} +declare function automockModule(code: string, mockType: "automock" | "autospy", parse: (code: string) => any, options?: AutomockOptions): MagicString; + +export { automockModule }; +export type { AutomockOptions }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.js new file mode 100644 index 00000000..d8d1fbf7 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/automock.js @@ -0,0 +1,8 @@ +import 'node:fs'; +import 'node:url'; +import 'magic-string'; +export { a as automockModule } from './chunk-automock.js'; +import 'estree-walker'; +import 'node:module'; +import 'node:path'; +import './chunk-helpers.js'; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.d.ts new file mode 100644 index 00000000..07c6ee59 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.d.ts @@ -0,0 +1,53 @@ +import { M as ModuleMockerInterceptor } from './mocker.d-CMHJLkLP.js'; +export { C as CompilerHintsOptions, b as ModuleMocker, a as ModuleMockerCompilerHints, c as ModuleMockerConfig, d as ModuleMockerRPC, R as ResolveIdResult, e as ResolveMockResult, f as createCompilerHints } from './mocker.d-CMHJLkLP.js'; +import { StartOptions, SetupWorker } from 'msw/browser'; +import { MockerRegistry, MockedModule } from './index.js'; +import '@vitest/spy'; +import './index.d-D4wtotQw.js'; + +interface ModuleMockerMSWInterceptorOptions { + /** + * The identifier to access the globalThis object in the worker. + * This will be injected into the script as is, so make sure it's a valid JS expression. + * @example + * ```js + * // globalThisAccessor: '__my_variable__' produces: + * globalThis[__my_variable__] + * // globalThisAccessor: 'Symbol.for('secret:mocks')' produces: + * globalThis[Symbol.for('secret:mocks')] + * // globalThisAccessor: '"__vitest_mocker__"' (notice quotes) produces: + * globalThis["__vitest_mocker__"] + * ``` + * @default `"__vitest_mocker__"` + */ + globalThisAccessor?: string; + /** + * Options passed down to `msw.setupWorker().start(options)` + */ + mswOptions?: StartOptions; + /** + * A pre-configured `msw.setupWorker` instance. + */ + mswWorker?: SetupWorker; +} +declare class ModuleMockerMSWInterceptor implements ModuleMockerInterceptor { + private readonly options; + protected readonly mocks: MockerRegistry; + private startPromise; + private worker; + constructor(options?: ModuleMockerMSWInterceptorOptions); + register(module: MockedModule): Promise; + delete(url: string): Promise; + invalidate(): Promise; + private resolveManualMock; + protected init(): Promise; +} + +declare class ModuleMockerServerInterceptor implements ModuleMockerInterceptor { + register(module: MockedModule): Promise; + delete(id: string): Promise; + invalidate(): Promise; +} + +export { ModuleMockerInterceptor, ModuleMockerMSWInterceptor, ModuleMockerServerInterceptor }; +export type { ModuleMockerMSWInterceptorOptions }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.js new file mode 100644 index 00000000..178839c2 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/browser.js @@ -0,0 +1,93 @@ +export { M as ModuleMocker, c as createCompilerHints } from './chunk-mocker.js'; +import { M as MockerRegistry } from './chunk-registry.js'; +import { c as createManualModuleSource, a as cleanUrl } from './chunk-utils.js'; +export { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js'; +import './chunk-helpers.js'; +import './index.js'; +import './chunk-pathe.M-eThtNZ.js'; + +class ModuleMockerMSWInterceptor { + options; + mocks = new MockerRegistry(); + startPromise; + worker; + constructor(options = {}) { + this.options = options; + if (!options.globalThisAccessor) { + options.globalThisAccessor = "\"__vitest_mocker__\""; + } + } + async register(module) { + await this.init(); + this.mocks.add(module); + } + async delete(url) { + await this.init(); + this.mocks.delete(url); + } + async invalidate() { + this.mocks.clear(); + } + async resolveManualMock(mock) { + const exports = Object.keys(await mock.resolve()); + const text = createManualModuleSource(mock.url, exports, this.options.globalThisAccessor); + return new Response(text, { headers: { "Content-Type": "application/javascript" } }); + } + async init() { + if (this.worker) { + return this.worker; + } + if (this.startPromise) { + return this.startPromise; + } + const worker = this.options.mswWorker; + this.startPromise = Promise.all([worker ? { setupWorker(handler) { + worker.use(handler); + return worker; + } } : import('msw/browser'), import('msw/core/http')]).then(([{ setupWorker }, { http }]) => { + const worker = setupWorker(http.get(/.+/, async ({ request }) => { + const path = cleanQuery(request.url.slice(location.origin.length)); + if (!this.mocks.has(path)) { + return passthrough(); + } + const mock = this.mocks.get(path); + switch (mock.type) { + case "manual": return this.resolveManualMock(mock); + case "automock": + case "autospy": return Response.redirect(injectQuery(path, `mock=${mock.type}`)); + case "redirect": return Response.redirect(mock.redirect); + default: throw new Error(`Unknown mock type: ${mock.type}`); + } + })); + return worker.start(this.options.mswOptions).then(() => worker); + }).finally(() => { + this.worker = worker; + this.startPromise = undefined; + }); + return await this.startPromise; + } +} +const trailingSeparatorRE = /[?&]$/; +const timestampRE = /\bt=\d{13}&?\b/; +const versionRE = /\bv=\w{8}&?\b/; +function cleanQuery(url) { + return url.replace(timestampRE, "").replace(versionRE, "").replace(trailingSeparatorRE, ""); +} +function passthrough() { + return new Response(null, { + status: 302, + statusText: "Passthrough", + headers: { "x-msw-intention": "passthrough" } + }); +} +const replacePercentageRE = /%/g; +function injectQuery(url, queryToInject) { + // encode percents for consistent behavior with pathToFileURL + // see #2614 for details + const resolvedUrl = new URL(url.replace(replacePercentageRE, "%25"), location.href); + const { search, hash } = resolvedUrl; + const pathname = cleanUrl(url); + return `${pathname}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`; +} + +export { ModuleMockerMSWInterceptor }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-automock.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-automock.js new file mode 100644 index 00000000..68ee9c71 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-automock.js @@ -0,0 +1,526 @@ +import { readFileSync } from 'node:fs'; +import { pathToFileURL, fileURLToPath } from 'node:url'; +import MagicString from 'magic-string'; +import { walk } from 'estree-walker'; +import module$1, { isBuiltin, createRequire } from 'node:module'; +import { extname } from 'node:path'; +import { f as filterOutComments } from './chunk-helpers.js'; + +const isNodeInPatternWeakSet = new WeakSet(); +function setIsNodeInPattern(node) { + return isNodeInPatternWeakSet.add(node); +} +function isNodeInPattern(node) { + return isNodeInPatternWeakSet.has(node); +} +/** +* Same logic from \@vue/compiler-core & \@vue/compiler-sfc +* Except this is using acorn AST +*/ +function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallExpression }) { + const parentStack = []; + const varKindStack = []; + const scopeMap = new WeakMap(); + const identifiers = []; + const setScope = (node, name) => { + let scopeIds = scopeMap.get(node); + if (scopeIds && scopeIds.has(name)) { + return; + } + if (!scopeIds) { + scopeIds = new Set(); + scopeMap.set(node, scopeIds); + } + scopeIds.add(name); + }; + function isInScope(name, parents) { + return parents.some((node) => node && scopeMap.get(node)?.has(name)); + } + function handlePattern(p, parentScope) { + if (p.type === "Identifier") { + setScope(parentScope, p.name); + } else if (p.type === "RestElement") { + handlePattern(p.argument, parentScope); + } else if (p.type === "ObjectPattern") { + p.properties.forEach((property) => { + if (property.type === "RestElement") { + setScope(parentScope, property.argument.name); + } else { + handlePattern(property.value, parentScope); + } + }); + } else if (p.type === "ArrayPattern") { + p.elements.forEach((element) => { + if (element) { + handlePattern(element, parentScope); + } + }); + } else if (p.type === "AssignmentPattern") { + handlePattern(p.left, parentScope); + } else { + setScope(parentScope, p.name); + } + } + walk(root, { + enter(node, parent) { + if (node.type === "ImportDeclaration") { + return this.skip(); + } + // track parent stack, skip for "else-if"/"else" branches as acorn nests + // the ast within "if" nodes instead of flattening them + if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) { + parentStack.unshift(parent); + } + // track variable declaration kind stack used by VariableDeclarator + if (node.type === "VariableDeclaration") { + varKindStack.unshift(node.kind); + } + if (node.type === "CallExpression") { + onCallExpression?.(node); + } + if (node.type === "MetaProperty" && node.meta.name === "import") { + onImportMeta?.(node); + } else if (node.type === "ImportExpression") { + onDynamicImport?.(node); + } + if (node.type === "Identifier") { + if (!isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack)) { + // record the identifier, for DFS -> BFS + identifiers.push([node, parentStack.slice(0)]); + } + } else if (node.type === "ClassDeclaration" && node.id) { + // A class declaration name could shadow an import, so add its name to the parent scope + const parentScope = findParentScope(parentStack); + if (parentScope) { + setScope(parentScope, node.id.name); + } + } else if (node.type === "ClassExpression" && node.id) { + // A class expression name could shadow an import, so add its name to the scope + setScope(node, node.id.name); + } else if (isFunctionNode(node)) { + // If it is a function declaration, it could be shadowing an import + // Add its name to the scope so it won't get replaced + if (node.type === "FunctionDeclaration") { + const parentScope = findParentScope(parentStack); + if (parentScope) { + setScope(parentScope, node.id.name); + } + } + // walk function expressions and add its arguments to known identifiers + // so that we don't prefix them + node.params.forEach((p) => { + if (p.type === "ObjectPattern" || p.type === "ArrayPattern") { + handlePattern(p, node); + return; + } + walk(p.type === "AssignmentPattern" ? p.left : p, { enter(child, parent) { + // skip params default value of destructure + if (parent?.type === "AssignmentPattern" && parent?.right === child) { + return this.skip(); + } + if (child.type !== "Identifier") { + return; + } + // do not record as scope variable if is a destructuring keyword + if (isStaticPropertyKey(child, parent)) { + return; + } + // do not record if this is a default value + // assignment of a destructuring variable + if (parent?.type === "TemplateLiteral" && parent?.expressions.includes(child) || parent?.type === "CallExpression" && parent?.callee === child) { + return; + } + setScope(node, child.name); + } }); + }); + } else if (node.type === "Property" && parent.type === "ObjectPattern") { + // mark property in destructuring pattern + setIsNodeInPattern(node); + } else if (node.type === "VariableDeclarator") { + const parentFunction = findParentScope(parentStack, varKindStack[0] === "var"); + if (parentFunction) { + handlePattern(node.id, parentFunction); + } + } else if (node.type === "CatchClause" && node.param) { + handlePattern(node.param, node); + } + }, + leave(node, parent) { + // untrack parent stack from above + if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) { + parentStack.shift(); + } + if (node.type === "VariableDeclaration") { + varKindStack.shift(); + } + } + }); + // emit the identifier events in BFS so the hoisted declarations + // can be captured correctly + identifiers.forEach(([node, stack]) => { + if (!isInScope(node.name, stack)) { + const parent = stack[0]; + const hasBindingShortcut = isStaticProperty(parent) && parent.shorthand && (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack)); + const classDeclaration = parent.type === "ClassDeclaration" && node === parent.superClass; + const classExpression = parent.type === "ClassExpression" && node === parent.id; + onIdentifier?.(node, { + hasBindingShortcut, + classDeclaration, + classExpression + }, stack); + } + }); +} +function isRefIdentifier(id, parent, parentStack) { + // declaration id + if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id) { + return false; + } + if (isFunctionNode(parent)) { + // function declaration/expression id + if (parent.id === id) { + return false; + } + // params list + if (parent.params.includes(id)) { + return false; + } + } + // class method name + if (parent.type === "MethodDefinition" && !parent.computed) { + return false; + } + // class property + if (parent.type === "PropertyDefinition" && !parent.computed) { + // Default values can still reference identifiers + return id === parent.value; + } + // property key + if (isStaticPropertyKey(id, parent)) { + return false; + } + // object destructuring pattern + if (isNodeInPattern(parent) && parent.value === id) { + return false; + } + // non-assignment array destructuring pattern + if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack)) { + return false; + } + // member expression property + if (parent.type === "MemberExpression" && parent.property === id && !parent.computed) { + return false; + } + if (parent.type === "ExportSpecifier") { + return false; + } + // is a special keyword but parsed as identifier + if (id.name === "arguments") { + return false; + } + return true; +} +function isStaticProperty(node) { + return node && node.type === "Property" && !node.computed; +} +function isStaticPropertyKey(node, parent) { + return isStaticProperty(parent) && parent.key === node; +} +const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/; +function isFunctionNode(node) { + return functionNodeTypeRE.test(node.type); +} +const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/; +function isBlock(node) { + return blockNodeTypeRE.test(node.type); +} +function findParentScope(parentStack, isVar = false) { + return parentStack.find(isVar ? isFunctionNode : isBlock); +} +function isInDestructuringAssignment(parent, parentStack) { + if (parent && (parent.type === "Property" || parent.type === "ArrayPattern")) { + return parentStack.some((i) => i.type === "AssignmentExpression"); + } + return false; +} +function getArbitraryModuleIdentifier(node) { + return node.type === "Identifier" ? node.name : node.raw; +} + +/* cjs-module-lexer 2.2.1 */ +let A$1;const B$1=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse$1(E,g="@"){if(!A$1)throw new Error("Not initialized");const w=E.length+1,D=(A$1.__heap_base.value||A$1.__heap_base)+4*w-A$1.memory.buffer.byteLength;D>0&&A$1.memory.grow(Math.ceil(D/65536));const G=A$1.sa(w);(B$1?C$1:I)(E,new Uint16Array(A$1.memory.buffer,G,w));const S=A$1.parseCJS(G,E.length,0,0,0);if(S){const B=new Error(`Parse error ${g}${A$1.e()}:${E.slice(0,A$1.e()).split("\n").length}:${A$1.e()-E.lastIndexOf("\n",A$1.e()-1)}`);throw Object.assign(B,{idx:A$1.e()}),5!==S&&6!==S&&7!==S||Object.assign(B,{code:"ERR_LEXER_ESM_SYNTAX"}),B}let o=new Set,R=new Set,y=new Set;for(;A$1.rre();){const B=Q$1(E.slice(A$1.res(),A$1.ree()));B&&R.add(B);}for(;A$1.ru();)y.add(Q$1(E.slice(A$1.us(),A$1.ue())));for(;A$1.re();){let B=Q$1(E.slice(A$1.es(),A$1.ee()));void 0===B||y.has(B)||o.add(B);}return {exports:[...o],reexports:[...R]}}function Q$1(A){if('"'!==A[0]&&"'"!==A[0])return A;try{const B=function(A){const B=A[0];if('"'===B)try{return JSON.parse(A)}catch{}else if("'"===B&&A.length>1&&"'"===A[A.length-1]&&-1===A.indexOf('"'))try{return JSON.parse('"'+A.slice(1,-1)+'"')}catch{}let Q="",g={v:1};for(;g.v1114111)throw new SyntaxError;++B.v;}while("}"!==A[B.v]);++B.v;}else for(let E=0;E<4;++E)Q=16*Q+g(A[B.v]),++B.v;return String.fromCodePoint(Q)}(A,B);case "0":case "1":case "2":case "3":case "4":case "5":case "6":case "7":return function(A,B,Q){let E=A<="3"?2:1,g=+A;do{if((A=B[Q.v])<"0"||A>"7")break;g=8*g+ +A,++Q.v,--E;}while(E>0);return String.fromCodePoint(g)}(Q,A,B);default:return Q}}function g(A){if(A>="0"&&A<="9")return +A;if(A>="a"&&A<="f")return A.charCodeAt(0)-87;if(A>="A"&&A<="F")return A.charCodeAt(0)-55;throw new SyntaxError}function I(A,B){const Q=A.length;let E=0;for(;E>>8;}}function C$1(A,B){const Q=A.length;let E=0;for(;EA.charCodeAt(0))}let D;function init$1(){return D||(D=(async()=>{const B=await WebAssembly.compile(w()),{exports:Q}=await WebAssembly.instantiate(B);A$1=Q;})())} + +/* es-module-lexer 2.3.2 */ +(function(A){return A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase",A})({});const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(C,g="@"){if(!E)return init.then(()=>parse(C,g));const I=C.length+1,w=(E.__heap_base.value||E.__heap_base)+4*I-E.memory.buffer.byteLength;w>0&&E.memory.grow(Math.ceil(w/65536));const D=E.sa(I-1);if("undefined"!=typeof Buffer?Buffer.from(E.memory.buffer,D,2*(I-1)).write(C,"utf16le"):(A?Q:B)(C,new Uint16Array(E.memory.buffer,D,I)),!E.parse())throw Object.assign(new Error(`Parse error ${g}:${C.slice(0,E.e()).split("\n").length}:${E.e()-C.lastIndexOf("\n",E.e()-1)}`),{idx:E.e()});const o=[],G=[];for(;E.ri();){const A=E.is(),B=E.ie(),Q=E.it(),g=E.ai(),I=E.id(),w=E.ss(),D=E.se();let G;E.ip()&&(G=i(C.slice(-1===I?A-1:A,-1===I?B+1:B)));let J=null;for(J=[],E.rsa();E.ra();){const A=E.aks(),B=E.ake(),Q=E.avs(),g=E.ave();J.push([s(C.slice(A,B)),s(C.slice(Q,g))]);}0===J.length&&(J=null),o.push({n:G,t:Q,s:A,e:B,ss:w,se:D,d:I,a:g,at:J});}for(;E.re();){const A=E.es(),B=E.ee(),Q=E.els(),g=E.ele(),I=Q<0?void 0:s(C.slice(Q,g)),w=s(C.slice(A,B));G.push({s:A,e:B,ls:Q,le:g,ss:E.ess(),n:w,ln:I});}function i(A){try{return (0,eval)(A)}catch(A){}}function s(A){if(!A)return A;const B=A[0];return ('"'===B||"'"===B)&&i(A)||A}return [o,G,!!E.f(),!!E.ms()]}function B(A,B){const Q=A.length;let E=0;for(;E>>8;}}function Q(A,B){const Q=A.length;let E=0;for(;E{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),A=>A.charCodeAt(0));var A;};const init=WebAssembly.compile(C()).then(WebAssembly.instantiate).then(({exports:A})=>{E=A;}); + +async function initSyntaxLexers() { + await Promise.all([init$1(), init]); +} +const isTransform = process.execArgv.includes("--experimental-transform-types") || process.env.NODE_OPTIONS?.includes("--experimental-transform-types"); +function transformCode(code, filename) { + const ext = extname(filename.split("?")[0]); + const isTs = ext === ".ts" || ext === ".cts" || ext === ".mts"; + if (!isTs) { + return code; + } + if (!module$1.stripTypeScriptTypes) { + throw new Error(`Cannot parse '${filename}' because "module.stripTypeScriptTypes" is not supported. Module mocking requires Node.js 22.15 or higher. This is NOT a bug of Vitest.`); + } + return module$1.stripTypeScriptTypes(code, { mode: isTransform ? "transform" : "strip" }); +} +const cachedFileExports = new Map(); +function collectModuleExports(filename, code, format, exports = []) { + if (format === "module") { + const [imports_, exports_] = parse(code, filename); + const fileExports = [...exports_.map((p) => p.n)]; + imports_.forEach(({ ss: start, se: end, n: name }) => { + const substring = code.substring(start, end).replace(/ +/g, " "); + if (name && substring.startsWith("export *") && !substring.startsWith("export * as")) { + fileExports.push(...tryParseModule(name)); + } + }); + cachedFileExports.set(filename, fileExports); + exports.push(...fileExports); + } else { + const { exports: exports_, reexports } = parse$1(code, filename); + const fileExports = [...exports_]; + reexports.forEach((name) => { + fileExports.push(...tryParseModule(name)); + }); + cachedFileExports.set(filename, fileExports); + exports.push(...fileExports); + } + function tryParseModule(name) { + try { + return parseModule(name); + } catch (error) { + console.warn(`[module mocking] Failed to parse '${name}' imported from ${filename}:`, error); + return []; + } + } + let __require; + function getModuleRequire() { + return __require ??= createRequire(filename); + } + function parseModule(name) { + if (isBuiltin(name)) { + if (cachedFileExports.has(name)) { + const cachedExports = cachedFileExports.get(name); + return cachedExports; + } + const builtinModule = getBuiltinModule(name); + const builtinExports = Object.keys(builtinModule); + cachedFileExports.set(name, builtinExports); + return builtinExports; + } + const resolvedModuleUrl = format === "module" ? import.meta.resolve(name, pathToFileURL(filename).toString()) : getModuleRequire().resolve(name); + const resolvedModulePath = format === "commonjs" ? resolvedModuleUrl : fileURLToPath(resolvedModuleUrl); + if (cachedFileExports.has(resolvedModulePath)) { + return cachedFileExports.get(resolvedModulePath); + } + const fileContent = readFileSync(resolvedModulePath, "utf-8"); + const ext = extname(resolvedModulePath); + const code = transformCode(fileContent, resolvedModulePath); + if (code == null) { + cachedFileExports.set(resolvedModulePath, []); + return []; + } + const resolvedModuleFormat = resolveModuleFormat(resolvedModulePath, code); + if (ext === ".json") { + return ["default"]; + } else { + // can't do wasm, for example + console.warn(`Cannot process '${resolvedModuleFormat}' imported from ${filename} because of unknown file extension: ${ext}.`); + } + if (resolvedModuleFormat) { + return collectModuleExports(resolvedModulePath, code, resolvedModuleFormat, exports); + } + return []; + } + return Array.from(new Set(exports)); +} +function resolveModuleFormat(url, code) { + const ext = extname(url); + if (ext === ".cjs" || ext === ".cts") { + return "commonjs"; + } else if (ext === ".mjs" || ext === ".mts") { + return "module"; + } else if (ext === ".js" || ext === ".ts" || ext === "") { + if (!module$1.findPackageJSON) { + throw new Error(`Cannot parse the module format of '${url}' because "module.findPackageJSON" is not available. Upgrade to Node 22.14 to use this feature. This is NOT a bug of Vitest.`); + } + const pkgJsonPath = module$1.findPackageJSON(url); + const pkgJson = pkgJsonPath ? JSON.parse(readFileSync(pkgJsonPath, "utf-8")) : {}; + if (pkgJson?.type === "module") { + return "module"; + } else if (pkgJson?.type === "commonjs") { + return "commonjs"; + } else { + // Ambiguous input! Check if it has ESM syntax. Node.js is much smarter here, + // but we don't need to run the code, so we can be more relaxed + if (hasESM(filterOutComments(code))) { + return "module"; + } else { + return "commonjs"; + } + } + } + return undefined; +} +let __globalRequire; +function getBuiltinModule(moduleId) { + __globalRequire ??= module$1.createRequire(import.meta.url); + return __globalRequire(moduleId); +} +const ESM_RE = /(?:[\s;]|^)(?:import[\s\w*,{}]*from|import\s*["'*{]|export\b\s*(?:[*{]|default|class|type|function|const|var|let|async function)|import\.meta\b)/m; +function hasESM(code) { + return ESM_RE.test(code); +} + +// TODO: better source map replacement +function automockModule(code, mockType, parse, options = {}) { + const globalThisAccessor = options.globalThisAccessor || "\"__vitest_mocker__\""; + let ast; + try { + ast = parse(code); + } catch (cause) { + if (options.id) { + throw new Error(`failed to parse ${options.id}`, { cause }); + } + throw cause; + } + const m = new MagicString(code); + const allSpecifiers = []; + const replacers = []; + let importIndex = 0; + for (const _node of ast.body) { + if (_node.type === "ExportAllDeclaration") { + const node = _node; + // TODO: pass it down in the browser mode + if (!options.id) { + throw new Error(`automocking files with \`export *\` is not supported because it cannot be easily statically analysed`); + } + const source = node.source.value; + if (typeof source !== "string") { + throw new TypeError(`unknown source type while automocking: ${source}`); + } + const moduleUrl = import.meta.resolve(source, pathToFileURL(options.id).toString()); + const modulePath = fileURLToPath(moduleUrl); + const moduleContent = readFileSync(modulePath, "utf-8"); + const transformedCode = transformCode(moduleContent, moduleUrl); + const moduleFormat = resolveModuleFormat(moduleUrl, transformedCode); + const moduleExports = collectModuleExports(modulePath, transformedCode, moduleFormat || "module"); + replacers.push(() => { + const importNames = []; + moduleExports.forEach((exportName) => { + const isReexported = allSpecifiers.some(({ name, alias }) => name === exportName || alias === exportName); + if (!isReexported) { + importNames.push(exportName); + allSpecifiers.push({ name: exportName }); + } + }); + const importString = `import { ${importNames.join(", ")} } from '${source}';`; + m.overwrite(node.start, node.end, importString); + }); + } + if (_node.type === "ExportNamedDeclaration") { + const node = _node; + const declaration = node.declaration; + function traversePattern(expression) { + // export const test = '1' + if (expression.type === "Identifier") { + allSpecifiers.push({ name: expression.name }); + } else if (expression.type === "ArrayPattern") { + expression.elements.forEach((element) => { + if (!element) { + return; + } + traversePattern(element); + }); + } else if (expression.type === "ObjectPattern") { + expression.properties.forEach((property) => { + // export const { ...rest } = {} + if (property.type === "RestElement") { + traversePattern(property); + } else if (property.type === "Property") { + traversePattern(property.value); + } else ; + }); + } else if (expression.type === "RestElement") { + traversePattern(expression.argument); + } else if (expression.type === "AssignmentPattern") { + throw new Error(`AssignmentPattern is not supported. Please open a new bug report.`); + } else if (expression.type === "MemberExpression") { + throw new Error(`MemberExpression is not supported. Please open a new bug report.`); + } else ; + } + if (declaration) { + if (declaration.type === "FunctionDeclaration") { + allSpecifiers.push({ name: declaration.id.name }); + } else if (declaration.type === "VariableDeclaration") { + declaration.declarations.forEach((declaration) => { + traversePattern(declaration.id); + }); + } else if (declaration.type === "ClassDeclaration") { + allSpecifiers.push({ name: declaration.id.name }); + } else ; + m.remove(node.start, declaration.start); + } + const specifiers = node.specifiers || []; + const source = node.source; + if (!source && specifiers.length) { + specifiers.forEach((specifier) => { + allSpecifiers.push({ + alias: getArbitraryModuleIdentifier(specifier.exported), + name: getArbitraryModuleIdentifier(specifier.local) + }); + }); + m.remove(node.start, node.end); + } else if (source && specifiers.length) { + const importNames = []; + specifiers.forEach((specifier) => { + const importedName = `__vitest_imported_${importIndex++}__`; + importNames.push([getArbitraryModuleIdentifier(specifier.local), importedName]); + allSpecifiers.push({ + name: importedName, + alias: getArbitraryModuleIdentifier(specifier.exported) + }); + }); + const importString = `import { ${importNames.map(([name, alias]) => `${name} as ${alias}`).join(", ")} } from '${source.value}'`; + m.overwrite(node.start, node.end, importString); + } + } + if (_node.type === "ExportDefaultDeclaration") { + const node = _node; + const declaration = node.declaration; + allSpecifiers.push({ + name: "__vitest_default", + alias: "default" + }); + m.overwrite(node.start, declaration.start, `const __vitest_default = `); + } + } + replacers.forEach((cb) => cb()); + const moduleObject = ` +const __vitest_current_es_module__ = { + __esModule: true, + ${allSpecifiers.map(({ name }) => `["${name}"]: ${name},`).join("\n ")} +} +const __vitest_mocked_module__ = globalThis[${globalThisAccessor}].mockObject(__vitest_current_es_module__, "${mockType}") +`; + const assigning = allSpecifiers.map(({ name }, index) => { + return `const __vitest_mocked_${index}__ = __vitest_mocked_module__["${name}"]`; + }).join("\n"); + const redeclarations = allSpecifiers.map(({ name, alias }, index) => { + return ` __vitest_mocked_${index}__ as ${alias || name},`; + }).join("\n"); + const specifiersExports = ` +export { +${redeclarations} +} +`; + m.append(moduleObject + assigning + specifiersExports); + return m; +} + +export { automockModule as a, collectModuleExports as c, esmWalker as e, initSyntaxLexers as i }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-helpers.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-helpers.js new file mode 100644 index 00000000..eff497d1 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-helpers.js @@ -0,0 +1,44 @@ +/** +* Get original stacktrace without source map support the most performant way. +* - Create only 1 stack frame. +* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms). +*/ +function createSimpleStackTrace(options) { + const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {}; + const limit = Error.stackTraceLimit; + const prepareStackTrace = Error.prepareStackTrace; + Error.stackTraceLimit = stackTraceLimit; + Error.prepareStackTrace = (e) => e.stack; + const err = new Error(message); + const stackTrace = err.stack || ""; + Error.prepareStackTrace = prepareStackTrace; + Error.stackTraceLimit = limit; + return stackTrace; +} +function filterOutComments(s) { + const result = []; + let commentState = "none"; + for (let i = 0; i < s.length; ++i) { + if (commentState === "singleline") { + if (s[i] === "\n") { + commentState = "none"; + } + } else if (commentState === "multiline") { + if (s[i - 1] === "*" && s[i] === "/") { + commentState = "none"; + } + } else if (commentState === "none") { + if (s[i] === "/" && s[i + 1] === "/") { + commentState = "singleline"; + } else if (s[i] === "/" && s[i + 1] === "*") { + commentState = "multiline"; + i += 2; + } else { + result.push(s[i]); + } + } + } + return result.join(""); +} + +export { createSimpleStackTrace as c, filterOutComments as f }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-hoistMocks.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-hoistMocks.js new file mode 100644 index 00000000..b545b836 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-hoistMocks.js @@ -0,0 +1,736 @@ +import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping'; +import MagicString from 'magic-string'; +import { e as esmWalker } from './chunk-automock.js'; +import { a as relative } from './chunk-pathe.M-eThtNZ.js'; + +// AST walker module for ESTree compatible trees + + +function makeTest(test) { + if (typeof test === "string") + { return function (type) { return type === test; } } + else if (!test) + { return function () { return true; } } + else + { return test } +} + +var Found = function Found(node, state) { this.node = node; this.state = state; }; + +// Find the innermost node of a given type that contains the given +// position. Interface similar to findNodeAt. +function findNodeAround(node, pos, test, baseVisitor, state) { + test = makeTest(test); + if (!baseVisitor) { baseVisitor = base; } + try { + (function c(node, st, override) { + var type = override || node.type; + if (node.start > pos || node.end < pos) { return } + visitNode(baseVisitor, type, node, st, c); + if (test(type, node)) { throw new Found(node, st) } + })(node, state); + } catch (e) { + if (e instanceof Found) { return e } + throw e + } +} + +function skipThrough(node, st, c) { c(node, st); } +function ignore(_node, _st, _c) {} + +function visitNode(baseVisitor, type, node, st, c) { + if (baseVisitor[type] == null) { throw new Error(("No walker function defined for node type " + type)) } + baseVisitor[type](node, st, c); +} + +// Node walkers. + +var base = {}; + +base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var stmt = list[i]; + + c(stmt, st, "Statement"); + } +}; +base.Statement = skipThrough; +base.EmptyStatement = ignore; +base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression = + function (node, st, c) { return c(node.expression, st, "Expression"); }; +base.IfStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Statement"); + if (node.alternate) { c(node.alternate, st, "Statement"); } +}; +base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }; +base.BreakStatement = base.ContinueStatement = ignore; +base.WithStatement = function (node, st, c) { + c(node.object, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.SwitchStatement = function (node, st, c) { + c(node.discriminant, st, "Expression"); + for (var i = 0, list = node.cases; i < list.length; i += 1) { + var cs = list[i]; + + c(cs, st); + } +}; +base.SwitchCase = function (node, st, c) { + if (node.test) { c(node.test, st, "Expression"); } + for (var i = 0, list = node.consequent; i < list.length; i += 1) + { + var cons = list[i]; + + c(cons, st, "Statement"); + } +}; +base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) { + if (node.argument) { c(node.argument, st, "Expression"); } +}; +base.ThrowStatement = base.SpreadElement = + function (node, st, c) { return c(node.argument, st, "Expression"); }; +base.TryStatement = function (node, st, c) { + c(node.block, st, "Statement"); + if (node.handler) { c(node.handler, st); } + if (node.finalizer) { c(node.finalizer, st, "Statement"); } +}; +base.CatchClause = function (node, st, c) { + if (node.param) { c(node.param, st, "Pattern"); } + c(node.body, st, "Statement"); +}; +base.WhileStatement = base.DoWhileStatement = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.ForStatement = function (node, st, c) { + if (node.init) { c(node.init, st, "ForInit"); } + if (node.test) { c(node.test, st, "Expression"); } + if (node.update) { c(node.update, st, "Expression"); } + c(node.body, st, "Statement"); +}; +base.ForInStatement = base.ForOfStatement = function (node, st, c) { + c(node.left, st, "ForInit"); + c(node.right, st, "Expression"); + c(node.body, st, "Statement"); +}; +base.ForInit = function (node, st, c) { + if (node.type === "VariableDeclaration") { c(node, st); } + else { c(node, st, "Expression"); } +}; +base.DebuggerStatement = ignore; + +base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }; +base.VariableDeclaration = function (node, st, c) { + for (var i = 0, list = node.declarations; i < list.length; i += 1) + { + var decl = list[i]; + + c(decl, st); + } +}; +base.VariableDeclarator = function (node, st, c) { + c(node.id, st, "Pattern"); + if (node.init) { c(node.init, st, "Expression"); } +}; + +base.Function = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + for (var i = 0, list = node.params; i < list.length; i += 1) + { + var param = list[i]; + + c(param, st, "Pattern"); + } + c(node.body, st, node.expression ? "Expression" : "Statement"); +}; + +base.Pattern = function (node, st, c) { + if (node.type === "Identifier") + { c(node, st, "VariablePattern"); } + else if (node.type === "MemberExpression") + { c(node, st, "MemberPattern"); } + else + { c(node, st); } +}; +base.VariablePattern = ignore; +base.MemberPattern = skipThrough; +base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }; +base.ArrayPattern = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Pattern"); } + } +}; +base.ObjectPattern = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) { + var prop = list[i]; + + if (prop.type === "Property") { + if (prop.computed) { c(prop.key, st, "Expression"); } + c(prop.value, st, "Pattern"); + } else if (prop.type === "RestElement") { + c(prop.argument, st, "Pattern"); + } + } +}; + +base.Expression = skipThrough; +base.ThisExpression = base.Super = base.MetaProperty = ignore; +base.ArrayExpression = function (node, st, c) { + for (var i = 0, list = node.elements; i < list.length; i += 1) { + var elt = list[i]; + + if (elt) { c(elt, st, "Expression"); } + } +}; +base.ObjectExpression = function (node, st, c) { + for (var i = 0, list = node.properties; i < list.length; i += 1) + { + var prop = list[i]; + + c(prop, st); + } +}; +base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration; +base.SequenceExpression = function (node, st, c) { + for (var i = 0, list = node.expressions; i < list.length; i += 1) + { + var expr = list[i]; + + c(expr, st, "Expression"); + } +}; +base.TemplateLiteral = function (node, st, c) { + for (var i = 0, list = node.quasis; i < list.length; i += 1) + { + var quasi = list[i]; + + c(quasi, st); + } + + for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1) + { + var expr = list$1[i$1]; + + c(expr, st, "Expression"); + } +}; +base.TemplateElement = ignore; +base.UnaryExpression = base.UpdateExpression = function (node, st, c) { + c(node.argument, st, "Expression"); +}; +base.BinaryExpression = base.LogicalExpression = function (node, st, c) { + c(node.left, st, "Expression"); + c(node.right, st, "Expression"); +}; +base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) { + c(node.left, st, "Pattern"); + c(node.right, st, "Expression"); +}; +base.ConditionalExpression = function (node, st, c) { + c(node.test, st, "Expression"); + c(node.consequent, st, "Expression"); + c(node.alternate, st, "Expression"); +}; +base.NewExpression = base.CallExpression = function (node, st, c) { + c(node.callee, st, "Expression"); + if (node.arguments) + { for (var i = 0, list = node.arguments; i < list.length; i += 1) + { + var arg = list[i]; + + c(arg, st, "Expression"); + } } +}; +base.MemberExpression = function (node, st, c) { + c(node.object, st, "Expression"); + if (node.computed) { c(node.property, st, "Expression"); } +}; +base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) { + if (node.declaration) + { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); } + if (node.source) { c(node.source, st, "Expression"); } + if (node.attributes) + { for (var i = 0, list = node.attributes; i < list.length; i += 1) + { + var attr = list[i]; + + c(attr, st); + } } +}; +base.ExportAllDeclaration = function (node, st, c) { + if (node.exported) + { c(node.exported, st); } + c(node.source, st, "Expression"); + if (node.attributes) + { for (var i = 0, list = node.attributes; i < list.length; i += 1) + { + var attr = list[i]; + + c(attr, st); + } } +}; +base.ImportAttribute = function (node, st, c) { + c(node.value, st, "Expression"); +}; +base.ImportDeclaration = function (node, st, c) { + for (var i = 0, list = node.specifiers; i < list.length; i += 1) + { + var spec = list[i]; + + c(spec, st); + } + c(node.source, st, "Expression"); + if (node.attributes) + { for (var i$1 = 0, list$1 = node.attributes; i$1 < list$1.length; i$1 += 1) + { + var attr = list$1[i$1]; + + c(attr, st); + } } +}; +base.ImportExpression = function (node, st, c) { + c(node.source, st, "Expression"); + if (node.options) { c(node.options, st, "Expression"); } +}; +base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore; + +base.TaggedTemplateExpression = function (node, st, c) { + c(node.tag, st, "Expression"); + c(node.quasi, st, "Expression"); +}; +base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }; +base.Class = function (node, st, c) { + if (node.id) { c(node.id, st, "Pattern"); } + if (node.superClass) { c(node.superClass, st, "Expression"); } + c(node.body, st); +}; +base.ClassBody = function (node, st, c) { + for (var i = 0, list = node.body; i < list.length; i += 1) + { + var elt = list[i]; + + c(elt, st); + } +}; +base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) { + if (node.computed) { c(node.key, st, "Expression"); } + if (node.value) { c(node.value, st, "Expression"); } +}; + +const API_NOT_FOUND_ERROR = `There are some problems in resolving the mocks API. +You may encounter this issue when importing the mocks API from another module other than 'vitest'. +To fix this issue you can either: +- import the mocks API directly from 'vitest' +- enable the 'globals' option`; +function API_NOT_FOUND_CHECK(names) { + return `\nif (${names.map((name) => `typeof globalThis["${name}"] === "undefined"`).join(" && ")}) ` + `{ throw new Error(${JSON.stringify(API_NOT_FOUND_ERROR)}) }\n`; +} +function isIdentifier(node) { + return node.type === "Identifier"; +} +function getNodeTail(code, node) { + let end = node.end; + if (code[node.end] === ";") { + end += 1; + } + if (code[node.end] === "\n") { + return end + 1; + } + if (code[node.end + 1] === "\n") { + end += 1; + } + return end; +} +const regexpHoistable = /\b(?:vi|vitest)\s*\.\s*(?:mock|unmock|hoisted|doMock|doUnmock)\s*\(/; +const hashbangRE = /^#!.*\n/; +// Public redistributions of Vitest that re-export its mocking API (`vi`) +// verbatim under their own specifier. Imports from these are treated as the +// hoisted module so `vi.mock()` is hoisted for e.g. +// `import { vi } from 'vite-plus/test'`, exactly as it is for `vitest`. +const REDISTRIBUTED_HOISTED_MODULES = ["vite-plus/test"]; +// this is a fork of Vite SSR transform +function hoistMocks(code, id, parse, options = {}) { + const needHoisting = (options.regexpHoistable || regexpHoistable).test(code); + if (!needHoisting) { + return; + } + const s = options.magicString?.() || new MagicString(code); + let ast; + try { + ast = parse(code); + } catch (err) { + console.error(`Cannot parse ${id}:\n${err.message}.`); + return; + } + const { hoistableMockMethodNames = ["mock", "unmock"], dynamicImportMockMethodNames = [ + "mock", + "unmock", + "doMock", + "doUnmock" + ], hoistedMethodNames = ["hoisted"], utilsObjectNames = ["vi", "vitest"], hoistedModule = "vitest" } = options; + // hoist at the start of the file, after the hashbang + const hashbangEnd = hashbangRE.exec(code)?.[0].length ?? 0; + let hoistIndex = hashbangEnd; + let hoistedModuleImported = false; + let uid = 0; + const idToImportMap = new Map(); + const imports = []; + // this will transform import statements into dynamic ones, if there are imports + // it will keep the import as is, if we don't need to mock anything + // in browser environment it will wrap the module value with "vitest_wrap_module" function + // that returns a proxy to the module so that named exports can be mocked + function defineImport(importNode) { + const source = importNode.source.value; + // always hoist vitest import to top of the file, so + // "vi" helpers can access it. Vitest redistributions that re-export the + // mocking API under their own specifier are recognized the same way. + if (hoistedModule === source || REDISTRIBUTED_HOISTED_MODULES.includes(source)) { + hoistedModuleImported = true; + return; + } + const importId = `__vi_import_${uid++}__`; + imports.push({ + id: importId, + node: importNode + }); + return importId; + } + // 1. check all import statements and record id -> importName map + for (const node of ast.body) { + // import foo from 'foo' --> foo -> __import_foo__.default + // import { baz } from 'foo' --> baz -> __import_foo__.baz + // import * as ok from 'foo' --> ok -> __import_foo__ + if (node.type === "ImportDeclaration") { + const importId = defineImport(node); + if (!importId) { + continue; + } + for (const spec of node.specifiers) { + if (spec.type === "ImportSpecifier") { + if (spec.imported.type === "Identifier") { + idToImportMap.set(spec.local.name, `${importId}.${spec.imported.name}`); + } else { + idToImportMap.set(spec.local.name, `${importId}[${JSON.stringify(spec.imported.value)}]`); + } + } else if (spec.type === "ImportDefaultSpecifier") { + idToImportMap.set(spec.local.name, `${importId}.default`); + } else { + // namespace specifier + idToImportMap.set(spec.local.name, importId); + } + } + } + } + const declaredConst = new Set(); + const hoistedNodes = new Set(); + function createSyntaxError(node, message) { + const _error = new SyntaxError(message); + Error.captureStackTrace(_error, createSyntaxError); + const serializedError = { + name: "SyntaxError", + message: _error.message, + stack: _error.stack + }; + if (options.codeFrameGenerator) { + serializedError.frame = options.codeFrameGenerator(node, id, code); + } + return serializedError; + } + function assertNotDefaultExport(node, error) { + const defaultExport = findNodeAround(ast, node.start, "ExportDefaultDeclaration")?.node; + if (defaultExport?.declaration === node || defaultExport?.declaration.type === "AwaitExpression" && defaultExport.declaration.argument === node) { + throw createSyntaxError(defaultExport, error); + } + } + function assertNotNamedExport(node, error) { + const nodeExported = findNodeAround(ast, node.start, "ExportNamedDeclaration")?.node; + if (nodeExported?.declaration === node) { + throw createSyntaxError(nodeExported, error); + } + } + function getVariableDeclaration(node) { + const declarationNode = findNodeAround(ast, node.start, "VariableDeclaration")?.node; + const init = declarationNode?.declarations[0]?.init; + if (init && (init === node || init.type === "AwaitExpression" && init.argument === node)) { + return declarationNode; + } + } + const usedUtilityExports = new Set(); + let hasImportMetaVitest = false; + let hasMockApiCall = false; + esmWalker(ast, { + onImportMeta(node) { + const property = code.slice(node.end, node.end + 7); + if (property === ".vitest") { + hasImportMetaVitest = true; + } + }, + onIdentifier(id, info, parentStack) { + const binding = idToImportMap.get(id.name); + if (!binding) { + return; + } + if (info.hasBindingShortcut) { + s.appendLeft(id.end, `: ${binding}`); + } else if (info.classDeclaration) { + if (!declaredConst.has(id.name)) { + declaredConst.add(id.name); + // locate the top-most node containing the class declaration + const topNode = parentStack[parentStack.length - 2]; + s.prependRight(topNode.start, `const ${id.name} = ${binding};\n`); + } + } else if (!info.classExpression) { + s.update(id.start, id.end, binding); + } + }, + onDynamicImport(_node) { + // TODO: vi.mock(import) breaks it, and vi.mock('', () => import) also does, + // only move imports that are outside of vi.mock + // backwards compat, don't do if not passed + // if (!options.globalThisAccessor) { + // return + // } + // const globalThisAccessor = options.globalThisAccessor + // const replaceString = `globalThis[${globalThisAccessor}].wrapDynamicImport(() => import(` + // const importSubstring = code.substring(node.start, node.end) + // const hasIgnore = importSubstring.includes('/* @vite-ignore */') + // s.overwrite( + // node.start, + // (node.source as Positioned).start, + // replaceString + (hasIgnore ? '/* @vite-ignore */ ' : ''), + // ) + // s.overwrite(node.end - 1, node.end, '))') + }, + onCallExpression(node) { + if (node.callee.type === "MemberExpression" && isIdentifier(node.callee.object) && utilsObjectNames.includes(node.callee.object.name) && isIdentifier(node.callee.property)) { + const methodName = node.callee.property.name; + usedUtilityExports.add(node.callee.object.name); + if (hoistableMockMethodNames.includes(methodName)) { + hasMockApiCall = true; + const method = `${node.callee.object.name}.${methodName}`; + assertNotDefaultExport(node, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn\'t return anything.`); + const declarationNode = getVariableDeclaration(node); + if (declarationNode) { + assertNotNamedExport(declarationNode, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn\'t return anything.`); + } + if (options.onStaticMock) { + const specifier = getStaticSpecifier(node.arguments[0]); + if (specifier != null) { + // anything but an inline function may still load the original + const factory = node.arguments[1]?.type === "ArrowFunctionExpression" || node.arguments[1]?.type === "FunctionExpression" ? node.arguments[1] : undefined; + options.onStaticMock({ + method: methodName, + specifier, + hasFactory: factory != null, + factoryLoadsOriginal: factory != null && (factory.params.length > 0 || code.slice(factory.start, factory.end).includes("importActual")) + }); + } + } + // rewrite vi.mock(import('..')) into vi.mock('..') + if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && dynamicImportMockMethodNames.includes(node.callee.property.name)) { + const moduleInfo = node.arguments[0]; + // vi.mock(import('./path')) -> vi.mock('./path') + if (moduleInfo.type === "ImportExpression") { + const source = moduleInfo.source; + s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end)); + } + // vi.mock(await import('./path')) -> vi.mock('./path') + if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression") { + const source = moduleInfo.argument.source; + s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end)); + } + } + hoistedNodes.add(node); + } else if (dynamicImportMockMethodNames.includes(methodName)) { + hasMockApiCall = true; + const moduleInfo = node.arguments[0]; + let source = null; + if (moduleInfo.type === "ImportExpression") { + source = moduleInfo.source; + } + if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression") { + source = moduleInfo.argument.source; + } + if (source) { + s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end)); + } + } + if (hoistedMethodNames.includes(methodName)) { + hasMockApiCall = true; + assertNotDefaultExport(node, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first."); + const declarationNode = getVariableDeclaration(node); + if (declarationNode) { + assertNotNamedExport(declarationNode, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first."); + // hoist "const variable = vi.hoisted(() => {})" + hoistedNodes.add(declarationNode); + } else { + const awaitedExpression = findNodeAround(ast, node.start, "AwaitExpression")?.node; + // hoist "await vi.hoisted(async () => {})" or "vi.hoisted(() => {})" + const moveNode = awaitedExpression?.argument === node ? awaitedExpression : node; + hoistedNodes.add(moveNode); + } + } + } + } + }); + if (!hasMockApiCall) { + return; + } + function getNodeName(node) { + const callee = node.callee || {}; + if (callee.type === "MemberExpression" && isIdentifier(callee.property) && isIdentifier(callee.object)) { + const argument = node.arguments[0]; + const argStr = argument.type === "Literal" || argument.type === "ImportExpression" ? code.slice(argument.start, argument.end) : ""; + return `${callee.object.name}.${callee.property.name}(${argStr})`; + } + return "\"hoisted method\""; + } + function getNodeCall(node) { + if (node.type === "CallExpression") { + return node; + } + if (node.type === "VariableDeclaration") { + const { declarations } = node; + const init = declarations[0].init; + if (init) { + return getNodeCall(init); + } + } + if (node.type === "AwaitExpression") { + const { argument } = node; + if (argument.type === "CallExpression") { + return getNodeCall(argument); + } + } + return node; + } + function createError(outsideNode, insideNode) { + const outsideCall = getNodeCall(outsideNode); + const insideCall = getNodeCall(insideNode); + throw createSyntaxError(insideCall, `Cannot call ${getNodeName(insideCall)} inside ${getNodeName(outsideCall)}: both methods are hoisted to the top of the file and not actually called inside each other.`); + } + // validate hoistedNodes doesn't have nodes inside other nodes + const arrayNodes = Array.from(hoistedNodes); + for (let i = 0; i < arrayNodes.length; i++) { + const node = arrayNodes[i]; + for (let j = i + 1; j < arrayNodes.length; j++) { + const otherNode = arrayNodes[j]; + if (node.start >= otherNode.start && node.end <= otherNode.end) { + throw createError(otherNode, node); + } + if (otherNode.start >= node.start && otherNode.end <= node.end) { + throw createError(node, otherNode); + } + } + } + // validate that hoisted nodes are defined on the top level + // ignore `import.meta.vitest` because it needs to be inside an IfStatement + // and it can be used anywhere in the code (inside methods too) + if (!hasImportMetaVitest) { + for (const node of ast.body) { + hoistedNodes.delete(node); + if (node.type === "ExpressionStatement") { + hoistedNodes.delete(node.expression); + } + } + if (hoistedNodes.size) { + const locations = createIndexLocationsMap(code); + const map = options.getMap && new TraceMap(options.getMap()); + const plural = hoistedNodes.size > 1; + const message = [ + `${hoistedNodes.size} call${plural ? "s" : ""} in "${relative(options.root || process.cwd(), id)}" ${plural ? "were" : "was"} defined outside of the module's top level scope:`, + "", + ...Array.from(hoistedNodes, (invalidNode) => { + const currentLocation = locations.get(invalidNode.start); + const originalLocation = map && currentLocation && originalPositionFor(map, currentLocation); + const location = originalLocation?.column != null && originalLocation?.line != null ? ` at ${relative(options.root || process.cwd(), id)}:${originalLocation.line}:${originalLocation.column + 1}` : ""; + return `- ${getNodeName(getNodeCall(invalidNode))}${location}`; + }), + "", + `Although ${plural ? "they appear nested, they" : "it appears nested, it"} will be hoisted and executed before anything in this file. Move ${plural ? "them" : "it"} to the top level to reflect ${plural ? "their" : "its"} actual execution order.`, + "See: https://vitest.dev/guide/mocking/modules#how-it-works" + ].join("\n"); + throw new Error(message); + } + } + // hoist vi.mock/vi.hoisted + for (const node of arrayNodes) { + const end = getNodeTail(code, node); + // don't hoist into itself if it's already at the top + if (hoistIndex === end || hoistIndex === node.start) { + hoistIndex = end; + } else { + s.move(node.start, end, hoistIndex); + } + } + // hoist actual dynamic imports last so they are inserted after all hoisted mocks + for (const { node: importNode, id: importId } of imports) { + const source = importNode.source.value; + const sourceString = JSON.stringify(source); + let importLine = `const ${importId} = await `; + if (options.globalThisAccessor) { + importLine += `globalThis[${options.globalThisAccessor}].wrapDynamicImport(() => import(${sourceString}));\n`; + } else { + importLine += `import(${sourceString});\n`; + } + s.update(importNode.start, importNode.end, importLine); + if (importNode.start === hoistIndex) { + // no need to hoist, but update hoistIndex to keep the order + hoistIndex = importNode.end; + } else { + // There will be an error if the module is called before it is imported, + // so the module import statement is hoisted to the top + s.move(importNode.start, importNode.end, hoistIndex); + } + } + if (!hoistedModuleImported && arrayNodes.length > 0) { + const utilityImports = [...usedUtilityExports]; + // "vi" or "vitest" is imported from a module other than "vitest" + if (utilityImports.some((name) => idToImportMap.has(name))) { + s.appendLeft(hashbangEnd, API_NOT_FOUND_CHECK(utilityImports)); + } else if (utilityImports.length) { + s.appendLeft(hashbangEnd, `import { ${[...usedUtilityExports].join(", ")} } from ${JSON.stringify(hoistedModule)}\n`); + } + } + return s; +} +function createIndexLocationsMap(source) { + const map = new Map(); + let offset = 0; + let line = 1; + let column = 1; + for (const char of source) { + map.set(offset++, { + line, + column + }); + if (char === "\n" || char === "\r\n") { + line++; + column = 0; + } else { + column++; + } + } + return map; +} +function getStaticSpecifier(node) { + if (node?.type === "AwaitExpression") { + node = node.argument; + } + if (node?.type === "ImportExpression") { + node = node.source; + } + if (node?.type === "Literal" && typeof node.value === "string") { + return node.value; + } + if (node?.type === "TemplateLiteral" && node.expressions.length === 0) { + return node.quasis[0].value.cooked ?? undefined; + } +} + +export { hoistMocks as h }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-interceptor-native.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-interceptor-native.js new file mode 100644 index 00000000..4b472ccf --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-interceptor-native.js @@ -0,0 +1,15 @@ +import { r as rpc } from './chunk-mocker.js'; + +class ModuleMockerServerInterceptor { + async register(module) { + await rpc("vitest:interceptor:register", module.toJSON()); + } + async delete(id) { + await rpc("vitest:interceptor:delete", id); + } + async invalidate() { + await rpc("vitest:interceptor:invalidate"); + } +} + +export { ModuleMockerServerInterceptor as M }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-mocker.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-mocker.js new file mode 100644 index 00000000..054c2664 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-mocker.js @@ -0,0 +1,536 @@ +import { c as createSimpleStackTrace } from './chunk-helpers.js'; +import { mockObject } from './index.js'; +import { M as MockerRegistry, R as RedirectedModule, A as AutomockedModule } from './chunk-registry.js'; +import { e as extname, j as join } from './chunk-pathe.M-eThtNZ.js'; + +const hot = import.meta.hot || { + on: warn, + off: warn, + send: warn +}; +function warn() { + console.warn("Vitest mocker cannot work if Vite didn't establish WS connection."); +} +function rpc(event, data) { + hot.send(event, data); + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + reject(new Error(`Failed to resolve ${event} in time`)); + }, 5e3); + hot.on(`${event}:result`, function r(data) { + resolve(data); + clearTimeout(timeout); + hot.off(`${event}:result`, r); + }); + }); +} + +const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//; +function normalizeWindowsPath(input = "") { + if (!input) { + return input; + } + return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase()); +} +const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/; +function cwd() { + if (typeof process !== "undefined" && typeof process.cwd === "function") { + return process.cwd().replace(/\\/g, "/"); + } + return "/"; +} +const resolve = function(...arguments_) { + arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument)); + let resolvedPath = ""; + let resolvedAbsolute = false; + for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) { + const path = index >= 0 ? arguments_[index] : cwd(); + if (!path || path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = isAbsolute(path); + } + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute && !isAbsolute(resolvedPath)) { + return `/${resolvedPath}`; + } + return resolvedPath.length > 0 ? resolvedPath : "."; +}; +function normalizeString(path, allowAboveRoot) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let char = null; + for (let index = 0; index <= path.length; ++index) { + if (index < path.length) { + char = path[index]; + } else if (char === "/") { + break; + } else { + char = "/"; + } + if (char === "/") { + if (lastSlash === index - 1 || dots === 1); + else if (dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf("/"); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf("/"); + } + lastSlash = index; + dots = 0; + continue; + } else if (res.length > 0) { + res = ""; + lastSegmentLength = 0; + lastSlash = index; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + res += res.length > 0 ? "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) { + res += `/${path.slice(lastSlash + 1, index)}`; + } else { + res = path.slice(lastSlash + 1, index); + } + lastSegmentLength = index - lastSlash - 1; + } + lastSlash = index; + dots = 0; + } else if (char === "." && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +const isAbsolute = function(p) { + return _IS_ABSOLUTE_RE.test(p); +}; + +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var intToChar = new Uint8Array(64); +var charToInt = new Uint8Array(128); +for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; +} +const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m; +const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/; +const NOW_LENGTH = Date.now().toString().length; +const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`); +function extractLocation(urlLike) { + // Fail-fast but return locations like "(native)" + if (!urlLike.includes(":")) { + return [urlLike]; + } + const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/; + const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, "")); + if (!parts) { + return [urlLike]; + } + let url = parts[1]; + if (url.startsWith("async ")) { + url = url.slice(6); + } + if (url.startsWith("http:") || url.startsWith("https:")) { + const urlObj = new URL(url); + urlObj.searchParams.delete("import"); + urlObj.searchParams.delete("browserv"); + url = urlObj.pathname + urlObj.hash + urlObj.search; + } + if (url.startsWith("/@fs/")) { + const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url); + url = url.slice(isWindows ? 5 : 4); + } + if (url.includes("vitest=")) { + url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, ""); + } + return [ + url, + parts[2] || undefined, + parts[3] || undefined + ]; +} +function parseSingleFFOrSafariStack(raw) { + let line = raw.trim(); + if (SAFARI_NATIVE_CODE_REGEXP.test(line)) { + return null; + } + if (line.includes(" > eval")) { + line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1"); + } + // Early return for lines that don't look like Firefox/Safari stack traces + // Firefox/Safari stack traces must contain '@' and should have location info after it + if (!line.includes("@")) { + return null; + } + // Find the correct @ that separates function name from location + // For cases like '@https://@fs/path' or 'functionName@https://@fs/path' + // we need to find the first @ that precedes a valid location (containing :) + let atIndex = -1; + let locationPart = ""; + let functionName; + // Try each @ from left to right to find the one that gives us a valid location + for (let i = 0; i < line.length; i++) { + if (line[i] === "@") { + const candidateLocation = line.slice(i + 1); + // Minimum length 3 for valid location: 1 for filename + 1 for colon + 1 for line number (e.g., "a:1") + if (candidateLocation.includes(":") && candidateLocation.length >= 3) { + atIndex = i; + locationPart = candidateLocation; + functionName = i > 0 ? line.slice(0, i) : undefined; + break; + } + } + } + // Validate we found a valid location with minimum length (filename:line format) + if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) { + return null; + } + const [url, lineNumber, columnNumber] = extractLocation(locationPart); + if (!url || !lineNumber || !columnNumber) { + return null; + } + return { + file: url, + method: functionName || "", + line: Number.parseInt(lineNumber), + column: Number.parseInt(columnNumber) + }; +} +function parseSingleStack(raw) { + const line = raw.trim(); + if (!CHROME_IE_STACK_REGEXP.test(line)) { + return parseSingleFFOrSafariStack(line); + } + return parseSingleV8Stack(line); +} +// Based on https://github.com/stacktracejs/error-stack-parser +// Credit to stacktracejs +function parseSingleV8Stack(raw) { + let line = raw.trim(); + if (!CHROME_IE_STACK_REGEXP.test(line)) { + return null; + } + if (line.includes("(eval ")) { + line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, ""); + } + let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, ""); + // capture and preserve the parenthesized location "(/foo/my bar.js:12:87)" in + // case it has spaces in it, as the string is split on \s+ later on + const location = sanitizedLine.match(/ (\(.+\)$)/); + // remove the parenthesized location from the line, if it was matched + sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine; + // if a location was matched, pass it to extractLocation() otherwise pass all sanitizedLine + // because this line doesn't have function name + const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine); + let method = location && sanitizedLine || ""; + let file = url && ["eval", ""].includes(url) ? undefined : url; + if (!file || !lineNumber || !columnNumber) { + return null; + } + if (method.startsWith("async ")) { + method = method.slice(6); + } + if (file.startsWith("file://")) { + file = file.slice(7); + } + // normalize Windows path (\ -> /) + file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file); + if (method) { + method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, ""); + } + return { + method, + file, + line: Number.parseInt(lineNumber), + column: Number.parseInt(columnNumber) + }; +} + +function createCompilerHints(options) { + const globalThisAccessor = options?.globalThisKey || "__vitest_mocker__"; + function _mocker() { + // @ts-expect-error injected by the plugin + return typeof globalThis[globalThisAccessor] !== "undefined" ? globalThis[globalThisAccessor] : new Proxy({}, { get(_, name) { + throw new Error("Vitest mocker was not initialized in this environment. " + `vi.${String(name)}() is forbidden.`); + } }); + } + return { + hoisted(factory) { + if (typeof factory !== "function") { + throw new TypeError(`vi.hoisted() expects a function, but received a ${typeof factory}`); + } + return factory(); + }, + mock(path, factory) { + if (typeof path !== "string") { + throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`); + } + const importer = getImporter("mock"); + _mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer)) : factory); + }, + unmock(path) { + if (typeof path !== "string") { + throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`); + } + _mocker().queueUnmock(path, getImporter("unmock")); + }, + doMock(path, factory) { + if (typeof path !== "string") { + throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`); + } + const importer = getImporter("doMock"); + _mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer)) : factory); + }, + doUnmock(path) { + if (typeof path !== "string") { + throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`); + } + _mocker().queueUnmock(path, getImporter("doUnmock")); + }, + async importActual(path) { + return _mocker().importActual(path, getImporter("importActual")); + }, + async importMock(path) { + return _mocker().importMock(path, getImporter("importMock")); + } + }; +} +function getImporter(name) { + const stackTrace = /* @__PURE__ */ createSimpleStackTrace({ stackTraceLimit: 5 }); + const stackArray = stackTrace.split("\n"); + // if there is no message in a stack trace, use the item - 1 + const importerStackIndex = stackArray.findIndex((stack) => { + return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`); + }); + const stack = /* @__PURE__ */ parseSingleStack(stackArray[importerStackIndex + 1]); + return stack?.file || ""; +} + +const { now } = Date; +class ModuleMocker { + interceptor; + rpc; + createMockInstance; + config; + registry = new MockerRegistry(); + queue = new Set(); + mockedIds = new Set(); + constructor(interceptor, rpc, createMockInstance, config) { + this.interceptor = interceptor; + this.rpc = rpc; + this.createMockInstance = createMockInstance; + this.config = config; + } + async prepare() { + if (!this.queue.size) { + return; + } + await Promise.all([...this.queue.values()]); + } + async resolveFactoryModule(id) { + const mock = this.registry.get(id); + if (!mock || mock.type !== "manual") { + throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`); + } + const result = await mock.resolve(); + return result; + } + getFactoryModule(id) { + const mock = this.registry.get(id); + if (!mock || mock.type !== "manual") { + throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`); + } + if (!mock.cache) { + throw new Error(`Mock ${id} wasn't resolved. This is probably a Vitest error. Please, open a new issue with reproduction.`); + } + return mock.cache; + } + async invalidate() { + const ids = Array.from(this.mockedIds); + if (!ids.length) { + return; + } + await this.rpc.invalidate(ids); + await this.interceptor.invalidate(); + this.registry.clear(); + } + async importActual(id, importer) { + const resolved = await this.rpc.resolveId(id, importer); + if (resolved == null) { + throw new Error(`[vitest] Cannot resolve "${id}" imported from "${importer}"`); + } + const ext = extname(resolved.id); + const url = new URL(resolved.url, this.getBaseUrl()); + const query = `_vitest_original&ext${ext}`; + const actualUrl = `${url.pathname}${url.search ? `${url.search}&${query}` : `?${query}`}${url.hash}`; + return this.wrapDynamicImport(() => import( + /* @vite-ignore */ + actualUrl +)).then((mod) => { + if (!resolved.optimized || typeof mod.default === "undefined") { + return mod; + } + // vite injects this helper for optimized modules, so we try to follow the same behavior + const m = mod.default; + return m?.__esModule ? m : { + ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, + default: m + }; + }); + } + getBaseUrl() { + return location.href; + } + async importMock(rawId, importer) { + await this.prepare(); + const { resolvedId, resolvedUrl, redirectUrl } = await this.rpc.resolveMock(rawId, importer, { mock: "auto" }); + const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl)); + let mock = this.registry.get(mockUrl); + if (!mock) { + if (redirectUrl) { + const resolvedRedirect = new URL(this.resolveMockPath(cleanVersion(redirectUrl)), this.getBaseUrl()).toString(); + mock = new RedirectedModule(rawId, resolvedId, mockUrl, resolvedRedirect); + } else { + mock = new AutomockedModule(rawId, resolvedId, mockUrl); + } + } + if (mock.type === "manual") { + return await mock.resolve(); + } + if (mock.type === "automock" || mock.type === "autospy") { + const url = new URL(`/@id/${resolvedId}`, this.getBaseUrl()); + const query = url.search ? `${url.search}&t=${now()}` : `?t=${now()}`; + const moduleObject = await import( + /* @vite-ignore */ + `${url.pathname}${query}&mock=${mock.type}${url.hash}` +); + return this.mockObject(moduleObject, mock.type); + } + return import( + /* @vite-ignore */ + mock.redirect +); + } + mockObject(object, mockExportsOrModuleType, moduleType) { + let mockExports; + if (mockExportsOrModuleType === "automock" || mockExportsOrModuleType === "autospy") { + moduleType = mockExportsOrModuleType; + mockExports = undefined; + } else { + mockExports = mockExportsOrModuleType; + } + moduleType ??= "automock"; + const result = mockObject({ + globalConstructors: { + Object, + Function, + Array, + Map, + RegExp + }, + createMockInstance: this.createMockInstance, + type: moduleType + }, object, mockExports); + return result; + } + getMockContext() { + return { callstack: null }; + } + queueMock(rawId, importer, factoryOrOptions) { + const promise = this.rpc.resolveMock(rawId, importer, { mock: typeof factoryOrOptions === "function" ? "factory" : factoryOrOptions?.spy ? "spy" : "auto" }).then(async ({ redirectUrl, resolvedId, resolvedUrl, needsInterop, mockType }) => { + const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl)); + this.mockedIds.add(resolvedId); + const factory = typeof factoryOrOptions === "function" ? async () => { + const data = await factoryOrOptions(); + // vite wraps all external modules that have "needsInterop" in a function that + // merges all exports from default into the module object + return needsInterop ? { default: data } : data; + } : undefined; + const mockRedirect = typeof redirectUrl === "string" ? new URL(this.resolveMockPath(cleanVersion(redirectUrl)), this.getBaseUrl()).toString() : null; + let module; + if (mockType === "manual") { + module = this.registry.register("manual", rawId, resolvedId, mockUrl, factory); + } else if (mockType === "autospy") { + module = this.registry.register("autospy", rawId, resolvedId, mockUrl); + } else if (mockType === "redirect") { + module = this.registry.register("redirect", rawId, resolvedId, mockUrl, mockRedirect); + } else { + module = this.registry.register("automock", rawId, resolvedId, mockUrl); + } + await this.interceptor.register(module); + }).finally(() => { + this.queue.delete(promise); + }); + this.queue.add(promise); + } + queueUnmock(id, importer) { + const promise = this.rpc.resolveId(id, importer).then(async (resolved) => { + if (!resolved) { + return; + } + const mockUrl = this.resolveMockPath(cleanVersion(resolved.url)); + this.mockedIds.add(resolved.id); + this.registry.delete(mockUrl); + await this.interceptor.delete(mockUrl); + }).finally(() => { + this.queue.delete(promise); + }); + this.queue.add(promise); + } + // We need to await mock registration before importing the actual module + // In case there is a mocked module in the import chain + wrapDynamicImport(moduleFactory) { + if (typeof moduleFactory === "function") { + const promise = new Promise((resolve, reject) => { + this.prepare().finally(() => { + moduleFactory().then(resolve, reject); + }); + }); + return promise; + } + return moduleFactory; + } + getMockedModuleById(id) { + return this.registry.getById(id); + } + reset() { + this.registry.clear(); + this.mockedIds.clear(); + this.queue.clear(); + } + resolveMockPath(path) { + const config = this.config; + const fsRoot = join("/@fs/", config.root); + // URL can be /file/path.js, but path is resolved to /file/path + if (path.startsWith(config.root)) { + return path.slice(config.root.length); + } + if (path.startsWith(fsRoot)) { + return path.slice(fsRoot.length); + } + return path; + } +} +const versionRegexp = /(\?|&)v=\w{8}/; +function cleanVersion(url) { + return url.replace(versionRegexp, ""); +} + +export { ModuleMocker as M, createCompilerHints as c, hot as h, rpc as r }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-pathe.M-eThtNZ.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-pathe.M-eThtNZ.js new file mode 100644 index 00000000..43074738 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-pathe.M-eThtNZ.js @@ -0,0 +1,191 @@ +const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//; +function normalizeWindowsPath(input = "") { + if (!input) { + return input; + } + return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase()); +} + +const _UNC_REGEX = /^[/\\]{2}/; +const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/; +const _DRIVE_LETTER_RE = /^[A-Za-z]:$/; +const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/; +const _EXTNAME_RE = /.(\.[^./]+|\.)$/; +const normalize = function(path) { + if (path.length === 0) { + return "."; + } + path = normalizeWindowsPath(path); + const isUNCPath = path.match(_UNC_REGEX); + const isPathAbsolute = isAbsolute(path); + const trailingSeparator = path[path.length - 1] === "/"; + path = normalizeString(path, !isPathAbsolute); + if (path.length === 0) { + if (isPathAbsolute) { + return "/"; + } + return trailingSeparator ? "./" : "."; + } + if (trailingSeparator) { + path += "/"; + } + if (_DRIVE_LETTER_RE.test(path)) { + path += "/"; + } + if (isUNCPath) { + if (!isPathAbsolute) { + return `//./${path}`; + } + return `//${path}`; + } + return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path; +}; +const join = function(...segments) { + let path = ""; + for (const seg of segments) { + if (!seg) { + continue; + } + if (path.length > 0) { + const pathTrailing = path[path.length - 1] === "/"; + const segLeading = seg[0] === "/"; + const both = pathTrailing && segLeading; + if (both) { + path += seg.slice(1); + } else { + path += pathTrailing || segLeading ? seg : `/${seg}`; + } + } else { + path += seg; + } + } + return normalize(path); +}; +function cwd() { + if (typeof process !== "undefined" && typeof process.cwd === "function") { + return process.cwd().replace(/\\/g, "/"); + } + return "/"; +} +const resolve = function(...arguments_) { + arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument)); + let resolvedPath = ""; + let resolvedAbsolute = false; + for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) { + const path = index >= 0 ? arguments_[index] : cwd(); + if (!path || path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = isAbsolute(path); + } + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute && !isAbsolute(resolvedPath)) { + return `/${resolvedPath}`; + } + return resolvedPath.length > 0 ? resolvedPath : "."; +}; +function normalizeString(path, allowAboveRoot) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let char = null; + for (let index = 0; index <= path.length; ++index) { + if (index < path.length) { + char = path[index]; + } else if (char === "/") { + break; + } else { + char = "/"; + } + if (char === "/") { + if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf("/"); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf("/"); + } + lastSlash = index; + dots = 0; + continue; + } else if (res.length > 0) { + res = ""; + lastSegmentLength = 0; + lastSlash = index; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + res += res.length > 0 ? "/.." : ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) { + res += `/${path.slice(lastSlash + 1, index)}`; + } else { + res = path.slice(lastSlash + 1, index); + } + lastSegmentLength = index - lastSlash - 1; + } + lastSlash = index; + dots = 0; + } else if (char === "." && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +const isAbsolute = function(p) { + return _IS_ABSOLUTE_RE.test(p); +}; +const extname = function(p) { + if (p === "..") return ""; + const match = _EXTNAME_RE.exec(normalizeWindowsPath(p)); + return match && match[1] || ""; +}; +const relative = function(from, to) { + const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/"); + const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/"); + if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) { + return _to.join("/"); + } + const _fromCopy = [..._from]; + for (const segment of _fromCopy) { + if (_to[0] !== segment) { + break; + } + _from.shift(); + _to.shift(); + } + return [..._from.map(() => ".."), ..._to].join("/"); +}; +const dirname = function(p) { + const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1); + if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) { + segments[0] += "/"; + } + return segments.join("/") || (isAbsolute(p) ? "/" : "."); +}; +const basename = function(p, extension) { + const segments = normalizeWindowsPath(p).split("/"); + let lastSegment = ""; + for (let i = segments.length - 1; i >= 0; i--) { + const val = segments[i]; + if (val) { + lastSegment = val; + break; + } + } + return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment; +}; + +export { relative as a, basename as b, dirname as d, extname as e, isAbsolute as i, join as j, resolve as r }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-registry.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-registry.js new file mode 100644 index 00000000..a922e0f3 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-registry.js @@ -0,0 +1,213 @@ +class MockerRegistry { + registryByUrl = new Map(); + registryById = new Map(); + clear() { + this.registryByUrl.clear(); + this.registryById.clear(); + } + keys() { + return this.registryByUrl.keys(); + } + add(mock) { + this.registryByUrl.set(mock.url, mock); + this.registryById.set(mock.id, mock); + } + register(typeOrEvent, raw, id, url, factoryOrRedirect) { + const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent; + if (typeof typeOrEvent === "object") { + const event = typeOrEvent; + if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) { + throw new TypeError(`[vitest] Cannot register a mock that is already defined. ` + `Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". ` + `Use "registry.add()" to update a mock instead.`); + } + if (event.type === "automock") { + const module = AutomockedModule.fromJSON(event); + this.add(module); + return module; + } else if (event.type === "autospy") { + const module = AutospiedModule.fromJSON(event); + this.add(module); + return module; + } else if (event.type === "redirect") { + const module = RedirectedModule.fromJSON(event); + this.add(module); + return module; + } else if (event.type === "manual") { + throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`); + } else { + throw new Error(`Unknown mock type: ${event.type}`); + } + } + if (typeof raw !== "string") { + throw new TypeError("[vitest] Mocks require a raw string."); + } + if (typeof url !== "string") { + throw new TypeError("[vitest] Mocks require a url string."); + } + if (typeof id !== "string") { + throw new TypeError("[vitest] Mocks require an id string."); + } + if (type === "manual") { + if (typeof factoryOrRedirect !== "function") { + throw new TypeError("[vitest] Manual mocks require a factory function."); + } + const mock = new ManualMockedModule(raw, id, url, factoryOrRedirect); + this.add(mock); + return mock; + } else if (type === "automock" || type === "autospy") { + const mock = type === "automock" ? new AutomockedModule(raw, id, url) : new AutospiedModule(raw, id, url); + this.add(mock); + return mock; + } else if (type === "redirect") { + if (typeof factoryOrRedirect !== "string") { + throw new TypeError("[vitest] Redirect mocks require a redirect string."); + } + const mock = new RedirectedModule(raw, id, url, factoryOrRedirect); + this.add(mock); + return mock; + } else { + throw new Error(`[vitest] Unknown mock type: ${type}`); + } + } + delete(id) { + this.registryByUrl.delete(id); + } + deleteById(id) { + this.registryById.delete(id); + } + get(id) { + return this.registryByUrl.get(id); + } + getById(id) { + return this.registryById.get(id); + } + has(id) { + return this.registryByUrl.has(id); + } +} +class AutomockedModule { + raw; + id; + url; + type = "automock"; + constructor(raw, id, url) { + this.raw = raw; + this.id = id; + this.url = url; + } + static fromJSON(data) { + return new AutomockedModule(data.raw, data.id, data.url); + } + toJSON() { + return { + type: this.type, + url: this.url, + raw: this.raw, + id: this.id + }; + } +} +class AutospiedModule { + raw; + id; + url; + type = "autospy"; + constructor(raw, id, url) { + this.raw = raw; + this.id = id; + this.url = url; + } + static fromJSON(data) { + return new AutospiedModule(data.raw, data.id, data.url); + } + toJSON() { + return { + type: this.type, + url: this.url, + id: this.id, + raw: this.raw + }; + } +} +class RedirectedModule { + raw; + id; + url; + redirect; + type = "redirect"; + constructor(raw, id, url, redirect) { + this.raw = raw; + this.id = id; + this.url = url; + this.redirect = redirect; + } + static fromJSON(data) { + return new RedirectedModule(data.raw, data.id, data.url, data.redirect); + } + toJSON() { + return { + type: this.type, + url: this.url, + raw: this.raw, + id: this.id, + redirect: this.redirect + }; + } +} +class ManualMockedModule { + raw; + id; + url; + factory; + cache; + type = "manual"; + constructor(raw, id, url, factory) { + this.raw = raw; + this.id = id; + this.url = url; + this.factory = factory; + } + resolve() { + if (this.cache) { + return this.cache; + } + let exports; + try { + exports = this.factory(); + } catch (err) { + throw createHelpfulError(err); + } + if (typeof exports === "object" && typeof exports?.then === "function") { + return exports.then((result) => { + assertValidExports(this.raw, result); + return this.cache = result; + }, (error) => { + throw createHelpfulError(error); + }); + } + assertValidExports(this.raw, exports); + return this.cache = exports; + } + static fromJSON(data, factory) { + return new ManualMockedModule(data.raw, data.id, data.url, factory); + } + toJSON() { + return { + type: this.type, + url: this.url, + id: this.id, + raw: this.raw + }; + } +} +function createHelpfulError(cause) { + const error = new Error("[vitest] There was an error when mocking a module. " + "If you are using \"vi.mock\" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. " + "Read more: https://vitest.dev/api/vi.html#vi-mock"); + error.cause = cause; + return error; +} +function assertValidExports(raw, exports) { + if (exports === null || typeof exports !== "object" || Array.isArray(exports)) { + throw new TypeError(`[vitest] vi.mock("${raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`); + } +} + +export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, ManualMockedModule as a, AutospiedModule as b }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-utils.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-utils.js new file mode 100644 index 00000000..2704ca91 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/chunk-utils.js @@ -0,0 +1,27 @@ +const postfixRE = /[?#].*$/; +function cleanUrl(url) { + return url.replace(postfixRE, ""); +} +function createManualModuleSource(moduleUrl, exports, globalAccessor = "\"__vitest_mocker__\"") { + const source = ` +const __factoryModule__ = await globalThis[${globalAccessor}].getFactoryModule("${moduleUrl}"); +`; + const keys = exports.map((name, index) => { + return `let __${index} = __factoryModule__["${name}"] +export { __${index} as "${name}" }`; + }).join("\n"); + let code = `${source}\n${keys}`; + // this prevents recursion + code += ` +if (__factoryModule__.__factoryPromise != null) { + __factoryModule__.__factoryPromise.then((resolvedModule) => { + ${exports.map((name, index) => { + return `__${index} = resolvedModule["${name}"];`; + }).join("\n")} + }) +} + `; + return code; +} + +export { cleanUrl as a, createManualModuleSource as c }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/hoistMocks.d-h98GpQUH.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/hoistMocks.d-h98GpQUH.d.ts new file mode 100644 index 00000000..6bba2226 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/hoistMocks.d-h98GpQUH.d.ts @@ -0,0 +1,754 @@ +import { Rollup } from 'vite'; +import MagicString from 'magic-string'; + +declare function createManualModuleSource(moduleUrl: string, exports: string[], globalAccessor?: string): string; + +// This definition file follows a somewhat unusual format. ESTree allows +// runtime type checks based on the `type` parameter. In order to explain this +// to typescript we want to use discriminated union types: +// https://github.com/Microsoft/TypeScript/pull/9163 +// +// For ESTree this is a bit tricky because the high level interfaces like +// Node or Function are pulling double duty. We want to pass common fields down +// to the interfaces that extend them (like Identifier or +// ArrowFunctionExpression), but you can't extend a type union or enforce +// common fields on them. So we've split the high level interfaces into two +// types, a base type which passes down inherited fields, and a type union of +// all types which extend the base type. Only the type union is exported, and +// the union is how other types refer to the collection of inheriting types. +// +// This makes the definitions file here somewhat more difficult to maintain, +// but it has the notable advantage of making ESTree much easier to use as +// an end user. + +interface BaseNodeWithoutComments { + // Every leaf interface that extends BaseNode must specify a type property. + // The type property should be a string literal. For example, Identifier + // has: `type: "Identifier"` + type: string; + loc?: SourceLocation | null | undefined; + range?: [number, number] | undefined; +} + +interface BaseNode extends BaseNodeWithoutComments { + leadingComments?: Comment[] | undefined; + trailingComments?: Comment[] | undefined; +} + +interface NodeMap { + AssignmentProperty: AssignmentProperty; + CatchClause: CatchClause; + Class: Class; + ClassBody: ClassBody; + Expression: Expression; + Function: Function; + Identifier: Identifier; + Literal: Literal; + MethodDefinition: MethodDefinition; + ModuleDeclaration: ModuleDeclaration; + ModuleSpecifier: ModuleSpecifier; + Pattern: Pattern; + PrivateIdentifier: PrivateIdentifier; + Program: Program; + Property: Property; + PropertyDefinition: PropertyDefinition; + SpreadElement: SpreadElement; + Statement: Statement; + Super: Super; + SwitchCase: SwitchCase; + TemplateElement: TemplateElement; + VariableDeclarator: VariableDeclarator; +} + +type Node$1 = NodeMap[keyof NodeMap]; + +interface Comment extends BaseNodeWithoutComments { + type: "Line" | "Block"; + value: string; +} + +interface SourceLocation { + source?: string | null | undefined; + start: Position; + end: Position; +} + +interface Position { + /** >= 1 */ + line: number; + /** >= 0 */ + column: number; +} + +interface Program extends BaseNode { + type: "Program"; + sourceType: "script" | "module"; + body: Array; + comments?: Comment[] | undefined; +} + +interface Directive extends BaseNode { + type: "ExpressionStatement"; + expression: Literal; + directive: string; +} + +interface BaseFunction extends BaseNode { + params: Pattern[]; + generator?: boolean | undefined; + async?: boolean | undefined; + // The body is either BlockStatement or Expression because arrow functions + // can have a body that's either. FunctionDeclarations and + // FunctionExpressions have only BlockStatement bodies. + body: BlockStatement | Expression; +} + +type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression; + +type Statement = + | ExpressionStatement + | BlockStatement + | StaticBlock + | EmptyStatement + | DebuggerStatement + | WithStatement + | ReturnStatement + | LabeledStatement + | BreakStatement + | ContinueStatement + | IfStatement + | SwitchStatement + | ThrowStatement + | TryStatement + | WhileStatement + | DoWhileStatement + | ForStatement + | ForInStatement + | ForOfStatement + | Declaration; + +interface BaseStatement extends BaseNode {} + +interface EmptyStatement extends BaseStatement { + type: "EmptyStatement"; +} + +interface BlockStatement extends BaseStatement { + type: "BlockStatement"; + body: Statement[]; + innerComments?: Comment[] | undefined; +} + +interface StaticBlock extends Omit { + type: "StaticBlock"; +} + +interface ExpressionStatement extends BaseStatement { + type: "ExpressionStatement"; + expression: Expression; +} + +interface IfStatement extends BaseStatement { + type: "IfStatement"; + test: Expression; + consequent: Statement; + alternate?: Statement | null | undefined; +} + +interface LabeledStatement extends BaseStatement { + type: "LabeledStatement"; + label: Identifier; + body: Statement; +} + +interface BreakStatement extends BaseStatement { + type: "BreakStatement"; + label?: Identifier | null | undefined; +} + +interface ContinueStatement extends BaseStatement { + type: "ContinueStatement"; + label?: Identifier | null | undefined; +} + +interface WithStatement extends BaseStatement { + type: "WithStatement"; + object: Expression; + body: Statement; +} + +interface SwitchStatement extends BaseStatement { + type: "SwitchStatement"; + discriminant: Expression; + cases: SwitchCase[]; +} + +interface ReturnStatement extends BaseStatement { + type: "ReturnStatement"; + argument?: Expression | null | undefined; +} + +interface ThrowStatement extends BaseStatement { + type: "ThrowStatement"; + argument: Expression; +} + +interface TryStatement extends BaseStatement { + type: "TryStatement"; + block: BlockStatement; + handler?: CatchClause | null | undefined; + finalizer?: BlockStatement | null | undefined; +} + +interface WhileStatement extends BaseStatement { + type: "WhileStatement"; + test: Expression; + body: Statement; +} + +interface DoWhileStatement extends BaseStatement { + type: "DoWhileStatement"; + body: Statement; + test: Expression; +} + +interface ForStatement extends BaseStatement { + type: "ForStatement"; + init?: VariableDeclaration | Expression | null | undefined; + test?: Expression | null | undefined; + update?: Expression | null | undefined; + body: Statement; +} + +interface BaseForXStatement extends BaseStatement { + left: VariableDeclaration | Pattern; + right: Expression; + body: Statement; +} + +interface ForInStatement extends BaseForXStatement { + type: "ForInStatement"; +} + +interface DebuggerStatement extends BaseStatement { + type: "DebuggerStatement"; +} + +type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration; + +interface BaseDeclaration extends BaseStatement {} + +interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration { + type: "FunctionDeclaration"; + /** It is null when a function declaration is a part of the `export default function` statement */ + id: Identifier | null; + body: BlockStatement; +} + +interface FunctionDeclaration extends MaybeNamedFunctionDeclaration { + id: Identifier; +} + +interface VariableDeclaration extends BaseDeclaration { + type: "VariableDeclaration"; + declarations: VariableDeclarator[]; + kind: "var" | "let" | "const" | "using" | "await using"; +} + +interface VariableDeclarator extends BaseNode { + type: "VariableDeclarator"; + id: Pattern; + init?: Expression | null | undefined; +} + +interface ExpressionMap { + ArrayExpression: ArrayExpression; + ArrowFunctionExpression: ArrowFunctionExpression; + AssignmentExpression: AssignmentExpression; + AwaitExpression: AwaitExpression; + BinaryExpression: BinaryExpression; + CallExpression: CallExpression; + ChainExpression: ChainExpression; + ClassExpression: ClassExpression; + ConditionalExpression: ConditionalExpression; + FunctionExpression: FunctionExpression; + Identifier: Identifier; + ImportExpression: ImportExpression; + Literal: Literal; + LogicalExpression: LogicalExpression; + MemberExpression: MemberExpression; + MetaProperty: MetaProperty; + NewExpression: NewExpression; + ObjectExpression: ObjectExpression; + SequenceExpression: SequenceExpression; + TaggedTemplateExpression: TaggedTemplateExpression; + TemplateLiteral: TemplateLiteral; + ThisExpression: ThisExpression; + UnaryExpression: UnaryExpression; + UpdateExpression: UpdateExpression; + YieldExpression: YieldExpression; +} + +type Expression = ExpressionMap[keyof ExpressionMap]; + +interface BaseExpression extends BaseNode {} + +type ChainElement = SimpleCallExpression | MemberExpression; + +interface ChainExpression extends BaseExpression { + type: "ChainExpression"; + expression: ChainElement; +} + +interface ThisExpression extends BaseExpression { + type: "ThisExpression"; +} + +interface ArrayExpression extends BaseExpression { + type: "ArrayExpression"; + elements: Array; +} + +interface ObjectExpression extends BaseExpression { + type: "ObjectExpression"; + properties: Array; +} + +interface PrivateIdentifier extends BaseNode { + type: "PrivateIdentifier"; + name: string; +} + +interface Property extends BaseNode { + type: "Property"; + key: Expression; + value: Expression | Pattern; // Could be an AssignmentProperty + kind: "init" | "get" | "set"; + method: boolean; + shorthand: boolean; + computed: boolean; +} + +interface PropertyDefinition extends BaseNode { + type: "PropertyDefinition"; + key: Expression | PrivateIdentifier; + value?: Expression | null | undefined; + computed: boolean; + static: boolean; +} + +interface FunctionExpression extends BaseFunction, BaseExpression { + id?: Identifier | null | undefined; + type: "FunctionExpression"; + body: BlockStatement; +} + +interface SequenceExpression extends BaseExpression { + type: "SequenceExpression"; + expressions: Expression[]; +} + +interface UnaryExpression extends BaseExpression { + type: "UnaryExpression"; + operator: UnaryOperator; + prefix: true; + argument: Expression; +} + +interface BinaryExpression extends BaseExpression { + type: "BinaryExpression"; + operator: BinaryOperator; + left: Expression | PrivateIdentifier; + right: Expression; +} + +interface AssignmentExpression extends BaseExpression { + type: "AssignmentExpression"; + operator: AssignmentOperator; + left: Pattern | MemberExpression; + right: Expression; +} + +interface UpdateExpression extends BaseExpression { + type: "UpdateExpression"; + operator: UpdateOperator; + argument: Expression; + prefix: boolean; +} + +interface LogicalExpression extends BaseExpression { + type: "LogicalExpression"; + operator: LogicalOperator; + left: Expression; + right: Expression; +} + +interface ConditionalExpression extends BaseExpression { + type: "ConditionalExpression"; + test: Expression; + alternate: Expression; + consequent: Expression; +} + +interface BaseCallExpression extends BaseExpression { + callee: Expression | Super; + arguments: Array; +} +type CallExpression = SimpleCallExpression | NewExpression; + +interface SimpleCallExpression extends BaseCallExpression { + type: "CallExpression"; + optional: boolean; +} + +interface NewExpression extends BaseCallExpression { + type: "NewExpression"; +} + +interface MemberExpression extends BaseExpression, BasePattern { + type: "MemberExpression"; + object: Expression | Super; + property: Expression | PrivateIdentifier; + computed: boolean; + optional: boolean; +} + +type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression; + +interface BasePattern extends BaseNode {} + +interface SwitchCase extends BaseNode { + type: "SwitchCase"; + test?: Expression | null | undefined; + consequent: Statement[]; +} + +interface CatchClause extends BaseNode { + type: "CatchClause"; + param: Pattern | null; + body: BlockStatement; +} + +interface Identifier extends BaseNode, BaseExpression, BasePattern { + type: "Identifier"; + name: string; +} + +type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral; + +interface SimpleLiteral extends BaseNode, BaseExpression { + type: "Literal"; + value: string | boolean | number | null; + raw?: string | undefined; +} + +interface RegExpLiteral extends BaseNode, BaseExpression { + type: "Literal"; + value?: RegExp | null | undefined; + regex: { + pattern: string; + flags: string; + }; + raw?: string | undefined; +} + +interface BigIntLiteral extends BaseNode, BaseExpression { + type: "Literal"; + value?: bigint | null | undefined; + bigint: string; + raw?: string | undefined; +} + +type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete"; + +type BinaryOperator = + | "==" + | "!=" + | "===" + | "!==" + | "<" + | "<=" + | ">" + | ">=" + | "<<" + | ">>" + | ">>>" + | "+" + | "-" + | "*" + | "/" + | "%" + | "**" + | "|" + | "^" + | "&" + | "in" + | "instanceof"; + +type LogicalOperator = "||" | "&&" | "??"; + +type AssignmentOperator = + | "=" + | "+=" + | "-=" + | "*=" + | "/=" + | "%=" + | "**=" + | "<<=" + | ">>=" + | ">>>=" + | "|=" + | "^=" + | "&=" + | "||=" + | "&&=" + | "??="; + +type UpdateOperator = "++" | "--"; + +interface ForOfStatement extends BaseForXStatement { + type: "ForOfStatement"; + await: boolean; +} + +interface Super extends BaseNode { + type: "Super"; +} + +interface SpreadElement extends BaseNode { + type: "SpreadElement"; + argument: Expression; +} + +interface ArrowFunctionExpression extends BaseExpression, BaseFunction { + type: "ArrowFunctionExpression"; + expression: boolean; + body: BlockStatement | Expression; +} + +interface YieldExpression extends BaseExpression { + type: "YieldExpression"; + argument?: Expression | null | undefined; + delegate: boolean; +} + +interface TemplateLiteral extends BaseExpression { + type: "TemplateLiteral"; + quasis: TemplateElement[]; + expressions: Expression[]; +} + +interface TaggedTemplateExpression extends BaseExpression { + type: "TaggedTemplateExpression"; + tag: Expression; + quasi: TemplateLiteral; +} + +interface TemplateElement extends BaseNode { + type: "TemplateElement"; + tail: boolean; + value: { + /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */ + cooked?: string | null | undefined; + raw: string; + }; +} + +interface AssignmentProperty extends Property { + value: Pattern; + kind: "init"; + method: boolean; // false +} + +interface ObjectPattern extends BasePattern { + type: "ObjectPattern"; + properties: Array; +} + +interface ArrayPattern extends BasePattern { + type: "ArrayPattern"; + elements: Array; +} + +interface RestElement extends BasePattern { + type: "RestElement"; + argument: Pattern; +} + +interface AssignmentPattern extends BasePattern { + type: "AssignmentPattern"; + left: Pattern; + right: Expression; +} + +type Class = ClassDeclaration | ClassExpression; +interface BaseClass extends BaseNode { + superClass?: Expression | null | undefined; + body: ClassBody; +} + +interface ClassBody extends BaseNode { + type: "ClassBody"; + body: Array; +} + +interface MethodDefinition extends BaseNode { + type: "MethodDefinition"; + key: Expression | PrivateIdentifier; + value: FunctionExpression; + kind: "constructor" | "method" | "get" | "set"; + computed: boolean; + static: boolean; +} + +interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration { + type: "ClassDeclaration"; + /** It is null when a class declaration is a part of the `export default class` statement */ + id: Identifier | null; +} + +interface ClassDeclaration extends MaybeNamedClassDeclaration { + id: Identifier; +} + +interface ClassExpression extends BaseClass, BaseExpression { + type: "ClassExpression"; + id?: Identifier | null | undefined; +} + +interface MetaProperty extends BaseExpression { + type: "MetaProperty"; + meta: Identifier; + property: Identifier; +} + +type ModuleDeclaration = + | ImportDeclaration + | ExportNamedDeclaration + | ExportDefaultDeclaration + | ExportAllDeclaration; +interface BaseModuleDeclaration extends BaseNode {} + +type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier; +interface BaseModuleSpecifier extends BaseNode { + local: Identifier; +} + +interface ImportDeclaration extends BaseModuleDeclaration { + type: "ImportDeclaration"; + specifiers: Array; + attributes: ImportAttribute[]; + source: Literal; +} + +interface ImportSpecifier extends BaseModuleSpecifier { + type: "ImportSpecifier"; + imported: Identifier | Literal; +} + +interface ImportAttribute extends BaseNode { + type: "ImportAttribute"; + key: Identifier | Literal; + value: Literal; +} + +interface ImportExpression extends BaseExpression { + type: "ImportExpression"; + source: Expression; + options?: Expression | null | undefined; +} + +interface ImportDefaultSpecifier extends BaseModuleSpecifier { + type: "ImportDefaultSpecifier"; +} + +interface ImportNamespaceSpecifier extends BaseModuleSpecifier { + type: "ImportNamespaceSpecifier"; +} + +interface ExportNamedDeclaration extends BaseModuleDeclaration { + type: "ExportNamedDeclaration"; + declaration?: Declaration | null | undefined; + specifiers: ExportSpecifier[]; + attributes: ImportAttribute[]; + source?: Literal | null | undefined; +} + +interface ExportSpecifier extends Omit { + type: "ExportSpecifier"; + local: Identifier | Literal; + exported: Identifier | Literal; +} + +interface ExportDefaultDeclaration extends BaseModuleDeclaration { + type: "ExportDefaultDeclaration"; + declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression; +} + +interface ExportAllDeclaration extends BaseModuleDeclaration { + type: "ExportAllDeclaration"; + exported: Identifier | Literal | null; + attributes: ImportAttribute[]; + source: Literal; +} + +interface AwaitExpression extends BaseExpression { + type: "AwaitExpression"; + argument: Expression; +} + +type Positioned = T & { + start: number; + end: number; +}; +type Node = Positioned; + +interface StaticMockCall { + method: string; + specifier: string; + hasFactory: boolean; + /** the factory uses `importOriginal`/`importActual` */ + factoryLoadsOriginal: boolean; +} +interface HoistMocksOptions { + onStaticMock?: (call: StaticMockCall) => void; + /** + * List of modules that should always be imported before compiler hints. + * @default 'vitest' + */ + hoistedModule?: string; + /** + * @default ["vi", "vitest"] + */ + utilsObjectNames?: string[]; + /** + * @default ["mock", "unmock"] + */ + hoistableMockMethodNames?: string[]; + /** + * @default ["mock", "unmock", "doMock", "doUnmock"] + */ + dynamicImportMockMethodNames?: string[]; + /** + * @default ["hoisted"] + */ + hoistedMethodNames?: string[]; + globalThisAccessor?: string; + regexpHoistable?: RegExp; + codeFrameGenerator?: CodeFrameGenerator; + magicString?: () => MagicString; + /** + * Root of the project + * @default process.cwd() + */ + root?: string; + getMap?: () => Rollup.SourceMap; +} +declare function hoistMocks(code: string, id: string, parse: (code: string) => any, options?: HoistMocksOptions): MagicString | undefined; +interface CodeFrameGenerator { + (node: Positioned, id: string, code: string): string; +} + +export { createManualModuleSource as c, hoistMocks as h }; +export type { HoistMocksOptions as H, StaticMockCall as S }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d-D4wtotQw.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d-D4wtotQw.d.ts new file mode 100644 index 00000000..3cfa8ceb --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d-D4wtotQw.d.ts @@ -0,0 +1,25 @@ +import './registry.d-xLx_FoyF.js'; + +type Key = string | symbol; +type CreateMockInstanceProcedure = (options?: { + prototypeMembers?: (string | symbol)[]; + name?: string | symbol; + originalImplementation?: (...args: any[]) => any; + keepMembersImplementation?: boolean; +}) => any; +interface MockObjectOptions { + type: "automock" | "autospy"; + globalConstructors: GlobalConstructors; + createMockInstance: CreateMockInstanceProcedure; +} +declare function mockObject(options: MockObjectOptions, object: Record, mockExports?: Record): Record; +interface GlobalConstructors { + Object: ObjectConstructor; + Function: FunctionConstructor; + RegExp: RegExpConstructor; + Array: ArrayConstructor; + Map: MapConstructor; +} + +export { mockObject as m }; +export type { CreateMockInstanceProcedure as C, GlobalConstructors as G, MockObjectOptions as M }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d.ts new file mode 100644 index 00000000..90cb4fde --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.d.ts @@ -0,0 +1,2 @@ +export { G as GlobalConstructors, M as MockObjectOptions, m as mockObject } from './index.d-D4wtotQw.js'; +export { A as AutomockedModule, g as AutomockedModuleSerialized, h as AutospiedModule, i as AutospiedModuleSerialized, j as ManualMockedModule, k as ManualMockedModuleSerialized, a as MockedModule, l as MockedModuleSerialized, d as MockedModuleType, M as MockerRegistry, e as ModuleMockContext, m as ModuleMockFactory, c as ModuleMockFactoryWithHelper, b as ModuleMockOptions, R as RedirectedModule, n as RedirectedModuleSerialized, f as ServerIdResolution, S as ServerMockResolution, T as TestModuleMocker } from './registry.d-xLx_FoyF.js'; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.js new file mode 100644 index 00000000..f0157c54 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/index.js @@ -0,0 +1,202 @@ +export { A as AutomockedModule, b as AutospiedModule, a as ManualMockedModule, M as MockerRegistry, R as RedirectedModule } from './chunk-registry.js'; + +function mockObject(options, object, mockExports = {}) { + const finalizers = new Array(); + const refs = new RefTracker(); + const define = (container, key, value) => { + try { + container[key] = value; + return true; + } catch { + return false; + } + }; + const createMock = (currentValue) => { + if (!options.createMockInstance) { + throw new Error("[@vitest/mocker] `createMockInstance` is not defined. This is a Vitest error. Please open a new issue with reproduction."); + } + const createMockInstance = options.createMockInstance; + const prototypeMembers = currentValue.prototype ? collectFunctionProperties(currentValue.prototype) : []; + return createMockInstance({ + name: currentValue.name, + prototypeMembers, + originalImplementation: options.type === "autospy" ? currentValue : undefined, + keepMembersImplementation: options.type === "autospy" + }); + }; + const mockPropertiesOf = (container, newContainer) => { + const containerType = getType(container); + const isModule = containerType === "Module" || !!container.__esModule; + for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, options.globalConstructors)) { + // Modules define their exports as getters. We want to process those. + if (!isModule && descriptor.get) { + try { + if (options.type === "autospy") { + Object.defineProperty(newContainer, property, descriptor); + } else { + Object.defineProperty(newContainer, property, { + configurable: descriptor.configurable, + enumerable: descriptor.enumerable, + // automatically mock getters and setters + // https://github.com/vitest-dev/vitest/issues/8345 + get: () => {}, + set: descriptor.set ? () => {} : undefined + }); + } + } catch {} + continue; + } + // Skip special read-only props, we don't want to mess with those. + if (isReadonlyProp(container[property], property)) { + continue; + } + const value = container[property]; + // Special handling of references we've seen before to prevent infinite + // recursion in circular objects. + const refId = refs.getId(value); + if (refId !== undefined) { + finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId))); + continue; + } + const type = getType(value); + if (Array.isArray(value)) { + if (options.type === "automock") { + define(newContainer, property, []); + } else { + const array = value.map((value) => { + if (value && typeof value === "object") { + const newObject = {}; + mockPropertiesOf(value, newObject); + return newObject; + } + if (typeof value === "function") { + return createMock(value); + } + return value; + }); + define(newContainer, property, array); + } + continue; + } + const isFunction = type.includes("Function") && typeof value === "function"; + if ((!isFunction || value._isMockFunction) && type !== "Object" && type !== "Module") { + define(newContainer, property, value); + continue; + } + if (options.type === "autospy" && type === "Module") { + // Replace with clean object to recursively autospy exported module objects: + // export * as ns from "./ns" + // or + // import * as ns from "./ns" + // export { ns } + const exports = Object.create(null); + Object.defineProperty(exports, Symbol.toStringTag, { + value: "Module", + configurable: true, + writable: true + }); + try { + newContainer[property] = exports; + } catch { + continue; + } + } else if (!define(newContainer, property, isFunction || options.type === "autospy" ? value : {})) { + continue; + } + if (isFunction) { + const mock = createMock(newContainer[property]); + newContainer[property] = mock; + } + refs.track(value, newContainer[property]); + mockPropertiesOf(value, newContainer[property]); + } + }; + const mockedObject = mockExports; + mockPropertiesOf(object, mockedObject); + // Plug together refs + for (const finalizer of finalizers) { + finalizer(); + } + return mockedObject; +} +class RefTracker { + idMap = new Map(); + mockedValueMap = new Map(); + getId(value) { + return this.idMap.get(value); + } + getMockedValue(id) { + return this.mockedValueMap.get(id); + } + track(originalValue, mockedValue) { + const newId = this.idMap.size; + this.idMap.set(originalValue, newId); + this.mockedValueMap.set(newId, mockedValue); + return newId; + } +} +function getType(value) { + return Object.prototype.toString.apply(value).slice(8, -1); +} +function isReadonlyProp(object, prop) { + if (prop === "arguments" || prop === "caller" || prop === "callee" || prop === "name" || prop === "length") { + const typeName = getType(object); + return typeName === "Function" || typeName === "AsyncFunction" || typeName === "GeneratorFunction" || typeName === "AsyncGeneratorFunction"; + } + if (prop === "source" || prop === "global" || prop === "ignoreCase" || prop === "multiline") { + return getType(object) === "RegExp"; + } + return false; +} +function getAllMockableProperties(obj, isModule, constructors) { + const { Map, Object, Function, RegExp, Array } = constructors; + const allProps = new Map(); + let curr = obj; + do { + // we don't need properties from these + if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype) { + break; + } + collectOwnProperties(curr, (key) => { + const descriptor = Object.getOwnPropertyDescriptor(curr, key); + if (descriptor) { + allProps.set(key, { + key, + descriptor + }); + } + }); + } while (curr = Object.getPrototypeOf(curr)); + // default is not specified in ownKeys, if module is interoped + if (isModule && !allProps.has("default") && "default" in obj) { + const descriptor = Object.getOwnPropertyDescriptor(obj, "default"); + if (descriptor) { + allProps.set("default", { + key: "default", + descriptor + }); + } + } + return Array.from(allProps.values()); +} +function collectOwnProperties(obj, collector) { + const collect = typeof collector === "function" ? collector : (key) => collector.add(key); + Object.getOwnPropertyNames(obj).forEach(collect); + Object.getOwnPropertySymbols(obj).forEach(collect); +} +function collectFunctionProperties(prototype) { + const properties = new Set(); + collectOwnProperties(prototype, (prop) => { + const descriptor = Object.getOwnPropertyDescriptor(prototype, prop); + if (!descriptor || descriptor.get) { + return; + } + const type = getType(descriptor.value); + if (type.includes("Function") && !isReadonlyProp(descriptor.value, prop)) { + properties.add(prop); + } + }); + return Array.from(properties); +} + +export { mockObject }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/mocker.d-CMHJLkLP.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/mocker.d-CMHJLkLP.d.ts new file mode 100644 index 00000000..75ccae58 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/mocker.d-CMHJLkLP.d.ts @@ -0,0 +1,86 @@ +import { MaybeMockedDeep } from '@vitest/spy'; +import { b as ModuleMockOptions, c as ModuleMockFactoryWithHelper, a as MockedModule, T as TestModuleMocker, M as MockerRegistry, d as MockedModuleType, e as ModuleMockContext } from './registry.d-xLx_FoyF.js'; +import { C as CreateMockInstanceProcedure } from './index.d-D4wtotQw.js'; + +interface CompilerHintsOptions { + /** + * This is the key used to access the globalThis object in the worker. + * Unlike `globalThisAccessor` in other APIs, this is not injected into the script. + * ```ts + * // globalThisKey: '__my_variable__' produces: + * globalThis['__my_variable__'] + * // globalThisKey: '"__my_variable__"' produces: + * globalThis['"__my_variable__"'] // notice double quotes + * ``` + * @default '__vitest_mocker__' + */ + globalThisKey?: string; +} +interface ModuleMockerCompilerHints { + hoisted: (factory: () => T) => T; + mock: (path: string | Promise, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void; + unmock: (path: string | Promise) => void; + doMock: (path: string | Promise, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void; + doUnmock: (path: string | Promise) => void; + importActual: (path: string) => Promise; + importMock: (path: string) => Promise>; +} +declare function createCompilerHints(options?: CompilerHintsOptions): ModuleMockerCompilerHints; + +interface ModuleMockerInterceptor { + register: (module: MockedModule) => Promise; + delete: (url: string) => Promise; + invalidate: () => Promise; +} + +declare class ModuleMocker implements TestModuleMocker { + private interceptor; + private rpc; + private createMockInstance; + private config; + protected registry: MockerRegistry; + private queue; + private mockedIds; + constructor(interceptor: ModuleMockerInterceptor, rpc: ModuleMockerRPC, createMockInstance: CreateMockInstanceProcedure, config: ModuleMockerConfig); + prepare(): Promise; + resolveFactoryModule(id: string): Promise>; + getFactoryModule(id: string): any; + invalidate(): Promise; + importActual(id: string, importer: string): Promise; + protected getBaseUrl(): string; + importMock(rawId: string, importer: string): Promise; + mockObject(object: Record, moduleType?: "automock" | "autospy"): Record; + mockObject(object: Record, mockExports: Record | undefined, moduleType?: "automock" | "autospy"): Record; + getMockContext(): ModuleMockContext; + queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void; + queueUnmock(id: string, importer: string): void; + wrapDynamicImport(moduleFactory: () => Promise): Promise; + getMockedModuleById(id: string): MockedModule | undefined; + reset(): void; + private resolveMockPath; +} +interface ResolveIdResult { + id: string; + url: string; + optimized: boolean; +} +interface ResolveMockResult { + mockType: MockedModuleType; + resolvedId: string; + resolvedUrl: string; + redirectUrl?: string | null; + needsInterop?: boolean; +} +interface ModuleMockerRPC { + invalidate: (ids: string[]) => Promise; + resolveId: (id: string, importer: string) => Promise; + resolveMock: (id: string, importer: string, options: { + mock: "spy" | "factory" | "auto"; + }) => Promise; +} +interface ModuleMockerConfig { + root: string; +} + +export { ModuleMocker as b, createCompilerHints as f }; +export type { CompilerHintsOptions as C, ModuleMockerInterceptor as M, ResolveIdResult as R, ModuleMockerCompilerHints as a, ModuleMockerConfig as c, ModuleMockerRPC as d, ResolveMockResult as e }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.d.ts new file mode 100644 index 00000000..2459e4f7 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.d.ts @@ -0,0 +1,78 @@ +import { H as HoistMocksOptions } from './hoistMocks.d-h98GpQUH.js'; +export { S as StaticMockCall, c as createManualModuleSource } from './hoistMocks.d-h98GpQUH.js'; +import { AutomockOptions } from './automock.js'; +export { automockModule } from './automock.js'; +import { Plugin, Environment, Rollup, ViteDevServer } from 'vite'; +import { SourceMap } from 'magic-string'; +import { MockerRegistry, ServerMockResolution, ServerIdResolution } from './index.js'; +export { findMockRedirect } from './redirect.js'; + +declare function automockPlugin(options?: AutomockOptions): Plugin; + +interface DynamicImportPluginOptions { + /** + * @default `"__vitest_mocker__"` + */ + globalThisAccessor?: string; + filter?: (id: string, environment: Environment) => boolean; +} +declare function dynamicImportPlugin(options?: DynamicImportPluginOptions): Plugin; + +interface HoistMocksPluginOptions extends Omit { + include?: string | RegExp | (string | RegExp)[]; + exclude?: string | RegExp | (string | RegExp)[]; + /** + * overrides include/exclude options + */ + filter?: (id: string) => boolean; +} +declare function hoistMocksPlugin(options?: HoistMocksPluginOptions): Plugin; +declare function hoistMockAndResolve(code: string, id: string, parse: Rollup.PluginContext["parse"], options?: HoistMocksOptions): HoistMocksResult | undefined; +interface HoistMocksResult { + code: string; + map: SourceMap; +} + +interface InterceptorPluginOptions { + /** + * @default "__vitest_mocker__" + */ + globalThisAccessor?: string; + registry?: MockerRegistry; + /** + * Register the `vitest:interceptor:*` WebSocket events in `configureServer`. + * Disable this when mocks are registered through another authenticated + * channel and the raw dev-server socket should not accept them. + * @default true + */ + registerWebSocketEvents?: boolean; +} +declare function interceptorPlugin(options?: InterceptorPluginOptions): Plugin; + +interface MockerPluginOptions extends AutomockOptions { + hoistMocks?: HoistMocksPluginOptions; +} +declare function mockerPlugin(options?: MockerPluginOptions): Plugin[]; + +interface ServerResolverOptions { + /** + * @default ['/node_modules/'] + */ + moduleDirectories?: string[]; +} +declare class ServerMockResolver { + private server; + private options; + constructor(server: ViteDevServer, options?: ServerResolverOptions); + resolveMock(rawId: string, importer: string, options: { + mock: "spy" | "factory" | "auto"; + }): Promise; + invalidate(ids: string[]): void; + resolveId(id: string, importer?: string): Promise; + private normalizeResolveIdToUrl; + private resolveMockId; + private resolveModule; +} + +export { AutomockOptions as AutomockPluginOptions, HoistMocksOptions, ServerMockResolver, automockPlugin, dynamicImportPlugin, hoistMockAndResolve as hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin }; +export type { HoistMocksPluginOptions, HoistMocksResult, InterceptorPluginOptions, ServerResolverOptions }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.js new file mode 100644 index 00000000..9c866d08 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/node.js @@ -0,0 +1,442 @@ +import { a as cleanUrl, c as createManualModuleSource } from './chunk-utils.js'; +import { a as automockModule, e as esmWalker } from './chunk-automock.js'; +import MagicString from 'magic-string'; +import { createFilter, isFileLoadingAllowed } from 'vite'; +import { h as hoistMocks } from './chunk-hoistMocks.js'; +import { readFile } from 'node:fs/promises'; +import { join } from 'node:path/posix'; +import { M as MockerRegistry, a as ManualMockedModule } from './chunk-registry.js'; +import { fileURLToPath } from 'node:url'; +import { existsSync, readFileSync } from 'node:fs'; +import { findMockRedirect } from './redirect.js'; +import { i as isAbsolute, j as join$1, r as resolve } from './chunk-pathe.M-eThtNZ.js'; +import 'estree-walker'; +import 'node:module'; +import 'node:path'; +import './chunk-helpers.js'; +import '@jridgewell/trace-mapping'; + +function automockPlugin(options = {}) { + return { + name: "vitest:automock", + enforce: "post", + transform(code, id) { + if (id.includes("mock=automock") || id.includes("mock=autospy")) { + const mockType = id.includes("mock=automock") ? "automock" : "autospy"; + const ms = automockModule(code, mockType, this.parse, options); + return { + code: ms.toString(), + map: ms.generateMap({ + hires: "boundary", + source: cleanUrl(id) + }) + }; + } + } + }; +} + +const regexDynamicImport = /import\s*\(/; +function dynamicImportPlugin(options = {}) { + return { + name: "vitest:browser:esm-injector", + enforce: "post", + transform: { + order: "post", + handler(source, id) { + // TODO: test is not called for static imports + if (!regexDynamicImport.test(source)) { + return; + } + if (options.filter && !options.filter(id, this.environment)) { + return; + } + return injectDynamicImport(source, id, this.parse, options); + } + } + }; +} +function injectDynamicImport(code, id, parse, options = {}) { + if (code.includes("wrapDynamicImport")) { + return; + } + const s = new MagicString(code); + let ast; + try { + ast = parse(code); + } catch (err) { + console.error(`Cannot parse ${id}:\n${err.message}`); + return; + } + // 3. convert references to import bindings & import.meta references + esmWalker(ast, { + // TODO: make env updatable + onImportMeta() { + // s.update(node.start, node.end, viImportMetaKey) + }, + onDynamicImport(node) { + const globalThisAccessor = options.globalThisAccessor || "\"__vitest_mocker__\""; + const replaceString = `globalThis[${globalThisAccessor}].wrapDynamicImport(async () => import(`; + const importSubstring = code.substring(node.start, node.end); + const hasIgnore = importSubstring.includes("/* @vite-ignore */"); + s.overwrite(node.start, node.source.start, replaceString + (hasIgnore ? "/* @vite-ignore */ " : "")); + s.overwrite(node.end - 1, node.end, "))"); + } + }); + return { + code: s.toString(), + map: s.generateMap({ + hires: "boundary", + source: id + }) + }; +} + +function hoistMocksPlugin(options = {}) { + const filter = options.filter || createFilter(options.include, options.exclude); + const { hoistableMockMethodNames = ["mock", "unmock"], dynamicImportMockMethodNames = [ + "mock", + "unmock", + "doMock", + "doUnmock" + ], hoistedMethodNames = ["hoisted"], utilsObjectNames = ["vi", "vitest"] } = options; + const methods = new Set([ + ...hoistableMockMethodNames, + ...hoistedMethodNames, + ...dynamicImportMockMethodNames + ]); + const regexpHoistable = new RegExp(`\\b(?:${utilsObjectNames.join("|")})\\s*\.\\s*(?:${Array.from(methods).join("|")})\\s*\\(`); + let root; + return { + name: "vitest:mocks", + enforce: "post", + configResolved(config) { + root = config.root; + }, + transform(code, id) { + if (!filter(id)) { + return; + } + const staticMocks = []; + const s = hoistMocks(code, id, this.parse, { + regexpHoistable, + hoistableMockMethodNames, + hoistedMethodNames, + utilsObjectNames, + dynamicImportMockMethodNames, + root, + getMap: () => this.getCombinedSourcemap(), + ...options, + onStaticMock(call) { + staticMocks.push(call); + options.onStaticMock?.(call); + } + }); + // vite keeps `meta` across re-transforms, so always reset it + if (!s) { + return { meta: { vitestStaticMocks: null } }; + } + return { + code: s.toString(), + map: s.generateMap({ + hires: "boundary", + source: cleanUrl(id) + }), + meta: { vitestStaticMocks: staticMocks } + }; + } + }; +} +// to keeb backwards compat +function hoistMockAndResolve(code, id, parse, options = {}) { + const s = hoistMocks(code, id, parse, options); + if (s) { + return { + code: s.toString(), + map: s.generateMap({ + hires: "boundary", + source: cleanUrl(id) + }) + }; + } +} + +function interceptorPlugin(options = {}) { + const registry = options.registry || new MockerRegistry(); + return { + name: "vitest:mocks:interceptor", + enforce: "pre", + load: { + order: "pre", + async handler(id) { + const mock = registry.getById(id); + if (!mock) { + return; + } + if (mock.type === "manual") { + const exports = Object.keys(await mock.resolve()); + const accessor = options.globalThisAccessor || "\"__vitest_mocker__\""; + return createManualModuleSource(mock.url, exports, accessor); + } + if (mock.type === "redirect") { + return readFile(mock.redirect, "utf-8"); + } + } + }, + transform: { + order: "post", + handler(code, id) { + const mock = registry.getById(id); + if (!mock) { + return; + } + if (mock.type === "automock" || mock.type === "autospy") { + const m = automockModule(code, mock.type, this.parse, { globalThisAccessor: options.globalThisAccessor }); + return { + code: m.toString(), + map: m.generateMap({ + hires: "boundary", + source: cleanUrl(id) + }) + }; + } + } + }, + configureServer(server) { + if (options.registerWebSocketEvents === false) { + return; + } + server.ws.on("vitest:interceptor:register", (event) => { + if (event.type === "manual") { + const module = ManualMockedModule.fromJSON(event, async () => { + const keys = await getFactoryExports(event.url); + return Object.fromEntries(keys.map((key) => [key, null])); + }); + registry.add(module); + } else { + if (event.type === "redirect") { + const redirectUrl = new URL(event.redirect); + const redirect = join(server.config.root, redirectUrl.pathname); + // the redirect is served through the `load` hook below, so it must + // stay inside the file-serving allowlist and never escape the root + if (!isFileLoadingAllowed(server.config, redirect)) { + server.ws.send("vitest:interceptor:register:result"); + return; + } + event.redirect = redirect; + } + registry.register(event); + } + server.ws.send("vitest:interceptor:register:result"); + }); + server.ws.on("vitest:interceptor:delete", (id) => { + registry.delete(id); + server.ws.send("vitest:interceptor:delete:result"); + }); + server.ws.on("vitest:interceptor:invalidate", () => { + registry.clear(); + server.ws.send("vitest:interceptor:invalidate:result"); + }); + function getFactoryExports(url) { + server.ws.send("vitest:interceptor:resolve", url); + let timeout; + return new Promise((resolve, reject) => { + timeout = setTimeout(() => { + reject(new Error(`Timeout while waiting for factory exports of ${url}`)); + }, 1e4); + server.ws.on("vitest:interceptor:resolved", ({ url: resolvedUrl, keys }) => { + if (resolvedUrl === url) { + clearTimeout(timeout); + resolve(keys); + } + }); + }); + } + } + }; +} + +const VALID_ID_PREFIX = "/@id/"; +class ServerMockResolver { + server; + options; + constructor(server, options = {}) { + this.server = server; + this.options = options; + } + async resolveMock(rawId, importer, options) { + const { id, fsPath, external } = await this.resolveMockId(rawId, importer); + const resolvedUrl = this.normalizeResolveIdToUrl({ id }).url; + if (options.mock === "factory") { + const manifest = getViteDepsManifest(this.server.config); + const needsInterop = manifest?.[fsPath]?.needsInterop ?? false; + return { + mockType: "manual", + resolvedId: id, + resolvedUrl, + needsInterop + }; + } + if (options.mock === "spy") { + return { + mockType: "autospy", + resolvedId: id, + resolvedUrl + }; + } + const redirectUrl = findMockRedirect(this.server.config.root, fsPath, external); + return { + mockType: redirectUrl === null ? "automock" : "redirect", + redirectUrl, + resolvedId: id, + resolvedUrl + }; + } + invalidate(ids) { + ids.forEach((id) => { + const moduleGraph = this.server.moduleGraph; + const module = moduleGraph.getModuleById(id); + if (module) { + module.transformResult = null; + } + }); + } + async resolveId(id, importer) { + const resolved = await this.server.environments.client.pluginContainer.resolveId(id, importer); + if (!resolved) { + return null; + } + return this.normalizeResolveIdToUrl(resolved); + } + normalizeResolveIdToUrl(resolved) { + const isOptimized = resolved.id.startsWith(withTrailingSlash(this.server.config.cacheDir)); + let url; + // normalise the URL to be acceptable by the browser + // https://github.com/vitejs/vite/blob/14027b0f2a9b01c14815c38aab22baf5b29594bb/packages/vite/src/node/plugins/importAnalysis.ts#L103 + const root = this.server.config.root; + if (resolved.id.startsWith(withTrailingSlash(root))) { + url = resolved.id.slice(root.length); + } else if (resolved.id !== "/@react-refresh" && isAbsolute(resolved.id) && existsSync(cleanUrl(resolved.id))) { + url = join$1("/@fs/", resolved.id); + } else { + url = resolved.id; + } + if (url[0] !== "." && url[0] !== "/") { + url = resolved.id.startsWith(VALID_ID_PREFIX) ? resolved.id : VALID_ID_PREFIX + resolved.id.replace("\0", "__x00__"); + } + return { + id: resolved.id, + url, + optimized: isOptimized + }; + } + async resolveMockId(rawId, importer) { + if (!this.server.moduleGraph.getModuleById(importer) && !importer.startsWith(this.server.config.root)) { + importer = join$1(this.server.config.root, importer); + } + const resolved = await this.server.pluginContainer.resolveId(rawId, importer, { ssr: false }); + return this.resolveModule(rawId, resolved); + } + resolveModule(rawId, resolved) { + const id = resolved?.id || rawId; + const external = !isAbsolute(id) || isModuleDirectory(this.options, id) ? rawId : null; + return { + id, + fsPath: cleanUrl(id), + external + }; + } +} +function isModuleDirectory(config, path) { + const moduleDirectories = config.moduleDirectories || ["/node_modules/"]; + return moduleDirectories.some((dir) => path.includes(dir)); +} +const metadata = new WeakMap(); +function getViteDepsManifest(config) { + if (metadata.has(config)) { + return metadata.get(config); + } + const cacheDirPath = getDepsCacheDir(config); + const metadataPath = resolve(cacheDirPath, "_metadata.json"); + if (!existsSync(metadataPath)) { + return null; + } + const { optimized } = JSON.parse(readFileSync(metadataPath, "utf-8")); + const newManifest = {}; + for (const name in optimized) { + const dep = optimized[name]; + const file = resolve(cacheDirPath, dep.file); + newManifest[file] = { + hash: dep.fileHash, + needsInterop: dep.needsInterop + }; + } + metadata.set(config, newManifest); + return newManifest; +} +function getDepsCacheDir(config) { + return resolve(config.cacheDir, "deps"); +} +function withTrailingSlash(path) { + if (path.at(-1) !== "/") { + return `${path}/`; + } + return path; +} + +// this is an implementation for public usage +// vitest doesn't use this plugin directly +function mockerPlugin(options = {}) { + let server; + const registerPath = resolve(fileURLToPath(new URL("./register.js", import.meta.url))); + return [ + { + name: "vitest:mocker:ws-rpc", + config(_, { command }) { + if (command !== "serve") { + return; + } + return { + server: { + // don't pre-transform request because they might be mocked at runtime +preTransformRequests: false }, + optimizeDeps: { exclude: ["@vitest/mocker/register", "@vitest/mocker/browser"] } + }; + }, + configureServer(server_) { + server = server_; + const mockResolver = new ServerMockResolver(server); + server.ws.on("vitest:mocks:resolveId", async ({ id, importer }) => { + const resolved = await mockResolver.resolveId(id, importer); + server.ws.send("vitest:mocks:resolvedId:result", resolved); + }); + server.ws.on("vitest:mocks:resolveMock", async ({ id, importer, options }) => { + const resolved = await mockResolver.resolveMock(id, importer, options); + server.ws.send("vitest:mocks:resolveMock:result", resolved); + }); + server.ws.on("vitest:mocks:invalidate", async ({ ids }) => { + mockResolver.invalidate(ids); + server.ws.send("vitest:mocks:invalidate:result"); + }); + }, + async load(id) { + if (id !== registerPath) { + return; + } + if (!server) { + // mocker doesn't work during build + return "export {}"; + } + const content = await readFile(registerPath, "utf-8"); + const result = content.replace(/__VITEST_GLOBAL_THIS_ACCESSOR__/g, options.globalThisAccessor ?? "\"__vitest_mocker__\"").replace("__VITEST_MOCKER_ROOT__", JSON.stringify(server.config.root)); + return result; + } + }, + hoistMocksPlugin(options.hoistMocks), + interceptorPlugin(options), + automockPlugin(options), + dynamicImportPlugin(options) + ]; +} + +export { ServerMockResolver, automockModule, automockPlugin, createManualModuleSource, dynamicImportPlugin, findMockRedirect, hoistMockAndResolve as hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.d.ts new file mode 100644 index 00000000..1f8256ba --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.d.ts @@ -0,0 +1,3 @@ +declare function findMockRedirect(root: string, mockPath: string, external: string | null): string | null; + +export { findMockRedirect }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.js new file mode 100644 index 00000000..b6efea13 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/redirect.js @@ -0,0 +1,79 @@ +import fs from 'node:fs'; +import module$1 from 'node:module'; +import { d as dirname, j as join, b as basename, r as resolve, e as extname } from './chunk-pathe.M-eThtNZ.js'; + +const { existsSync, readdirSync, statSync } = fs; +function findMockRedirect(root, mockPath, external) { + const path = external || mockPath; + // it's a node_module alias + // all mocks should be inside /__mocks__ + if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) { + const mockDirname = dirname(path); + const mockFolder = join(root, "__mocks__", mockDirname); + if (!existsSync(mockFolder)) { + return null; + } + const baseOriginal = basename(path); + function findFile(mockFolder, baseOriginal) { + const files = readdirSync(mockFolder); + for (const file of files) { + const baseFile = basename(file, extname(file)); + if (baseFile === baseOriginal) { + const path = resolve(mockFolder, file); + // if the same name, return the file + if (statSync(path).isFile()) { + return path; + } else { + // find folder/index.{js,ts} + const indexFile = findFile(path, "index"); + if (indexFile) { + return indexFile; + } + } + } + } + return null; + } + return findFile(mockFolder, baseOriginal); + } + const dir = dirname(path); + const baseId = basename(path); + const fullPath = resolve(dir, "__mocks__", baseId); + return existsSync(fullPath) ? fullPath : null; +} +const builtins = new Set([ + ...module$1.builtinModules, + "assert/strict", + "diagnostics_channel", + "dns/promises", + "fs/promises", + "path/posix", + "path/win32", + "readline/promises", + "stream/consumers", + "stream/promises", + "stream/web", + "timers/promises", + "util/types", + "wasi" +]); +// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix +const prefixedBuiltins = new Set([ + "node:sea", + "node:sqlite", + "node:test", + "node:test/reporters" +]); +const NODE_BUILTIN_NAMESPACE = "node:"; +function isNodeBuiltin(id) { + // Added in v18.6.0 + if (module$1.isBuiltin) { + return module$1.isBuiltin(id); + } + if (prefixedBuiltins.has(id)) { + return true; + } + return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id); +} + +export { findMockRedirect }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.d.ts new file mode 100644 index 00000000..93ba1cd5 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.d.ts @@ -0,0 +1,9 @@ +import { ModuleMockerInterceptor, ModuleMockerCompilerHints, ModuleMocker } from './browser.js'; +import '@vitest/spy'; +import './registry.d-xLx_FoyF.js'; +import './index.d-D4wtotQw.js'; + +declare function registerModuleMocker(interceptor: (accessor: string) => ModuleMockerInterceptor): ModuleMockerCompilerHints; +declare function registerNativeFactoryResolver(mocker: ModuleMocker): void; + +export { registerModuleMocker, registerNativeFactoryResolver }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.js new file mode 100644 index 00000000..6c5cbc05 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/register.js @@ -0,0 +1,42 @@ +import { createMockInstance } from '@vitest/spy'; +import { M as ModuleMocker, r as rpc, c as createCompilerHints, h as hot } from './chunk-mocker.js'; +import './chunk-helpers.js'; +import './index.js'; +import './chunk-registry.js'; +import './chunk-pathe.M-eThtNZ.js'; + +function registerModuleMocker(interceptor) { + const mocker = new ModuleMocker(interceptor(__VITEST_GLOBAL_THIS_ACCESSOR__), { + resolveId(id, importer) { + return rpc("vitest:mocks:resolveId", { + id, + importer + }); + }, + resolveMock(id, importer, options) { + return rpc("vitest:mocks:resolveMock", { + id, + importer, + options + }); + }, + async invalidate(ids) { + return rpc("vitest:mocks:invalidate", { ids }); + } + }, createMockInstance, { root: __VITEST_MOCKER_ROOT__ }); + globalThis[__VITEST_GLOBAL_THIS_ACCESSOR__] = mocker; + registerNativeFactoryResolver(mocker); + return createCompilerHints({ globalThisKey: __VITEST_GLOBAL_THIS_ACCESSOR__ }); +} +function registerNativeFactoryResolver(mocker) { + hot.on("vitest:interceptor:resolve", async (url) => { + const exports = await mocker.resolveFactoryModule(url); + const keys = Object.keys(exports); + hot.send("vitest:interceptor:resolved", { + url, + keys + }); + }); +} + +export { registerModuleMocker, registerNativeFactoryResolver }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/registry.d-xLx_FoyF.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/registry.d-xLx_FoyF.d.ts new file mode 100644 index 00000000..841fcbce --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/registry.d-xLx_FoyF.d.ts @@ -0,0 +1,123 @@ +type Awaitable = T | PromiseLike; +type ModuleMockFactoryWithHelper = (importOriginal: () => Promise) => Awaitable>; +type ModuleMockFactory = () => any; +interface ModuleMockOptions { + spy?: boolean; +} +interface ServerMockResolution { + mockType: "manual" | "redirect" | "automock" | "autospy"; + resolvedId: string; + resolvedUrl: string; + needsInterop?: boolean; + redirectUrl?: string | null; +} +interface ServerIdResolution { + id: string; + url: string; + optimized: boolean; +} +interface ModuleMockContext { + /** + * When mocking with a factory, this refers to the module that imported the mock. + */ + callstack: null | string[]; +} +interface TestModuleMocker { + queueMock(id: string, importer: string, factoryOrOptions?: ModuleMockFactory | ModuleMockOptions): void; + queueUnmock(id: string, importer: string): void; + importActual(rawId: string, importer: string, callstack?: string[] | null): Promise; + importMock(rawId: string, importer: string): Promise; + mockObject(object: Record, moduleType?: "automock" | "autospy"): Record; + mockObject(object: Record, mockExports: Record | undefined, moduleType?: "automock" | "autospy"): Record; + getMockContext(): ModuleMockContext; + reset(): void; +} + +declare class MockerRegistry { + private readonly registryByUrl; + private readonly registryById; + clear(): void; + keys(): IterableIterator; + add(mock: MockedModule): void; + register(json: MockedModuleSerialized): MockedModule; + register(type: "redirect", raw: string, id: string, url: string, redirect: string): RedirectedModule; + register(type: "manual", raw: string, id: string, url: string, factory: () => any): ManualMockedModule; + register(type: "automock", raw: string, id: string, url: string): AutomockedModule; + register(type: "autospy", id: string, raw: string, url: string): AutospiedModule; + delete(id: string): void; + deleteById(id: string): void; + get(id: string): MockedModule | undefined; + getById(id: string): MockedModule | undefined; + has(id: string): boolean; +} +type MockedModule = AutomockedModule | AutospiedModule | ManualMockedModule | RedirectedModule; +type MockedModuleType = "automock" | "autospy" | "manual" | "redirect"; +type MockedModuleSerialized = AutomockedModuleSerialized | AutospiedModuleSerialized | ManualMockedModuleSerialized | RedirectedModuleSerialized; +declare class AutomockedModule { + raw: string; + id: string; + url: string; + readonly type = "automock"; + constructor(raw: string, id: string, url: string); + static fromJSON(data: AutomockedModuleSerialized): AutomockedModule; + toJSON(): AutomockedModuleSerialized; +} +interface AutomockedModuleSerialized { + type: "automock"; + url: string; + raw: string; + id: string; +} +declare class AutospiedModule { + raw: string; + id: string; + url: string; + readonly type = "autospy"; + constructor(raw: string, id: string, url: string); + static fromJSON(data: AutospiedModuleSerialized): AutospiedModule; + toJSON(): AutospiedModuleSerialized; +} +interface AutospiedModuleSerialized { + type: "autospy"; + url: string; + raw: string; + id: string; +} +declare class RedirectedModule { + raw: string; + id: string; + url: string; + redirect: string; + readonly type = "redirect"; + constructor(raw: string, id: string, url: string, redirect: string); + static fromJSON(data: RedirectedModuleSerialized): RedirectedModule; + toJSON(): RedirectedModuleSerialized; +} +interface RedirectedModuleSerialized { + type: "redirect"; + url: string; + id: string; + raw: string; + redirect: string; +} +declare class ManualMockedModule { + raw: string; + id: string; + url: string; + factory: () => T; + cache: T | undefined; + readonly type = "manual"; + constructor(raw: string, id: string, url: string, factory: () => T); + resolve(): T; + static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule; + toJSON(): ManualMockedModuleSerialized; +} +interface ManualMockedModuleSerialized { + type: "manual"; + url: string; + id: string; + raw: string; +} + +export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, AutospiedModule as h, ManualMockedModule as j }; +export type { ServerMockResolution as S, TestModuleMocker as T, MockedModule as a, ModuleMockOptions as b, ModuleMockFactoryWithHelper as c, MockedModuleType as d, ModuleMockContext as e, ServerIdResolution as f, AutomockedModuleSerialized as g, AutospiedModuleSerialized as i, ManualMockedModuleSerialized as k, MockedModuleSerialized as l, ModuleMockFactory as m, RedirectedModuleSerialized as n }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.d.ts b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.d.ts new file mode 100644 index 00000000..0516b838 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.d.ts @@ -0,0 +1,9 @@ +export { c as createManualModuleSource, h as hoistMocks } from './hoistMocks.d-h98GpQUH.js'; +export { automockModule } from './automock.js'; +import 'vite'; +import 'magic-string'; + +declare function initSyntaxLexers(): Promise; +declare function collectModuleExports(filename: string, code: string, format: "module" | "commonjs", exports?: string[]): string[]; + +export { collectModuleExports, initSyntaxLexers }; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.js b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.js new file mode 100644 index 00000000..8f0c106f --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/dist/transforms.js @@ -0,0 +1,12 @@ +export { c as createManualModuleSource } from './chunk-utils.js'; +export { a as automockModule, c as collectModuleExports, i as initSyntaxLexers } from './chunk-automock.js'; +export { h as hoistMocks } from './chunk-hoistMocks.js'; +import 'node:fs'; +import 'node:url'; +import 'magic-string'; +import 'estree-walker'; +import 'node:module'; +import 'node:path'; +import './chunk-helpers.js'; +import '@jridgewell/trace-mapping'; +import './chunk-pathe.M-eThtNZ.js'; diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/node_modules/.bin/vite b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/node_modules/.bin/vite new file mode 100755 index 00000000..622af201 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/node_modules/.bin/vite @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/node_modules:$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/node_modules:$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules:$basedir_abs/../../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js" "$@" +else + exec node "$basedir_abs/../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js" "$@" +fi +# cmd-shim-target=../../../../../../vite@8.3.1_jiti@2.7.0/node_modules/vite/bin/vite.js diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/package.json b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/package.json new file mode 100644 index 00000000..9af53323 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/mocker/package.json @@ -0,0 +1,105 @@ +{ + "name": "@vitest/mocker", + "type": "module", + "version": "5.0.2", + "description": "Vitest module mocker implementation", + "license": "MIT", + "funding": "https://opencollective.com/vitest", + "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/mocker", + "repository": { + "type": "git", + "url": "git+https://github.com/vitest-dev/vitest.git", + "directory": "packages/mocker" + }, + "bugs": { + "url": "https://github.com/vitest-dev/vitest/issues" + }, + "keywords": [ + "vitest", + "test", + "mock" + ], + "sideEffects": false, + "exports": { + ".": { + "__vitest_source__": "./src/index.ts", + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "./node": { + "__vitest_source__": "./src/node/index.ts", + "types": "./dist/node.d.ts", + "default": "./dist/node.js" + }, + "./browser": { + "__vitest_source__": "./src/browser/index.ts", + "types": "./dist/browser.d.ts", + "default": "./dist/browser.js" + }, + "./redirect": { + "__vitest_source__": "./src/node/redirect.ts", + "types": "./dist/redirect.d.ts", + "default": "./dist/redirect.js" + }, + "./automock": { + "__vitest_source__": "./src/node/automock.ts", + "types": "./dist/automock.d.ts", + "default": "./dist/automock.js" + }, + "./register": { + "__vitest_source__": "./src/browser/register.ts", + "types": "./dist/register.d.ts", + "default": "./dist/register.js" + }, + "./auto-register": { + "__vitest_source__": "./src/browser/auto-register.ts", + "types": "./dist/register.d.ts", + "default": "./dist/register.js" + }, + "./transforms": { + "__vitest_source__": "./src/node/transforms.ts", + "types": "./dist/transforms.d.ts", + "default": "./dist/transforms.js" + }, + "./package.json": "./package.json" + }, + "main": "./dist/index.js", + "module": "./dist/index.js", + "types": "./dist/index.d.ts", + "files": [ + "*.d.ts", + "dist" + ], + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + }, + "dependencies": { + "@jridgewell/trace-mapping": "0.3.31", + "@vitest/spy": "5.0.2", + "estree-walker": "^3.0.3", + "magic-string": "^1.2.3" + }, + "devDependencies": { + "@types/estree": "^1.0.9", + "@vitest/utils": "5.0.2", + "acorn-walk": "^8.3.5", + "cjs-module-lexer": "^2.2.1", + "es-module-lexer": "^2.3.2", + "msw": "^2.15.0", + "pathe": "^2.0.3", + "vite": "^6.3.5" + }, + "scripts": { + "build": "premove dist && rollup -c", + "dev": "rollup -c --watch" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/spy b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/spy new file mode 120000 index 00000000..5101b0ba --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/@vitest/spy @@ -0,0 +1 @@ +../../../@vitest+spy@5.0.2/node_modules/@vitest/spy \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/estree-walker b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/estree-walker new file mode 120000 index 00000000..fa2d548d --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/estree-walker @@ -0,0 +1 @@ +../../estree-walker@3.0.3/node_modules/estree-walker \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/magic-string b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/magic-string new file mode 120000 index 00000000..f6feae5e --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/magic-string @@ -0,0 +1 @@ +../../magic-string@1.4.2/node_modules/magic-string \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vite b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vite new file mode 120000 index 00000000..a2ea35ae --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+mocker@5.0.2_vite@8.3.1_jiti@2.7.0_/node_modules/vite @@ -0,0 +1 @@ +../../vite@8.3.1_jiti@2.7.0/node_modules/vite \ No newline at end of file diff --git a/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/LICENSE b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/LICENSE new file mode 100644 index 00000000..0e5771dd --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors + +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/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/README.md b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/README.md new file mode 100644 index 00000000..97129c5e --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/README.md @@ -0,0 +1,7 @@ +# @vitest/spy + +[![NPM version](https://img.shields.io/npm/v/@vitest/spy?color=a1b858&label=)](https://npmx.dev/package/@vitest/spy) + +Lightweight Jest-compatible mocking implementation. + +[GitHub](https://github.com/vitest-dev/vitest/tree/main/packages/spy) | [Documentation](https://vitest.dev/api/mock) diff --git a/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.d.ts b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.d.ts new file mode 100644 index 00000000..863873a7 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.d.ts @@ -0,0 +1,432 @@ +import { Disposable } from '@vitest/spy/optional-types.js'; + +interface MockResultReturn { + type: "return"; + /** + * The value that was returned from the function. If function returned a Promise, then this will be a resolved value. + */ + value: T; +} +interface MockResultIncomplete { + type: "incomplete"; + value: undefined; +} +interface MockResultThrow { + type: "throw"; + /** + * An error that was thrown during function execution. + */ + value: any; +} +interface MockSettledResultIncomplete { + type: "incomplete"; + value: undefined; +} +interface MockSettledResultFulfilled { + type: "fulfilled"; + value: T; +} +interface MockSettledResultRejected { + type: "rejected"; + value: any; +} +type MockResult = MockResultReturn | MockResultThrow | MockResultIncomplete; +type MockSettledResult = MockSettledResultFulfilled | MockSettledResultRejected | MockSettledResultIncomplete; +type MockParameters = T extends Constructable ? ConstructorParameters : T extends Procedure ? Parameters : never; +type MockReturnType = T extends Constructable ? InstanceType : T extends Procedure ? ReturnType : never; +type MockProcedureContext = T extends Constructable ? InstanceType : ThisParameterType; +interface MockContext { + /** + * This is an array containing all arguments for each call. One item of the array is the arguments of that call. + * + * @see https://vitest.dev/api/mock#mock-calls + * @example + * const fn = vi.fn() + * + * fn('arg1', 'arg2') + * fn('arg3') + * + * fn.mock.calls === [ + * ['arg1', 'arg2'], // first call + * ['arg3'], // second call + * ] + */ + calls: MockParameters[]; + /** + * This is an array containing all instances that were instantiated when mock was called with a `new` keyword. Note that this is an actual context (`this`) of the function, not a return value. + * @see https://vitest.dev/api/mock#mock-instances + */ + instances: MockProcedureContext[]; + /** + * An array of `this` values that were used during each call to the mock function. + * @see https://vitest.dev/api/mock#mock-contexts + */ + contexts: MockProcedureContext[]; + /** + * The order of mock's execution. This returns an array of numbers which are shared between all defined mocks. + * + * @see https://vitest.dev/api/mock#mock-invocationcallorder + * @example + * const fn1 = vi.fn() + * const fn2 = vi.fn() + * + * fn1() + * fn2() + * fn1() + * + * fn1.mock.invocationCallOrder === [1, 3] + * fn2.mock.invocationCallOrder === [2] + */ + invocationCallOrder: number[]; + /** + * This is an array containing all values that were `returned` from the function. + * + * The `value` property contains the returned value or thrown error. If the function returned a `Promise`, then `result` will always be `'return'` even if the promise was rejected. + * + * @see https://vitest.dev/api/mock#mock-results + * @example + * const fn = vi.fn() + * .mockReturnValueOnce('result') + * .mockImplementationOnce(() => { throw new Error('thrown error') }) + * + * const result = fn() + * + * try { + * fn() + * } + * catch {} + * + * fn.mock.results === [ + * { + * type: 'return', + * value: 'result', + * }, + * { + * type: 'throw', + * value: Error, + * }, + * ] + */ + results: MockResult>[]; + /** + * An array containing all values that were `resolved` or `rejected` from the function. + * + * This array will be empty if the function was never resolved or rejected. + * + * @see https://vitest.dev/api/mock#mock-settledresults + * @example + * const fn = vi.fn().mockResolvedValueOnce('result') + * + * const result = fn() + * + * fn.mock.settledResults === [ + * { + * type: 'incomplete', + * value: undefined, + * } + * ] + * fn.mock.results === [ + * { + * type: 'return', + * value: Promise<'result'>, + * }, + * ] + * + * await result + * + * fn.mock.settledResults === [ + * { + * type: 'fulfilled', + * value: 'result', + * }, + * ] + */ + settledResults: MockSettledResult>>[]; + /** + * This contains the arguments of the last call. If spy wasn't called, will return `undefined`. + * @see https://vitest.dev/api/mock#mock-lastcall + */ + lastCall: MockParameters | undefined; +} +type Procedure = (...args: any[]) => any; +type NormalizedProcedure = T extends Constructable ? ({ + new (...args: ConstructorParameters): InstanceType; +}) | ({ + (this: InstanceType, ...args: ConstructorParameters): void; +}) : T extends Procedure ? (...args: Parameters) => ReturnType : never; +type Methods = keyof { [K in keyof T as T[K] extends Procedure ? K : never]: T[K] }; +type Properties = { [K in keyof T]: T[K] extends Procedure ? never : K }[keyof T] & (string | symbol); +type Classes = { [K in keyof T]: T[K] extends new (...args: any[]) => any ? K : never }[keyof T] & (string | symbol); +interface MockInstance extends Disposable { + /** + * Use it to return the name assigned to the mock with the `.mockName(name)` method. By default, it will return `vi.fn()`. + * @see https://vitest.dev/api/mock#getmockname + */ + getMockName(): string; + /** + * Sets the internal mock name. This is useful for identifying the mock when an assertion fails. + * @see https://vitest.dev/api/mock#mockname + */ + mockName(name: string): this; + /** + * Current context of the mock. It stores information about all invocation calls, instances, and results. + */ + mock: MockContext; + /** + * Clears all information about every call. After calling it, all properties on `.mock` will return to their initial state. This method does not reset implementations. It is useful for cleaning up mocks between different assertions. + * + * To automatically call this method before each test, enable the [`clearMocks`](https://vitest.dev/config/clearmocks) setting in the configuration. + * @see https://vitest.dev/api/mock#mockclear + */ + mockClear(): this; + /** + * Does what `mockClear` does and resets inner implementation to the original function. This also resets all "once" implementations. + * + * Note that resetting a mock from `vi.fn()` will set implementation to an empty function that returns `undefined`. + * Resetting a mock from `vi.fn(impl)` will set implementation to `impl`. It is useful for completely resetting a mock to its default state. + * + * To automatically call this method before each test, enable the [`mockReset`](https://vitest.dev/config/mockreset) setting in the configuration. + * @see https://vitest.dev/api/mock#mockreset + */ + mockReset(): this; + /** + * Does what `mockReset` does and restores original descriptors of spied-on objects. + * @see https://vitest.dev/api/mock#mockrestore + */ + mockRestore(): void; + /** + * Returns current permanent mock implementation if there is one. + * + * If mock was created with `vi.fn`, it will consider passed down method as a mock implementation. + * + * If mock was created with `vi.spyOn`, it will return `undefined` unless a custom implementation was provided. + */ + getMockImplementation(): NormalizedProcedure | undefined; + /** + * Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function. + * @see https://vitest.dev/api/mock#mockimplementation + * @example + * const increment = vi.fn().mockImplementation(count => count + 1); + * expect(increment(3)).toBe(4); + */ + mockImplementation(fn: NormalizedProcedure): this; + /** + * Accepts a function to be used as the mock implementation. TypeScript expects the arguments and return type to match those of the original function. This method can be chained to produce different results for multiple function calls. + * + * When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called. + * @see https://vitest.dev/api/mock#mockimplementationonce + * @example + * const fn = vi.fn(count => count).mockImplementationOnce(count => count + 1); + * expect(fn(3)).toBe(4); + * expect(fn(3)).toBe(3); + */ + mockImplementationOnce(fn: NormalizedProcedure): this; + /** + * Overrides the original mock implementation temporarily while the callback is being executed. + * + * Note that this method takes precedence over the [`mockImplementationOnce`](https://vitest.dev/api/mock#mockimplementationonce). + * @see https://vitest.dev/api/mock#withimplementation + * @example + * const myMockFn = vi.fn(() => 'original') + * + * myMockFn.withImplementation(() => 'temp', () => { + * myMockFn() // 'temp' + * }) + * + * myMockFn() // 'original' + */ + withImplementation(fn: NormalizedProcedure, cb: () => Promise): Promise; + withImplementation(fn: NormalizedProcedure, cb: () => unknown): this; + /** + * Use this if you need to return the `this` context from the method without invoking the actual implementation. + * @see https://vitest.dev/api/mock#mockreturnthis + */ + mockReturnThis(): this; + /** + * Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function. + * @see https://vitest.dev/api/mock#mockreturnvalue + * @example + * const mock = vi.fn() + * mock.mockReturnValue(42) + * mock() // 42 + * mock.mockReturnValue(43) + * mock() // 43 + */ + mockReturnValue(value: MockReturnType): this; + /** + * Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function. + * + * When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called. + * @example + * const myMockFn = vi + * .fn() + * .mockReturnValue('default') + * .mockReturnValueOnce('first call') + * .mockReturnValueOnce('second call') + * + * // 'first call', 'second call', 'default' + * console.log(myMockFn(), myMockFn(), myMockFn()) + */ + mockReturnValueOnce(value: MockReturnType): this; + /** + * Accepts a value that will be thrown whenever the mock function is called. + * @see https://vitest.dev/api/mock#mockthrow + * @example + * const myMockFn = vi.fn().mockThrow(new Error('error')) + * myMockFn() // throws 'error' + */ + mockThrow(value: unknown): this; + /** + * Accepts a value that will be thrown during the next function call. If chained, every consecutive call will throw the specified value. + * @example + * const myMockFn = vi + * .fn() + * .mockReturnValue('default') + * .mockThrowOnce(new Error('first call error')) + * .mockThrowOnce('second call error') + * + * expect(() => myMockFn()).toThrowError('first call error') + * expect(() => myMockFn()).toThrowError('second call error') + * expect(myMockFn()).toEqual('default') + */ + mockThrowOnce(value: unknown): this; + /** + * Accepts a value that will be resolved when the async function is called. TypeScript will only accept values that match the return type of the original function. + * @example + * const asyncMock = vi.fn().mockResolvedValue(42) + * asyncMock() // Promise<42> + */ + mockResolvedValue(value: Awaited>): this; + /** + * Accepts a value that will be resolved during the next function call. TypeScript will only accept values that match the return type of the original function. If chained, each consecutive call will resolve the specified value. + * @example + * const myMockFn = vi + * .fn() + * .mockResolvedValue('default') + * .mockResolvedValueOnce('first call') + * .mockResolvedValueOnce('second call') + * + * // Promise<'first call'>, Promise<'second call'>, Promise<'default'> + * console.log(myMockFn(), myMockFn(), myMockFn()) + */ + mockResolvedValueOnce(value: Awaited>): this; + /** + * Accepts an error that will be rejected when async function is called. + * @example + * const asyncMock = vi.fn().mockRejectedValue(new Error('Async error')) + * await asyncMock() // throws Error<'Async error'> + */ + mockRejectedValue(error: unknown): this; + /** + * Accepts a value that will be rejected during the next function call. If chained, each consecutive call will reject the specified value. + * @example + * const asyncMock = vi + * .fn() + * .mockResolvedValueOnce('first call') + * .mockRejectedValueOnce(new Error('Async error')) + * + * await asyncMock() // first call + * await asyncMock() // throws Error<'Async error'> + */ + mockRejectedValueOnce(error: unknown): this; +} +type Mock = MockInstance & (T extends Constructable ? (T extends Procedure ? { + new (...args: ConstructorParameters): InstanceType; + (...args: Parameters): ReturnType; +} : { + new (...args: ConstructorParameters): InstanceType; +}) : { + new (...args: MockParameters): MockReturnType; + (...args: MockParameters): MockReturnType; +}) & { [P in keyof T]: T[P] }; +type PartialMaybePromise = T extends Promise> ? Promise>> : Partial; +type PartialResultFunction = T extends Constructable ? ({ + new (...args: ConstructorParameters): InstanceType; +}) | ({ + (this: InstanceType, ...args: ConstructorParameters): void; +}) : T extends Procedure ? (...args: Parameters) => PartialMaybePromise> : T; +type PartialMock = Mock> : T>>; +type DeepPartial = T extends Procedure ? T : T extends Array ? Array> : T extends object ? { [K in keyof T]?: DeepPartial } : T; +type DeepPartialMaybePromise = T extends Promise> ? Promise>> : DeepPartial; +type DeepPartialResultFunction = T extends Constructable ? ({ + new (...args: ConstructorParameters): InstanceType; +}) | ({ + (this: InstanceType, ...args: ConstructorParameters): void; +}) : T extends Procedure ? (...args: Parameters) => DeepPartialMaybePromise> : T; +type DeepPartialMock = Mock> : T>>; +type MaybeMockedConstructor = T extends Constructable ? Mock : T; +type MockedFunction = Mock & MockedObject; +type PartiallyMockedFunction = PartialMock & MockedObject; +type MockedFunctionDeep = Mock & MockedObjectDeep; +type PartiallyMockedFunctionDeep = DeepPartialMock & MockedObjectDeep; +type MockedObject = MaybeMockedConstructor & { [K in Methods]: T[K] extends Procedure ? MockedFunction : T[K] } & { [K in Properties]: T[K] }; +type MockedObjectDeep = MaybeMockedConstructor & { [K in Methods]: T[K] extends Procedure ? MockedFunctionDeep : T[K] } & { [K in Properties]: MaybeMockedDeep }; +type MaybeMockedDeep = T extends Procedure | Constructable ? MockedFunctionDeep : T extends object ? MockedObjectDeep : T; +type MaybePartiallyMockedDeep = T extends Procedure | Constructable ? PartiallyMockedFunctionDeep : T extends object ? MockedObjectDeep : T; +type MaybeMocked = T extends Procedure | Constructable ? MockedFunction : T extends object ? MockedObject : T; +type MaybePartiallyMocked = T extends Procedure | Constructable ? PartiallyMockedFunction : T extends object ? MockedObject : T; +interface Constructable { + new (...args: any[]): any; +} +type MockedClass = MockInstance & { + prototype: T extends { + prototype: any; + } ? Mocked : never; +} & T; +type Mocked = { [P in keyof T]: T[P] extends Procedure ? MockInstance : T[P] extends Constructable ? MockedClass : T[P] } & T; +interface MockConfig { + mockImplementation: Procedure | Constructable | undefined; + mockOriginal: Procedure | Constructable | undefined; + mockName: string; + onceMockImplementations: Array; +} +interface MockInstanceOption { + originalImplementation?: Procedure | Constructable; + mockImplementation?: Procedure | Constructable; + resetToMockImplementation?: boolean; + restore?: () => void; + prototypeMembers?: (string | symbol)[]; + keepMembersImplementation?: boolean; + prototypeState?: MockContext; + prototypeConfig?: MockConfig; + resetToMockName?: boolean; + name?: string | symbol; +} + +declare function isMockFunction(fn: any): fn is Mock; +declare function createMockInstance(options?: MockInstanceOption): Mock; +declare function fn(originalImplementation?: T): Mock; +type SpyOnValue< + T extends object, + K extends keyof any +> = K extends keyof Required ? Required[K] : (T & Record)[K]; +type SpyOnMethod< + T extends object, + K extends keyof any +> = SpyOnValue extends Constructable | Procedure ? SpyOnValue : never; +type SpyOnMethodKey< + T extends object, + K extends keyof any +> = SpyOnValue extends Constructable | Procedure ? K : never; +declare function spyOn< + T extends object, + S extends Properties> +>(object: T, key: S, accessor: "get"): Mock<() => T[S]>; +declare function spyOn< + T extends object, + G extends Properties> +>(object: T, key: G, accessor: "set"): Mock<(arg: T[G]) => void>; +declare function spyOn< + T extends object, + M extends Classes> | Methods> +>(object: T, key: M): Required[M] extends Constructable | Procedure ? Mock[M]> : never; +declare function spyOn< + T extends object, + K extends keyof any +>(object: T, key: SpyOnMethodKey): Mock>; +declare function restoreAllMocks(): void; +declare function clearAllMocks(): void; +declare function resetAllMocks(): void; + +export { clearAllMocks, createMockInstance, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn }; +export type { Constructable, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MaybePartiallyMocked, MaybePartiallyMockedDeep, Mock, MockContext, MockInstance, MockInstanceOption, MockParameters, MockProcedureContext, MockResult, MockResultIncomplete, MockResultReturn, MockResultThrow, MockReturnType, MockSettledResult, MockSettledResultFulfilled, MockSettledResultIncomplete, MockSettledResultRejected, Mocked, MockedClass, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, PartialMock, PartiallyMockedFunction, PartiallyMockedFunctionDeep, Procedure }; diff --git a/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.js b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.js new file mode 100644 index 00000000..951a545f --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/dist/index.js @@ -0,0 +1,553 @@ +function isMockFunction(fn) { + return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction === true; +} +const MOCK_RESTORE = new Set(); +// Jest keeps the state in a separate WeakMap which is good for memory, +// but it makes the state slower to access and return different values +// if you stored it before calling `mockClear` where it will be recreated +const DIRTY_MOCK_STATES = new Set(); +const addDirtyMock = DIRTY_MOCK_STATES.add.bind(DIRTY_MOCK_STATES); +const REGISTERED_MOCKS = new Set(); +const MOCK_FINALIZER = new FinalizationRegistry((ref) => { + REGISTERED_MOCKS.delete(ref); +}); +const MOCK_CONFIGS = new WeakMap(); +const MOCKS_BY_STATE = new WeakMap(); +function createMockInstance(options = {}) { + const { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options; + if (restore) { + MOCK_RESTORE.add(restore); + } + const config = getDefaultConfig(originalImplementation); + const state = getDefaultState(); + const mock = createMock({ + config, + state, + ...options + }); + const mockLength = (mockImplementation || originalImplementation)?.length ?? 0; + Object.defineProperty(mock, "length", { + writable: true, + enumerable: false, + value: mockLength, + configurable: true + }); + // inherit the default name so it appears in snapshots and logs + // this is used by `vi.spyOn()` for better debugging. + // when `vi.fn()` is called, we just use the default string + if (resetToMockName) { + config.mockName = mock.name || "vi.fn()"; + } + MOCK_CONFIGS.set(mock, config); + MOCKS_BY_STATE.set(state, mock); + const ref = new WeakRef(mock); + REGISTERED_MOCKS.add(ref); + MOCK_FINALIZER.register(mock, ref); + mock._isMockFunction = true; + mock.getMockImplementation = () => { + // Jest only returns `config.mockImplementation` here, + // but we think it makes sense to return what the next function will be called + return config.onceMockImplementations[0] || config.mockImplementation; + }; + // keep the prototype chain in sync with the implementation the next + // construction will use, so it is correct before any `new` call. + // automocked classes are skipped: their methods are pre-mocked + // on `mock.prototype` + const updateMockPrototype = () => { + if (!options.prototypeMembers?.length) { + reparentMockPrototype(mock, config.onceMockImplementations[0] || config.mockImplementation || originalImplementation); + } + }; + Object.defineProperty(mock, "mock", { + configurable: false, + enumerable: true, + writable: false, + value: state + }); + mock.mockImplementation = function mockImplementation(implementation) { + config.mockImplementation = implementation; + updateMockPrototype(); + return mock; + }; + mock.mockImplementationOnce = function mockImplementationOnce(implementation) { + config.onceMockImplementations.push(implementation); + updateMockPrototype(); + return mock; + }; + mock.withImplementation = function withImplementation(implementation, callback) { + const previousImplementation = config.mockImplementation; + const previousOnceImplementations = config.onceMockImplementations; + const reset = () => { + config.mockImplementation = previousImplementation; + config.onceMockImplementations = previousOnceImplementations; + updateMockPrototype(); + }; + config.mockImplementation = implementation; + config.onceMockImplementations = []; + updateMockPrototype(); + const returnValue = callback(); + if (typeof returnValue === "object" && typeof returnValue?.then === "function") { + return returnValue.then(() => { + reset(); + return mock; + }); + } else { + reset(); + } + return mock; + }; + mock.mockReturnThis = function mockReturnThis() { + return mock.mockImplementation(function() { + return this; + }); + }; + mock.mockReturnValue = function mockReturnValue(value) { + return mock.mockImplementation(function() { + if (new.target) { + throwConstructorError("mockReturnValue"); + } + return value; + }); + }; + mock.mockReturnValueOnce = function mockReturnValueOnce(value) { + return mock.mockImplementationOnce(function() { + if (new.target) { + throwConstructorError("mockReturnValueOnce"); + } + return value; + }); + }; + mock.mockThrow = function mockThrow(value) { + // eslint-disable-next-line prefer-arrow-callback + return mock.mockImplementation(function() { + throw value; + }); + }; + mock.mockThrowOnce = function mockThrowOnce(value) { + // eslint-disable-next-line prefer-arrow-callback + return mock.mockImplementationOnce(function() { + throw value; + }); + }; + mock.mockResolvedValue = function mockResolvedValue(value) { + return mock.mockImplementation(function() { + if (new.target) { + throwConstructorError("mockResolvedValue"); + } + return Promise.resolve(value); + }); + }; + mock.mockResolvedValueOnce = function mockResolvedValueOnce(value) { + return mock.mockImplementationOnce(function() { + if (new.target) { + throwConstructorError("mockResolvedValueOnce"); + } + return Promise.resolve(value); + }); + }; + mock.mockRejectedValue = function mockRejectedValue(value) { + return mock.mockImplementation(function() { + if (new.target) { + throwConstructorError("mockRejectedValue"); + } + return Promise.reject(value); + }); + }; + mock.mockRejectedValueOnce = function mockRejectedValueOnce(value) { + return mock.mockImplementationOnce(function() { + if (new.target) { + throwConstructorError("mockRejectedValueOnce"); + } + return Promise.reject(value); + }); + }; + mock.mockClear = function mockClear() { + state.calls = []; + state.contexts = []; + state.instances = []; + state.invocationCallOrder = []; + state.results = []; + state.settledResults = []; + DIRTY_MOCK_STATES.delete(mock); + return mock; + }; + mock.mockReset = function mockReset() { + mock.mockClear(); + config.mockImplementation = resetToMockImplementation ? mockImplementation : undefined; + config.mockName = resetToMockName ? mock.name || "vi.fn()" : "vi.fn()"; + config.onceMockImplementations = []; + updateMockPrototype(); + return mock; + }; + mock.mockRestore = function mockRestore() { + mock.mockReset(); + return restore?.(); + }; + mock.mockName = function mockName(name) { + if (typeof name === "string") { + config.mockName = name; + } + return mock; + }; + mock.getMockName = function getMockName() { + return config.mockName || "vi.fn()"; + }; + if (Symbol.dispose) { + mock[Symbol.dispose] = () => mock.mockRestore(); + } + if (mockImplementation) { + mock.mockImplementation(mockImplementation); + } else { + // vi.spyOn() has no mock implementation, chain the original one + updateMockPrototype(); + } + return mock; +} +function fn(originalImplementation) { + // if the function is already a mock, just return the same function, + // similarly to how vi.spyOn() works + if (originalImplementation != null && isMockFunction(originalImplementation)) { + return originalImplementation; + } + return createMockInstance({ + // we pass this down so getMockImplementation() always returns the value + mockImplementation: originalImplementation, + // special case so that .mockReset() resets the value to + // the the originalImplementation instead of () => undefined + resetToMockImplementation: true + }); +} +function spyOn(object, key, accessor) { + assert(object != null, "The vi.spyOn() function could not find an object to spy upon. The first argument must be defined."); + assert(typeof object === "object" || typeof object === "function", "Vitest cannot spy on a primitive value."); + const [originalDescriptorObject, originalDescriptor] = getDescriptor(object, key) || []; + assert(originalDescriptor || key in object, `The property "${String(key)}" is not defined on the ${typeof object}.`); + let accessType = accessor || "value"; + let ssr = false; + // vite ssr support - actual function is stored inside a getter + if (accessType === "value" && originalDescriptor && originalDescriptor.value == null && originalDescriptor.get) { + accessType = "get"; + ssr = true; + } + let original; + if (originalDescriptor) { + original = originalDescriptor[accessType]; + // weird Proxy edge case where descriptor's value is undefined, + // but there's still a value on the object when called + // https://github.com/vitest-dev/vitest/issues/9439 + if (original == null && accessType === "value") { + original = object[key]; + } + } else if (accessType !== "value") { + original = () => object[key]; + } else { + original = object[key]; + } + const originalImplementation = ssr && original ? original() : original; + const originalType = typeof originalImplementation; + assert( + // allow only functions + originalType === "function" || accessType !== "value" && original == null, + `vi.spyOn() can only spy on a function. Received ${originalType}.` + ); + if (isMockFunction(originalImplementation)) { + return originalImplementation; + } + const reassign = (cb) => { + const { value, ...desc } = originalDescriptor || { + configurable: true, + writable: true + }; + if (accessType !== "value") { + delete desc.writable; + } + desc[accessType] = cb; + Object.defineProperty(object, key, desc); + }; + const restore = () => { + // if method is defined on the prototype, we can just remove it from + // the current object instead of redefining a copy of it + if (originalDescriptorObject !== object) { + Reflect.deleteProperty(object, key); + } else if (originalDescriptor && !original) { + Object.defineProperty(object, key, originalDescriptor); + } else { + reassign(original); + } + }; + const mock = createMockInstance({ + restore, + originalImplementation, + resetToMockName: true + }); + try { + reassign(ssr ? () => mock : mock); + } catch (error) { + if (error instanceof TypeError && Symbol.toStringTag && object[Symbol.toStringTag] === "Module" && (error.message.includes("Cannot redefine property") || error.message.includes("Cannot replace module namespace") || error.message.includes("can't redefine non-configurable property"))) { + throw new TypeError(`Cannot spy on export "${String(key)}". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/mocking/modules#mocking-a-module`, { cause: error }); + } + throw error; + } + return mock; +} +function getDescriptor(obj, method) { + const objDescriptor = Object.getOwnPropertyDescriptor(obj, method); + if (objDescriptor) { + return [obj, objDescriptor]; + } + let currentProto = Object.getPrototypeOf(obj); + while (currentProto !== null) { + const descriptor = Object.getOwnPropertyDescriptor(currentProto, method); + if (descriptor) { + return [currentProto, descriptor]; + } + currentProto = Object.getPrototypeOf(currentProto); + } +} +function assert(condition, message) { + if (!condition) { + throw new Error(message); + } +} +let invocationCallCounter = 1; +function createMock({ state, config, name: mockName, prototypeState, prototypeConfig, keepMembersImplementation, mockImplementation, prototypeMembers = [] }) { + const original = config.mockOriginal; + const pseudoOriginal = mockImplementation; + const name = mockName || original?.name || "Mock"; + const noopImplementation = function() {}; + const prototypeMock = prototypeState && MOCKS_BY_STATE.get(prototypeState); + const namedObject = { + // to keep the name of the function intact +[name]: (function(...args) { + addDirtyMock(namedObject[name]); + if (prototypeMock) { + addDirtyMock(prototypeMock); + } + registerCalls(args, state, prototypeState); + registerInvocationOrder(invocationCallCounter++, state, prototypeState); + const result = { + type: "incomplete", + value: undefined + }; + const settledResult = { + type: "incomplete", + value: undefined + }; + registerResult(result, state, prototypeState); + registerSettledResult(settledResult, state, prototypeState); + const context = new.target ? undefined : this; + const [instanceIndex, instancePrototypeIndex] = registerInstance(context, state, prototypeState); + const [contextIndex, contextPrototypeIndex] = registerContext(context, state, prototypeState); + const implementation = config.onceMockImplementations.shift() || config.mockImplementation || prototypeConfig?.onceMockImplementations.shift() || prototypeConfig?.mockImplementation || original || noopImplementation; + let returnValue; + let thrownValue; + let didThrow = false; + try { + if (new.target) { + // the prototype chain is already prepared when the implementation + // is registered, but a consumed `mockImplementationOnce` can change + // which implementation this construction uses + if (prototypeMembers.length === 0) { + // eslint-disable-next-line ts/no-use-before-define + reparentMockPrototype(mock, implementation === noopImplementation ? undefined : implementation); + } + returnValue = Reflect.construct(implementation, args, new.target); + // jest calls this before the implementation, but we have to resolve this _after_ + // because we cannot do it before the `Reflect.construct` called the custom implementation. + // fortunately, the constructor is always an empty function because `prototypeMethods` + // are only used by the automocker, so this doesn't matter + for (const prop of prototypeMembers) { + const prototypeMock = returnValue[prop]; + // the method was overridden because of inheritance, ignore it + // eslint-disable-next-line ts/no-use-before-define + if (prototypeMock !== mock.prototype[prop]) { + continue; + } + const isMock = isMockFunction(prototypeMock); + const prototypeState = isMock ? prototypeMock.mock : undefined; + const prototypeConfig = isMock ? MOCK_CONFIGS.get(prototypeMock) : undefined; + returnValue[prop] = createMockInstance({ + originalImplementation: keepMembersImplementation ? prototypeConfig?.mockOriginal : undefined, + prototypeState, + prototypeConfig, + keepMembersImplementation + }); + } + } else { + returnValue = implementation.apply(this, args); + } + } catch (error) { + thrownValue = error; + didThrow = true; + if (error instanceof TypeError && error.message.includes("is not a constructor")) { + console.warn(`[vitest] The ${namedObject[name].getMockName()} mock did not use 'function' or 'class' in its implementation, see https://vitest.dev/api/vi#vi-spyon for examples.`); + } + throw error; + } finally { + if (didThrow) { + result.type = "throw"; + result.value = thrownValue; + settledResult.type = "rejected"; + settledResult.value = thrownValue; + } else { + result.type = "return"; + result.value = returnValue; + if (new.target) { + state.contexts[contextIndex - 1] = returnValue; + state.instances[instanceIndex - 1] = returnValue; + if (contextPrototypeIndex != null && prototypeState) { + prototypeState.contexts[contextPrototypeIndex - 1] = returnValue; + } + if (instancePrototypeIndex != null && prototypeState) { + prototypeState.instances[instancePrototypeIndex - 1] = returnValue; + } + } + if (returnValue instanceof Promise) { + returnValue.then((settledValue) => { + settledResult.type = "fulfilled"; + settledResult.value = settledValue; + }, (rejectedValue) => { + settledResult.type = "rejected"; + settledResult.value = rejectedValue; + }); + } else { + settledResult.type = "fulfilled"; + settledResult.value = returnValue; + } + } + } + return returnValue; + }) }; + const mock = namedObject[name]; + const copyPropertiesFrom = original || pseudoOriginal; + if (copyPropertiesFrom) { + copyOriginalStaticProperties(mock, copyPropertiesFrom); + } + return mock; +} +// puts the implementation's prototype behind `mock.prototype` so instances +// see prototype methods both during and after construction, while properties +// assigned on `mock.prototype` still shadow them +function reparentMockPrototype(mock, implementation) { + const mockPrototype = mock.prototype; + if (mockPrototype == null) { + return; + } + // an implementation without a usable prototype (reset mock, arrow or bound + // function) reverts the chain to `Object.prototype`, the parent every mock + // is created with + const parent = implementation?.prototype ?? Object.prototype; + if (mockPrototype !== parent && Object.getPrototypeOf(mockPrototype) !== parent) { + Object.setPrototypeOf(mockPrototype, parent); + } +} +function registerCalls(args, state, prototypeState) { + state.calls.push(args); + prototypeState?.calls.push(args); +} +function registerInvocationOrder(order, state, prototypeState) { + state.invocationCallOrder.push(order); + prototypeState?.invocationCallOrder.push(order); +} +function registerResult(result, state, prototypeState) { + state.results.push(result); + prototypeState?.results.push(result); +} +function registerSettledResult(result, state, prototypeState) { + state.settledResults.push(result); + prototypeState?.settledResults.push(result); +} +function registerInstance(instance, state, prototypeState) { + const instanceIndex = state.instances.push(instance); + const instancePrototypeIndex = prototypeState?.instances.push(instance); + return [instanceIndex, instancePrototypeIndex]; +} +function registerContext(context, state, prototypeState) { + const contextIndex = state.contexts.push(context); + const contextPrototypeIndex = prototypeState?.contexts.push(context); + return [contextIndex, contextPrototypeIndex]; +} +function copyOriginalStaticProperties(mock, original) { + const { properties, descriptors } = getAllProperties(original); + for (const key of properties) { + const descriptor = descriptors[key]; + const mockDescriptor = getDescriptor(mock, key); + if (mockDescriptor) { + continue; + } + Object.defineProperty(mock, key, descriptor); + } +} +const ignoreProperties = new Set([ + "length", + "name", + "prototype", + Symbol.for("nodejs.util.promisify.custom") +]); +function getAllProperties(original) { + const properties = new Set(); + const descriptors = {}; + while (original && original !== Object.prototype && original !== Function.prototype) { + const ownProperties = [...Object.getOwnPropertyNames(original), ...Object.getOwnPropertySymbols(original)]; + for (const prop of ownProperties) { + if (descriptors[prop] || ignoreProperties.has(prop)) { + continue; + } + properties.add(prop); + descriptors[prop] = Object.getOwnPropertyDescriptor(original, prop); + } + original = Object.getPrototypeOf(original); + } + return { + properties, + descriptors + }; +} +function getDefaultConfig(original) { + return { + mockImplementation: undefined, + mockOriginal: original, + mockName: "vi.fn()", + onceMockImplementations: [] + }; +} +function getDefaultState() { + const state = { + calls: [], + contexts: [], + instances: [], + invocationCallOrder: [], + settledResults: [], + results: [], + get lastCall() { + return state.calls.at(-1); + } + }; + return state; +} +function restoreAllMocks() { + for (const restore of MOCK_RESTORE) { + restore(); + } + MOCK_RESTORE.clear(); +} +function clearAllMocks() { + for (const mock of DIRTY_MOCK_STATES) { + mock.mockClear(); + } +} +function resetAllMocks() { + for (const ref of REGISTERED_MOCKS) { + const mock = ref.deref(); + if (mock) { + mock.mockReset(); + } else { + REGISTERED_MOCKS.delete(ref); + } + } +} +function throwConstructorError(shorthand) { + throw new TypeError(`Cannot use \`${shorthand}\` when called with \`new\`. Use \`mockImplementation\` with a \`class\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`); +} + +export { clearAllMocks, createMockInstance, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn }; diff --git a/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/optional-types.d.ts b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/optional-types.d.ts new file mode 100644 index 00000000..ba943366 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/optional-types.d.ts @@ -0,0 +1,6 @@ +/* eslint-disable ts/ban-ts-comment */ + +export interface Disposable { + // @ts-ignore -- Symbol.dispose might not be in user types + [Symbol.dispose]: () => void +} diff --git a/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/package.json b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/package.json new file mode 100644 index 00000000..e9faf686 --- /dev/null +++ b/backend/node_modules/.pnpm/@vitest+spy@5.0.2/node_modules/@vitest/spy/package.json @@ -0,0 +1,46 @@ +{ + "name": "@vitest/spy", + "type": "module", + "version": "5.0.2", + "description": "Lightweight Jest compatible spy implementation", + "license": "MIT", + "funding": "https://opencollective.com/vitest", + "homepage": "https://vitest.dev/api/mock", + "repository": { + "type": "git", + "url": "git+https://github.com/vitest-dev/vitest.git", + "directory": "packages/spy" + }, + "bugs": { + "url": "https://github.com/vitest-dev/vitest/issues" + }, + "keywords": [ + "vitest", + "test", + "mock", + "spy", + "intercept" + ], + "sideEffects": false, + "exports": { + ".": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "./optional-types.js": { + "types": "./optional-types.d.ts" + }, + "./*": "./*" + }, + "main": "./dist/index.js", + "module": "./dist/index.js", + "types": "./dist/index.d.ts", + "files": [ + "dist", + "optional-types.d.ts" + ], + "scripts": { + "build": "premove dist && rollup -c", + "dev": "rollup -c --watch" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/LICENSE b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/LICENSE new file mode 100644 index 00000000..5e9f3ac6 --- /dev/null +++ b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2013 Jake Luer jake@qualiancy.com (http://qualiancy.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/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/README.md b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/README.md new file mode 100644 index 00000000..37c39287 --- /dev/null +++ b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/README.md @@ -0,0 +1,68 @@ +

+ AssertionError and AssertionResult classes. +

+ +

+ + build:? + + downloads:? + + devDependencies:none + +

+ +## What is AssertionError? + +Assertion Error is a module that contains two classes: `AssertionError`, which +is an instance of an `Error`, and `AssertionResult` which is not an instance of +Error. + +These can be useful for returning from a function - if the function "succeeds" +return an `AssertionResult` and if the function fails return (or throw) an +`AssertionError`. + +Both `AssertionError` and `AssertionResult` implement the `Result` interface: + +```typescript +interface Result { + name: "AssertionError" | "AssertionResult"; + ok: boolean; + toJSON(...args: unknown[]): Record; +} +``` + +So if a function returns `AssertionResult | AssertionError` it is easy to check +_which_ one is returned by checking either `.name` or `.ok`, or check +`instanceof Error`. + +## Installation + +### Node.js + +`assertion-error` is available on [npm](http://npmjs.org). + +``` +$ npm install --save assertion-error +``` + +### Deno + +`assertion_error` is available on +[Deno.land](https://deno.land/x/assertion_error) + +```typescript +import { + AssertionError, + AssertionResult, +} from "https://deno.land/x/assertion_error@2.0.0/mod.ts"; +``` diff --git a/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.d.ts b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.d.ts new file mode 100644 index 00000000..d8fda2c7 --- /dev/null +++ b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.d.ts @@ -0,0 +1,27 @@ +interface Result { + name: "AssertionError" | "AssertionResult"; + ok: boolean; + toJSON(...args: unknown[]): Record; +} + +declare class AssertionError extends Error implements Result { + [key: string]: unknown + name: "AssertionError"; + ok: false; + message: string; + // deno-lint-ignore ban-types + constructor(message: string, props?: T, ssf?: Function); + stack: string; + toJSON(stack?: boolean): Record; +} + +declare class AssertionResult implements Result { + [key: string]: unknown + name: "AssertionResult"; + ok: true; + message: string; + constructor(props?: T); + toJSON(): Record; +} + +export { AssertionError, AssertionResult, Result }; diff --git a/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.js b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.js new file mode 100644 index 00000000..2bfcb81e --- /dev/null +++ b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/index.js @@ -0,0 +1,60 @@ +// deno-fmt-ignore-file +// deno-lint-ignore-file +// This code was bundled using `deno bundle` and it's not recommended to edit it manually + +const canElideFrames = "captureStackTrace" in Error; +class AssertionError extends Error { + message; + get name() { + return "AssertionError"; + } + get ok() { + return false; + } + constructor(message = "Unspecified AssertionError", props, ssf){ + super(message); + this.message = message; + if (canElideFrames) { + Error.captureStackTrace(this, ssf || AssertionError); + } + for(const key in props){ + if (!(key in this)) { + this[key] = props[key]; + } + } + } + toJSON(stack) { + return { + ...this, + name: this.name, + message: this.message, + ok: false, + stack: stack !== false ? this.stack : undefined + }; + } +} +class AssertionResult { + get name() { + return "AssertionResult"; + } + get ok() { + return true; + } + constructor(props){ + for(const key in props){ + if (!(key in this)) { + this[key] = props[key]; + } + } + } + toJSON() { + return { + ...this, + name: this.name, + ok: this.ok + }; + } +} +export { AssertionError as AssertionError }; +export { AssertionResult as AssertionResult }; + diff --git a/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/package.json b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/package.json new file mode 100644 index 00000000..02dc0f5b --- /dev/null +++ b/backend/node_modules/.pnpm/assertion-error@2.0.1/node_modules/assertion-error/package.json @@ -0,0 +1,32 @@ +{ + "name": "assertion-error", + "version": "2.0.1", + "description": "Error constructor for test and validation frameworks that implements standardized AssertionError specification.", + "author": "Jake Luer (http://qualiancy.com)", + "license": "MIT", + "types": "./index.d.ts", + "keywords": [ + "test", + "assertion", + "assertion-error" + ], + "repository": { + "type": "git", + "url": "git@github.com:chaijs/assertion-error.git" + }, + "engines": { + "node": ">=12" + }, + "files": [ + "index.d.ts" + ], + "type": "module", + "module": "index.js", + "main": "index.js", + "scripts": { + "build": "deno bundle mod.ts > index.js", + "pretest": "rm -rf coverage/", + "test": "deno test --coverage=coverage", + "posttest": "deno coverage coverage --lcov > coverage/lcov.info && lcov --summary coverage/lcov.info" + } +} diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/LICENSE b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/LICENSE new file mode 100644 index 00000000..eedbe238 --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Chai.js Assertion Library + +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/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/README.md b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/README.md new file mode 100644 index 00000000..9382e24f --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/README.md @@ -0,0 +1,162 @@ +

+ + ChaiJS + +
+ chai +

+ +

+ Chai is a BDD / TDD assertion library for node and the browser that can be delightfully paired with any javascript testing framework. +

+ +

+ + downloads:? + + + node:? + +
+ + Join the Slack chat + + + Join the Gitter chat + + + OpenCollective Backers + +

+ +For more information or to download plugins, view the [documentation](http://chaijs.com). + +## What is Chai? + +Chai is an _assertion library_, similar to Node's built-in `assert`. It makes testing much easier by giving you lots of assertions you can run against your code. + +## Installation + +### Node.js + +`chai` is available on [npm](http://npmjs.org). To install it, type: + + $ npm install --save-dev chai + +### Browsers + +You can also use it within the browser; install via npm and use the `index.js` file found within the download. For example: + +```html + +``` + +## Usage + +Import the library in your code, and then pick one of the styles you'd like to use - either `assert`, `expect` or `should`: + +```js +import { assert } from 'chai'; // Using Assert style +import { expect } from 'chai'; // Using Expect style +import { should } from 'chai'; // Using Should style +``` + +### Register the chai testing style globally + +```js +import 'chai/register-assert'; // Using Assert style +import 'chai/register-expect'; // Using Expect style +import 'chai/register-should'; // Using Should style +``` + +### Import assertion styles as local variables + +```js +import { assert } from 'chai'; // Using Assert style +import { expect } from 'chai'; // Using Expect style +import { should } from 'chai'; // Using Should style +should(); // Modifies `Object.prototype` + +import { expect, use } from 'chai'; // Creates local variables `expect` and `use`; useful for plugin use +``` + +### Usage with Mocha + +```bash +mocha spec.js --require chai/register-assert.js # Using Assert style +mocha spec.js --require chai/register-expect.js # Using Expect style +mocha spec.js --require chai/register-should.js # Using Should style +``` + +[Read more about these styles in our docs](http://chaijs.com/guide/styles/). + +## Plugins + +Chai offers a robust Plugin architecture for extending Chai's assertions and interfaces. + +- Need a plugin? View the [official plugin list](http://chaijs.com/plugins). +- Want to build a plugin? Read the [plugin api documentation](http://chaijs.com/guide/plugins/). +- Have a plugin and want it listed? Simply add the following keywords to your package.json: + - `chai-plugin` + - `browser` if your plugin works in the browser as well as Node.js + - `browser-only` if your plugin does not work with Node.js + +### Related Projects + +- [chaijs / chai-docs](https://github.com/chaijs/chai-docs): The chaijs.com website source code. +- [chaijs / assertion-error](https://github.com/chaijs/assertion-error): Custom `Error` constructor thrown upon an assertion failing. +- [chaijs / deep-eql](https://github.com/chaijs/deep-eql): Improved deep equality testing for Node.js and the browser. +- [chaijs / check-error](https://github.com/chaijs/check-error): Error comparison and information related utility for Node.js and the browser. +- [chaijs / loupe](https://github.com/chaijs/loupe): Inspect utility for Node.js and browsers. +- [chaijs / pathval](https://github.com/chaijs/pathval): Object value retrieval given a string path. + +### Contributing + +Thank you very much for considering to contribute! + +Please make sure you follow our [Code Of Conduct](https://github.com/chaijs/chai/blob/master/CODE_OF_CONDUCT.md) and we also strongly recommend reading our [Contributing Guide](https://github.com/chaijs/chai/blob/master/CONTRIBUTING.md). + +Here are a few issues other contributors frequently ran into when opening pull requests: + +- Please do not commit changes to the `chai.js` build. We do it once per release. +- Before pushing your commits, please make sure you [rebase](https://github.com/chaijs/chai/blob/master/CONTRIBUTING.md#pull-requests) them. + +### Contributors + +Please see the full +[Contributors Graph](https://github.com/chaijs/chai/graphs/contributors) for our +list of contributors. + +### Core Contributors + +Feel free to reach out to any of the core contributors with your questions or +concerns. We will do our best to respond in a timely manner. + +[![Keith Cirkel](https://avatars3.githubusercontent.com/u/118266?v=3&s=50)](https://github.com/keithamus) +[![James Garbutt](https://avatars3.githubusercontent.com/u/5677153?v=3&s=50)](https://github.com/43081j) +[![Kristján Oddsson](https://avatars3.githubusercontent.com/u/318208?v=3&s=50)](https://github.com/koddsson) + +### Core Contributor Alumni + +This project would not be what it is without the contributions from our prior +core contributors, for whom we are forever grateful: + +[![Jake Luer](https://avatars3.githubusercontent.com/u/58988?v=3&s=50)](https://github.com/logicalparadox) +[![Veselin Todorov](https://avatars3.githubusercontent.com/u/330048?v=3&s=50)](https://github.com/vesln) +[![Lucas Fernandes da Costa](https://avatars3.githubusercontent.com/u/6868147?v=3&s=50)](https://github.com/lucasfcosta) +[![Grant Snodgrass](https://avatars3.githubusercontent.com/u/17260989?v=3&s=50)](https://github.com/meeber) diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/index.js b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/index.js new file mode 100644 index 00000000..601eb535 --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/index.js @@ -0,0 +1,4172 @@ +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + +// lib/chai/utils/index.js +var utils_exports = {}; +__export(utils_exports, { + addChainableMethod: () => addChainableMethod, + addLengthGuard: () => addLengthGuard, + addMethod: () => addMethod, + addProperty: () => addProperty, + checkError: () => check_error_exports, + compareByInspect: () => compareByInspect, + eql: () => deep_eql_default, + events: () => events, + expectTypes: () => expectTypes, + flag: () => flag, + getActual: () => getActual, + getMessage: () => getMessage2, + getName: () => getName, + getOperator: () => getOperator, + getOwnEnumerableProperties: () => getOwnEnumerableProperties, + getOwnEnumerablePropertySymbols: () => getOwnEnumerablePropertySymbols, + getPathInfo: () => getPathInfo, + hasProperty: () => hasProperty, + inspect: () => inspect2, + isNaN: () => isNaN2, + isNumeric: () => isNumeric, + isProxyEnabled: () => isProxyEnabled, + isRegExp: () => isRegExp2, + objDisplay: () => objDisplay, + overwriteChainableMethod: () => overwriteChainableMethod, + overwriteMethod: () => overwriteMethod, + overwriteProperty: () => overwriteProperty, + proxify: () => proxify, + test: () => test, + transferFlags: () => transferFlags, + type: () => type +}); + +// node_modules/check-error/index.js +var check_error_exports = {}; +__export(check_error_exports, { + compatibleConstructor: () => compatibleConstructor, + compatibleInstance: () => compatibleInstance, + compatibleMessage: () => compatibleMessage, + getConstructorName: () => getConstructorName, + getMessage: () => getMessage +}); +function isErrorInstance(obj) { + return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]"; +} +__name(isErrorInstance, "isErrorInstance"); +function isRegExp(obj) { + return Object.prototype.toString.call(obj) === "[object RegExp]"; +} +__name(isRegExp, "isRegExp"); +function compatibleInstance(thrown, errorLike) { + return isErrorInstance(errorLike) && thrown === errorLike; +} +__name(compatibleInstance, "compatibleInstance"); +function compatibleConstructor(thrown, errorLike) { + if (isErrorInstance(errorLike)) { + return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor; + } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) { + return thrown.constructor === errorLike || thrown instanceof errorLike; + } + return false; +} +__name(compatibleConstructor, "compatibleConstructor"); +function compatibleMessage(thrown, errMatcher) { + const comparisonString = typeof thrown === "string" ? thrown : thrown.message; + if (isRegExp(errMatcher)) { + return errMatcher.test(comparisonString); + } else if (typeof errMatcher === "string") { + return comparisonString.indexOf(errMatcher) !== -1; + } + return false; +} +__name(compatibleMessage, "compatibleMessage"); +function getConstructorName(errorLike) { + let constructorName = errorLike; + if (isErrorInstance(errorLike)) { + constructorName = errorLike.constructor.name; + } else if (typeof errorLike === "function") { + constructorName = errorLike.name; + if (constructorName === "") { + const newConstructorName = new errorLike().name; + constructorName = newConstructorName || constructorName; + } + } + return constructorName; +} +__name(getConstructorName, "getConstructorName"); +function getMessage(errorLike) { + let msg = ""; + if (errorLike && errorLike.message) { + msg = errorLike.message; + } else if (typeof errorLike === "string") { + msg = errorLike; + } + return msg; +} +__name(getMessage, "getMessage"); + +// lib/chai/utils/flag.js +function flag(obj, key, value) { + let flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null)); + if (arguments.length === 3) { + flags[key] = value; + } else { + return flags[key]; + } +} +__name(flag, "flag"); + +// lib/chai/utils/test.js +function test(obj, args) { + let negate = flag(obj, "negate"), expr = args[0]; + return negate ? !expr : expr; +} +__name(test, "test"); + +// lib/chai/utils/type-detect.js +function type(obj) { + if (typeof obj === "undefined") { + return "undefined"; + } + if (obj === null) { + return "null"; + } + const stringTag = obj[Symbol.toStringTag]; + if (typeof stringTag === "string") { + return stringTag; + } + const type3 = Object.prototype.toString.call(obj).slice(8, -1); + return type3; +} +__name(type, "type"); + +// node_modules/assertion-error/index.js +var canElideFrames = "captureStackTrace" in Error; +var _AssertionError = class _AssertionError extends Error { + constructor(message = "Unspecified AssertionError", props, ssf) { + super(message); + __publicField(this, "message"); + this.message = message; + if (canElideFrames) { + Error.captureStackTrace(this, ssf || _AssertionError); + } + for (const key in props) { + if (!(key in this)) { + this[key] = props[key]; + } + } + } + get name() { + return "AssertionError"; + } + get ok() { + return false; + } + toJSON(stack) { + return { + ...this, + name: this.name, + message: this.message, + ok: false, + stack: stack !== false ? this.stack : void 0 + }; + } +}; +__name(_AssertionError, "AssertionError"); +var AssertionError = _AssertionError; + +// lib/chai/utils/expectTypes.js +function expectTypes(obj, types) { + let flagMsg = flag(obj, "message"); + let ssfi = flag(obj, "ssfi"); + flagMsg = flagMsg ? flagMsg + ": " : ""; + obj = flag(obj, "object"); + types = types.map(function(t) { + return t.toLowerCase(); + }); + types.sort(); + let str = types.map(function(t, index) { + let art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a"; + let or = types.length > 1 && index === types.length - 1 ? "or " : ""; + return or + art + " " + t; + }).join(", "); + let objType = type(obj).toLowerCase(); + if (!types.some(function(expected) { + return objType === expected; + })) { + throw new AssertionError( + flagMsg + "object tested must be " + str + ", but " + objType + " given", + void 0, + ssfi + ); + } +} +__name(expectTypes, "expectTypes"); + +// lib/chai/utils/getActual.js +function getActual(obj, args) { + return args.length > 4 ? args[4] : obj._obj; +} +__name(getActual, "getActual"); + +// node_modules/loupe/lib/helpers.js +var ansiColors = { + bold: ["1", "22"], + dim: ["2", "22"], + italic: ["3", "23"], + underline: ["4", "24"], + // 5 & 6 are blinking + inverse: ["7", "27"], + hidden: ["8", "28"], + strike: ["9", "29"], + // 10-20 are fonts + // 21-29 are resets for 1-9 + black: ["30", "39"], + red: ["31", "39"], + green: ["32", "39"], + yellow: ["33", "39"], + blue: ["34", "39"], + magenta: ["35", "39"], + cyan: ["36", "39"], + white: ["37", "39"], + brightblack: ["30;1", "39"], + brightred: ["31;1", "39"], + brightgreen: ["32;1", "39"], + brightyellow: ["33;1", "39"], + brightblue: ["34;1", "39"], + brightmagenta: ["35;1", "39"], + brightcyan: ["36;1", "39"], + brightwhite: ["37;1", "39"], + grey: ["90", "39"] +}; +var styles = { + special: "cyan", + number: "yellow", + bigint: "yellow", + boolean: "yellow", + undefined: "grey", + null: "bold", + string: "green", + symbol: "green", + date: "magenta", + regexp: "red" +}; +var truncator = "\u2026"; +function colorise(value, styleType) { + const color = ansiColors[styles[styleType]] || ansiColors[styleType] || ""; + if (!color) { + return String(value); + } + return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`; +} +__name(colorise, "colorise"); +function normaliseOptions({ + showHidden = false, + depth = 2, + colors = false, + customInspect = true, + showProxy = false, + maxArrayLength = Infinity, + breakLength = Infinity, + seen = [], + // eslint-disable-next-line no-shadow + truncate: truncate2 = Infinity, + stylize = String +} = {}, inspect3) { + const options = { + showHidden: Boolean(showHidden), + depth: Number(depth), + colors: Boolean(colors), + customInspect: Boolean(customInspect), + showProxy: Boolean(showProxy), + maxArrayLength: Number(maxArrayLength), + breakLength: Number(breakLength), + truncate: Number(truncate2), + seen, + inspect: inspect3, + stylize + }; + if (options.colors) { + options.stylize = colorise; + } + return options; +} +__name(normaliseOptions, "normaliseOptions"); +function isHighSurrogate(char) { + return char >= "\uD800" && char <= "\uDBFF"; +} +__name(isHighSurrogate, "isHighSurrogate"); +function truncate(string, length, tail = truncator) { + string = String(string); + const tailLength = tail.length; + const stringLength = string.length; + if (tailLength > length && stringLength > tailLength) { + return tail; + } + if (stringLength > length && stringLength > tailLength) { + let end = length - tailLength; + if (end > 0 && isHighSurrogate(string[end - 1])) { + end = end - 1; + } + return `${string.slice(0, end)}${tail}`; + } + return string; +} +__name(truncate, "truncate"); +function inspectList(list, options, inspectItem, separator = ", ") { + inspectItem = inspectItem || options.inspect; + const size = list.length; + if (size === 0) + return ""; + const originalLength = options.truncate; + let output = ""; + let peek = ""; + let truncated = ""; + for (let i = 0; i < size; i += 1) { + const last = i + 1 === list.length; + const secondToLast = i + 2 === list.length; + truncated = `${truncator}(${list.length - i})`; + const value = list[i]; + options.truncate = originalLength - output.length - (last ? 0 : separator.length); + const string = peek || inspectItem(value, options) + (last ? "" : separator); + const nextLength = output.length + string.length; + const truncatedLength = nextLength + truncated.length; + if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) { + break; + } + if (!last && !secondToLast && truncatedLength > originalLength) { + break; + } + peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator); + if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) { + break; + } + output += string; + if (!last && !secondToLast && nextLength + peek.length >= originalLength) { + truncated = `${truncator}(${list.length - i - 1})`; + break; + } + truncated = ""; + } + return `${output}${truncated}`; +} +__name(inspectList, "inspectList"); +function quoteComplexKey(key) { + if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) { + return key; + } + return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"); +} +__name(quoteComplexKey, "quoteComplexKey"); +function inspectProperty([key, value], options) { + options.truncate -= 2; + if (typeof key === "string") { + key = quoteComplexKey(key); + } else if (typeof key !== "number") { + key = `[${options.inspect(key, options)}]`; + } + options.truncate -= key.length; + value = options.inspect(value, options); + return `${key}: ${value}`; +} +__name(inspectProperty, "inspectProperty"); + +// node_modules/loupe/lib/array.js +function inspectArray(array, options) { + const nonIndexProperties = Object.keys(array).slice(array.length); + if (!array.length && !nonIndexProperties.length) + return "[]"; + options.truncate -= 4; + const listContents = inspectList(array, options); + options.truncate -= listContents.length; + let propertyContents = ""; + if (nonIndexProperties.length) { + propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty); + } + return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`; +} +__name(inspectArray, "inspectArray"); + +// node_modules/loupe/lib/typedarray.js +var getArrayName = /* @__PURE__ */ __name((array) => { + if (typeof Buffer === "function" && array instanceof Buffer) { + return "Buffer"; + } + if (array[Symbol.toStringTag]) { + return array[Symbol.toStringTag]; + } + return array.constructor.name; +}, "getArrayName"); +function inspectTypedArray(array, options) { + const name = getArrayName(array); + options.truncate -= name.length + 4; + const nonIndexProperties = Object.keys(array).slice(array.length); + if (!array.length && !nonIndexProperties.length) + return `${name}[]`; + let output = ""; + for (let i = 0; i < array.length; i++) { + const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`; + options.truncate -= string.length; + if (array[i] !== array.length && options.truncate <= 3) { + output += `${truncator}(${array.length - array[i] + 1})`; + break; + } + output += string; + } + let propertyContents = ""; + if (nonIndexProperties.length) { + propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty); + } + return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`; +} +__name(inspectTypedArray, "inspectTypedArray"); + +// node_modules/loupe/lib/date.js +function inspectDate(dateObject, options) { + const stringRepresentation = dateObject.toJSON(); + if (stringRepresentation === null) { + return "Invalid Date"; + } + const split = stringRepresentation.split("T"); + const date = split[0]; + return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date"); +} +__name(inspectDate, "inspectDate"); + +// node_modules/loupe/lib/function.js +function inspectFunction(func, options) { + const functionType = func[Symbol.toStringTag] || "Function"; + const name = func.name; + if (!name) { + return options.stylize(`[${functionType}]`, "special"); + } + return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special"); +} +__name(inspectFunction, "inspectFunction"); + +// node_modules/loupe/lib/map.js +function inspectMapEntry([key, value], options) { + options.truncate -= 4; + key = options.inspect(key, options); + options.truncate -= key.length; + value = options.inspect(value, options); + return `${key} => ${value}`; +} +__name(inspectMapEntry, "inspectMapEntry"); +function mapToEntries(map) { + const entries = []; + map.forEach((value, key) => { + entries.push([key, value]); + }); + return entries; +} +__name(mapToEntries, "mapToEntries"); +function inspectMap(map, options) { + if (map.size === 0) + return "Map{}"; + options.truncate -= 7; + return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`; +} +__name(inspectMap, "inspectMap"); + +// node_modules/loupe/lib/number.js +var isNaN = Number.isNaN || ((i) => i !== i); +function inspectNumber(number, options) { + if (isNaN(number)) { + return options.stylize("NaN", "number"); + } + if (number === Infinity) { + return options.stylize("Infinity", "number"); + } + if (number === -Infinity) { + return options.stylize("-Infinity", "number"); + } + if (number === 0) { + return options.stylize(1 / number === Infinity ? "+0" : "-0", "number"); + } + return options.stylize(truncate(String(number), options.truncate), "number"); +} +__name(inspectNumber, "inspectNumber"); + +// node_modules/loupe/lib/bigint.js +function inspectBigInt(number, options) { + let nums = truncate(number.toString(), options.truncate - 1); + if (nums !== truncator) + nums += "n"; + return options.stylize(nums, "bigint"); +} +__name(inspectBigInt, "inspectBigInt"); + +// node_modules/loupe/lib/regexp.js +function inspectRegExp(value, options) { + const flags = value.toString().split("/")[2]; + const sourceLength = options.truncate - (2 + flags.length); + const source = value.source; + return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp"); +} +__name(inspectRegExp, "inspectRegExp"); + +// node_modules/loupe/lib/set.js +function arrayFromSet(set2) { + const values = []; + set2.forEach((value) => { + values.push(value); + }); + return values; +} +__name(arrayFromSet, "arrayFromSet"); +function inspectSet(set2, options) { + if (set2.size === 0) + return "Set{}"; + options.truncate -= 7; + return `Set{ ${inspectList(arrayFromSet(set2), options)} }`; +} +__name(inspectSet, "inspectSet"); + +// node_modules/loupe/lib/string.js +var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g"); +var escapeCharacters = { + "\b": "\\b", + " ": "\\t", + "\n": "\\n", + "\f": "\\f", + "\r": "\\r", + "'": "\\'", + "\\": "\\\\" +}; +var hex = 16; +var unicodeLength = 4; +function escape(char) { + return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`; +} +__name(escape, "escape"); +function inspectString(string, options) { + if (stringEscapeChars.test(string)) { + string = string.replace(stringEscapeChars, escape); + } + return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string"); +} +__name(inspectString, "inspectString"); + +// node_modules/loupe/lib/symbol.js +function inspectSymbol(value) { + if ("description" in Symbol.prototype) { + return value.description ? `Symbol(${value.description})` : "Symbol()"; + } + return value.toString(); +} +__name(inspectSymbol, "inspectSymbol"); + +// node_modules/loupe/lib/promise.js +var getPromiseValue = /* @__PURE__ */ __name(() => "Promise{\u2026}", "getPromiseValue"); +var promise_default = getPromiseValue; + +// node_modules/loupe/lib/object.js +function inspectObject(object, options) { + const properties = Object.getOwnPropertyNames(object); + const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []; + if (properties.length === 0 && symbols.length === 0) { + return "{}"; + } + options.truncate -= 4; + options.seen = options.seen || []; + if (options.seen.includes(object)) { + return "[Circular]"; + } + options.seen.push(object); + const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty); + const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty); + options.seen.pop(); + let sep = ""; + if (propertyContents && symbolContents) { + sep = ", "; + } + return `{ ${propertyContents}${sep}${symbolContents} }`; +} +__name(inspectObject, "inspectObject"); + +// node_modules/loupe/lib/class.js +var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false; +function inspectClass(value, options) { + let name = ""; + if (toStringTag && toStringTag in value) { + name = value[toStringTag]; + } + name = name || value.constructor.name; + if (!name || name === "_class") { + name = ""; + } + options.truncate -= name.length; + return `${name}${inspectObject(value, options)}`; +} +__name(inspectClass, "inspectClass"); + +// node_modules/loupe/lib/arguments.js +function inspectArguments(args, options) { + if (args.length === 0) + return "Arguments[]"; + options.truncate -= 13; + return `Arguments[ ${inspectList(args, options)} ]`; +} +__name(inspectArguments, "inspectArguments"); + +// node_modules/loupe/lib/error.js +var errorKeys = [ + "stack", + "line", + "column", + "name", + "message", + "fileName", + "lineNumber", + "columnNumber", + "number", + "description", + "cause" +]; +function inspectObject2(error, options) { + const properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1); + const name = error.name; + options.truncate -= name.length; + let message = ""; + if (typeof error.message === "string") { + message = truncate(error.message, options.truncate); + } else { + properties.unshift("message"); + } + message = message ? `: ${message}` : ""; + options.truncate -= message.length + 5; + options.seen = options.seen || []; + if (options.seen.includes(error)) { + return "[Circular]"; + } + options.seen.push(error); + const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty); + return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`; +} +__name(inspectObject2, "inspectObject"); + +// node_modules/loupe/lib/html.js +function inspectAttribute([key, value], options) { + options.truncate -= 3; + if (!value) { + return `${options.stylize(String(key), "yellow")}`; + } + return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`; +} +__name(inspectAttribute, "inspectAttribute"); +function inspectNodeCollection(collection, options) { + return inspectList(collection, options, inspectNode, "\n"); +} +__name(inspectNodeCollection, "inspectNodeCollection"); +function inspectNode(node, options) { + switch (node.nodeType) { + case 1: + return inspectHTML(node, options); + case 3: + return options.inspect(node.data, options); + default: + return options.inspect(node, options); + } +} +__name(inspectNode, "inspectNode"); +function inspectHTML(element, options) { + const properties = element.getAttributeNames(); + const name = element.tagName.toLowerCase(); + const head = options.stylize(`<${name}`, "special"); + const headClose = options.stylize(`>`, "special"); + const tail = options.stylize(``, "special"); + options.truncate -= name.length * 2 + 5; + let propertyContents = ""; + if (properties.length > 0) { + propertyContents += " "; + propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " "); + } + options.truncate -= propertyContents.length; + const truncate2 = options.truncate; + let children = inspectNodeCollection(element.children, options); + if (children && children.length > truncate2) { + children = `${truncator}(${element.children.length})`; + } + return `${head}${propertyContents}${headClose}${children}${tail}`; +} +__name(inspectHTML, "inspectHTML"); + +// node_modules/loupe/lib/index.js +var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function"; +var chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect"; +var nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"); +var constructorMap = /* @__PURE__ */ new WeakMap(); +var stringTagMap = {}; +var baseTypesMap = { + undefined: /* @__PURE__ */ __name((value, options) => options.stylize("undefined", "undefined"), "undefined"), + null: /* @__PURE__ */ __name((value, options) => options.stylize("null", "null"), "null"), + boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "boolean"), + Boolean: /* @__PURE__ */ __name((value, options) => options.stylize(String(value), "boolean"), "Boolean"), + number: inspectNumber, + Number: inspectNumber, + bigint: inspectBigInt, + BigInt: inspectBigInt, + string: inspectString, + String: inspectString, + function: inspectFunction, + Function: inspectFunction, + symbol: inspectSymbol, + // A Symbol polyfill will return `Symbol` not `symbol` from typedetect + Symbol: inspectSymbol, + Array: inspectArray, + Date: inspectDate, + Map: inspectMap, + Set: inspectSet, + RegExp: inspectRegExp, + Promise: promise_default, + // WeakSet, WeakMap are totally opaque to us + WeakSet: /* @__PURE__ */ __name((value, options) => options.stylize("WeakSet{\u2026}", "special"), "WeakSet"), + WeakMap: /* @__PURE__ */ __name((value, options) => options.stylize("WeakMap{\u2026}", "special"), "WeakMap"), + Arguments: inspectArguments, + Int8Array: inspectTypedArray, + Uint8Array: inspectTypedArray, + Uint8ClampedArray: inspectTypedArray, + Int16Array: inspectTypedArray, + Uint16Array: inspectTypedArray, + Int32Array: inspectTypedArray, + Uint32Array: inspectTypedArray, + Float32Array: inspectTypedArray, + Float64Array: inspectTypedArray, + Generator: /* @__PURE__ */ __name(() => "", "Generator"), + DataView: /* @__PURE__ */ __name(() => "", "DataView"), + ArrayBuffer: /* @__PURE__ */ __name(() => "", "ArrayBuffer"), + Error: inspectObject2, + HTMLCollection: inspectNodeCollection, + NodeList: inspectNodeCollection +}; +var inspectCustom = /* @__PURE__ */ __name((value, options, type3, inspectFn) => { + if (chaiInspect in value && typeof value[chaiInspect] === "function") { + return value[chaiInspect](options); + } + if (nodeInspect in value && typeof value[nodeInspect] === "function") { + return value[nodeInspect](options.depth, options, inspectFn); + } + if ("inspect" in value && typeof value.inspect === "function") { + return value.inspect(options.depth, options); + } + if ("constructor" in value && constructorMap.has(value.constructor)) { + return constructorMap.get(value.constructor)(value, options); + } + if (stringTagMap[type3]) { + return stringTagMap[type3](value, options); + } + return ""; +}, "inspectCustom"); +var toString = Object.prototype.toString; +function inspect(value, opts = {}) { + const options = normaliseOptions(opts, inspect); + const { customInspect } = options; + let type3 = value === null ? "null" : typeof value; + if (type3 === "object") { + type3 = toString.call(value).slice(8, -1); + } + if (type3 in baseTypesMap) { + return baseTypesMap[type3](value, options); + } + if (customInspect && value) { + const output = inspectCustom(value, options, type3, inspect); + if (output) { + if (typeof output === "string") + return output; + return inspect(output, options); + } + } + const proto = value ? Object.getPrototypeOf(value) : false; + if (proto === Object.prototype || proto === null) { + return inspectObject(value, options); + } + if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) { + return inspectHTML(value, options); + } + if ("constructor" in value) { + if (value.constructor !== Object) { + return inspectClass(value, options); + } + return inspectObject(value, options); + } + if (value === Object(value)) { + return inspectObject(value, options); + } + return options.stylize(String(value), type3); +} +__name(inspect, "inspect"); + +// lib/chai/config.js +var config = { + /** + * ### config.includeStack + * + * User configurable property, influences whether stack trace + * is included in Assertion error message. Default of false + * suppresses stack trace in the error message. + * + * chai.config.includeStack = true; // enable stack on error + * + * @param {boolean} + * @public + */ + includeStack: false, + /** + * ### config.showDiff + * + * User configurable property, influences whether or not + * the `showDiff` flag should be included in the thrown + * AssertionErrors. `false` will always be `false`; `true` + * will be true when the assertion has requested a diff + * be shown. + * + * @param {boolean} + * @public + */ + showDiff: true, + /** + * ### config.truncateThreshold + * + * User configurable property, sets length threshold for actual and + * expected values in assertion errors. If this threshold is exceeded, for + * example for large data structures, the value is replaced with something + * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`. + * + * Set it to zero if you want to disable truncating altogether. + * + * This is especially userful when doing assertions on arrays: having this + * set to a reasonable large value makes the failure messages readily + * inspectable. + * + * chai.config.truncateThreshold = 0; // disable truncating + * + * @param {number} + * @public + */ + truncateThreshold: 40, + /** + * ### config.useProxy + * + * User configurable property, defines if chai will use a Proxy to throw + * an error when a non-existent property is read, which protects users + * from typos when using property-based assertions. + * + * Set it to false if you want to disable this feature. + * + * chai.config.useProxy = false; // disable use of Proxy + * + * This feature is automatically disabled regardless of this config value + * in environments that don't support proxies. + * + * @param {boolean} + * @public + */ + useProxy: true, + /** + * ### config.proxyExcludedKeys + * + * User configurable property, defines which properties should be ignored + * instead of throwing an error if they do not exist on the assertion. + * This is only applied if the environment Chai is running in supports proxies and + * if the `useProxy` configuration setting is enabled. + * By default, `then` and `inspect` will not throw an error if they do not exist on the + * assertion object because the `.inspect` property is read by `util.inspect` (for example, when + * using `console.log` on the assertion object) and `.then` is necessary for promise type-checking. + * + * // By default these keys will not throw an error if they do not exist on the assertion object + * chai.config.proxyExcludedKeys = ['then', 'inspect']; + * + * @param {Array} + * @public + */ + proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"], + /** + * ### config.deepEqual + * + * User configurable property, defines which a custom function to use for deepEqual + * comparisons. + * By default, the function used is the one from the `deep-eql` package without custom comparator. + * + * // use a custom comparator + * chai.config.deepEqual = (expected, actual) => { + * return chai.util.eql(expected, actual, { + * comparator: (expected, actual) => { + * // for non number comparison, use the default behavior + * if(typeof expected !== 'number') return null; + * // allow a difference of 10 between compared numbers + * return typeof actual === 'number' && Math.abs(actual - expected) < 10 + * } + * }) + * }; + * + * @param {Function} + * @public + */ + deepEqual: null +}; + +// lib/chai/utils/inspect.js +function inspect2(obj, showHidden, depth, colors) { + let options = { + colors, + depth: typeof depth === "undefined" ? 2 : depth, + showHidden, + truncate: config.truncateThreshold ? config.truncateThreshold : Infinity + }; + return inspect(obj, options); +} +__name(inspect2, "inspect"); + +// lib/chai/utils/objDisplay.js +function objDisplay(obj) { + let str = inspect2(obj), type3 = Object.prototype.toString.call(obj); + if (config.truncateThreshold && str.length >= config.truncateThreshold) { + if (type3 === "[object Function]") { + return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]"; + } else if (type3 === "[object Array]") { + return "[ Array(" + obj.length + ") ]"; + } else if (type3 === "[object Object]") { + let keys = Object.keys(obj), kstr = keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", "); + return "{ Object (" + kstr + ") }"; + } else { + return str; + } + } else { + return str; + } +} +__name(objDisplay, "objDisplay"); + +// lib/chai/utils/getMessage.js +function getMessage2(obj, args) { + let negate = flag(obj, "negate"); + let val = flag(obj, "object"); + let expected = args[3]; + let actual = getActual(obj, args); + let msg = negate ? args[2] : args[1]; + let flagMsg = flag(obj, "message"); + if (typeof msg === "function") msg = msg(); + msg = msg || ""; + msg = msg.replace(/#\{this\}/g, function() { + return objDisplay(val); + }).replace(/#\{act\}/g, function() { + return objDisplay(actual); + }).replace(/#\{exp\}/g, function() { + return objDisplay(expected); + }); + return flagMsg ? flagMsg + ": " + msg : msg; +} +__name(getMessage2, "getMessage"); + +// lib/chai/utils/transferFlags.js +function transferFlags(assertion, object, includeAll) { + let flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null)); + if (!object.__flags) { + object.__flags = /* @__PURE__ */ Object.create(null); + } + includeAll = arguments.length === 3 ? includeAll : true; + for (let flag3 in flags) { + if (includeAll || flag3 !== "object" && flag3 !== "ssfi" && flag3 !== "lockSsfi" && flag3 != "message") { + object.__flags[flag3] = flags[flag3]; + } + } +} +__name(transferFlags, "transferFlags"); + +// node_modules/deep-eql/index.js +function type2(obj) { + if (typeof obj === "undefined") { + return "undefined"; + } + if (obj === null) { + return "null"; + } + const stringTag = obj[Symbol.toStringTag]; + if (typeof stringTag === "string") { + return stringTag; + } + const sliceStart = 8; + const sliceEnd = -1; + return Object.prototype.toString.call(obj).slice(sliceStart, sliceEnd); +} +__name(type2, "type"); +function FakeMap() { + this._key = "chai/deep-eql__" + Math.random() + Date.now(); +} +__name(FakeMap, "FakeMap"); +FakeMap.prototype = { + get: /* @__PURE__ */ __name(function get(key) { + return key[this._key]; + }, "get"), + set: /* @__PURE__ */ __name(function set(key, value) { + if (Object.isExtensible(key)) { + Object.defineProperty(key, this._key, { + value, + configurable: true + }); + } + }, "set") +}; +var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap; +function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) { + if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return null; + } + var leftHandMap = memoizeMap.get(leftHandOperand); + if (leftHandMap) { + var result = leftHandMap.get(rightHandOperand); + if (typeof result === "boolean") { + return result; + } + } + return null; +} +__name(memoizeCompare, "memoizeCompare"); +function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) { + if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return; + } + var leftHandMap = memoizeMap.get(leftHandOperand); + if (leftHandMap) { + leftHandMap.set(rightHandOperand, result); + } else { + leftHandMap = new MemoizeMap(); + leftHandMap.set(rightHandOperand, result); + memoizeMap.set(leftHandOperand, leftHandMap); + } +} +__name(memoizeSet, "memoizeSet"); +var deep_eql_default = deepEqual; +function deepEqual(leftHandOperand, rightHandOperand, options) { + if (options && options.comparator) { + return extensiveDeepEqual(leftHandOperand, rightHandOperand, options); + } + var simpleResult = simpleEqual(leftHandOperand, rightHandOperand); + if (simpleResult !== null) { + return simpleResult; + } + return extensiveDeepEqual(leftHandOperand, rightHandOperand, options); +} +__name(deepEqual, "deepEqual"); +function simpleEqual(leftHandOperand, rightHandOperand) { + if (leftHandOperand === rightHandOperand) { + return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand; + } + if (leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare + rightHandOperand !== rightHandOperand) { + return true; + } + if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return false; + } + return null; +} +__name(simpleEqual, "simpleEqual"); +function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) { + options = options || {}; + options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap(); + var comparator = options && options.comparator; + var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize); + if (memoizeResultLeft !== null) { + return memoizeResultLeft; + } + var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize); + if (memoizeResultRight !== null) { + return memoizeResultRight; + } + if (comparator) { + var comparatorResult = comparator(leftHandOperand, rightHandOperand); + if (comparatorResult === false || comparatorResult === true) { + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult); + return comparatorResult; + } + var simpleResult = simpleEqual(leftHandOperand, rightHandOperand); + if (simpleResult !== null) { + return simpleResult; + } + } + var leftHandType = type2(leftHandOperand); + if (leftHandType !== type2(rightHandOperand)) { + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false); + return false; + } + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true); + var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options); + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result); + return result; +} +__name(extensiveDeepEqual, "extensiveDeepEqual"); +function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) { + switch (leftHandType) { + case "String": + case "Number": + case "Boolean": + case "Date": + return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf()); + case "Promise": + case "Symbol": + case "function": + case "WeakMap": + case "WeakSet": + return leftHandOperand === rightHandOperand; + case "Error": + return keysEqual(leftHandOperand, rightHandOperand, ["name", "message", "code"], options); + case "Arguments": + case "Int8Array": + case "Uint8Array": + case "Uint8ClampedArray": + case "Int16Array": + case "Uint16Array": + case "Int32Array": + case "Uint32Array": + case "Float32Array": + case "Float64Array": + case "Array": + return iterableEqual(leftHandOperand, rightHandOperand, options); + case "RegExp": + return regexpEqual(leftHandOperand, rightHandOperand); + case "Generator": + return generatorEqual(leftHandOperand, rightHandOperand, options); + case "DataView": + return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options); + case "ArrayBuffer": + return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options); + case "Set": + return entriesEqual(leftHandOperand, rightHandOperand, options); + case "Map": + return entriesEqual(leftHandOperand, rightHandOperand, options); + case "Temporal.PlainDate": + case "Temporal.PlainTime": + case "Temporal.PlainDateTime": + case "Temporal.Instant": + case "Temporal.ZonedDateTime": + case "Temporal.PlainYearMonth": + case "Temporal.PlainMonthDay": + return leftHandOperand.equals(rightHandOperand); + case "Temporal.Duration": + return leftHandOperand.total("nanoseconds") === rightHandOperand.total("nanoseconds"); + case "Temporal.TimeZone": + case "Temporal.Calendar": + return leftHandOperand.toString() === rightHandOperand.toString(); + default: + return objectEqual(leftHandOperand, rightHandOperand, options); + } +} +__name(extensiveDeepEqualByType, "extensiveDeepEqualByType"); +function regexpEqual(leftHandOperand, rightHandOperand) { + return leftHandOperand.toString() === rightHandOperand.toString(); +} +__name(regexpEqual, "regexpEqual"); +function entriesEqual(leftHandOperand, rightHandOperand, options) { + try { + if (leftHandOperand.size !== rightHandOperand.size) { + return false; + } + if (leftHandOperand.size === 0) { + return true; + } + } catch (sizeError) { + return false; + } + var leftHandItems = []; + var rightHandItems = []; + leftHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) { + leftHandItems.push([key, value]); + }, "gatherEntries")); + rightHandOperand.forEach(/* @__PURE__ */ __name(function gatherEntries(key, value) { + rightHandItems.push([key, value]); + }, "gatherEntries")); + return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options); +} +__name(entriesEqual, "entriesEqual"); +function iterableEqual(leftHandOperand, rightHandOperand, options) { + var length = leftHandOperand.length; + if (length !== rightHandOperand.length) { + return false; + } + if (length === 0) { + return true; + } + var index = -1; + while (++index < length) { + if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) { + return false; + } + } + return true; +} +__name(iterableEqual, "iterableEqual"); +function generatorEqual(leftHandOperand, rightHandOperand, options) { + return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options); +} +__name(generatorEqual, "generatorEqual"); +function hasIteratorFunction(target) { + return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function"; +} +__name(hasIteratorFunction, "hasIteratorFunction"); +function getIteratorEntries(target) { + if (hasIteratorFunction(target)) { + try { + return getGeneratorEntries(target[Symbol.iterator]()); + } catch (iteratorError) { + return []; + } + } + return []; +} +__name(getIteratorEntries, "getIteratorEntries"); +function getGeneratorEntries(generator) { + var generatorResult = generator.next(); + var accumulator = [generatorResult.value]; + while (generatorResult.done === false) { + generatorResult = generator.next(); + accumulator.push(generatorResult.value); + } + return accumulator; +} +__name(getGeneratorEntries, "getGeneratorEntries"); +function getEnumerableKeys(target) { + var keys = []; + for (var key in target) { + keys.push(key); + } + return keys; +} +__name(getEnumerableKeys, "getEnumerableKeys"); +function getEnumerableSymbols(target) { + var keys = []; + var allKeys = Object.getOwnPropertySymbols(target); + for (var i = 0; i < allKeys.length; i += 1) { + var key = allKeys[i]; + if (Object.getOwnPropertyDescriptor(target, key).enumerable) { + keys.push(key); + } + } + return keys; +} +__name(getEnumerableSymbols, "getEnumerableSymbols"); +function keysEqual(leftHandOperand, rightHandOperand, keys, options) { + var length = keys.length; + if (length === 0) { + return true; + } + for (var i = 0; i < length; i += 1) { + if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) { + return false; + } + } + return true; +} +__name(keysEqual, "keysEqual"); +function objectEqual(leftHandOperand, rightHandOperand, options) { + var leftHandKeys = getEnumerableKeys(leftHandOperand); + var rightHandKeys = getEnumerableKeys(rightHandOperand); + var leftHandSymbols = getEnumerableSymbols(leftHandOperand); + var rightHandSymbols = getEnumerableSymbols(rightHandOperand); + leftHandKeys = leftHandKeys.concat(leftHandSymbols); + rightHandKeys = rightHandKeys.concat(rightHandSymbols); + if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) { + if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) { + return false; + } + return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options); + } + var leftHandEntries = getIteratorEntries(leftHandOperand); + var rightHandEntries = getIteratorEntries(rightHandOperand); + if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) { + leftHandEntries.sort(); + rightHandEntries.sort(); + return iterableEqual(leftHandEntries, rightHandEntries, options); + } + if (leftHandKeys.length === 0 && leftHandEntries.length === 0 && rightHandKeys.length === 0 && rightHandEntries.length === 0) { + return true; + } + return false; +} +__name(objectEqual, "objectEqual"); +function isPrimitive(value) { + return value === null || typeof value !== "object"; +} +__name(isPrimitive, "isPrimitive"); +function mapSymbols(arr) { + return arr.map(/* @__PURE__ */ __name(function mapSymbol(entry) { + if (typeof entry === "symbol") { + return entry.toString(); + } + return entry; + }, "mapSymbol")); +} +__name(mapSymbols, "mapSymbols"); + +// node_modules/pathval/index.js +function hasProperty(obj, name) { + if (typeof obj === "undefined" || obj === null) { + return false; + } + return name in Object(obj); +} +__name(hasProperty, "hasProperty"); +function parsePath(path) { + const str = path.replace(/([^\\])\[/g, "$1.["); + const parts = str.match(/(\\\.|[^.]+?)+/g); + return parts.map((value) => { + if (value === "constructor" || value === "__proto__" || value === "prototype") { + return {}; + } + const regexp = /^\[(\d+)\]$/; + const mArr = regexp.exec(value); + let parsed = null; + if (mArr) { + parsed = { i: parseFloat(mArr[1]) }; + } else { + parsed = { p: value.replace(/\\([.[\]])/g, "$1") }; + } + return parsed; + }); +} +__name(parsePath, "parsePath"); +function internalGetPathValue(obj, parsed, pathDepth) { + let temporaryValue = obj; + let res = null; + pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth; + for (let i = 0; i < pathDepth; i++) { + const part = parsed[i]; + if (temporaryValue) { + if (typeof part.p === "undefined") { + temporaryValue = temporaryValue[part.i]; + } else { + temporaryValue = temporaryValue[part.p]; + } + if (i === pathDepth - 1) { + res = temporaryValue; + } + } + } + return res; +} +__name(internalGetPathValue, "internalGetPathValue"); +function getPathInfo(obj, path) { + const parsed = parsePath(path); + const last = parsed[parsed.length - 1]; + const info = { + parent: parsed.length > 1 ? internalGetPathValue(obj, parsed, parsed.length - 1) : obj, + name: last.p || last.i, + value: internalGetPathValue(obj, parsed) + }; + info.exists = hasProperty(info.parent, info.name); + return info; +} +__name(getPathInfo, "getPathInfo"); + +// lib/chai/assertion.js +var _Assertion = class _Assertion { + /** + * Creates object for chaining. + * `Assertion` objects contain metadata in the form of flags. Three flags can + * be assigned during instantiation by passing arguments to this constructor: + * + * - `object`: This flag contains the target of the assertion. For example, in + * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will + * contain `numKittens` so that the `equal` assertion can reference it when + * needed. + * + * - `message`: This flag contains an optional custom error message to be + * prepended to the error message that's generated by the assertion when it + * fails. + * + * - `ssfi`: This flag stands for "start stack function indicator". It + * contains a function reference that serves as the starting point for + * removing frames from the stack trace of the error that's created by the + * assertion when it fails. The goal is to provide a cleaner stack trace to + * end users by removing Chai's internal functions. Note that it only works + * in environments that support `Error.captureStackTrace`, and only when + * `Chai.config.includeStack` hasn't been set to `false`. + * + * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag + * should retain its current value, even as assertions are chained off of + * this object. This is usually set to `true` when creating a new assertion + * from within another assertion. It's also temporarily set to `true` before + * an overwritten assertion gets called by the overwriting assertion. + * + * - `eql`: This flag contains the deepEqual function to be used by the assertion. + * + * @param {unknown} obj target of the assertion + * @param {string} [msg] (optional) custom error message + * @param {Function} [ssfi] (optional) starting point for removing stack frames + * @param {boolean} [lockSsfi] (optional) whether or not the ssfi flag is locked + */ + constructor(obj, msg, ssfi, lockSsfi) { + /** @type {{}} */ + __publicField(this, "__flags", {}); + flag(this, "ssfi", ssfi || _Assertion); + flag(this, "lockSsfi", lockSsfi); + flag(this, "object", obj); + flag(this, "message", msg); + flag(this, "eql", config.deepEqual || deep_eql_default); + return proxify(this); + } + /** @returns {boolean} */ + static get includeStack() { + console.warn( + "Assertion.includeStack is deprecated, use chai.config.includeStack instead." + ); + return config.includeStack; + } + /** @param {boolean} value */ + static set includeStack(value) { + console.warn( + "Assertion.includeStack is deprecated, use chai.config.includeStack instead." + ); + config.includeStack = value; + } + /** @returns {boolean} */ + static get showDiff() { + console.warn( + "Assertion.showDiff is deprecated, use chai.config.showDiff instead." + ); + return config.showDiff; + } + /** @param {boolean} value */ + static set showDiff(value) { + console.warn( + "Assertion.showDiff is deprecated, use chai.config.showDiff instead." + ); + config.showDiff = value; + } + /** + * @param {string} name + * @param {Function} fn + */ + static addProperty(name, fn) { + addProperty(this.prototype, name, fn); + } + /** + * @param {string} name + * @param {Function} fn + */ + static addMethod(name, fn) { + addMethod(this.prototype, name, fn); + } + /** + * @param {string} name + * @param {Function} fn + * @param {Function} chainingBehavior + */ + static addChainableMethod(name, fn, chainingBehavior) { + addChainableMethod(this.prototype, name, fn, chainingBehavior); + } + /** + * @param {string} name + * @param {Function} fn + */ + static overwriteProperty(name, fn) { + overwriteProperty(this.prototype, name, fn); + } + /** + * @param {string} name + * @param {Function} fn + */ + static overwriteMethod(name, fn) { + overwriteMethod(this.prototype, name, fn); + } + /** + * @param {string} name + * @param {Function} fn + * @param {Function} chainingBehavior + */ + static overwriteChainableMethod(name, fn, chainingBehavior) { + overwriteChainableMethod(this.prototype, name, fn, chainingBehavior); + } + /** + * ### .assert(expression, message, negateMessage, expected, actual, showDiff) + * + * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass. + * + * @name assert + * @param {unknown} _expr to be tested + * @param {string | Function} msg or function that returns message to display if expression fails + * @param {string | Function} _negateMsg or function that returns negatedMessage to display if negated expression fails + * @param {unknown} expected value (remember to check for negation) + * @param {unknown} _actual (optional) will default to `this.obj` + * @param {boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails + * @returns {void} + */ + assert(_expr, msg, _negateMsg, expected, _actual, showDiff) { + const ok = test(this, arguments); + if (false !== showDiff) showDiff = true; + if (void 0 === expected && void 0 === _actual) showDiff = false; + if (true !== config.showDiff) showDiff = false; + if (!ok) { + msg = getMessage2(this, arguments); + const actual = getActual(this, arguments); + const assertionErrorObjectProperties = { + actual, + expected, + showDiff + }; + const operator = getOperator(this, arguments); + if (operator) { + assertionErrorObjectProperties.operator = operator; + } + throw new AssertionError( + msg, + assertionErrorObjectProperties, + // @ts-expect-error Not sure what to do about these types yet + config.includeStack ? this.assert : flag(this, "ssfi") + ); + } + } + /** + * Quick reference to stored `actual` value for plugin developers. + * + * @returns {unknown} + */ + get _obj() { + return flag(this, "object"); + } + /** + * Quick reference to stored `actual` value for plugin developers. + * + * @param {unknown} val + */ + set _obj(val) { + flag(this, "object", val); + } +}; +__name(_Assertion, "Assertion"); +var Assertion = _Assertion; + +// lib/chai/utils/events.js +var events = new EventTarget(); +var _PluginEvent = class _PluginEvent extends Event { + constructor(type3, name, fn) { + super(type3); + this.name = String(name); + this.fn = fn; + } +}; +__name(_PluginEvent, "PluginEvent"); +var PluginEvent = _PluginEvent; + +// lib/chai/utils/isProxyEnabled.js +function isProxyEnabled() { + return config.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined"; +} +__name(isProxyEnabled, "isProxyEnabled"); + +// lib/chai/utils/addProperty.js +function addProperty(ctx, name, getter) { + getter = getter === void 0 ? function() { + } : getter; + Object.defineProperty(ctx, name, { + get: /* @__PURE__ */ __name(function propertyGetter() { + if (!isProxyEnabled() && !flag(this, "lockSsfi")) { + flag(this, "ssfi", propertyGetter); + } + let result = getter.call(this); + if (result !== void 0) return result; + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "propertyGetter"), + configurable: true + }); + events.dispatchEvent(new PluginEvent("addProperty", name, getter)); +} +__name(addProperty, "addProperty"); + +// lib/chai/utils/addLengthGuard.js +var fnLengthDesc = Object.getOwnPropertyDescriptor(function() { +}, "length"); +function addLengthGuard(fn, assertionName, isChainable) { + if (!fnLengthDesc.configurable) return fn; + Object.defineProperty(fn, "length", { + get: /* @__PURE__ */ __name(function() { + if (isChainable) { + throw Error( + "Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.' + ); + } + throw Error( + "Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".' + ); + }, "get") + }); + return fn; +} +__name(addLengthGuard, "addLengthGuard"); + +// lib/chai/utils/getProperties.js +function getProperties(object) { + let result = Object.getOwnPropertyNames(object); + function addProperty2(property) { + if (result.indexOf(property) === -1) { + result.push(property); + } + } + __name(addProperty2, "addProperty"); + let proto = Object.getPrototypeOf(object); + while (proto !== null) { + Object.getOwnPropertyNames(proto).forEach(addProperty2); + proto = Object.getPrototypeOf(proto); + } + return result; +} +__name(getProperties, "getProperties"); + +// lib/chai/utils/proxify.js +var builtins = ["__flags", "__methods", "_obj", "assert"]; +function proxify(obj, nonChainableMethodName) { + if (!isProxyEnabled()) return obj; + return new Proxy(obj, { + get: /* @__PURE__ */ __name(function proxyGetter(target, property) { + if (typeof property === "string" && config.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) { + if (nonChainableMethodName) { + throw Error( + "Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".' + ); + } + let suggestion = null; + let suggestionDistance = 4; + getProperties(target).forEach(function(prop) { + if ( + // we actually mean to check `Object.prototype` here + // eslint-disable-next-line no-prototype-builtins + !Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1 + ) { + let dist = stringDistanceCapped(property, prop, suggestionDistance); + if (dist < suggestionDistance) { + suggestion = prop; + suggestionDistance = dist; + } + } + }); + if (suggestion !== null) { + throw Error( + "Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?' + ); + } else { + throw Error("Invalid Chai property: " + property); + } + } + if (builtins.indexOf(property) === -1 && !flag(target, "lockSsfi")) { + flag(target, "ssfi", proxyGetter); + } + return Reflect.get(target, property); + }, "proxyGetter") + }); +} +__name(proxify, "proxify"); +function stringDistanceCapped(strA, strB, cap) { + if (Math.abs(strA.length - strB.length) >= cap) { + return cap; + } + let memo = []; + for (let i = 0; i <= strA.length; i++) { + memo[i] = Array(strB.length + 1).fill(0); + memo[i][0] = i; + } + for (let j = 0; j < strB.length; j++) { + memo[0][j] = j; + } + for (let i = 1; i <= strA.length; i++) { + let ch = strA.charCodeAt(i - 1); + for (let j = 1; j <= strB.length; j++) { + if (Math.abs(i - j) >= cap) { + memo[i][j] = cap; + continue; + } + memo[i][j] = Math.min( + memo[i - 1][j] + 1, + memo[i][j - 1] + 1, + memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1) + ); + } + } + return memo[strA.length][strB.length]; +} +__name(stringDistanceCapped, "stringDistanceCapped"); + +// lib/chai/utils/addMethod.js +function addMethod(ctx, name, method) { + let methodWrapper = /* @__PURE__ */ __name(function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", methodWrapper); + } + let result = method.apply(this, arguments); + if (result !== void 0) return result; + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "methodWrapper"); + addLengthGuard(methodWrapper, name, false); + ctx[name] = proxify(methodWrapper, name); + events.dispatchEvent(new PluginEvent("addMethod", name, method)); +} +__name(addMethod, "addMethod"); + +// lib/chai/utils/overwriteProperty.js +function overwriteProperty(ctx, name, getter) { + let _get = Object.getOwnPropertyDescriptor(ctx, name), _super = /* @__PURE__ */ __name(function() { + }, "_super"); + if (_get && "function" === typeof _get.get) _super = _get.get; + Object.defineProperty(ctx, name, { + get: /* @__PURE__ */ __name(function overwritingPropertyGetter() { + if (!isProxyEnabled() && !flag(this, "lockSsfi")) { + flag(this, "ssfi", overwritingPropertyGetter); + } + let origLockSsfi = flag(this, "lockSsfi"); + flag(this, "lockSsfi", true); + let result = getter(_super).call(this); + flag(this, "lockSsfi", origLockSsfi); + if (result !== void 0) { + return result; + } + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "overwritingPropertyGetter"), + configurable: true + }); +} +__name(overwriteProperty, "overwriteProperty"); + +// lib/chai/utils/overwriteMethod.js +function overwriteMethod(ctx, name, method) { + let _method = ctx[name], _super = /* @__PURE__ */ __name(function() { + throw new Error(name + " is not a function"); + }, "_super"); + if (_method && "function" === typeof _method) _super = _method; + let overwritingMethodWrapper = /* @__PURE__ */ __name(function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", overwritingMethodWrapper); + } + let origLockSsfi = flag(this, "lockSsfi"); + flag(this, "lockSsfi", true); + let result = method(_super).apply(this, arguments); + flag(this, "lockSsfi", origLockSsfi); + if (result !== void 0) { + return result; + } + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "overwritingMethodWrapper"); + addLengthGuard(overwritingMethodWrapper, name, false); + ctx[name] = proxify(overwritingMethodWrapper, name); +} +__name(overwriteMethod, "overwriteMethod"); + +// lib/chai/utils/addChainableMethod.js +var canSetPrototype = typeof Object.setPrototypeOf === "function"; +var testFn = /* @__PURE__ */ __name(function() { +}, "testFn"); +var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) { + let propDesc = Object.getOwnPropertyDescriptor(testFn, name); + if (typeof propDesc !== "object") return true; + return !propDesc.configurable; +}); +var call = Function.prototype.call; +var apply = Function.prototype.apply; +var _PluginAddChainableMethodEvent = class _PluginAddChainableMethodEvent extends PluginEvent { + constructor(type3, name, fn, chainingBehavior) { + super(type3, name, fn); + this.chainingBehavior = chainingBehavior; + } +}; +__name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent"); +var PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent; +function addChainableMethod(ctx, name, method, chainingBehavior) { + if (typeof chainingBehavior !== "function") { + chainingBehavior = /* @__PURE__ */ __name(function() { + }, "chainingBehavior"); + } + let chainableBehavior = { + method, + chainingBehavior + }; + if (!ctx.__methods) { + ctx.__methods = {}; + } + ctx.__methods[name] = chainableBehavior; + Object.defineProperty(ctx, name, { + get: /* @__PURE__ */ __name(function chainableMethodGetter() { + chainableBehavior.chainingBehavior.call(this); + let chainableMethodWrapper = /* @__PURE__ */ __name(function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", chainableMethodWrapper); + } + let result = chainableBehavior.method.apply(this, arguments); + if (result !== void 0) { + return result; + } + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "chainableMethodWrapper"); + addLengthGuard(chainableMethodWrapper, name, true); + if (canSetPrototype) { + let prototype = Object.create(this); + prototype.call = call; + prototype.apply = apply; + Object.setPrototypeOf(chainableMethodWrapper, prototype); + } else { + let asserterNames = Object.getOwnPropertyNames(ctx); + asserterNames.forEach(function(asserterName) { + if (excludeNames.indexOf(asserterName) !== -1) { + return; + } + let pd = Object.getOwnPropertyDescriptor(ctx, asserterName); + Object.defineProperty(chainableMethodWrapper, asserterName, pd); + }); + } + transferFlags(this, chainableMethodWrapper); + return proxify(chainableMethodWrapper); + }, "chainableMethodGetter"), + configurable: true + }); + events.dispatchEvent( + new PluginAddChainableMethodEvent( + "addChainableMethod", + name, + method, + chainingBehavior + ) + ); +} +__name(addChainableMethod, "addChainableMethod"); + +// lib/chai/utils/overwriteChainableMethod.js +function overwriteChainableMethod(ctx, name, method, chainingBehavior) { + let chainableBehavior = ctx.__methods[name]; + let _chainingBehavior = chainableBehavior.chainingBehavior; + chainableBehavior.chainingBehavior = /* @__PURE__ */ __name(function overwritingChainableMethodGetter() { + let result = chainingBehavior(_chainingBehavior).call(this); + if (result !== void 0) { + return result; + } + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "overwritingChainableMethodGetter"); + let _method = chainableBehavior.method; + chainableBehavior.method = /* @__PURE__ */ __name(function overwritingChainableMethodWrapper() { + let result = method(_method).apply(this, arguments); + if (result !== void 0) { + return result; + } + let newAssertion = new Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, "overwritingChainableMethodWrapper"); +} +__name(overwriteChainableMethod, "overwriteChainableMethod"); + +// lib/chai/utils/compareByInspect.js +function compareByInspect(a, b) { + return inspect2(a) < inspect2(b) ? -1 : 1; +} +__name(compareByInspect, "compareByInspect"); + +// lib/chai/utils/getOwnEnumerablePropertySymbols.js +function getOwnEnumerablePropertySymbols(obj) { + if (typeof Object.getOwnPropertySymbols !== "function") return []; + return Object.getOwnPropertySymbols(obj).filter(function(sym) { + return Object.getOwnPropertyDescriptor(obj, sym).enumerable; + }); +} +__name(getOwnEnumerablePropertySymbols, "getOwnEnumerablePropertySymbols"); + +// lib/chai/utils/getOwnEnumerableProperties.js +function getOwnEnumerableProperties(obj) { + return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj)); +} +__name(getOwnEnumerableProperties, "getOwnEnumerableProperties"); + +// lib/chai/utils/isNaN.js +var isNaN2 = Number.isNaN; + +// lib/chai/utils/getOperator.js +function isObjectType(obj) { + let objectType = type(obj); + let objectTypes = ["Array", "Object", "Function"]; + return objectTypes.indexOf(objectType) !== -1; +} +__name(isObjectType, "isObjectType"); +function getOperator(obj, args) { + let operator = flag(obj, "operator"); + let negate = flag(obj, "negate"); + let expected = args[3]; + let msg = negate ? args[2] : args[1]; + if (operator) { + return operator; + } + if (typeof msg === "function") msg = msg(); + msg = msg || ""; + if (!msg) { + return void 0; + } + if (/\shave\s/.test(msg)) { + return void 0; + } + let isObject = isObjectType(expected); + if (/\snot\s/.test(msg)) { + return isObject ? "notDeepStrictEqual" : "notStrictEqual"; + } + return isObject ? "deepStrictEqual" : "strictEqual"; +} +__name(getOperator, "getOperator"); + +// lib/chai/utils/index.js +function getName(fn) { + return fn.name; +} +__name(getName, "getName"); +function isRegExp2(obj) { + return Object.prototype.toString.call(obj) === "[object RegExp]"; +} +__name(isRegExp2, "isRegExp"); +function isNumeric(obj) { + return ["Number", "BigInt"].includes(type(obj)); +} +__name(isNumeric, "isNumeric"); + +// lib/chai/core/assertions.js +var { flag: flag2 } = utils_exports; +[ + "to", + "be", + "been", + "is", + "and", + "has", + "have", + "with", + "that", + "which", + "at", + "of", + "same", + "but", + "does", + "still", + "also" +].forEach(function(chain) { + Assertion.addProperty(chain); +}); +Assertion.addProperty("not", function() { + flag2(this, "negate", true); +}); +Assertion.addProperty("deep", function() { + flag2(this, "deep", true); +}); +Assertion.addProperty("nested", function() { + flag2(this, "nested", true); +}); +Assertion.addProperty("own", function() { + flag2(this, "own", true); +}); +Assertion.addProperty("ordered", function() { + flag2(this, "ordered", true); +}); +Assertion.addProperty("any", function() { + flag2(this, "any", true); + flag2(this, "all", false); +}); +Assertion.addProperty("all", function() { + flag2(this, "all", true); + flag2(this, "any", false); +}); +var functionTypes = { + function: [ + "function", + "asyncfunction", + "generatorfunction", + "asyncgeneratorfunction" + ], + asyncfunction: ["asyncfunction", "asyncgeneratorfunction"], + generatorfunction: ["generatorfunction", "asyncgeneratorfunction"], + asyncgeneratorfunction: ["asyncgeneratorfunction"] +}; +function an(type3, msg) { + if (msg) flag2(this, "message", msg); + type3 = type3.toLowerCase(); + let obj = flag2(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type3.charAt(0)) ? "an " : "a "; + const detectedType = type(obj).toLowerCase(); + if (functionTypes["function"].includes(type3)) { + this.assert( + functionTypes[type3].includes(detectedType), + "expected #{this} to be " + article + type3, + "expected #{this} not to be " + article + type3 + ); + } else { + this.assert( + type3 === detectedType, + "expected #{this} to be " + article + type3, + "expected #{this} not to be " + article + type3 + ); + } +} +__name(an, "an"); +Assertion.addChainableMethod("an", an); +Assertion.addChainableMethod("a", an); +function SameValueZero(a, b) { + return isNaN2(a) && isNaN2(b) || a === b; +} +__name(SameValueZero, "SameValueZero"); +function includeChainingBehavior() { + flag2(this, "contains", true); +} +__name(includeChainingBehavior, "includeChainingBehavior"); +function include(val, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), negate = flag2(this, "negate"), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag2(this, "eql") : SameValueZero; + flagMsg = flagMsg ? flagMsg + ": " : ""; + let included = false; + switch (objType) { + case "string": + included = obj.indexOf(val) !== -1; + break; + case "weakset": + if (isDeep) { + throw new AssertionError( + flagMsg + "unable to use .deep.include with WeakSet", + void 0, + ssfi + ); + } + included = obj.has(val); + break; + case "map": + obj.forEach(function(item) { + included = included || isEql(item, val); + }); + break; + case "set": + if (isDeep) { + obj.forEach(function(item) { + included = included || isEql(item, val); + }); + } else { + included = obj.has(val); + } + break; + case "array": + if (isDeep) { + included = obj.some(function(item) { + return isEql(item, val); + }); + } else { + included = obj.indexOf(val) !== -1; + } + break; + default: { + if (val !== Object(val)) { + throw new AssertionError( + flagMsg + "the given combination of arguments (" + objType + " and " + type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + type(val).toLowerCase(), + void 0, + ssfi + ); + } + let props = Object.keys(val); + let firstErr = null; + let numErrs = 0; + props.forEach(function(prop) { + let propAssertion = new Assertion(obj); + transferFlags(this, propAssertion, true); + flag2(propAssertion, "lockSsfi", true); + if (!negate || props.length === 1) { + propAssertion.property(prop, val[prop]); + return; + } + try { + propAssertion.property(prop, val[prop]); + } catch (err) { + if (!check_error_exports.compatibleConstructor(err, AssertionError)) { + throw err; + } + if (firstErr === null) firstErr = err; + numErrs++; + } + }, this); + if (negate && props.length > 1 && numErrs === props.length) { + throw firstErr; + } + return; + } + } + this.assert( + included, + "expected #{this} to " + descriptor + "include " + inspect2(val), + "expected #{this} to not " + descriptor + "include " + inspect2(val) + ); +} +__name(include, "include"); +Assertion.addChainableMethod("include", include, includeChainingBehavior); +Assertion.addChainableMethod("contain", include, includeChainingBehavior); +Assertion.addChainableMethod("contains", include, includeChainingBehavior); +Assertion.addChainableMethod("includes", include, includeChainingBehavior); +Assertion.addProperty("ok", function() { + this.assert( + flag2(this, "object"), + "expected #{this} to be truthy", + "expected #{this} to be falsy" + ); +}); +Assertion.addProperty("true", function() { + this.assert( + true === flag2(this, "object"), + "expected #{this} to be true", + "expected #{this} to be false", + flag2(this, "negate") ? false : true + ); +}); +Assertion.addProperty("numeric", function() { + const object = flag2(this, "object"); + this.assert( + ["Number", "BigInt"].includes(type(object)), + "expected #{this} to be numeric", + "expected #{this} to not be numeric", + flag2(this, "negate") ? false : true + ); +}); +Assertion.addProperty("callable", function() { + const val = flag2(this, "object"); + const ssfi = flag2(this, "ssfi"); + const message = flag2(this, "message"); + const msg = message ? `${message}: ` : ""; + const negate = flag2(this, "negate"); + const assertionMessage = negate ? `${msg}expected ${inspect2(val)} not to be a callable function` : `${msg}expected ${inspect2(val)} to be a callable function`; + const isCallable = [ + "Function", + "AsyncFunction", + "GeneratorFunction", + "AsyncGeneratorFunction" + ].includes(type(val)); + if (isCallable && negate || !isCallable && !negate) { + throw new AssertionError(assertionMessage, void 0, ssfi); + } +}); +Assertion.addProperty("false", function() { + this.assert( + false === flag2(this, "object"), + "expected #{this} to be false", + "expected #{this} to be true", + flag2(this, "negate") ? true : false + ); +}); +Assertion.addProperty("null", function() { + this.assert( + null === flag2(this, "object"), + "expected #{this} to be null", + "expected #{this} not to be null" + ); +}); +Assertion.addProperty("undefined", function() { + this.assert( + void 0 === flag2(this, "object"), + "expected #{this} to be undefined", + "expected #{this} not to be undefined" + ); +}); +Assertion.addProperty("NaN", function() { + this.assert( + isNaN2(flag2(this, "object")), + "expected #{this} to be NaN", + "expected #{this} not to be NaN" + ); +}); +function assertExist() { + let val = flag2(this, "object"); + this.assert( + val !== null && val !== void 0, + "expected #{this} to exist", + "expected #{this} to not exist" + ); +} +__name(assertExist, "assertExist"); +Assertion.addProperty("exist", assertExist); +Assertion.addProperty("exists", assertExist); +Assertion.addProperty("empty", function() { + let val = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), itemsCount; + flagMsg = flagMsg ? flagMsg + ": " : ""; + switch (type(val).toLowerCase()) { + case "array": + case "string": + itemsCount = val.length; + break; + case "map": + case "set": + itemsCount = val.size; + break; + case "weakmap": + case "weakset": + throw new AssertionError( + flagMsg + ".empty was passed a weak collection", + void 0, + ssfi + ); + case "function": { + const msg = flagMsg + ".empty was passed a function " + getName(val); + throw new AssertionError(msg.trim(), void 0, ssfi); + } + default: + if (val !== Object(val)) { + throw new AssertionError( + flagMsg + ".empty was passed non-string primitive " + inspect2(val), + void 0, + ssfi + ); + } + itemsCount = Object.keys(val).length; + } + this.assert( + 0 === itemsCount, + "expected #{this} to be empty", + "expected #{this} not to be empty" + ); +}); +function checkArguments() { + let obj = flag2(this, "object"), type3 = type(obj); + this.assert( + "Arguments" === type3, + "expected #{this} to be arguments but got " + type3, + "expected #{this} to not be arguments" + ); +} +__name(checkArguments, "checkArguments"); +Assertion.addProperty("arguments", checkArguments); +Assertion.addProperty("Arguments", checkArguments); +function assertEqual(val, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"); + if (flag2(this, "deep")) { + let prevLockSsfi = flag2(this, "lockSsfi"); + flag2(this, "lockSsfi", true); + this.eql(val); + flag2(this, "lockSsfi", prevLockSsfi); + } else { + this.assert( + val === obj, + "expected #{this} to equal #{exp}", + "expected #{this} to not equal #{exp}", + val, + this._obj, + true + ); + } +} +__name(assertEqual, "assertEqual"); +Assertion.addMethod("equal", assertEqual); +Assertion.addMethod("equals", assertEqual); +Assertion.addMethod("eq", assertEqual); +function assertEql(obj, msg) { + if (msg) flag2(this, "message", msg); + let eql = flag2(this, "eql"); + this.assert( + eql(obj, flag2(this, "object")), + "expected #{this} to deeply equal #{exp}", + "expected #{this} to not deeply equal #{exp}", + obj, + this._obj, + true + ); +} +__name(assertEql, "assertEql"); +Assertion.addMethod("eql", assertEql); +Assertion.addMethod("eqls", assertEql); +function assertAbove(n, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(); + if (doLength && objType !== "map" && objType !== "set") { + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && objType === "date" && nType !== "date") { + throw new AssertionError( + msgPrefix + "the argument to above must be a date", + void 0, + ssfi + ); + } else if (!isNumeric(n) && (doLength || isNumeric(obj))) { + throw new AssertionError( + msgPrefix + "the argument to above must be a number", + void 0, + ssfi + ); + } else if (!doLength && objType !== "date" && !isNumeric(obj)) { + let printObj = objType === "string" ? "'" + obj + "'" : obj; + throw new AssertionError( + msgPrefix + "expected " + printObj + " to be a number or a date", + void 0, + ssfi + ); + } + if (doLength) { + let descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount > n, + "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " above #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj > n, + "expected #{this} to be above #{exp}", + "expected #{this} to be at most #{exp}", + n + ); + } +} +__name(assertAbove, "assertAbove"); +Assertion.addMethod("above", assertAbove); +Assertion.addMethod("gt", assertAbove); +Assertion.addMethod("greaterThan", assertAbove); +function assertLeast(n, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && objType === "date" && nType !== "date") { + errorMessage = msgPrefix + "the argument to least must be a date"; + } else if (!isNumeric(n) && (doLength || isNumeric(obj))) { + errorMessage = msgPrefix + "the argument to least must be a number"; + } else if (!doLength && objType !== "date" && !isNumeric(obj)) { + let printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError(errorMessage, void 0, ssfi); + } + if (doLength) { + let descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount >= n, + "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}", + "expected #{this} to have a " + descriptor + " below #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj >= n, + "expected #{this} to be at least #{exp}", + "expected #{this} to be below #{exp}", + n + ); + } +} +__name(assertLeast, "assertLeast"); +Assertion.addMethod("least", assertLeast); +Assertion.addMethod("gte", assertLeast); +Assertion.addMethod("greaterThanOrEqual", assertLeast); +function assertBelow(n, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && objType === "date" && nType !== "date") { + errorMessage = msgPrefix + "the argument to below must be a date"; + } else if (!isNumeric(n) && (doLength || isNumeric(obj))) { + errorMessage = msgPrefix + "the argument to below must be a number"; + } else if (!doLength && objType !== "date" && !isNumeric(obj)) { + let printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError(errorMessage, void 0, ssfi); + } + if (doLength) { + let descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount < n, + "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " below #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj < n, + "expected #{this} to be below #{exp}", + "expected #{this} to be at least #{exp}", + n + ); + } +} +__name(assertBelow, "assertBelow"); +Assertion.addMethod("below", assertBelow); +Assertion.addMethod("lt", assertBelow); +Assertion.addMethod("lessThan", assertBelow); +function assertMost(n, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), nType = type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && objType === "date" && nType !== "date") { + errorMessage = msgPrefix + "the argument to most must be a date"; + } else if (!isNumeric(n) && (doLength || isNumeric(obj))) { + errorMessage = msgPrefix + "the argument to most must be a number"; + } else if (!doLength && objType !== "date" && !isNumeric(obj)) { + let printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError(errorMessage, void 0, ssfi); + } + if (doLength) { + let descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount <= n, + "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}", + "expected #{this} to have a " + descriptor + " above #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj <= n, + "expected #{this} to be at most #{exp}", + "expected #{this} to be above #{exp}", + n + ); + } +} +__name(assertMost, "assertMost"); +Assertion.addMethod("most", assertMost); +Assertion.addMethod("lte", assertMost); +Assertion.addMethod("lessThanOrEqual", assertMost); +Assertion.addMethod("within", function(start, finish, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), doLength = flag2(this, "doLength"), flagMsg = flag2(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag2(this, "ssfi"), objType = type(obj).toLowerCase(), startType = type(start).toLowerCase(), finishType = type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && objType === "date" && (startType !== "date" || finishType !== "date")) { + errorMessage = msgPrefix + "the arguments to within must be dates"; + } else if ((!isNumeric(start) || !isNumeric(finish)) && (doLength || isNumeric(obj))) { + errorMessage = msgPrefix + "the arguments to within must be numbers"; + } else if (!doLength && objType !== "date" && !isNumeric(obj)) { + let printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError(errorMessage, void 0, ssfi); + } + if (doLength) { + let descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount >= start && itemsCount <= finish, + "expected #{this} to have a " + descriptor + " within " + range, + "expected #{this} to not have a " + descriptor + " within " + range + ); + } else { + this.assert( + obj >= start && obj <= finish, + "expected #{this} to be within " + range, + "expected #{this} to not be within " + range + ); + } +}); +function assertInstanceOf(constructor, msg) { + if (msg) flag2(this, "message", msg); + let target = flag2(this, "object"); + let ssfi = flag2(this, "ssfi"); + let flagMsg = flag2(this, "message"); + let isInstanceOf; + try { + isInstanceOf = target instanceof constructor; + } catch (err) { + if (err instanceof TypeError) { + flagMsg = flagMsg ? flagMsg + ": " : ""; + throw new AssertionError( + flagMsg + "The instanceof assertion needs a constructor but " + type(constructor) + " was given.", + void 0, + ssfi + ); + } + throw err; + } + let name = getName(constructor); + if (name == null) { + name = "an unnamed constructor"; + } + this.assert( + isInstanceOf, + "expected #{this} to be an instance of " + name, + "expected #{this} to not be an instance of " + name + ); +} +__name(assertInstanceOf, "assertInstanceOf"); +Assertion.addMethod("instanceof", assertInstanceOf); +Assertion.addMethod("instanceOf", assertInstanceOf); +function assertProperty(name, val, msg) { + if (msg) flag2(this, "message", msg); + let isNested = flag2(this, "nested"), isOwn = flag2(this, "own"), flagMsg = flag2(this, "message"), obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), nameType = typeof name; + flagMsg = flagMsg ? flagMsg + ": " : ""; + if (isNested) { + if (nameType !== "string") { + throw new AssertionError( + flagMsg + "the argument to property must be a string when using nested syntax", + void 0, + ssfi + ); + } + } else { + if (nameType !== "string" && nameType !== "number" && nameType !== "symbol") { + throw new AssertionError( + flagMsg + "the argument to property must be a string, number, or symbol", + void 0, + ssfi + ); + } + } + if (isNested && isOwn) { + throw new AssertionError( + flagMsg + 'The "nested" and "own" flags cannot be combined.', + void 0, + ssfi + ); + } + if (obj === null || obj === void 0) { + throw new AssertionError( + flagMsg + "Target cannot be null or undefined.", + void 0, + ssfi + ); + } + let isDeep = flag2(this, "deep"), negate = flag2(this, "negate"), pathInfo = isNested ? getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2; + let descriptor = ""; + if (isDeep) descriptor += "deep "; + if (isOwn) descriptor += "own "; + if (isNested) descriptor += "nested "; + descriptor += "property "; + let hasProperty2; + if (isOwn) hasProperty2 = Object.prototype.hasOwnProperty.call(obj, name); + else if (isNested) hasProperty2 = pathInfo.exists; + else hasProperty2 = hasProperty(obj, name); + if (!negate || arguments.length === 1) { + this.assert( + hasProperty2, + "expected #{this} to have " + descriptor + inspect2(name), + "expected #{this} to not have " + descriptor + inspect2(name) + ); + } + if (arguments.length > 1) { + this.assert( + hasProperty2 && isEql(val, value), + "expected #{this} to have " + descriptor + inspect2(name) + " of #{exp}, but got #{act}", + "expected #{this} to not have " + descriptor + inspect2(name) + " of #{act}", + val, + value + ); + } + flag2(this, "object", value); +} +__name(assertProperty, "assertProperty"); +Assertion.addMethod("property", assertProperty); +function assertOwnProperty(_name, _value, _msg) { + flag2(this, "own", true); + assertProperty.apply(this, arguments); +} +__name(assertOwnProperty, "assertOwnProperty"); +Assertion.addMethod("ownProperty", assertOwnProperty); +Assertion.addMethod("haveOwnProperty", assertOwnProperty); +function assertOwnPropertyDescriptor(name, descriptor, msg) { + if (typeof descriptor === "string") { + msg = descriptor; + descriptor = null; + } + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"); + let actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name); + let eql = flag2(this, "eql"); + if (actualDescriptor && descriptor) { + this.assert( + eql(descriptor, actualDescriptor), + "expected the own property descriptor for " + inspect2(name) + " on #{this} to match " + inspect2(descriptor) + ", got " + inspect2(actualDescriptor), + "expected the own property descriptor for " + inspect2(name) + " on #{this} to not match " + inspect2(descriptor), + descriptor, + actualDescriptor, + true + ); + } else { + this.assert( + actualDescriptor, + "expected #{this} to have an own property descriptor for " + inspect2(name), + "expected #{this} to not have an own property descriptor for " + inspect2(name) + ); + } + flag2(this, "object", actualDescriptor); +} +__name(assertOwnPropertyDescriptor, "assertOwnPropertyDescriptor"); +Assertion.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor); +Assertion.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor); +function assertLengthChain() { + flag2(this, "doLength", true); +} +__name(assertLengthChain, "assertLengthChain"); +function assertLength(n, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), objType = type(obj).toLowerCase(), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), descriptor = "length", itemsCount; + switch (objType) { + case "map": + case "set": + descriptor = "size"; + itemsCount = obj.size; + break; + default: + new Assertion(obj, flagMsg, ssfi, true).to.have.property("length"); + itemsCount = obj.length; + } + this.assert( + itemsCount == n, + "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " of #{act}", + n, + itemsCount + ); +} +__name(assertLength, "assertLength"); +Assertion.addChainableMethod("length", assertLength, assertLengthChain); +Assertion.addChainableMethod("lengthOf", assertLength, assertLengthChain); +function assertMatch(re, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"); + this.assert( + re.exec(obj), + "expected #{this} to match " + re, + "expected #{this} not to match " + re + ); +} +__name(assertMatch, "assertMatch"); +Assertion.addMethod("match", assertMatch); +Assertion.addMethod("matches", assertMatch); +Assertion.addMethod("string", function(str, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(obj, flagMsg, ssfi, true).is.a("string"); + this.assert( + ~obj.indexOf(str), + "expected #{this} to contain " + inspect2(str), + "expected #{this} to not contain " + inspect2(str) + ); +}); +function assertKeys(keys) { + let obj = flag2(this, "object"), objType = type(obj), keysType = type(keys), ssfi = flag2(this, "ssfi"), isDeep = flag2(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag2(this, "message"); + flagMsg = flagMsg ? flagMsg + ": " : ""; + let mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments"; + if (objType === "Map" || objType === "Set") { + deepStr = isDeep ? "deeply " : ""; + actual = []; + obj.forEach(function(val, key) { + actual.push(key); + }); + if (keysType !== "Array") { + keys = Array.prototype.slice.call(arguments); + } + } else { + actual = getOwnEnumerableProperties(obj); + switch (keysType) { + case "Array": + if (arguments.length > 1) { + throw new AssertionError(mixedArgsMsg, void 0, ssfi); + } + break; + case "Object": + if (arguments.length > 1) { + throw new AssertionError(mixedArgsMsg, void 0, ssfi); + } + keys = Object.keys(keys); + break; + default: + keys = Array.prototype.slice.call(arguments); + } + keys = keys.map(function(val) { + return typeof val === "symbol" ? val : String(val); + }); + } + if (!keys.length) { + throw new AssertionError(flagMsg + "keys required", void 0, ssfi); + } + let len = keys.length, any = flag2(this, "any"), all = flag2(this, "all"), expected = keys, isEql = isDeep ? flag2(this, "eql") : (val1, val2) => val1 === val2; + if (!any && !all) { + all = true; + } + if (any) { + ok = expected.some(function(expectedKey) { + return actual.some(function(actualKey) { + return isEql(expectedKey, actualKey); + }); + }); + } + if (all) { + ok = expected.every(function(expectedKey) { + return actual.some(function(actualKey) { + return isEql(expectedKey, actualKey); + }); + }); + if (!flag2(this, "contains")) { + ok = ok && keys.length == actual.length; + } + } + if (len > 1) { + keys = keys.map(function(key) { + return inspect2(key); + }); + let last = keys.pop(); + if (all) { + str = keys.join(", ") + ", and " + last; + } + if (any) { + str = keys.join(", ") + ", or " + last; + } + } else { + str = inspect2(keys[0]); + } + str = (len > 1 ? "keys " : "key ") + str; + str = (flag2(this, "contains") ? "contain " : "have ") + str; + this.assert( + ok, + "expected #{this} to " + deepStr + str, + "expected #{this} to not " + deepStr + str, + expected.slice(0).sort(compareByInspect), + actual.sort(compareByInspect), + true + ); +} +__name(assertKeys, "assertKeys"); +Assertion.addMethod("keys", assertKeys); +Assertion.addMethod("key", assertKeys); +function assertThrows(errorLike, errMsgMatcher, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false; + new Assertion(obj, flagMsg, ssfi, true).is.a("function"); + if (isRegExp2(errorLike) || typeof errorLike === "string") { + errMsgMatcher = errorLike; + errorLike = null; + } + let caughtErr; + let errorWasThrown = false; + try { + obj(); + } catch (err) { + errorWasThrown = true; + caughtErr = err; + } + let everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0; + let everyArgIsDefined = Boolean(errorLike && errMsgMatcher); + let errorLikeFail = false; + let errMsgMatcherFail = false; + if (everyArgIsUndefined || !everyArgIsUndefined && !negate) { + let errorLikeString = "an error"; + if (errorLike instanceof Error) { + errorLikeString = "#{exp}"; + } else if (errorLike) { + errorLikeString = check_error_exports.getConstructorName(errorLike); + } + let actual = caughtErr; + if (caughtErr instanceof Error) { + actual = caughtErr.toString(); + } else if (typeof caughtErr === "string") { + actual = caughtErr; + } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) { + try { + actual = check_error_exports.getConstructorName(caughtErr); + } catch (_err) { + } + } + this.assert( + errorWasThrown, + "expected #{this} to throw " + errorLikeString, + "expected #{this} to not throw an error but #{act} was thrown", + errorLike && errorLike.toString(), + actual + ); + } + if (errorLike && caughtErr) { + if (errorLike instanceof Error) { + let isCompatibleInstance = check_error_exports.compatibleInstance( + caughtErr, + errorLike + ); + if (isCompatibleInstance === negate) { + if (everyArgIsDefined && negate) { + errorLikeFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""), + errorLike.toString(), + caughtErr.toString() + ); + } + } + } + let isCompatibleConstructor = check_error_exports.compatibleConstructor( + caughtErr, + errorLike + ); + if (isCompatibleConstructor === negate) { + if (everyArgIsDefined && negate) { + errorLikeFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), + errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), + caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr) + ); + } + } + } + if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) { + let placeholder = "including"; + if (isRegExp2(errMsgMatcher)) { + placeholder = "matching"; + } + let isCompatibleMessage = check_error_exports.compatibleMessage( + caughtErr, + errMsgMatcher + ); + if (isCompatibleMessage === negate) { + if (everyArgIsDefined && negate) { + errMsgMatcherFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}", + "expected #{this} to throw error not " + placeholder + " #{exp}", + errMsgMatcher, + check_error_exports.getMessage(caughtErr) + ); + } + } + } + if (errorLikeFail && errMsgMatcherFail) { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), + errorLike instanceof Error ? errorLike.toString() : errorLike && check_error_exports.getConstructorName(errorLike), + caughtErr instanceof Error ? caughtErr.toString() : caughtErr && check_error_exports.getConstructorName(caughtErr) + ); + } + flag2(this, "object", caughtErr); +} +__name(assertThrows, "assertThrows"); +Assertion.addMethod("throw", assertThrows); +Assertion.addMethod("throws", assertThrows); +Assertion.addMethod("Throw", assertThrows); +function respondTo(method, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), itself = flag2(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method]; + this.assert( + "function" === typeof context, + "expected #{this} to respond to " + inspect2(method), + "expected #{this} to not respond to " + inspect2(method) + ); +} +__name(respondTo, "respondTo"); +Assertion.addMethod("respondTo", respondTo); +Assertion.addMethod("respondsTo", respondTo); +Assertion.addProperty("itself", function() { + flag2(this, "itself", true); +}); +function satisfy(matcher, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"); + let result = matcher(obj); + this.assert( + result, + "expected #{this} to satisfy " + objDisplay(matcher), + "expected #{this} to not satisfy" + objDisplay(matcher), + flag2(this, "negate") ? false : true, + result + ); +} +__name(satisfy, "satisfy"); +Assertion.addMethod("satisfy", satisfy); +Assertion.addMethod("satisfies", satisfy); +function closeTo(expected, delta, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(obj, flagMsg, ssfi, true).is.numeric; + let message = "A `delta` value is required for `closeTo`"; + if (delta == void 0) { + throw new AssertionError( + flagMsg ? `${flagMsg}: ${message}` : message, + void 0, + ssfi + ); + } + new Assertion(delta, flagMsg, ssfi, true).is.numeric; + message = "A `expected` value is required for `closeTo`"; + if (expected == void 0) { + throw new AssertionError( + flagMsg ? `${flagMsg}: ${message}` : message, + void 0, + ssfi + ); + } + new Assertion(expected, flagMsg, ssfi, true).is.numeric; + const abs = /* @__PURE__ */ __name((x) => x < 0 ? -x : x, "abs"); + const strip = /* @__PURE__ */ __name((number) => parseFloat(parseFloat(number).toPrecision(12)), "strip"); + this.assert( + strip(abs(obj - expected)) <= delta, + "expected #{this} to be close to " + expected + " +/- " + delta, + "expected #{this} not to be close to " + expected + " +/- " + delta + ); +} +__name(closeTo, "closeTo"); +Assertion.addMethod("closeTo", closeTo); +Assertion.addMethod("approximately", closeTo); +function isSubsetOf(_subset, _superset, cmp, contains, ordered) { + let superset = Array.from(_superset); + let subset = Array.from(_subset); + if (!contains) { + if (subset.length !== superset.length) return false; + superset = superset.slice(); + } + return subset.every(function(elem, idx) { + if (ordered) return cmp ? cmp(elem, superset[idx]) : elem === superset[idx]; + if (!cmp) { + let matchIdx = superset.indexOf(elem); + if (matchIdx === -1) return false; + if (!contains) superset.splice(matchIdx, 1); + return true; + } + return superset.some(function(elem2, matchIdx) { + if (!cmp(elem, elem2)) return false; + if (!contains) superset.splice(matchIdx, 1); + return true; + }); + }); +} +__name(isSubsetOf, "isSubsetOf"); +Assertion.addMethod("members", function(subset, msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(obj, flagMsg, ssfi, true).to.be.iterable; + new Assertion(subset, flagMsg, ssfi, true).to.be.iterable; + let contains = flag2(this, "contains"); + let ordered = flag2(this, "ordered"); + let subject, failMsg, failNegateMsg; + if (contains) { + subject = ordered ? "an ordered superset" : "a superset"; + failMsg = "expected #{this} to be " + subject + " of #{exp}"; + failNegateMsg = "expected #{this} to not be " + subject + " of #{exp}"; + } else { + subject = ordered ? "ordered members" : "members"; + failMsg = "expected #{this} to have the same " + subject + " as #{exp}"; + failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}"; + } + let cmp = flag2(this, "deep") ? flag2(this, "eql") : void 0; + this.assert( + isSubsetOf(subset, obj, cmp, contains, ordered), + failMsg, + failNegateMsg, + subset, + obj, + true + ); +}); +Assertion.addProperty("iterable", function(msg) { + if (msg) flag2(this, "message", msg); + let obj = flag2(this, "object"); + this.assert( + obj != void 0 && obj[Symbol.iterator], + "expected #{this} to be an iterable", + "expected #{this} to not be an iterable", + obj + ); +}); +function oneOf(list, msg) { + if (msg) flag2(this, "message", msg); + let expected = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"), contains = flag2(this, "contains"), isDeep = flag2(this, "deep"), eql = flag2(this, "eql"); + new Assertion(list, flagMsg, ssfi, true).to.be.an("array"); + if (contains) { + this.assert( + list.some(function(possibility) { + return expected.indexOf(possibility) > -1; + }), + "expected #{this} to contain one of #{exp}", + "expected #{this} to not contain one of #{exp}", + list, + expected + ); + } else { + if (isDeep) { + this.assert( + list.some(function(possibility) { + return eql(expected, possibility); + }), + "expected #{this} to deeply equal one of #{exp}", + "expected #{this} to deeply equal one of #{exp}", + list, + expected + ); + } else { + this.assert( + list.indexOf(expected) > -1, + "expected #{this} to be one of #{exp}", + "expected #{this} to not be one of #{exp}", + list, + expected + ); + } + } +} +__name(oneOf, "oneOf"); +Assertion.addMethod("oneOf", oneOf); +function assertChanges(subject, prop, msg) { + if (msg) flag2(this, "message", msg); + let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(fn, flagMsg, ssfi, true).is.a("function"); + let initial; + if (!prop) { + new Assertion(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + fn(); + let final = prop === void 0 || prop === null ? subject() : subject[prop]; + let msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag2(this, "deltaMsgObj", msgObj); + flag2(this, "initialDeltaValue", initial); + flag2(this, "finalDeltaValue", final); + flag2(this, "deltaBehavior", "change"); + flag2(this, "realDelta", final !== initial); + this.assert( + initial !== final, + "expected " + msgObj + " to change", + "expected " + msgObj + " to not change" + ); +} +__name(assertChanges, "assertChanges"); +Assertion.addMethod("change", assertChanges); +Assertion.addMethod("changes", assertChanges); +function assertIncreases(subject, prop, msg) { + if (msg) flag2(this, "message", msg); + let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(fn, flagMsg, ssfi, true).is.a("function"); + let initial; + if (!prop) { + new Assertion(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + new Assertion(initial, flagMsg, ssfi, true).is.a("number"); + fn(); + let final = prop === void 0 || prop === null ? subject() : subject[prop]; + let msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag2(this, "deltaMsgObj", msgObj); + flag2(this, "initialDeltaValue", initial); + flag2(this, "finalDeltaValue", final); + flag2(this, "deltaBehavior", "increase"); + flag2(this, "realDelta", final - initial); + this.assert( + final - initial > 0, + "expected " + msgObj + " to increase", + "expected " + msgObj + " to not increase" + ); +} +__name(assertIncreases, "assertIncreases"); +Assertion.addMethod("increase", assertIncreases); +Assertion.addMethod("increases", assertIncreases); +function assertDecreases(subject, prop, msg) { + if (msg) flag2(this, "message", msg); + let fn = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi"); + new Assertion(fn, flagMsg, ssfi, true).is.a("function"); + let initial; + if (!prop) { + new Assertion(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + new Assertion(initial, flagMsg, ssfi, true).is.a("number"); + fn(); + let final = prop === void 0 || prop === null ? subject() : subject[prop]; + let msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag2(this, "deltaMsgObj", msgObj); + flag2(this, "initialDeltaValue", initial); + flag2(this, "finalDeltaValue", final); + flag2(this, "deltaBehavior", "decrease"); + flag2(this, "realDelta", initial - final); + this.assert( + final - initial < 0, + "expected " + msgObj + " to decrease", + "expected " + msgObj + " to not decrease" + ); +} +__name(assertDecreases, "assertDecreases"); +Assertion.addMethod("decrease", assertDecreases); +Assertion.addMethod("decreases", assertDecreases); +function assertDelta(delta, msg) { + if (msg) flag2(this, "message", msg); + let msgObj = flag2(this, "deltaMsgObj"); + let initial = flag2(this, "initialDeltaValue"); + let final = flag2(this, "finalDeltaValue"); + let behavior = flag2(this, "deltaBehavior"); + let realDelta = flag2(this, "realDelta"); + let expression; + if (behavior === "change") { + expression = Math.abs(final - initial) === Math.abs(delta); + } else { + expression = realDelta === Math.abs(delta); + } + this.assert( + expression, + "expected " + msgObj + " to " + behavior + " by " + delta, + "expected " + msgObj + " to not " + behavior + " by " + delta + ); +} +__name(assertDelta, "assertDelta"); +Assertion.addMethod("by", assertDelta); +Assertion.addProperty("extensible", function() { + let obj = flag2(this, "object"); + let isExtensible = obj === Object(obj) && Object.isExtensible(obj); + this.assert( + isExtensible, + "expected #{this} to be extensible", + "expected #{this} to not be extensible" + ); +}); +Assertion.addProperty("sealed", function() { + let obj = flag2(this, "object"); + let isSealed = obj === Object(obj) ? Object.isSealed(obj) : true; + this.assert( + isSealed, + "expected #{this} to be sealed", + "expected #{this} to not be sealed" + ); +}); +Assertion.addProperty("frozen", function() { + let obj = flag2(this, "object"); + let isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true; + this.assert( + isFrozen, + "expected #{this} to be frozen", + "expected #{this} to not be frozen" + ); +}); +Assertion.addProperty("finite", function(_msg) { + let obj = flag2(this, "object"); + this.assert( + typeof obj === "number" && isFinite(obj), + "expected #{this} to be a finite number", + "expected #{this} to not be a finite number" + ); +}); +function compareSubset(expected, actual) { + if (expected === actual) { + return true; + } + if (typeof actual !== typeof expected) { + return false; + } + if (typeof expected !== "object" || expected === null) { + return expected === actual; + } + if (!actual) { + return false; + } + if (Array.isArray(expected)) { + if (!Array.isArray(actual)) { + return false; + } + return expected.every(function(exp) { + return actual.some(function(act) { + return compareSubset(exp, act); + }); + }); + } + if (expected instanceof Date) { + if (actual instanceof Date) { + return expected.getTime() === actual.getTime(); + } else { + return false; + } + } + return Object.keys(expected).every(function(key) { + let expectedValue = expected[key]; + let actualValue = actual[key]; + if (typeof expectedValue === "object" && expectedValue !== null && actualValue !== null) { + return compareSubset(expectedValue, actualValue); + } + if (typeof expectedValue === "function") { + return expectedValue(actualValue); + } + return actualValue === expectedValue; + }); +} +__name(compareSubset, "compareSubset"); +Assertion.addMethod("containSubset", function(expected) { + const actual = flag(this, "object"); + const showDiff = config.showDiff; + this.assert( + compareSubset(expected, actual), + "expected #{act} to contain subset #{exp}", + "expected #{act} to not contain subset #{exp}", + expected, + actual, + showDiff + ); +}); + +// lib/chai/interface/expect.js +function expect(val, message) { + return new Assertion(val, message); +} +__name(expect, "expect"); +expect.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "expect.fail()"; + throw new AssertionError( + message, + { + actual, + expected, + operator + }, + expect.fail + ); +}; + +// lib/chai/interface/should.js +var should_exports = {}; +__export(should_exports, { + Should: () => Should, + should: () => should +}); +function loadShould() { + function shouldGetter() { + if (this instanceof String || this instanceof Number || this instanceof Boolean || typeof Symbol === "function" && this instanceof Symbol || typeof BigInt === "function" && this instanceof BigInt) { + return new Assertion(this.valueOf(), null, shouldGetter); + } + return new Assertion(this, null, shouldGetter); + } + __name(shouldGetter, "shouldGetter"); + function shouldSetter(value) { + Object.defineProperty(this, "should", { + value, + enumerable: true, + configurable: true, + writable: true + }); + } + __name(shouldSetter, "shouldSetter"); + Object.defineProperty(Object.prototype, "should", { + set: shouldSetter, + get: shouldGetter, + configurable: true + }); + let should2 = {}; + should2.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "should.fail()"; + throw new AssertionError( + message, + { + actual, + expected, + operator + }, + should2.fail + ); + }; + should2.equal = function(actual, expected, message) { + new Assertion(actual, message).to.equal(expected); + }; + should2.Throw = function(fn, errt, errs, msg) { + new Assertion(fn, msg).to.Throw(errt, errs); + }; + should2.exist = function(val, msg) { + new Assertion(val, msg).to.exist; + }; + should2.not = {}; + should2.not.equal = function(actual, expected, msg) { + new Assertion(actual, msg).to.not.equal(expected); + }; + should2.not.Throw = function(fn, errt, errs, msg) { + new Assertion(fn, msg).to.not.Throw(errt, errs); + }; + should2.not.exist = function(val, msg) { + new Assertion(val, msg).to.not.exist; + }; + should2["throw"] = should2["Throw"]; + should2.not["throw"] = should2.not["Throw"]; + return should2; +} +__name(loadShould, "loadShould"); +var should = loadShould; +var Should = loadShould; + +// lib/chai/interface/assert.js +function assert(express, errmsg) { + let test2 = new Assertion(null, null, assert, true); + test2.assert(express, errmsg, "[ negation message unavailable ]"); +} +__name(assert, "assert"); +assert.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "assert.fail()"; + throw new AssertionError( + message, + { + actual, + expected, + operator + }, + assert.fail + ); +}; +assert.isOk = function(val, msg) { + new Assertion(val, msg, assert.isOk, true).is.ok; +}; +assert.isNotOk = function(val, msg) { + new Assertion(val, msg, assert.isNotOk, true).is.not.ok; +}; +assert.equal = function(act, exp, msg) { + let test2 = new Assertion(act, msg, assert.equal, true); + test2.assert( + exp == flag(test2, "object"), + "expected #{this} to equal #{exp}", + "expected #{this} to not equal #{act}", + exp, + act, + true + ); +}; +assert.notEqual = function(act, exp, msg) { + let test2 = new Assertion(act, msg, assert.notEqual, true); + test2.assert( + exp != flag(test2, "object"), + "expected #{this} to not equal #{exp}", + "expected #{this} to equal #{act}", + exp, + act, + true + ); +}; +assert.strictEqual = function(act, exp, msg) { + new Assertion(act, msg, assert.strictEqual, true).to.equal(exp); +}; +assert.notStrictEqual = function(act, exp, msg) { + new Assertion(act, msg, assert.notStrictEqual, true).to.not.equal(exp); +}; +assert.deepEqual = assert.deepStrictEqual = function(act, exp, msg) { + new Assertion(act, msg, assert.deepEqual, true).to.eql(exp); +}; +assert.notDeepEqual = function(act, exp, msg) { + new Assertion(act, msg, assert.notDeepEqual, true).to.not.eql(exp); +}; +assert.isAbove = function(val, abv, msg) { + new Assertion(val, msg, assert.isAbove, true).to.be.above(abv); +}; +assert.isAtLeast = function(val, atlst, msg) { + new Assertion(val, msg, assert.isAtLeast, true).to.be.least(atlst); +}; +assert.isBelow = function(val, blw, msg) { + new Assertion(val, msg, assert.isBelow, true).to.be.below(blw); +}; +assert.isAtMost = function(val, atmst, msg) { + new Assertion(val, msg, assert.isAtMost, true).to.be.most(atmst); +}; +assert.isTrue = function(val, msg) { + new Assertion(val, msg, assert.isTrue, true).is["true"]; +}; +assert.isNotTrue = function(val, msg) { + new Assertion(val, msg, assert.isNotTrue, true).to.not.equal(true); +}; +assert.isFalse = function(val, msg) { + new Assertion(val, msg, assert.isFalse, true).is["false"]; +}; +assert.isNotFalse = function(val, msg) { + new Assertion(val, msg, assert.isNotFalse, true).to.not.equal(false); +}; +assert.isNull = function(val, msg) { + new Assertion(val, msg, assert.isNull, true).to.equal(null); +}; +assert.isNotNull = function(val, msg) { + new Assertion(val, msg, assert.isNotNull, true).to.not.equal(null); +}; +assert.isNaN = function(val, msg) { + new Assertion(val, msg, assert.isNaN, true).to.be.NaN; +}; +assert.isNotNaN = function(value, message) { + new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN; +}; +assert.exists = function(val, msg) { + new Assertion(val, msg, assert.exists, true).to.exist; +}; +assert.notExists = function(val, msg) { + new Assertion(val, msg, assert.notExists, true).to.not.exist; +}; +assert.isUndefined = function(val, msg) { + new Assertion(val, msg, assert.isUndefined, true).to.equal(void 0); +}; +assert.isDefined = function(val, msg) { + new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0); +}; +assert.isCallable = function(value, message) { + new Assertion(value, message, assert.isCallable, true).is.callable; +}; +assert.isNotCallable = function(value, message) { + new Assertion(value, message, assert.isNotCallable, true).is.not.callable; +}; +assert.isObject = function(val, msg) { + new Assertion(val, msg, assert.isObject, true).to.be.a("object"); +}; +assert.isNotObject = function(val, msg) { + new Assertion(val, msg, assert.isNotObject, true).to.not.be.a("object"); +}; +assert.isArray = function(val, msg) { + new Assertion(val, msg, assert.isArray, true).to.be.an("array"); +}; +assert.isNotArray = function(val, msg) { + new Assertion(val, msg, assert.isNotArray, true).to.not.be.an("array"); +}; +assert.isString = function(val, msg) { + new Assertion(val, msg, assert.isString, true).to.be.a("string"); +}; +assert.isNotString = function(val, msg) { + new Assertion(val, msg, assert.isNotString, true).to.not.be.a("string"); +}; +assert.isNumber = function(val, msg) { + new Assertion(val, msg, assert.isNumber, true).to.be.a("number"); +}; +assert.isNotNumber = function(val, msg) { + new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a("number"); +}; +assert.isNumeric = function(val, msg) { + new Assertion(val, msg, assert.isNumeric, true).is.numeric; +}; +assert.isNotNumeric = function(val, msg) { + new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric; +}; +assert.isFinite = function(val, msg) { + new Assertion(val, msg, assert.isFinite, true).to.be.finite; +}; +assert.isBoolean = function(val, msg) { + new Assertion(val, msg, assert.isBoolean, true).to.be.a("boolean"); +}; +assert.isNotBoolean = function(val, msg) { + new Assertion(val, msg, assert.isNotBoolean, true).to.not.be.a("boolean"); +}; +assert.typeOf = function(val, type3, msg) { + new Assertion(val, msg, assert.typeOf, true).to.be.a(type3); +}; +assert.notTypeOf = function(value, type3, message) { + new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3); +}; +assert.instanceOf = function(val, type3, msg) { + new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3); +}; +assert.notInstanceOf = function(val, type3, msg) { + new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf( + type3 + ); +}; +assert.include = function(exp, inc, msg) { + new Assertion(exp, msg, assert.include, true).include(inc); +}; +assert.notInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.notInclude, true).not.include(inc); +}; +assert.deepInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.deepInclude, true).deep.include(inc); +}; +assert.notDeepInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.notDeepInclude, true).not.deep.include(inc); +}; +assert.nestedInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.nestedInclude, true).nested.include(inc); +}; +assert.notNestedInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include( + inc + ); +}; +assert.deepNestedInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include( + inc + ); +}; +assert.notDeepNestedInclude = function(exp, inc, msg) { + new Assertion( + exp, + msg, + assert.notDeepNestedInclude, + true + ).not.deep.nested.include(inc); +}; +assert.ownInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.ownInclude, true).own.include(inc); +}; +assert.notOwnInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc); +}; +assert.deepOwnInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc); +}; +assert.notDeepOwnInclude = function(exp, inc, msg) { + new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include( + inc + ); +}; +assert.match = function(exp, re, msg) { + new Assertion(exp, msg, assert.match, true).to.match(re); +}; +assert.notMatch = function(exp, re, msg) { + new Assertion(exp, msg, assert.notMatch, true).to.not.match(re); +}; +assert.property = function(obj, prop, msg) { + new Assertion(obj, msg, assert.property, true).to.have.property(prop); +}; +assert.notProperty = function(obj, prop, msg) { + new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop); +}; +assert.propertyVal = function(obj, prop, val, msg) { + new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val); +}; +assert.notPropertyVal = function(obj, prop, val, msg) { + new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property( + prop, + val + ); +}; +assert.deepPropertyVal = function(obj, prop, val, msg) { + new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property( + prop, + val + ); +}; +assert.notDeepPropertyVal = function(obj, prop, val, msg) { + new Assertion( + obj, + msg, + assert.notDeepPropertyVal, + true + ).to.not.have.deep.property(prop, val); +}; +assert.ownProperty = function(obj, prop, msg) { + new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop); +}; +assert.notOwnProperty = function(obj, prop, msg) { + new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property( + prop + ); +}; +assert.ownPropertyVal = function(obj, prop, value, msg) { + new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property( + prop, + value + ); +}; +assert.notOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion( + obj, + msg, + assert.notOwnPropertyVal, + true + ).to.not.have.own.property(prop, value); +}; +assert.deepOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion( + obj, + msg, + assert.deepOwnPropertyVal, + true + ).to.have.deep.own.property(prop, value); +}; +assert.notDeepOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion( + obj, + msg, + assert.notDeepOwnPropertyVal, + true + ).to.not.have.deep.own.property(prop, value); +}; +assert.nestedProperty = function(obj, prop, msg) { + new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property( + prop + ); +}; +assert.notNestedProperty = function(obj, prop, msg) { + new Assertion( + obj, + msg, + assert.notNestedProperty, + true + ).to.not.have.nested.property(prop); +}; +assert.nestedPropertyVal = function(obj, prop, val, msg) { + new Assertion( + obj, + msg, + assert.nestedPropertyVal, + true + ).to.have.nested.property(prop, val); +}; +assert.notNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion( + obj, + msg, + assert.notNestedPropertyVal, + true + ).to.not.have.nested.property(prop, val); +}; +assert.deepNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion( + obj, + msg, + assert.deepNestedPropertyVal, + true + ).to.have.deep.nested.property(prop, val); +}; +assert.notDeepNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion( + obj, + msg, + assert.notDeepNestedPropertyVal, + true + ).to.not.have.deep.nested.property(prop, val); +}; +assert.lengthOf = function(exp, len, msg) { + new Assertion(exp, msg, assert.lengthOf, true).to.have.lengthOf(len); +}; +assert.hasAnyKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys); +}; +assert.hasAllKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys); +}; +assert.containsAllKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys( + keys + ); +}; +assert.doesNotHaveAnyKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys( + keys + ); +}; +assert.doesNotHaveAllKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys( + keys + ); +}; +assert.hasAnyDeepKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys( + keys + ); +}; +assert.hasAllDeepKeys = function(obj, keys, msg) { + new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys( + keys + ); +}; +assert.containsAllDeepKeys = function(obj, keys, msg) { + new Assertion( + obj, + msg, + assert.containsAllDeepKeys, + true + ).to.contain.all.deep.keys(keys); +}; +assert.doesNotHaveAnyDeepKeys = function(obj, keys, msg) { + new Assertion( + obj, + msg, + assert.doesNotHaveAnyDeepKeys, + true + ).to.not.have.any.deep.keys(keys); +}; +assert.doesNotHaveAllDeepKeys = function(obj, keys, msg) { + new Assertion( + obj, + msg, + assert.doesNotHaveAllDeepKeys, + true + ).to.not.have.all.deep.keys(keys); +}; +assert.throws = function(fn, errorLike, errMsgMatcher, msg) { + if ("string" === typeof errorLike || errorLike instanceof RegExp) { + errMsgMatcher = errorLike; + errorLike = null; + } + let assertErr = new Assertion(fn, msg, assert.throws, true).to.throw( + errorLike, + errMsgMatcher + ); + return flag(assertErr, "object"); +}; +assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) { + if ("string" === typeof errorLike || errorLike instanceof RegExp) { + errMsgMatcher = errorLike; + errorLike = null; + } + new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw( + errorLike, + errMsgMatcher + ); +}; +assert.operator = function(val, operator, val2, msg) { + let ok; + switch (operator) { + case "==": + ok = val == val2; + break; + case "===": + ok = val === val2; + break; + case ">": + ok = val > val2; + break; + case ">=": + ok = val >= val2; + break; + case "<": + ok = val < val2; + break; + case "<=": + ok = val <= val2; + break; + case "!=": + ok = val != val2; + break; + case "!==": + ok = val !== val2; + break; + default: + msg = msg ? msg + ": " : msg; + throw new AssertionError( + msg + 'Invalid operator "' + operator + '"', + void 0, + assert.operator + ); + } + let test2 = new Assertion(ok, msg, assert.operator, true); + test2.assert( + true === flag(test2, "object"), + "expected " + inspect2(val) + " to be " + operator + " " + inspect2(val2), + "expected " + inspect2(val) + " to not be " + operator + " " + inspect2(val2) + ); +}; +assert.closeTo = function(act, exp, delta, msg) { + new Assertion(act, msg, assert.closeTo, true).to.be.closeTo(exp, delta); +}; +assert.approximately = function(act, exp, delta, msg) { + new Assertion(act, msg, assert.approximately, true).to.be.approximately( + exp, + delta + ); +}; +assert.sameMembers = function(set1, set2, msg) { + new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set2); +}; +assert.notSameMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.notSameMembers, + true + ).to.not.have.same.members(set2); +}; +assert.sameDeepMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.sameDeepMembers, + true + ).to.have.same.deep.members(set2); +}; +assert.notSameDeepMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.notSameDeepMembers, + true + ).to.not.have.same.deep.members(set2); +}; +assert.sameOrderedMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.sameOrderedMembers, + true + ).to.have.same.ordered.members(set2); +}; +assert.notSameOrderedMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.notSameOrderedMembers, + true + ).to.not.have.same.ordered.members(set2); +}; +assert.sameDeepOrderedMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.sameDeepOrderedMembers, + true + ).to.have.same.deep.ordered.members(set2); +}; +assert.notSameDeepOrderedMembers = function(set1, set2, msg) { + new Assertion( + set1, + msg, + assert.notSameDeepOrderedMembers, + true + ).to.not.have.same.deep.ordered.members(set2); +}; +assert.includeMembers = function(superset, subset, msg) { + new Assertion(superset, msg, assert.includeMembers, true).to.include.members( + subset + ); +}; +assert.notIncludeMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.notIncludeMembers, + true + ).to.not.include.members(subset); +}; +assert.includeDeepMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.includeDeepMembers, + true + ).to.include.deep.members(subset); +}; +assert.notIncludeDeepMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.notIncludeDeepMembers, + true + ).to.not.include.deep.members(subset); +}; +assert.includeOrderedMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.includeOrderedMembers, + true + ).to.include.ordered.members(subset); +}; +assert.notIncludeOrderedMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.notIncludeOrderedMembers, + true + ).to.not.include.ordered.members(subset); +}; +assert.includeDeepOrderedMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.includeDeepOrderedMembers, + true + ).to.include.deep.ordered.members(subset); +}; +assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) { + new Assertion( + superset, + msg, + assert.notIncludeDeepOrderedMembers, + true + ).to.not.include.deep.ordered.members(subset); +}; +assert.oneOf = function(inList, list, msg) { + new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list); +}; +assert.isIterable = function(obj, msg) { + if (obj == void 0 || !obj[Symbol.iterator]) { + msg = msg ? `${msg} expected ${inspect2(obj)} to be an iterable` : `expected ${inspect2(obj)} to be an iterable`; + throw new AssertionError(msg, void 0, assert.isIterable); + } +}; +assert.changes = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + new Assertion(fn, msg, assert.changes, true).to.change(obj, prop); +}; +assert.changesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.changesBy, true).to.change(obj, prop).by(delta); +}; +assert.doesNotChange = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change( + obj, + prop + ); +}; +assert.changesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.changesButNotBy, true).to.change(obj, prop).but.not.by(delta); +}; +assert.increases = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion(fn, msg, assert.increases, true).to.increase(obj, prop); +}; +assert.increasesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.increasesBy, true).to.increase(obj, prop).by(delta); +}; +assert.doesNotIncrease = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase( + obj, + prop + ); +}; +assert.increasesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta); +}; +assert.decreases = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion(fn, msg, assert.decreases, true).to.decrease(obj, prop); +}; +assert.decreasesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.decreasesBy, true).to.decrease(obj, prop).by(delta); +}; +assert.doesNotDecrease = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease( + obj, + prop + ); +}; +assert.doesNotDecreaseBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + return new Assertion(fn, msg, assert.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta); +}; +assert.decreasesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + let tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion(fn, msg, assert.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta); +}; +assert.ifError = function(val) { + if (val) { + throw val; + } +}; +assert.isExtensible = function(obj, msg) { + new Assertion(obj, msg, assert.isExtensible, true).to.be.extensible; +}; +assert.isNotExtensible = function(obj, msg) { + new Assertion(obj, msg, assert.isNotExtensible, true).to.not.be.extensible; +}; +assert.isSealed = function(obj, msg) { + new Assertion(obj, msg, assert.isSealed, true).to.be.sealed; +}; +assert.isNotSealed = function(obj, msg) { + new Assertion(obj, msg, assert.isNotSealed, true).to.not.be.sealed; +}; +assert.isFrozen = function(obj, msg) { + new Assertion(obj, msg, assert.isFrozen, true).to.be.frozen; +}; +assert.isNotFrozen = function(obj, msg) { + new Assertion(obj, msg, assert.isNotFrozen, true).to.not.be.frozen; +}; +assert.isEmpty = function(val, msg) { + new Assertion(val, msg, assert.isEmpty, true).to.be.empty; +}; +assert.isNotEmpty = function(val, msg) { + new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty; +}; +assert.containsSubset = function(val, exp, msg) { + new Assertion(val, msg).to.containSubset(exp); +}; +assert.doesNotContainSubset = function(val, exp, msg) { + new Assertion(val, msg).to.not.containSubset(exp); +}; +var aliases = [ + ["isOk", "ok"], + ["isNotOk", "notOk"], + ["throws", "throw"], + ["throws", "Throw"], + ["isExtensible", "extensible"], + ["isNotExtensible", "notExtensible"], + ["isSealed", "sealed"], + ["isNotSealed", "notSealed"], + ["isFrozen", "frozen"], + ["isNotFrozen", "notFrozen"], + ["isEmpty", "empty"], + ["isNotEmpty", "notEmpty"], + ["isCallable", "isFunction"], + ["isNotCallable", "isNotFunction"], + ["containsSubset", "containSubset"] +]; +for (const [name, as] of aliases) { + assert[as] = assert[name]; +} + +// lib/chai.js +var used = []; +function use(fn) { + const exports = { + use, + AssertionError, + util: utils_exports, + config, + expect, + assert, + Assertion, + ...should_exports + }; + if (!~used.indexOf(fn)) { + fn(exports, utils_exports); + used.push(fn); + } + return exports; +} +__name(use, "use"); +export { + Assertion, + AssertionError, + Should, + assert, + config, + expect, + should, + use, + utils_exports as util +}; diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/package.json b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/package.json new file mode 100644 index 00000000..f2ad34b1 --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/package.json @@ -0,0 +1,71 @@ +{ + "author": "Jake Luer ", + "name": "chai", + "type": "module", + "description": "BDD/TDD assertion library for node.js and the browser. Test framework agnostic.", + "keywords": [ + "test", + "assertion", + "assert", + "testing", + "chai" + ], + "files": [ + "index.js", + "register-*.js" + ], + "homepage": "http://chaijs.com", + "license": "MIT", + "contributors": [ + "Jake Luer ", + "Domenic Denicola (http://domenicdenicola.com)", + "Veselin Todorov ", + "John Firebaugh " + ], + "version": "6.2.2", + "repository": { + "type": "git", + "url": "https://github.com/chaijs/chai" + }, + "bugs": { + "url": "https://github.com/chaijs/chai/issues" + }, + "main": "./index.js", + "scripts": { + "build": "esbuild --bundle --format=esm --target=es2021 --keep-names --legal-comments=none --outfile=index.js lib/chai.js", + "prebuild": "npm run clean", + "format": "prettier --write lib", + "pretest": "npm run lint", + "test": "npm run test-node && npm run test-chrome", + "test-node": "c8 --99 --check-coverage mocha --require ./test/bootstrap/index.js test/*.js", + "test-chrome": "web-test-runner --playwright", + "lint": "npm run lint:js && npm run lint:format", + "lint:js": "eslint lib/", + "lint:format": "prettier --check lib", + "lint:types": "tsc", + "clean": "rm -rf index.js coverage/" + }, + "engines": { + "node": ">=18" + }, + "devDependencies": { + "@eslint/js": "^9.17.0", + "@rollup/plugin-commonjs": "^29.0.0", + "@web/dev-server-rollup": "^0.6.1", + "@web/test-runner": "^0.20.0", + "@web/test-runner-playwright": "^0.11.0", + "assertion-error": "^2.0.1", + "c8": "^10.1.3", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "esbuild": "^0.27.0", + "eslint": "^9.0.0", + "eslint-plugin-jsdoc": "^61.0.0", + "globals": "^16.3.0", + "loupe": "^3.1.0", + "mocha": "^11.0.0", + "pathval": "^2.0.0", + "prettier": "^3.4.2", + "typescript": "~5.9.0" + } +} diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-assert.js b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-assert.js new file mode 100644 index 00000000..f593717e --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-assert.js @@ -0,0 +1,3 @@ +import {assert} from './index.js'; + +globalThis.assert = assert; diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-expect.js b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-expect.js new file mode 100644 index 00000000..2807b89b --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-expect.js @@ -0,0 +1,3 @@ +import {expect} from './index.js'; + +globalThis.expect = expect; diff --git a/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-should.js b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-should.js new file mode 100644 index 00000000..1339ee4c --- /dev/null +++ b/backend/node_modules/.pnpm/chai@6.2.2/node_modules/chai/register-should.js @@ -0,0 +1,3 @@ +import {should} from './index.js'; + +globalThis.should = should(); diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/LICENSE b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/LICENSE new file mode 100644 index 00000000..8dada3ed --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/README.md b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/README.md new file mode 100644 index 00000000..23212fdd --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/README.md @@ -0,0 +1,163 @@ +# detect-libc + +Node.js module to detect details of the C standard library (libc) +implementation provided by a given Linux system. + +Currently supports detection of GNU glibc and MUSL libc. + +Provides asychronous and synchronous functions for the +family (e.g. `glibc`, `musl`) and version (e.g. `1.23`, `1.2.3`). + +The version numbers of libc implementations +are not guaranteed to be semver-compliant. + +For previous v1.x releases, please see the +[v1](https://github.com/lovell/detect-libc/tree/v1) branch. + +## Install + +```sh +npm install detect-libc +``` + +## API + +### GLIBC + +```ts +const GLIBC: string = 'glibc'; +``` + +A String constant containing the value `glibc`. + +### MUSL + +```ts +const MUSL: string = 'musl'; +``` + +A String constant containing the value `musl`. + +### family + +```ts +function family(): Promise; +``` + +Resolves asychronously with: + +* `glibc` or `musl` when the libc family can be determined +* `null` when the libc family cannot be determined +* `null` when run on a non-Linux platform + +```js +const { family, GLIBC, MUSL } = require('detect-libc'); + +switch (await family()) { + case GLIBC: ... + case MUSL: ... + case null: ... +} +``` + +### familySync + +```ts +function familySync(): string | null; +``` + +Synchronous version of `family()`. + +```js +const { familySync, GLIBC, MUSL } = require('detect-libc'); + +switch (familySync()) { + case GLIBC: ... + case MUSL: ... + case null: ... +} +``` + +### version + +```ts +function version(): Promise; +``` + +Resolves asychronously with: + +* The version when it can be determined +* `null` when the libc family cannot be determined +* `null` when run on a non-Linux platform + +```js +const { version } = require('detect-libc'); + +const v = await version(); +if (v) { + const [major, minor, patch] = v.split('.'); +} +``` + +### versionSync + +```ts +function versionSync(): string | null; +``` + +Synchronous version of `version()`. + +```js +const { versionSync } = require('detect-libc'); + +const v = versionSync(); +if (v) { + const [major, minor, patch] = v.split('.'); +} +``` + +### isNonGlibcLinux + +```ts +function isNonGlibcLinux(): Promise; +``` + +Resolves asychronously with: + +* `false` when the libc family is `glibc` +* `true` when the libc family is not `glibc` +* `false` when run on a non-Linux platform + +```js +const { isNonGlibcLinux } = require('detect-libc'); + +if (await isNonGlibcLinux()) { ... } +``` + +### isNonGlibcLinuxSync + +```ts +function isNonGlibcLinuxSync(): boolean; +``` + +Synchronous version of `isNonGlibcLinux()`. + +```js +const { isNonGlibcLinuxSync } = require('detect-libc'); + +if (isNonGlibcLinuxSync()) { ... } +``` + +## Licensing + +Copyright 2017 Lovell Fuller and others. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html) + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/index.d.ts b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/index.d.ts new file mode 100644 index 00000000..4c0fb2b0 --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/index.d.ts @@ -0,0 +1,14 @@ +// Copyright 2017 Lovell Fuller and others. +// SPDX-License-Identifier: Apache-2.0 + +export const GLIBC: 'glibc'; +export const MUSL: 'musl'; + +export function family(): Promise; +export function familySync(): string | null; + +export function isNonGlibcLinux(): Promise; +export function isNonGlibcLinuxSync(): boolean; + +export function version(): Promise; +export function versionSync(): string | null; diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js new file mode 100644 index 00000000..01299b4d --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js @@ -0,0 +1,313 @@ +// Copyright 2017 Lovell Fuller and others. +// SPDX-License-Identifier: Apache-2.0 + +'use strict'; + +const childProcess = require('child_process'); +const { isLinux, getReport } = require('./process'); +const { LDD_PATH, SELF_PATH, readFile, readFileSync } = require('./filesystem'); +const { interpreterPath } = require('./elf'); + +let cachedFamilyInterpreter; +let cachedFamilyFilesystem; +let cachedVersionFilesystem; + +const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true'; +let commandOut = ''; + +const safeCommand = () => { + if (!commandOut) { + return new Promise((resolve) => { + childProcess.exec(command, (err, out) => { + commandOut = err ? ' ' : out; + resolve(commandOut); + }); + }); + } + return commandOut; +}; + +const safeCommandSync = () => { + if (!commandOut) { + try { + commandOut = childProcess.execSync(command, { encoding: 'utf8' }); + } catch (_err) { + commandOut = ' '; + } + } + return commandOut; +}; + +/** + * A String constant containing the value `glibc`. + * @type {string} + * @public + */ +const GLIBC = 'glibc'; + +/** + * A Regexp constant to get the GLIBC Version. + * @type {string} + */ +const RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i; + +/** + * A String constant containing the value `musl`. + * @type {string} + * @public + */ +const MUSL = 'musl'; + +const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-'); + +const familyFromReport = () => { + const report = getReport(); + if (report.header && report.header.glibcVersionRuntime) { + return GLIBC; + } + if (Array.isArray(report.sharedObjects)) { + if (report.sharedObjects.some(isFileMusl)) { + return MUSL; + } + } + return null; +}; + +const familyFromCommand = (out) => { + const [getconf, ldd1] = out.split(/[\r\n]+/); + if (getconf && getconf.includes(GLIBC)) { + return GLIBC; + } + if (ldd1 && ldd1.includes(MUSL)) { + return MUSL; + } + return null; +}; + +const familyFromInterpreterPath = (path) => { + if (path) { + if (path.includes('/ld-musl-')) { + return MUSL; + } else if (path.includes('/ld-linux-')) { + return GLIBC; + } + } + return null; +}; + +const getFamilyFromLddContent = (content) => { + content = content.toString(); + if (content.includes('musl')) { + return MUSL; + } + if (content.includes('GNU C Library')) { + return GLIBC; + } + return null; +}; + +const familyFromFilesystem = async () => { + if (cachedFamilyFilesystem !== undefined) { + return cachedFamilyFilesystem; + } + cachedFamilyFilesystem = null; + try { + const lddContent = await readFile(LDD_PATH); + cachedFamilyFilesystem = getFamilyFromLddContent(lddContent); + } catch (e) {} + return cachedFamilyFilesystem; +}; + +const familyFromFilesystemSync = () => { + if (cachedFamilyFilesystem !== undefined) { + return cachedFamilyFilesystem; + } + cachedFamilyFilesystem = null; + try { + const lddContent = readFileSync(LDD_PATH); + cachedFamilyFilesystem = getFamilyFromLddContent(lddContent); + } catch (e) {} + return cachedFamilyFilesystem; +}; + +const familyFromInterpreter = async () => { + if (cachedFamilyInterpreter !== undefined) { + return cachedFamilyInterpreter; + } + cachedFamilyInterpreter = null; + try { + const selfContent = await readFile(SELF_PATH); + const path = interpreterPath(selfContent); + cachedFamilyInterpreter = familyFromInterpreterPath(path); + } catch (e) {} + return cachedFamilyInterpreter; +}; + +const familyFromInterpreterSync = () => { + if (cachedFamilyInterpreter !== undefined) { + return cachedFamilyInterpreter; + } + cachedFamilyInterpreter = null; + try { + const selfContent = readFileSync(SELF_PATH); + const path = interpreterPath(selfContent); + cachedFamilyInterpreter = familyFromInterpreterPath(path); + } catch (e) {} + return cachedFamilyInterpreter; +}; + +/** + * Resolves with the libc family when it can be determined, `null` otherwise. + * @returns {Promise} + */ +const family = async () => { + let family = null; + if (isLinux()) { + family = await familyFromInterpreter(); + if (!family) { + family = await familyFromFilesystem(); + if (!family) { + family = familyFromReport(); + } + if (!family) { + const out = await safeCommand(); + family = familyFromCommand(out); + } + } + } + return family; +}; + +/** + * Returns the libc family when it can be determined, `null` otherwise. + * @returns {?string} + */ +const familySync = () => { + let family = null; + if (isLinux()) { + family = familyFromInterpreterSync(); + if (!family) { + family = familyFromFilesystemSync(); + if (!family) { + family = familyFromReport(); + } + if (!family) { + const out = safeCommandSync(); + family = familyFromCommand(out); + } + } + } + return family; +}; + +/** + * Resolves `true` only when the platform is Linux and the libc family is not `glibc`. + * @returns {Promise} + */ +const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC; + +/** + * Returns `true` only when the platform is Linux and the libc family is not `glibc`. + * @returns {boolean} + */ +const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC; + +const versionFromFilesystem = async () => { + if (cachedVersionFilesystem !== undefined) { + return cachedVersionFilesystem; + } + cachedVersionFilesystem = null; + try { + const lddContent = await readFile(LDD_PATH); + const versionMatch = lddContent.match(RE_GLIBC_VERSION); + if (versionMatch) { + cachedVersionFilesystem = versionMatch[1]; + } + } catch (e) {} + return cachedVersionFilesystem; +}; + +const versionFromFilesystemSync = () => { + if (cachedVersionFilesystem !== undefined) { + return cachedVersionFilesystem; + } + cachedVersionFilesystem = null; + try { + const lddContent = readFileSync(LDD_PATH); + const versionMatch = lddContent.match(RE_GLIBC_VERSION); + if (versionMatch) { + cachedVersionFilesystem = versionMatch[1]; + } + } catch (e) {} + return cachedVersionFilesystem; +}; + +const versionFromReport = () => { + const report = getReport(); + if (report.header && report.header.glibcVersionRuntime) { + return report.header.glibcVersionRuntime; + } + return null; +}; + +const versionSuffix = (s) => s.trim().split(/\s+/)[1]; + +const versionFromCommand = (out) => { + const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/); + if (getconf && getconf.includes(GLIBC)) { + return versionSuffix(getconf); + } + if (ldd1 && ldd2 && ldd1.includes(MUSL)) { + return versionSuffix(ldd2); + } + return null; +}; + +/** + * Resolves with the libc version when it can be determined, `null` otherwise. + * @returns {Promise} + */ +const version = async () => { + let version = null; + if (isLinux()) { + version = await versionFromFilesystem(); + if (!version) { + version = versionFromReport(); + } + if (!version) { + const out = await safeCommand(); + version = versionFromCommand(out); + } + } + return version; +}; + +/** + * Returns the libc version when it can be determined, `null` otherwise. + * @returns {?string} + */ +const versionSync = () => { + let version = null; + if (isLinux()) { + version = versionFromFilesystemSync(); + if (!version) { + version = versionFromReport(); + } + if (!version) { + const out = safeCommandSync(); + version = versionFromCommand(out); + } + } + return version; +}; + +module.exports = { + GLIBC, + MUSL, + family, + familySync, + isNonGlibcLinux, + isNonGlibcLinuxSync, + version, + versionSync +}; diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js new file mode 100644 index 00000000..aa166aa2 --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js @@ -0,0 +1,39 @@ +// Copyright 2017 Lovell Fuller and others. +// SPDX-License-Identifier: Apache-2.0 + +'use strict'; + +const interpreterPath = (elf) => { + if (elf.length < 64) { + return null; + } + if (elf.readUInt32BE(0) !== 0x7F454C46) { + // Unexpected magic bytes + return null; + } + if (elf.readUInt8(4) !== 2) { + // Not a 64-bit ELF + return null; + } + if (elf.readUInt8(5) !== 1) { + // Not little-endian + return null; + } + const offset = elf.readUInt32LE(32); + const size = elf.readUInt16LE(54); + const count = elf.readUInt16LE(56); + for (let i = 0; i < count; i++) { + const headerOffset = offset + (i * size); + const type = elf.readUInt32LE(headerOffset); + if (type === 3) { + const fileOffset = elf.readUInt32LE(headerOffset + 8); + const fileSize = elf.readUInt32LE(headerOffset + 32); + return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, ''); + } + } + return null; +}; + +module.exports = { + interpreterPath +}; diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js new file mode 100644 index 00000000..4c2443cc --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js @@ -0,0 +1,51 @@ +// Copyright 2017 Lovell Fuller and others. +// SPDX-License-Identifier: Apache-2.0 + +'use strict'; + +const fs = require('fs'); + +const LDD_PATH = '/usr/bin/ldd'; +const SELF_PATH = '/proc/self/exe'; +const MAX_LENGTH = 2048; + +/** + * Read the content of a file synchronous + * + * @param {string} path + * @returns {Buffer} + */ +const readFileSync = (path) => { + const fd = fs.openSync(path, 'r'); + const buffer = Buffer.alloc(MAX_LENGTH); + const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0); + fs.close(fd, () => {}); + return buffer.subarray(0, bytesRead); +}; + +/** + * Read the content of a file + * + * @param {string} path + * @returns {Promise} + */ +const readFile = (path) => new Promise((resolve, reject) => { + fs.open(path, 'r', (err, fd) => { + if (err) { + reject(err); + } else { + const buffer = Buffer.alloc(MAX_LENGTH); + fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => { + resolve(buffer.subarray(0, bytesRead)); + fs.close(fd, () => {}); + }); + } + }); +}); + +module.exports = { + LDD_PATH, + SELF_PATH, + readFileSync, + readFile +}; diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js new file mode 100644 index 00000000..ee78ad26 --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js @@ -0,0 +1,24 @@ +// Copyright 2017 Lovell Fuller and others. +// SPDX-License-Identifier: Apache-2.0 + +'use strict'; + +const isLinux = () => process.platform === 'linux'; + +let report = null; +const getReport = () => { + if (!report) { + /* istanbul ignore next */ + if (isLinux() && process.report) { + const orig = process.report.excludeNetwork; + process.report.excludeNetwork = true; + report = process.report.getReport(); + process.report.excludeNetwork = orig; + } else { + report = {}; + } + } + return report; +}; + +module.exports = { isLinux, getReport }; diff --git a/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/package.json b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/package.json new file mode 100644 index 00000000..36d0f2be --- /dev/null +++ b/backend/node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/package.json @@ -0,0 +1,44 @@ +{ + "name": "detect-libc", + "version": "2.1.2", + "description": "Node.js module to detect the C standard library (libc) implementation family and version", + "main": "lib/detect-libc.js", + "files": [ + "lib/", + "index.d.ts" + ], + "scripts": { + "test": "semistandard && nyc --reporter=text --check-coverage --branches=100 ava test/unit.js", + "changelog": "conventional-changelog -i CHANGELOG.md -s", + "bench": "node benchmark/detect-libc", + "bench:calls": "node benchmark/call-familySync.js && sleep 1 && node benchmark/call-isNonGlibcLinuxSync.js && sleep 1 && node benchmark/call-versionSync.js" + }, + "repository": { + "type": "git", + "url": "git://github.com/lovell/detect-libc.git" + }, + "keywords": [ + "libc", + "glibc", + "musl" + ], + "author": "Lovell Fuller ", + "contributors": [ + "Niklas Salmoukas ", + "Vinícius Lourenço " + ], + "license": "Apache-2.0", + "devDependencies": { + "ava": "^2.4.0", + "benchmark": "^2.1.4", + "conventional-changelog-cli": "^5.0.0", + "eslint-config-standard": "^13.0.1", + "nyc": "^15.1.0", + "proxyquire": "^2.1.3", + "semistandard": "^14.2.3" + }, + "engines": { + "node": ">=8" + }, + "types": "index.d.ts" +} diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/LICENSE b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/LICENSE new file mode 100755 index 00000000..013561a8 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/LICENSE @@ -0,0 +1,10 @@ +MIT License +----------- + +Copyright (C) 2018-2022 Guy Bedford + +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/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/README.md b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/README.md new file mode 100755 index 00000000..73abd08e --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/README.md @@ -0,0 +1,403 @@ +# ES Module Lexer + +[![Build Status][actions-image]][actions-url] + +A JS module syntax lexer used in [es-module-shims](https://github.com/guybedford/es-module-shims). + +Outputs the list of exports and locations of import specifiers, including dynamic import and import meta handling. + +Supports new syntax features including import attributes and source phase imports. + +A very small single JS file (~7KiB gzipped) that includes inlined Web Assembly for very fast source analysis of ECMAScript module syntax only. + +For an example of the performance, Angular 1 (720KiB) is fully parsed in 5ms, in comparison to the fastest JS parser, Acorn which takes over 100ms. + +_Comprehensively handles the JS language grammar while remaining small and fast. - ~10ms per MB of JS cold and ~5ms per MB of JS warm, [see benchmarks](#benchmarks) for more info._ + +> [Built with](https://github.com/guybedford/es-module-lexer/blob/main/chompfile.toml) [Chomp](https://chompbuild.com/) + +### Usage + +``` +npm install es-module-lexer +``` + +See [src/lexer.ts](src/lexer.ts) for the type definitions. + +For use in CommonJS: + +```js +const { init, parse } = require('es-module-lexer'); + +(async () => { + // either await init, or call parse asynchronously + // this is necessary for the Web Assembly boot + await init; + + const source = 'export var p = 5'; + const [imports, exports] = parse(source); + + // Returns "p" + source.slice(exports[0].s, exports[0].e); + // Returns "p" + source.slice(exports[0].ls, exports[0].le); +})(); +``` + +An ES module version is also available: + +```js +import { init, parse } from 'es-module-lexer'; + +(async () => { + await init; + + const source = ` + import { name } from 'mod\\u1011'; + import json from './json.json' with { type: 'json' } + export var p = 5; + export function q () { + + }; + export { x as 'external name' } from 'external'; + + // Comments provided to demonstrate edge cases + import /*comment!*/ ( 'asdf', { with: { type: 'json' }}); + import /*comment!*/.meta.asdf; + + // Source phase imports: + import source mod from './mod.wasm'; + import.source('./mod.wasm'); + `; + + const [imports, exports] = parse(source, 'optional-sourcename'); + + // Returns "modထ" + imports[0].n + // Returns "mod\u1011" + source.slice(imports[0].s, imports[0].e); + // "s" = start + // "e" = end + + // Returns "import { name } from 'mod'" + source.slice(imports[0].ss, imports[0].se); + // "ss" = statement start + // "se" = statement end + + // Returns "{ type: 'json' }" + source.slice(imports[1].a, imports[1].se); + // "a" = attribute start, -1 for no import attributes + + // Parsed import attributes are available in `at` + // Returns [['type', 'json']] + imports[1].at; + // Returns 'json' + imports[1].at[0][1]; + + // Returns null (no attributes) + imports[0].at; + + // Returns "external" + source.slice(imports[2].s, imports[2].e); + + // Returns "p" + source.slice(exports[0].s, exports[0].e); + // Returns "p" + source.slice(exports[0].ls, exports[0].le); + // Returns "q" + source.slice(exports[1].s, exports[1].e); + // Returns "q" + source.slice(exports[1].ls, exports[1].le); + + // "ss" = export statement start (only the start is tracked, not the end) + // Returns "export" + source.slice(exports[0].ss, exports[0].ss + 6); + + // Returns "'external name'" + source.slice(exports[2].s, exports[2].e); + // Returns -1 + exports[2].ls; + // Returns -1 + exports[2].le; + + // Import type is provided by `t` value + // (1 for static, 2, for dynamic) + // Returns true + imports[2].t == 2; + + // Returns "asdf" (only for string literal dynamic imports) + imports[2].n + // Returns "import /*comment!*/ ( 'asdf', { with: { type: 'json' } })" + source.slice(imports[3].ss, imports[3].se); + // Returns "'asdf'" + source.slice(imports[3].s, imports[3].e); + // Returns "( 'asdf', { with: { type: 'json' } })" + source.slice(imports[3].d, imports[3].se); + // Returns "{ with: { type: 'json' } }" + source.slice(imports[3].a, imports[3].se - 1); + + // For non-string dynamic import expressions: + // - n will be undefined + // - a is currently -1 even if there is an import attribute + // - e is currently the character before the closing ) + + // For nested dynamic imports, the se value of the outer import is -1 as end tracking does not + // currently support nested dynamic immports + + // import.meta is indicated by imports[3].d === -2 + // Returns true + imports[4].d === -2; + // Returns "import /*comment!*/.meta" + source.slice(imports[4].s, imports[4].e); + // ss and se are the same for import meta + + // Returns "'./mod.wasm'" + source.slice(imports[5].s, imports[5].e); + + // Import type 4 and 5 for static and dynamic source phase + imports[5].t === 4; + imports[6].t === 5; +})(); +``` + +### CSP asm.js Build + +The default version of the library uses Wasm and (safe) eval usage for performance and a minimal footprint. + +Neither of these represent security escalation possibilities since there are no execution string injection vectors, but that can still violate existing CSP policies for applications. + +For a version that works with CSP eval disabled, use the `es-module-lexer/js` build: + +```js +import { parse } from 'es-module-lexer/js'; +``` + +Instead of Web Assembly, this uses an asm.js build which is almost as fast as the Wasm version ([see benchmarks below](#benchmarks)). + +### Minimal Build + +For size-sensitive embedders, the `es-module-lexer/minimal` build drops certain features to reduce the binary size. This is used for example by [es-module-shims](https://github.com/guybedford/es-module-shims): + +```js +import { parse } from 'es-module-lexer/minimal'; +``` + +Compared to the full build: + +* `parse` returns a two-element `[imports, exports]` tuple only - the third and fourth facade and `hasModuleSyntax` booleans are dropped. +* Imports drop the parsed attribute list `at` (the attribute source remains recoverable via the `a` attributes index). +* Exports drop the statement start `ss`. + +All other fields are identical to the full build. For CSP eval disabled support, the equivalent asm.js build is available as `es-module-lexer/minimal/js`. + +### Import Attributes + +The `a` field provides the index of the start of the `{` attributes bracket, or -1 for no attributes. + +The list of attribute key and value pairs are provided on the `at` field (full build only): + +```js +const [imports] = parse(` + import json from './foo.json' with { type: 'json' }; + import './foo.css' with { type: 'css' }; + import pkg from 'pkg' with { type: 'json', integrity: 'sha384-...' }; +`); + +// Returns [['type', 'json']] +imports[0].at; + +// Returns [['type', 'css']] +imports[1].at; + +// Multiple attributes +// Returns [['type', 'json'], ['integrity', 'sha384-...']] +imports[2].at; +``` + +The `at` field is an array of `[key, value]` tuples, or `null` if there are no attributes. + +Both keys and values support escape sequences: + +```js +const [imports] = parse(` + import foo from './foo.js' with { "custom-key": "value" }; + import bar from './bar.js' with { "key\\nwith\\nnewlines": "value\\twith\\ttabs" }; +`); + +// Quoted keys are unquoted +// Returns [['custom-key', 'value']] +imports[0].at; + +// Escape sequences are processed +// Returns [['key\nwith\nnewlines', 'value\twith\ttabs']] +imports[1].at; +``` + +### Escape Sequences + +To handle escape sequences in specifier strings, the `.n` field of imported specifiers will be provided where possible. + +For dynamic import expressions, this field will be empty if not a valid JS string. + +### Facade Detection + +Facade modules that only use import / export syntax can be detected via the third return value (full build only): + +```js +const [,, facade] = parse(` + export * from 'external'; + import * as ns from 'external2'; + export { a as b } from 'external3'; + export { ns }; +`); +facade === true; +``` + +### ESM Detection + +Modules that uses ESM syntaxes can be detected via the fourth return value (full build only): + +```js +const [,,, hasModuleSyntax] = parse(` + export {} +`); +hasModuleSyntax === true; +``` + +Dynamic imports are ignored since they can be used in Non-ESM files. + +```js +const [,,, hasModuleSyntax] = parse(` + import('./foo.js') +`); +hasModuleSyntax === false; +``` + +### Environment Support + +Node.js 10+, and [all browsers with Web Assembly support](https://caniuse.com/#feat=wasm). + +### Grammar Support + +* Token state parses all line comments, block comments, strings, template strings, blocks, parens and punctuators. +* Division operator / regex token ambiguity is handled via backtracking checks against punctuator prefixes, including closing brace or paren backtracking. +* Always correctly parses valid JS source, but may parse invalid JS source without errors. + +### Limitations + +The lexing approach is designed to deal with the full language grammar including RegEx / division operator ambiguity through backtracking and paren / brace tracking. + +Because it lexes rather than fully parses, the analysis is not a validation pass: valid JS source is always analyzed correctly, but some invalid source is accepted without an error rather than rejected. For example `export const = 1` lexes to an empty exports list instead of throwing. Callers that need to reject invalid source should run a validating parser separately. + +Multiple exports per declaration (`export var a = 'asdf', q = z`) and renamed destructured exports (`export var { a: b } = asdf`) are detected correctly; earlier versions missed `q` and `b` in these forms. + +### Benchmarks + +Benchmarks can be run with `npm run bench`. + +Current results on a standard desktop machine: + +#### Wasm Build + +``` +Module load time +> 1ms +Cold Run, All Samples +test/samples/*.js (3057 KiB) +> 13ms + +Warm Runs (average of 25 runs) +test/samples/angular.js (719 KiB) +> 1ms +test/samples/angular.min.js (188 KiB) +> 1ms +test/samples/d3.js (491 KiB) +> 2ms +test/samples/d3.min.js (274 KiB) +> 1.04ms +test/samples/magic-string.js (34 KiB) +> 0ms +test/samples/magic-string.min.js (20 KiB) +> 0ms +test/samples/rollup.js (902 KiB) +> 3ms +test/samples/rollup.min.js (429 KiB) +> 2ms + +Warm Runs, All Samples (average of 25 runs) +test/samples/*.js (3057 KiB) +> 10m +``` + +### JS Build (asm.js) + +``` +Module load time +> 1ms +Cold Run, All Samples +test/samples/*.js (3057 KiB) +> 92ms + +Warm Runs (average of 25 runs) +test/samples/angular.js (719 KiB) +> 3.6ms +test/samples/angular.min.js (188 KiB) +> 2ms +test/samples/d3.js (491 KiB) +> 4ms +test/samples/d3.min.js (274 KiB) +> 2.52ms +test/samples/magic-string.js (34 KiB) +> 0ms +test/samples/magic-string.min.js (20 KiB) +> 0ms +test/samples/rollup.js (902 KiB) +> 6ms +test/samples/rollup.min.js (429 KiB) +> 3.2ms + +Warm Runs, All Samples (average of 25 runs) +test/samples/*.js (3057 KiB) +> 20.88ms +``` + +### Building + +This project uses [Chomp](https://chompbuild.com) for building. + +With Chomp installed, download the WASI SDK 12.0 from https://github.com/WebAssembly/wasi-sdk/releases/tag/wasi-sdk-12. + +- [Linux](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz) +- [Windows (MinGW)](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-mingw.tar.gz) +- [macOS](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-macos.tar.gz) + +Locate the WASI-SDK as a sibling folder, or customize the path via the `WASI_PATH` environment variable. + +Emscripten emsdk is also assumed to be a sibling folder or via the `EMSDK_PATH` environment variable. + +Example setup: + +``` +git clone https://github.com:guybedford/es-module-lexer +git clone https://github.com/emscripten-core/emsdk +cd emsdk +git checkout 1.40.1-fastcomp +./emsdk install 1.40.1-fastcomp +cd .. +wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz +gunzip wasi-sdk-12.0-linux.tar.gz +tar -xf wasi-sdk-12.0-linux.tar +mv wasi-sdk-12.0-linux.tar wasi-sdk-12.0 +cargo install chompbuild +cd es-module-lexer +chomp test +``` + +For the `asm.js` build, git clone `emsdk` from is assumed to be a sibling folder as well. + +### License + +MIT + +[actions-image]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml/badge.svg +[actions-url]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.asm.js b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.asm.js new file mode 100644 index 00000000..936c4123 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.asm.js @@ -0,0 +1,2 @@ +/* es-module-lexer 2.3.2 */ +let e,a,r,i=2<<19;const s=1===new Uint8Array(new Uint16Array([1]).buffer)[0]?function(e,a){const r=e.length;let i=0;for(;i>>8}},f="xportportetaourceeferromsyncunctionlassvoyiedelecontininstantybreareturdebuggeawaithrwhileforifcatcfinallels";let c,t,n;export function parse(k,l="@"){c=k,t=l;const u=2*c.length+(2<<18);if(u>i||!e){for(;u>i;)i*=2;a=new ArrayBuffer(i),s(f,new Uint16Array(a,16,108)),e=function(e,a,r){"use asm";var i=new e.Int8Array(r),s=new e.Int16Array(r),f=new e.Int32Array(r),c=new e.Uint8Array(r),t=new e.Uint16Array(r),n=1040;function b(){var e=0,a=0,r=0,c=0,t=0,b=0,k=0,o=0,h=0;h=n;n=n+10240|0;i[808]=1;i[807]=0;s[401]=0;s[402]=0;f[70]=f[2];i[809]=0;f[68]=0;i[806]=0;f[71]=h+2048;f[72]=h;i[810]=0;e=(f[3]|0)+-2|0;f[73]=e;a=e+(f[66]<<1)|0;f[74]=a;e:while(1){r=e+2|0;f[73]=r;if(e>>>0>=a>>>0){c=19;break}a:do{switch(s[r>>1]|0){case 9:case 10:case 11:case 12:case 13:case 32:break;case 101:{if((((s[402]|0)==0?R(r)|0:0)?(S(e+4|0,16,10)|0)==0:0)?(u(),(i[808]|0)==0):0){c=9;break e}else c=18;break}case 105:{if(((s[e+4>>1]|0)==109?R(r)|0:0)?(S(e+6|0,26,8)|0)==0:0){l();c=18}else c=18;break}case 59:{c=18;break}case 47:switch(s[e+4>>1]|0){case 47:{F();break a}case 42:{x(1);break a}default:{c=17;break e}}default:{c=17;break e}}}while(0);if((c|0)==18){c=0;f[70]=f[73]}e=f[73]|0;a=f[74]|0}if((c|0)==9){e=f[73]|0;f[70]=e;c=20}else if((c|0)==17){i[808]=0;f[73]=e;c=20}else if((c|0)==19)if(!(i[806]|0)){e=r;c=20}else e=0;do{if((c|0)==20){r=e;e:while(1){e=r+2|0;f[73]=e;if(r>>>0>=(f[74]|0)>>>0){c=108;break}a=s[e>>1]|0;a:do{switch(a<<16>>16){case 9:case 10:case 11:case 12:case 13:case 32:break;case 101:{if(((s[402]|0)==0?R(e)|0:0)?(S(r+4|0,16,10)|0)==0:0){u();c=107}else c=104;break}case 105:{if(((s[r+4>>1]|0)==109?R(e)|0:0)?(S(r+6|0,26,8)|0)==0:0){l();c=107}else c=104;break}case 99:{if((((s[r+4>>1]|0)==108?R(e)|0:0)?(S(r+6|0,88,6)|0)==0:0)?L(s[r+12>>1]|0)|0:0){i[810]=1;c=104}else c=104;break}case 40:{r=f[71]|0;c=s[402]|0;f[r+((c&65535)<<3)>>2]=1;a=f[70]|0;s[402]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=a;c=107;break}case 91:{r=f[71]|0;c=s[402]|0;f[r+((c&65535)<<3)>>2]=8;a=f[70]|0;s[402]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=a;c=107;break}case 93:{e=s[402]|0;if(!(e<<16>>16)){c=40;break e}s[402]=e+-1<<16>>16;c=107;break}case 44:{e=s[401]|0;if(((e<<16>>16!=0?(t=s[402]|0,t<<16>>16!=0):0)?(f[(f[71]|0)+((t&65535)+-1<<3)>>2]|0)==5:0)?(b=f[(f[72]|0)+((e&65535)+-1<<2)>>2]|0,(f[b+4>>2]|0)==0):0){f[b+4>>2]=(f[70]|0)+2;f[73]=r+4;v(1)|0;c=f[73]|0;f[b+16>>2]=c;f[73]=c+-2;c=107}else c=107;break}case 41:{e=s[402]|0;if(!(e<<16>>16)){c=48;break e}s[402]=e+-1<<16>>16;a=s[401]|0;if(a<<16>>16!=0?(f[(f[71]|0)+((e+-1&65535)<<3)>>2]|0)==5:0){e=f[(f[72]|0)+((a&65535)+-1<<2)>>2]|0;if(!(f[e+4>>2]|0))f[e+4>>2]=(f[70]|0)+2;f[e+12>>2]=r+4;s[401]=a+-1<<16>>16;c=107}else c=107;break}case 123:{e=f[70]|0;c=f[62]|0;do{if((s[e>>1]|0)==41&(c|0)!=0?(f[c+12>>2]|0)==(e+2|0):0){a=f[63]|0;f[62]=a;if(!a){f[58]=0;break}else{f[a+36>>2]=0;break}}}while(0);r=f[71]|0;c=s[402]|0;f[r+((c&65535)<<3)>>2]=(i[810]|0)==0?2:6;s[402]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=e;i[810]=0;c=107;break}case 125:{e=s[402]|0;if(!(e<<16>>16)){c=61;break e}c=f[71]|0;s[402]=e+-1<<16>>16;if((f[c+((e+-1&65535)<<3)>>2]|0)==4){d();c=107}else c=107;break}case 34:case 39:{C(a);c=107;break}case 47:switch(s[r+4>>1]|0){case 47:{F();break a}case 42:{x(1);break a}default:{e=f[70]|0;a=s[e>>1]|0;r:do{if(!($(a)|0))if(a<<16>>16==41){r=s[402]|0;if(!(K(f[(f[71]|0)+((r&65535)<<3)+4>>2]|0)|0))c=76}else c=75;else switch(a<<16>>16){case 46:if(((s[e+-2>>1]|0)+-48&65535)<10){c=75;break r}else break r;case 43:if((s[e+-2>>1]|0)==43){c=75;break r}else break r;case 45:if((s[e+-2>>1]|0)==45){c=75;break r}else break r;default:break r}}while(0);if((c|0)==75){r=s[402]|0;c=76}r:do{if((c|0)==76){c=0;if(r<<16>>16!=0?(k=f[71]|0,o=(r&65535)+-1|0,a<<16>>16==102?(f[k+(o<<3)>>2]|0)==1:0):0){if(((s[e+-2>>1]|0)==111?g(e+-4|0)|0:0)?E(f[k+(o<<3)+4>>2]|0,196,3)|0:0)break}else c=81;if((c|0)==81?(0,a<<16>>16==125):0){c=f[71]|0;r=r&65535;if(U(f[c+(r<<3)+4>>2]|0)|0)break;if((f[c+(r<<3)>>2]|0)==6)break}if(!(w(e)|0)){switch(a<<16>>16){case 0:break r;case 47:{if(i[809]|0)break r;break}default:{}}c=f[64]|0;if((c|0?e>>>0>=(f[c>>2]|0)>>>0:0)?e>>>0<=(f[c+4>>2]|0)>>>0:0){I();i[809]=0;c=107;break a}r=f[3]|0;do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[70]=e;a=s[e>>1]|0}while(!(D(a)|0));if(M(a)|0){do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[70]=e}while(M(s[e>>1]|0)|0);if(q(e)|0){I();i[809]=0;c=107;break a}}i[809]=1;c=107;break a}}}while(0);I();i[809]=0;c=107;break a}}case 96:{r=f[71]|0;c=s[402]|0;f[r+((c&65535)<<3)+4>>2]=f[70];s[402]=c+1<<16>>16;f[r+((c&65535)<<3)>>2]=3;d();c=107;break}default:if((a&65535)>127&a<<16>>16!=160|(a<<16>>16==92|(a<<16>>16==95|(a<<16>>16==36|((a+-48&65535)<10|((a|32)+-97&65535)<26)))))c=104;else c=107}}while(0);a:do{if((c|0)==104)while(1){e=e+2|0;c=s[e>>1]|0;if(!((c&65535)>127&c<<16>>16!=160|(c<<16>>16==92|(c<<16>>16==95|(c<<16>>16==36|((c+-48&65535)<10|((c|32)+-97&65535)<26)))))){c=107;break a}f[73]=e}}while(0);if((c|0)==107){c=0;f[70]=f[73]}r=f[73]|0}if((c|0)==40){ae();e=0;break}else if((c|0)==48){ae();e=0;break}else if((c|0)==61){ae();e=0;break}else if((c|0)==108){e=(i[806]|0)==0?(s[401]|s[402])<<16>>16==0:0;break}}}while(0);n=h;return e|0}function k(e){e=e|0;var a=0,r=0,c=0,t=0,n=0,b=0,k=0,o=0,h=0,A=0,p=0,y=0,m=0,O=0,T=0;y=s[402]|0;a=f[73]|0;f[70]=a;k=a;p=a;o=y;A=0;e:while(1){c=f[74]|0;n=o<<16>>16==y<<16>>16;t=A&e;b=a;while(1){r=b+2|0;if(b>>>0>=c>>>0){a=0;h=104;break e}a=s[r>>1]|0;if(!(M(a)|0)){if(n){switch(a<<16>>16){case 125:case 93:case 41:case 59:case 44:{h=104;break e}default:{}}if(t?be(a)|0:0){h=104;break e}}if(!(be(a)|0))break}b=r}f[73]=r;a:do{switch(a<<16>>16){case 101:{if((o<<16>>16==0?R(r)|0:0)?(S(b+4|0,16,10)|0)==0:0){u();h=93}else h=90;break}case 105:{if(((s[b+4>>1]|0)==109?R(r)|0:0)?(S(b+6|0,26,8)|0)==0:0){l();h=93}else h=90;break}case 99:{if((((s[b+4>>1]|0)==108?R(r)|0:0)?(S(b+6|0,88,6)|0)==0:0)?L(s[b+12>>1]|0)|0:0){i[810]=1;h=90}else h=90;break}case 40:{b=f[71]|0;h=o&65535;f[b+(h<<3)>>2]=1;s[402]=o+1<<16>>16;f[b+(h<<3)+4>>2]=k;h=93;break}case 91:{b=f[71]|0;h=o&65535;f[b+(h<<3)>>2]=8;s[402]=o+1<<16>>16;f[b+(h<<3)+4>>2]=k;h=93;break}case 93:if(!(o<<16>>16)){ae();break a}else{s[402]=o+-1<<16>>16;h=93;break a}case 44:{r=s[401]|0;if((!(o<<16>>16==0|r<<16>>16==0)?(f[(f[71]|0)+((o&65535)+-1<<3)>>2]|0)==5:0)?(m=f[(f[72]|0)+((r&65535)+-1<<2)>>2]|0,(f[m+4>>2]|0)==0):0){f[m+4>>2]=p+2;f[73]=b+4;v(1)|0;h=f[73]|0;f[m+16>>2]=h;f[73]=h+-2;h=93}else h=93;break}case 41:{if(!(o<<16>>16)){ae();break a}h=o+-1<<16>>16;s[402]=h;r=s[401]|0;if(r<<16>>16!=0?(f[(f[71]|0)+((h&65535)<<3)>>2]|0)==5:0){c=f[(f[72]|0)+((r&65535)+-1<<2)>>2]|0;if(!(f[c+4>>2]|0))f[c+4>>2]=p+2;f[c+12>>2]=b+4;s[401]=r+-1<<16>>16;h=93}else h=93;break}case 123:{h=f[62]|0;do{if((s[p>>1]|0)==41&(h|0)!=0?(f[h+12>>2]|0)==(p+2|0):0){r=f[63]|0;f[62]=r;if(!r){f[58]=0;break}else{f[r+36>>2]=0;break}}}while(0);b=f[71]|0;h=o&65535;f[b+(h<<3)>>2]=(i[810]|0)==0?2:6;s[402]=o+1<<16>>16;f[b+(h<<3)+4>>2]=k;i[810]=0;h=93;break}case 125:{if(!(o<<16>>16)){ae();break a}k=f[71]|0;h=o+-1<<16>>16;s[402]=h;if((f[k+((h&65535)<<3)>>2]|0)==4){d();h=93}else h=93;break}case 34:case 39:{C(a);h=93;break}case 47:switch(s[b+4>>1]|0){case 47:{F();break a}case 42:{x(1);break a}default:{c=s[p>>1]|0;r:do{if(!($(c)|0)){if(!(c<<16>>16==41?K(f[(f[71]|0)+((o&65535)<<3)+4>>2]|0)|0:0))h=62}else switch(c<<16>>16){case 46:if(((s[p+-2>>1]|0)+-48&65535)<10){h=62;break r}else break r;case 43:if((s[p+-2>>1]|0)==43){h=62;break r}else break r;case 45:if((s[p+-2>>1]|0)==45){h=62;break r}else break r;default:break r}}while(0);r:do{if((h|0)==62){h=0;if(o<<16>>16!=0?(O=f[71]|0,T=(o&65535)+-1|0,c<<16>>16==102?(f[O+(T<<3)>>2]|0)==1:0):0){if(((s[p+-2>>1]|0)==111?g(p+-4|0)|0:0)?E(f[O+(T<<3)+4>>2]|0,196,3)|0:0)break}else h=67;if((h|0)==67?(0,c<<16>>16==125):0){t=f[71]|0;r=o&65535;if(U(f[t+(r<<3)+4>>2]|0)|0)break;if((f[t+(r<<3)>>2]|0)==6)break}if(!(w(p)|0)){switch(c<<16>>16){case 0:break r;case 47:{if(i[809]|0)break r;break}default:{}}h=f[64]|0;if((h|0?p>>>0>=(f[h>>2]|0)>>>0:0)?p>>>0<=(f[h+4>>2]|0)>>>0:0){I();i[809]=0;h=93;break a}t=f[3]|0;r=p;do{if(r>>>0<=t>>>0)break;r=r+-2|0;f[70]=r;c=s[r>>1]|0}while(!(D(c)|0));if(M(c)|0){do{if(r>>>0<=t>>>0)break;r=r+-2|0;f[70]=r}while(M(s[r>>1]|0)|0);if(q(r)|0){I();i[809]=0;h=93;break a}}i[809]=1;h=93;break a}}}while(0);I();i[809]=0;h=93;break a}}case 96:{b=f[71]|0;h=o&65535;f[b+(h<<3)+4>>2]=k;s[402]=o+1<<16>>16;f[b+(h<<3)>>2]=3;d();h=93;break}default:if((a&65535)>127&a<<16>>16!=160|(a<<16>>16==92|(a<<16>>16==95|(a<<16>>16==36|((a+-48&65535)<10|((a|32)+-97&65535)<26)))))h=90;else h=93}}while(0);a:do{if((h|0)==90)while(1){r=r+2|0;h=s[r>>1]|0;if(!((h&65535)>127&h<<16>>16!=160|(h<<16>>16==92|(h<<16>>16==95|(h<<16>>16==36|((h+-48&65535)<10|((h|32)+-97&65535)<26)))))){h=93;break a}f[73]=r}}while(0);if((h|0)==93){h=0;f[70]=f[73]}if(i[806]|0){a=0;break}r=f[70]|0;a:do{if((r|0)==(p|0))if(A&((s[402]|0)==y<<16>>16&e)){a=s[f[73]>>1]|0;if(be(a)|0)break e;else a=1}else a=A;else{if(a<<16>>16==47){a=(i[809]|0)==0;break}if(G(a)|0)a=1;else{switch(a<<16>>16){case 96:case 34:case 39:case 41:case 93:case 125:{a=1;break a}default:{}}a=0}}}while(0);k=r;p=r;o=s[402]|0;A=a;a=f[73]|0}if((h|0)==104)f[73]=r;return a|0}function l(){var e=0,a=0,r=0,c=0,t=0,n=0;n=f[73]|0;f[73]=n+12;e=v(1)|0;r=f[73]|0;e:do{if(e<<16>>16!=46){if(!(e<<16>>16==115&r>>>0>(n+12|0)>>>0)){if(!(e<<16>>16==100&r>>>0>(n+10|0)>>>0)){r=0;t=28;break}if(S(r+2|0,50,8)|0){a=r;e=100;r=0;t=60;break}if(!(L(s[r+10>>1]|0)|0)){a=r;e=100;r=0;t=60;break}f[73]=r+10;e=v(1)|0;if(e<<16>>16==42){e=42;c=2;t=62;break}f[73]=r;r=0;t=28;break}if((S(r+2|0,40,10)|0)==0?L(s[r+12>>1]|0)|0:0){f[73]=r+12;e=v(1)|0;a=f[73]|0;if((a|0)!=(r+12|0)){if(e<<16>>16!=102){r=1;t=28;break}if(S(a+2|0,58,6)|0){e=102;r=1;t=60;break}if(!(D(s[a+8>>1]|0)|0)){e=102;r=1;t=60;break}}f[73]=r;r=0;t=28}else{a=r;e=115;r=0;t=60}}else{f[73]=r+2;switch((v(1)|0)<<16>>16){case 109:{e=f[73]|0;if(S(e+2|0,34,6)|0)break e;a=f[70]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;A(n,n,e+8|0,2);break e}case 115:{e=f[73]|0;if(S(e+2|0,40,10)|0)break e;a=f[70]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;f[73]=e+12;e=v(1)|0;r=1;t=28;break e}case 100:{e=f[73]|0;if(S(e+2|0,50,8)|0)break e;a=f[70]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;f[73]=e+10;e=v(1)|0;r=2;t=28;break e}default:break e}}}while(0);e:do{if((t|0)==28){if(e<<16>>16==40){a=f[71]|0;c=s[402]|0;f[a+((c&65535)<<3)>>2]=5;e=f[73]|0;s[402]=c+1<<16>>16;f[a+((c&65535)<<3)+4>>2]=e;if((s[f[70]>>1]|0)==46)break;f[73]=e+2;a=v(1)|0;A(n,f[73]|0,0,e);if(!r)e=f[62]|0;else{e=f[62]|0;f[e+28>>2]=(r|0)==1?5:7}c=f[72]|0;n=s[401]|0;s[401]=n+1<<16>>16;f[c+((n&65535)<<2)>>2]=e;switch(a<<16>>16){case 39:{C(39);break}case 34:{C(34);break}case 96:{if(!(y()|0))t=37;break}default:t=37}if((t|0)==37){f[73]=(f[73]|0)+-2;break}e=(f[73]|0)+2|0;f[73]=e;switch((v(1)|0)<<16>>16){case 44:{f[73]=(f[73]|0)+2;v(1)|0;c=f[62]|0;f[c+4>>2]=e;n=f[73]|0;f[c+16>>2]=n;i[c+24>>0]=1;f[73]=n+-2;break e}case 41:{s[402]=(s[402]|0)+-1<<16>>16;n=f[62]|0;f[n+4>>2]=e;f[n+12>>2]=(f[73]|0)+2;i[n+24>>0]=1;s[401]=(s[401]|0)+-1<<16>>16;break e}default:{f[73]=(f[73]|0)+-2;break e}}}if(!((r|0)==0&e<<16>>16==123)){switch(e<<16>>16){case 42:case 39:case 34:{c=r;t=62;break e}default:{}}a=f[73]|0;t=60;break}e=f[73]|0;if(s[402]|0){f[73]=e+-2;break}while(1){if(e>>>0>=(f[74]|0)>>>0)break;e=v(1)|0;if(!(re(e)|0)){if(e<<16>>16==125){t=50;break}}else C(e);e=(f[73]|0)+2|0;f[73]=e}if((t|0)==50)f[73]=(f[73]|0)+2;c=(v(1)|0)<<16>>16==102;e=f[73]|0;if(c?S(e+2|0,58,6)|0:0){ae();break}f[73]=e+8;e=v(1)|0;if(re(e)|0){o(n,e,0);break}else{ae();break}}}while(0);if((t|0)==60)if((a|0)==(n+12|0))f[73]=n+10;else{c=r;t=62}do{if((t|0)==62){if(!((e<<16>>16==42|(c|0)!=2)&(s[402]|0)==0)){f[73]=(f[73]|0)+-2;break}e=f[74]|0;a=f[73]|0;while(1){if(a>>>0>=e>>>0){t=69;break}r=s[a>>1]|0;if(re(r)|0){t=67;break}t=a+2|0;f[73]=t;a=t}if((t|0)==67){o(n,r,c);break}else if((t|0)==69){ae();break}}}while(0);return}function u(){var e=0,a=0,r=0,c=0,t=0,n=0,b=0,l=0,u=0,h=0;l=f[73]|0;u=f[64]|0;f[73]=l+12;a=v(1)|0;e=f[73]|0;if(!((e|0)==(l+12|0)?!(O(a)|0):0))h=3;e:do{if((h|0)==3){f[65]=l;a:do{switch(a<<16>>16){case 123:{f[73]=e+2;e=v(1)|0;a=f[73]|0;while(1){if(re(e)|0){C(e);e=(f[73]|0)+2|0;f[73]=e}else{H(e)|0;e=f[73]|0}v(1)|0;e=p(a,e)|0;if(e<<16>>16==44){f[73]=(f[73]|0)+2;e=v(1)|0}if(e<<16>>16==125){h=15;break}h=a;a=f[73]|0;if((a|0)==(h|0)){h=12;break}if(a>>>0>(f[74]|0)>>>0){h=14;break}}if((h|0)==12){ae();break e}else if((h|0)==14){ae();break e}else if((h|0)==15){i[807]=1;f[73]=(f[73]|0)+2;break a}break}case 42:{f[73]=e+2;v(1)|0;h=f[73]|0;p(h,h)|0;break}default:{i[808]=0;switch(a<<16>>16){case 100:{f[73]=e+14;switch((v(1)|0)<<16>>16){case 97:{a=f[73]|0;if((S(a+2|0,64,8)|0)==0?M(s[a+10>>1]|0)|0:0){f[73]=a+10;v(0)|0;h=22}break}case 102:{h=22;break}case 99:{a=f[73]|0;if(((S(a+2|0,86,8)|0)==0?(u=s[a+10>>1]|0,L(u)|0|u<<16>>16==123):0)?(f[73]=a+10,r=v(1)|0,r<<16>>16!=123):0){b=r;h=31}break}default:{}}r:do{if((h|0)==22?(c=f[73]|0,(S(c+2|0,72,14)|0)==0):0){a=s[c+16>>1]|0;if(!(L(a)|0))switch(a<<16>>16){case 40:case 42:break;default:break r}f[73]=c+16;a=v(1)|0;if(a<<16>>16==42){f[73]=(f[73]|0)+2;a=v(1)|0}if(a<<16>>16!=40){b=a;h=31}}}while(0);if((h|0)==31?(t=f[73]|0,H(b)|0,n=f[73]|0,n>>>0>t>>>0):0){T(e,e+14|0,t,n);f[73]=(f[73]|0)+-2;break e}T(e,e+14|0,0,0);f[73]=e+12;break e}case 97:{f[73]=e+10;v(0)|0;e=f[73]|0;h=35;break}case 102:{h=35;break}case 99:{if((S(e+2|0,86,8)|0)==0?D(s[e+10>>1]|0)|0:0){f[73]=e+10;h=v(1)|0;u=f[73]|0;H(h)|0;h=f[73]|0;T(u,h,u,h);f[73]=(f[73]|0)+-2;break e}f[73]=e+4;e=e+4|0;break}case 108:case 118:break;default:break e}if((h|0)==35){f[73]=e+16;e=v(1)|0;if(e<<16>>16==42){f[73]=(f[73]|0)+2;e=v(1)|0}u=f[73]|0;H(e)|0;h=f[73]|0;T(u,h,u,h);f[73]=(f[73]|0)+-2;break e}f[73]=e+6;i[808]=0;while(1){a=v(1)|0;e=f[73]|0;if(e>>>0>(f[74]|0)>>>0)break;a=P(a)|0;if((f[73]|0)==(e|0))break;if(a<<16>>16==61)a=k(1)|0;e=f[73]|0;if(a<<16>>16!=44)break;f[73]=e+2}f[73]=e+-2;break e}}}while(0);h=(v(1)|0)<<16>>16==102;e=f[73]|0;if(h?(S(e+2|0,58,6)|0)==0:0){f[73]=e+8;o(l,v(1)|0,0);e=(u|0)==0?236:u+20|0;while(1){e=f[e>>2]|0;if(!e)break e;f[e+12>>2]=0;f[e+8>>2]=0;e=e+20|0}}f[73]=e+-2}}while(0);return}function o(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,c=0,t=0,n=0,b=0;i=(f[73]|0)+2|0;switch(a<<16>>16){case 39:{C(39);c=5;break}case 34:{C(34);c=5;break}default:ae()}do{if((c|0)==5){A(e,i,f[73]|0,1);if((r|0)>0)f[(f[62]|0)+28>>2]=(r|0)==1?4:6;f[73]=(f[73]|0)+2;n=(v(0)|0)<<16>>16==119;t=f[73]|0;if(((n?(s[t+2>>1]|0)==105:0)?(s[t+4>>1]|0)==116:0)?(s[t+6>>1]|0)==104:0){f[73]=t+8;if((v(1)|0)<<16>>16!=123){f[73]=t;break}n=f[73]|0;i=n;c=0;e:while(1){f[73]=i+2;i=v(1)|0;do{if(i<<16>>16!=39){a=f[73]|0;if(i<<16>>16==34){C(34);e=(f[73]|0)+2|0;f[73]=e;i=v(1)|0;break}else{i=H(i)|0;e=f[73]|0;break}}else{a=f[73]|0;C(39);e=(f[73]|0)+2|0;f[73]=e;i=v(1)|0}}while(0);if(i<<16>>16!=58){c=21;break}f[73]=(f[73]|0)+2;switch((v(1)|0)<<16>>16){case 39:{i=f[73]|0;C(39);break}case 34:{i=f[73]|0;C(34);break}default:{c=25;break e}}b=(f[73]|0)+2|0;r=f[67]|0;f[67]=r+20;f[r>>2]=a;f[r+4>>2]=e;f[r+8>>2]=i;f[r+12>>2]=b;f[r+16>>2]=0;f[((c|0)==0?(f[62]|0)+32|0:c+16|0)>>2]=r;f[73]=(f[73]|0)+2;switch((v(1)|0)<<16>>16){case 125:{c=29;break e}case 44:break;default:{c=27;break e}}i=(f[73]|0)+2|0;f[73]=i;c=r}if((c|0)==21){f[73]=t;break}else if((c|0)==25){f[73]=t;break}else if((c|0)==27){f[73]=t;break}else if((c|0)==29){b=f[62]|0;f[b+16>>2]=n;f[b+12>>2]=(f[73]|0)+2;break}}f[73]=t+-2}}while(0);return}function h(){var e=0,a=0,r=0,i=0,c=0,t=0,n=0;e=f[73]|0;c=(s[e>>1]|0)==123;f[73]=e+2;e=v(1)|0;t=c?125:93;e:while(1){if((t|0)==(e&65535|0))break;i=f[73]|0;if(i>>>0>(f[74]|0)>>>0)break;if((e<<16>>16==46?(s[i+2>>1]|0)==46:0)?(s[i+4>>1]|0)==46:0){f[73]=i+6;e=P(v(1)|0)|0}else n=9;a:do{if((n|0)==9){n=0;do{if(c){do{if(e<<16>>16==91){k(0)|0;f[73]=(f[73]|0)+2;a=i}else{if(re(e)|0){C(e);f[73]=(f[73]|0)+2;a=i;break}if((e+-48&65535)>=10){H(e)|0;a=f[73]|0;break}e=i;r:while(1){r=e+2|0;a=s[r>>1]|0;i:do{if((a+-48&65535)>=10){switch(a<<16>>16){case 67:case 68:case 70:case 97:case 65:case 99:case 100:case 102:case 46:case 66:case 69:case 79:case 88:case 95:case 98:case 101:case 110:case 111:case 120:break i;case 43:case 45:break;default:break r}switch(s[e>>1]|0){case 69:case 101:break;default:break r}}}while(0);e=r}f[73]=r;a=i}}while(0);e=v(1)|0;if(e<<16>>16==58){f[73]=(f[73]|0)+2;e=P(v(1)|0)|0;break}if(a>>>0>i>>>0)T(i,a,i,a)}else if(e<<16>>16==44){f[73]=i+2;e=v(1)|0;break a}else{e=P(e)|0;break}}while(0);if(e<<16>>16==61)e=k(0)|0;if(e<<16>>16!=44)break e;f[73]=(f[73]|0)+2;e=v(1)|0}}while(0)}return}function w(e){e=e|0;e:do{switch(s[e>>1]|0){case 100:switch(s[e+-2>>1]|0){case 105:{e=E(e+-4|0,94,2)|0;break e}case 108:{e=E(e+-4|0,98,3)|0;break e}default:{e=0;break e}}case 101:switch(s[e+-2>>1]|0){case 115:switch(s[e+-4>>1]|0){case 108:{e=z(e+-6|0,101)|0;break e}case 97:{e=z(e+-6|0,99)|0;break e}default:{e=0;break e}}case 116:{e=E(e+-4|0,104,4)|0;break e}case 117:{e=E(e+-4|0,112,6)|0;break e}default:{e=0;break e}}case 102:{if((s[e+-2>>1]|0)==111?(s[e+-4>>1]|0)==101:0)switch(s[e+-6>>1]|0){case 99:{e=E(e+-8|0,124,6)|0;break e}case 112:{e=E(e+-8|0,136,2)|0;break e}default:{e=0;break e}}else e=0;break}case 107:{e=E(e+-2|0,140,4)|0;break}case 110:{if(z(e+-2|0,105)|0)e=1;else e=E(e+-2|0,148,5)|0;break}case 111:{e=z(e+-2|0,100)|0;break}case 114:{e=E(e+-2|0,158,7)|0;break}case 116:{e=E(e+-2|0,172,4)|0;break}case 119:switch(s[e+-2>>1]|0){case 101:{e=z(e+-4|0,110)|0;break e}case 111:{e=E(e+-4|0,180,3)|0;break e}default:{e=0;break e}}default:e=0}}while(0);return e|0}function d(){var e=0,a=0,r=0;a=f[74]|0;r=f[73]|0;e:while(1){e=r+2|0;if(r>>>0>=a>>>0){a=10;break}switch(s[e>>1]|0){case 96:{a=7;break e}case 36:{if((s[r+4>>1]|0)==123){a=6;break e}break}case 92:{e=r+4|0;break}default:{}}r=e}if((a|0)==6){e=r+4|0;f[73]=e;a=f[71]|0;r=s[402]|0;f[a+((r&65535)<<3)>>2]=4;s[402]=r+1<<16>>16;f[a+((r&65535)<<3)+4>>2]=e}else if((a|0)==7){f[73]=e;a=f[71]|0;r=(s[402]|0)+-1<<16>>16;s[402]=r;if((f[a+((r&65535)<<3)>>2]|0)!=3)ae()}else if((a|0)==10){f[73]=e;ae()}return}function v(e){e=e|0;var a=0,r=0,i=0;r=f[73]|0;e:do{a=s[r>>1]|0;a:do{if(a<<16>>16!=47)if(e)if(L(a)|0)break;else break e;else if(M(a)|0)break;else break e;else switch(s[r+2>>1]|0){case 47:{F();break a}case 42:{x(e);break a}default:{a=47;break e}}}while(0);i=f[73]|0;r=i+2|0;f[73]=r}while(i>>>0<(f[74]|0)>>>0);return a|0}function A(e,a,r,s){e=e|0;a=a|0;r=r|0;s=s|0;var c=0,t=0;t=f[67]|0;f[67]=t+40;c=f[62]|0;f[((c|0)==0?232:c+36|0)>>2]=t;f[63]=c;f[62]=t;f[t+8>>2]=e;if(2==(s|0)){e=3;c=r}else{e=1==(s|0)?1:2;c=1==(s|0)?r+2|0:0}f[t+12>>2]=c;f[t+28>>2]=e;f[t>>2]=a;f[t+4>>2]=r;f[t+16>>2]=0;f[t+20>>2]=s;i[t+24>>0]=1==(s|0)&1;f[t+32>>2]=0;f[t+36>>2]=0;if(1==(s|0)|2==(s|0))i[807]=1;return}function C(e){e=e|0;var a=0,r=0,i=0,c=0;c=f[74]|0;a=f[73]|0;while(1){i=a+2|0;if(a>>>0>=c>>>0){a=9;break}r=s[i>>1]|0;if(r<<16>>16==e<<16>>16){a=10;break}if(r<<16>>16==92){r=a+4|0;if((s[r>>1]|0)==13){a=a+6|0;a=(s[a>>1]|0)==10?a:r}else a=r}else if(be(r)|0){a=9;break}else a=i}if((a|0)==9){f[73]=i;ae()}else if((a|0)==10)f[73]=i;return}function g(e){e=e|0;var a=0,r=0;a=s[e>>1]|0;if(L(a)|0)r=3;else switch(a<<16>>16){case 41:case 125:case 93:{r=3;break}default:e=0}e:do{if((r|0)==3){r=f[3]|0;while(1){if(e>>>0<=r>>>0)break;e=e+-2|0;if(!(L(a)|0))break;a=s[e>>1]|0}switch(a<<16>>16){case 41:case 125:case 93:{e=1;break e}default:{}}e=(O(a)|0)^1}}while(0);return e|0}function p(e,a){e=e|0;a=a|0;var r=0,i=0,c=0,t=0;r=f[73]|0;i=s[r>>1]|0;c=(e|0)==(a|0)?0:e;t=(e|0)==(a|0)?0:a;if(i<<16>>16==97){f[73]=r+4;r=v(1)|0;e=f[73]|0;if(re(r)|0){C(r);a=(f[73]|0)+2|0;f[73]=a}else{H(r)|0;a=f[73]|0}i=v(1)|0;r=f[73]|0}if((r|0)!=(e|0))T(e,a,c,t);return i|0}function y(){var e=0,a=0,r=0,i=0;i=f[73]|0;r=f[74]|0;a=i;e:while(1){e=a+2|0;if(a>>>0>=r>>>0){a=7;break}switch(s[e>>1]|0){case 96:{a=8;break e}case 92:{e=a+4|0;break}case 36:{if((s[a+4>>1]|0)==123){a=7;break e}break}default:{}}a=e}if((a|0)==7){f[73]=i;e=0}else if((a|0)==8){f[73]=e;e=1}return e|0}function m(){var e=0,a=0,r=0;r=f[74]|0;a=f[73]|0;e:while(1){e=a+2|0;if(a>>>0>=r>>>0){a=6;break}switch(s[e>>1]|0){case 13:case 10:{a=6;break e}case 93:{a=7;break e}case 92:{e=a+4|0;break}default:{}}a=e}if((a|0)==6){f[73]=e;ae();e=0}else if((a|0)==7){f[73]=e;e=93}return e|0}function I(){var e=0,a=0;e:while(1){e=f[73]|0;f[73]=e+2;if(e>>>0>=(f[74]|0)>>>0){a=7;break}switch(s[e+2>>1]|0){case 13:case 10:{a=7;break e}case 47:break e;case 91:{m()|0;break}case 92:{f[73]=e+4;break}default:{}}}if((a|0)==7)ae();return}function U(e){e=e|0;switch(s[e>>1]|0){case 62:{e=(s[e+-2>>1]|0)==61;break}case 41:case 59:{e=1;break}case 104:{e=E(e+-2|0,206,4)|0;break}case 121:{e=E(e+-2|0,214,6)|0;break}case 101:{e=E(e+-2|0,226,3)|0;break}default:e=0}return e|0}function x(e){e=e|0;var a=0,r=0,i=0,c=0,t=0;c=(f[73]|0)+2|0;f[73]=c;r=f[74]|0;while(1){a=c+2|0;if(c>>>0>=r>>>0)break;i=s[a>>1]|0;if(!e?be(i)|0:0)break;if(i<<16>>16==42?(s[c+4>>1]|0)==47:0){t=8;break}c=a}if((t|0)==8){f[73]=a;a=c+4|0}f[73]=a;return}function S(e,a,r){e=e|0;a=a|0;r=r|0;var s=0,f=0;e:do{if(!r)e=0;else{while(1){s=i[e>>0]|0;f=i[a>>0]|0;if(s<<24>>24!=f<<24>>24)break;r=r+-1|0;if(!r){e=0;break e}else{e=e+1|0;a=a+1|0}}e=(s&255)-(f&255)|0}}while(0);return e|0}function O(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:{e=1;break}default:if((e&-8)<<16>>16==40|(e+-58&65535)<6)e=1;else{switch(e<<16>>16){case 91:case 93:case 94:{e=1;break e}default:{}}e=(e+-123&65535)<4}}}while(0);return e|0}function $(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:break;default:if(!((e+-58&65535)<6|(e+-40&65535)<7&e<<16>>16!=41)){switch(e<<16>>16){case 91:case 94:break e;default:{}}return e<<16>>16!=125&(e+-123&65535)<4|0}}}while(0);return 1}function T(e,a,r,s){e=e|0;a=a|0;r=r|0;s=s|0;var c=0,t=0;c=f[67]|0;f[67]=c+24;t=f[64]|0;f[((t|0)==0?236:t+20|0)>>2]=c;f[64]=c;f[c>>2]=e;f[c+4>>2]=a;f[c+8>>2]=r;f[c+12>>2]=s;f[c+16>>2]=f[65];f[c+20>>2]=0;i[807]=1;return}function j(e){e=e|0;var a=0;a=s[e>>1]|0;e:do{if((a+-9&65535)>=5){switch(a<<16>>16){case 160:case 32:{a=1;break e}default:{}}if(O(a)|0)return a<<16>>16!=46|(N(e)|0)|0;else a=0}else a=1}while(0);return a|0}function B(e){e=e|0;var a=0,r=0;r=n;n=n+16|0;f[r>>2]=0;f[66]=e;a=f[3]|0;s[a+(e<<1)>>1]=0;f[r>>2]=a+(e<<1)+2;f[67]=a+(e<<1)+2;f[58]=0;f[62]=0;f[60]=0;f[59]=0;f[64]=0;f[61]=0;n=r;return a|0}function E(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,s=0;s=e+(0-r<<1)+2|0;i=f[3]|0;if(s>>>0>=i>>>0?(S(s,a,r<<1)|0)==0:0)if((s|0)==(i|0))i=1;else i=j(e+(0-r<<1)|0)|0;else i=0;return i|0}function P(e){e=e|0;var a=0;switch(e<<16>>16){case 91:case 123:{h();f[73]=(f[73]|0)+2;break}default:{a=f[73]|0;H(e)|0;e=f[73]|0;if(e>>>0>a>>>0)T(a,e,a,e)}}return v(1)|0}function q(e){e=e|0;switch(s[e>>1]|0){case 107:{e=E(e+-2|0,140,4)|0;break}case 101:{if((s[e+-2>>1]|0)==117)e=E(e+-4|0,112,6)|0;else e=0;break}default:e=0}return e|0}function z(e,a){e=e|0;a=a|0;var r=0;r=f[3]|0;if(r>>>0<=e>>>0?(s[e>>1]|0)==a<<16>>16:0)if((r|0)==(e|0))r=1;else r=D(s[e+-2>>1]|0)|0;else r=0;return r|0}function D(e){e=e|0;e:do{if((e+-9&65535)<5)e=1;else{switch(e<<16>>16){case 32:case 160:{e=1;break e}default:{}}e=e<<16>>16!=46&(O(e)|0)}}while(0);return e|0}function F(){var e=0,a=0,r=0;e=f[74]|0;r=f[73]|0;e:while(1){a=r+2|0;if(r>>>0>=e>>>0)break;switch(s[a>>1]|0){case 13:case 10:break e;default:r=a}}f[73]=a;return}function G(e){e=e|0;e:do{if(((e&-33)+-65&65535)<26|(e+-48&65535)<10)e=1;else{switch(e<<16>>16){case 36:case 95:{e=1;break e}default:{}}e=(e&65535)>127}}while(0);return e|0}function H(e){e=e|0;while(1){if(L(e)|0)break;if(O(e)|0)break;e=(f[73]|0)+2|0;f[73]=e;e=s[e>>1]|0;if(!(e<<16>>16)){e=0;break}}return e|0}function J(){var e=0;e=f[(f[60]|0)+20>>2]|0;switch(e|0){case 1:{e=-1;break}case 2:{e=-2;break}default:e=e-(f[3]|0)>>1}return e|0}function K(e){e=e|0;if(!(E(e,186,5)|0)?!(E(e,196,3)|0):0)e=E(e,202,2)|0;else e=1;return e|0}function L(e){e=e|0;switch(e<<16>>16){case 160:case 9:case 10:case 11:case 12:case 13:case 32:{e=1;break}default:e=0}return e|0}function M(e){e=e|0;switch(e<<16>>16){case 160:case 32:case 12:case 11:case 9:{e=1;break}default:e=0}return e|0}function N(e){e=e|0;if((s[e>>1]|0)==46?(s[e+-2>>1]|0)==46:0)e=(s[e+-4>>1]|0)==46;else e=0;return e|0}function Q(){var e=0;e=f[69]|0;e=f[((e|0)==0?(f[60]|0)+32|0:e+16|0)>>2]|0;f[69]=e;return(e|0)!=0|0}function R(e){e=e|0;if((f[3]|0)==(e|0))e=1;else e=j(e+-2|0)|0;return e|0}function V(){var e=0;e=f[(f[61]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function W(){var e=0;e=f[(f[60]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function X(){var e=0;e=f[(f[61]|0)+8>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function Y(){var e=0;e=f[(f[60]|0)+16>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function Z(){var e=0;e=f[(f[60]|0)+4>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function _(){var e=0;e=f[60]|0;e=f[((e|0)==0?232:e+36|0)>>2]|0;f[60]=e;return(e|0)!=0|0}function ee(){var e=0;e=f[61]|0;e=f[((e|0)==0?236:e+20|0)>>2]|0;f[61]=e;return(e|0)!=0|0}function ae(){i[806]=1;f[68]=(f[73]|0)-(f[3]|0)>>1;f[73]=(f[74]|0)+2;return}function re(e){e=e|0;return e<<16>>16==39|e<<16>>16==34|0}function ie(){return(f[(f[61]|0)+16>>2]|0)-(f[3]|0)>>1|0}function se(){return(f[(f[69]|0)+12>>2]|0)-(f[3]|0)>>1|0}function fe(){return(f[(f[69]|0)+8>>2]|0)-(f[3]|0)>>1|0}function ce(){return(f[(f[69]|0)+4>>2]|0)-(f[3]|0)>>1|0}function te(){return(f[(f[60]|0)+8>>2]|0)-(f[3]|0)>>1|0}function ne(){return(f[(f[61]|0)+4>>2]|0)-(f[3]|0)>>1|0}function be(e){e=e|0;return e<<16>>16==13|e<<16>>16==10|0}function ke(){return(f[f[69]>>2]|0)-(f[3]|0)>>1|0}function le(){return(f[f[60]>>2]|0)-(f[3]|0)>>1|0}function ue(){return(f[f[61]>>2]|0)-(f[3]|0)>>1|0}function oe(){return c[(f[60]|0)+24>>0]|0|0}function he(e){e=e|0;f[3]=e;return}function we(){return f[(f[60]|0)+28>>2]|0}function de(){return(i[807]|0)!=0|0}function ve(){return(i[808]|0)!=0|0}function Ae(){f[69]=0;return}function Ce(){return f[68]|0}function ge(e,a){e=e|0;a=a|0;n=e+a+15&-16;return a|0}return{su:ge,ai:Y,ake:ce,aks:ke,ave:se,avs:fe,e:Ce,ee:ne,ele:V,els:X,es:ue,ess:ie,f:ve,id:J,ie:Z,ip:oe,is:le,it:we,ms:de,p:b,ra:Q,re:ee,ri:_,rsa:Ae,sa:B,se:W,ses:he,ss:te}}("undefined"!=typeof globalThis?globalThis:self,{},a),r=e.su(i-(2<<17),1040)}const h=c.length+1;e.ses(r),e.sa(h-1),s(c,new Uint16Array(a,r,h)),e.p()||(n=e.e(),o());const w=[],d=[];for(;e.ri();){const a=e.is(),r=e.ie(),i=e.ai(),s=e.id(),f=e.ss(),t=e.se(),n=e.it();let k;e.ip()&&(k=b(-1===s?a:a+1,c.charCodeAt(-1===s?a-1:a)));let l=null;for(l=[],e.rsa();e.ra();){const a=e.aks(),r=e.ake(),i=e.avs(),s=e.ave();l.push([v(a,r),v(i,s)])}l=l.length>0?l:null,w.push({t:n,n:k,s:a,e:r,ss:f,se:t,d:s,a:i,at:l})}for(;e.re();){const a=e.es(),r=e.ee(),i=e.els(),s=e.ele(),f=i<0?void 0:v(i,s),c=v(a,r);d.push({s:a,e:r,ls:i,le:s,ss:e.ess(),n:c,ln:f})}return[w,d,!!e.f(),!!e.ms()];function v(e,a){const r=c.charCodeAt(e);return 34===r||39===r?b(e+1,r):c.slice(e,a)}}function b(e,a){n=e;let r="",i=n;for(;;){n>=c.length&&o();const e=c.charCodeAt(n);if(e===a)break;92===e?(r+=c.slice(i,n),r+=k(),i=n):(8232===e||8233===e||u(e)&&96!==a&&o(),++n)}return r+=c.slice(i,n++),r}function k(){let e=c.charCodeAt(++n);switch(++n,e){case 110:return"\n";case 114:return"\r";case 120:return String.fromCharCode(l(2));case 117:return function(){const e=c.charCodeAt(n);let a;123===e?(++n,a=l(c.indexOf("}",n)-n),++n,a>1114111&&o()):a=l(4);return a<=65535?String.fromCharCode(a):(a-=65536,String.fromCharCode(55296+(a>>10),56320+(1023&a)))}();case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===c.charCodeAt(n)&&++n;case 10:return"";case 56:case 57:o();default:if(e>=48&&e<=55){let a=c.substr(n-1,3).match(/^[0-7]+/)[0],r=parseInt(a,8);return r>255&&(a=a.slice(0,-1),r=parseInt(a,8)),n+=a.length-1,e=c.charCodeAt(n),"0"===a&&56!==e&&57!==e||o(),String.fromCharCode(r)}return u(e)?"":String.fromCharCode(e)}}function l(e){const a=n;let r=0,i=0;for(let a=0;a=97)e=s-97+10;else if(s>=65)e=s-65+10;else{if(!(s>=48&&s<=57))break;e=s-48}if(e>=16)break;i=s,r=16*r+e}else 95!==i&&0!==a||o(),i=s}return 95!==i&&n-a===e||o(),r}function u(e){return 13===e||10===e}function o(){throw Object.assign(Error(`Parse error ${t}:${c.slice(0,n).split("\n").length}:${n-c.lastIndexOf("\n",n-1)}`),{idx:n})} diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.cjs b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.cjs new file mode 100644 index 00000000..8c4223d8 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.cjs @@ -0,0 +1 @@ +"use strict";exports.initSync=exports.init=exports.ImportType=void 0,exports.parse=parse;var ImportType=exports.ImportType=function(A){return A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase",A}({});const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(C,g="@"){if(!E)return init.then(()=>parse(C,g));const I=C.length+1,w=(E.__heap_base.value||E.__heap_base)+4*I-E.memory.buffer.byteLength;w>0&&E.memory.grow(Math.ceil(w/65536));const D=E.sa(I-1);if("undefined"!=typeof Buffer?Buffer.from(E.memory.buffer,D,2*(I-1)).write(C,"utf16le"):(A?Q:B)(C,new Uint16Array(E.memory.buffer,D,I)),!E.parse())throw Object.assign(new Error(`Parse error ${g}:${C.slice(0,E.e()).split("\n").length}:${E.e()-C.lastIndexOf("\n",E.e()-1)}`),{idx:E.e()});const o=[],i=[];for(;E.ri();){const A=E.is(),B=E.ie(),Q=E.it(),g=E.ai(),I=E.id(),w=E.ss(),D=E.se();let i;E.ip()&&(i=s(C.slice(-1===I?A-1:A,-1===I?B+1:B)));let J=null;for(J=[],E.rsa();E.ra();){const A=E.aks(),B=E.ake(),Q=E.avs(),g=E.ave();J.push([G(C.slice(A,B)),G(C.slice(Q,g))])}0===J.length&&(J=null),o.push({n:i,t:Q,s:A,e:B,ss:w,se:D,d:I,a:g,at:J})}for(;E.re();){const A=E.es(),B=E.ee(),Q=E.els(),g=E.ele(),I=Q<0?void 0:G(C.slice(Q,g)),w=G(C.slice(A,B));i.push({s:A,e:B,ls:Q,le:g,ss:E.ess(),n:w,ln:I})}function s(A){try{return(0,eval)(A)}catch(A){}}function G(A){if(!A)return A;const B=A[0];return('"'===B||"'"===B)&&s(A)||A}return[o,i,!!E.f(),!!E.ms()]}function B(A,B){const Q=A.length;let E=0;for(;E>>8}}function Q(A,B){const Q=A.length;let E=0;for(;E{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),A=>A.charCodeAt(0));var A},init=exports.init=WebAssembly.compile(C()).then(WebAssembly.instantiate).then(({exports:A})=>{E=A}),initSync=()=>{if(E)return;const A=new WebAssembly.Module(C());E=new WebAssembly.Instance(A).exports};exports.initSync=initSync; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.js b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.js new file mode 100644 index 00000000..1f296744 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.js @@ -0,0 +1,2 @@ +/* es-module-lexer 2.3.2 */ +export var ImportType=function(A){return A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase",A}({});const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];export function parse(C,g="@"){if(!E)return init.then(()=>parse(C,g));const I=C.length+1,w=(E.__heap_base.value||E.__heap_base)+4*I-E.memory.buffer.byteLength;w>0&&E.memory.grow(Math.ceil(w/65536));const D=E.sa(I-1);if("undefined"!=typeof Buffer?Buffer.from(E.memory.buffer,D,2*(I-1)).write(C,"utf16le"):(A?Q:B)(C,new Uint16Array(E.memory.buffer,D,I)),!E.parse())throw Object.assign(new Error(`Parse error ${g}:${C.slice(0,E.e()).split("\n").length}:${E.e()-C.lastIndexOf("\n",E.e()-1)}`),{idx:E.e()});const o=[],G=[];for(;E.ri();){const A=E.is(),B=E.ie(),Q=E.it(),g=E.ai(),I=E.id(),w=E.ss(),D=E.se();let G;E.ip()&&(G=i(C.slice(-1===I?A-1:A,-1===I?B+1:B)));let J=null;for(J=[],E.rsa();E.ra();){const A=E.aks(),B=E.ake(),Q=E.avs(),g=E.ave();J.push([s(C.slice(A,B)),s(C.slice(Q,g))])}0===J.length&&(J=null),o.push({n:G,t:Q,s:A,e:B,ss:w,se:D,d:I,a:g,at:J})}for(;E.re();){const A=E.es(),B=E.ee(),Q=E.els(),g=E.ele(),I=Q<0?void 0:s(C.slice(Q,g)),w=s(C.slice(A,B));G.push({s:A,e:B,ls:Q,le:g,ss:E.ess(),n:w,ln:I})}function i(A){try{return(0,eval)(A)}catch(A){}}function s(A){if(!A)return A;const B=A[0];return('"'===B||"'"===B)&&i(A)||A}return[o,G,!!E.f(),!!E.ms()]}function B(A,B){const Q=A.length;let E=0;for(;E>>8}}function Q(A,B){const Q=A.length;let E=0;for(;E{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),A=>A.charCodeAt(0));var A};export const init=WebAssembly.compile(C()).then(WebAssembly.instantiate).then(({exports:A})=>{E=A});export const initSync=()=>{if(E)return;const A=new WebAssembly.Module(C());E=new WebAssembly.Instance(A).exports}; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.asm.js b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.asm.js new file mode 100644 index 00000000..c68ed358 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.asm.js @@ -0,0 +1,2 @@ +/* es-module-lexer (minimal) 2.3.2 */ +let e,a,r,i=2<<19;const s=1===new Uint8Array(new Uint16Array([1]).buffer)[0]?function(e,a){const r=e.length;let i=0;for(;i>>8}},f="etaourceeferromsyncunctionlassvoyiedelecontininstantybreareturdebuggeawaithrwhileforifcatcfinallelsxportport";let c,t,n;export function parse(k,l="@"){c=k,t=l;const u=2*c.length+(2<<18);if(u>i||!e){for(;u>i;)i*=2;a=new ArrayBuffer(i),s(f,new Uint16Array(a,16,108)),e=function(e,a,r){"use asm";var i=new e.Int8Array(r),s=new e.Int16Array(r),f=new e.Int32Array(r),c=new e.Uint8Array(r),t=new e.Uint16Array(r),n=1040;function b(e){e=e|0;var a=0,r=0,c=0,t=0,n=0,b=0,k=0,o=0,w=0,g=0,p=0,y=0,m=0,O=0,T=0;y=s[398]|0;a=f[71]|0;f[68]=a;k=a;p=a;o=y;g=0;e:while(1){c=f[72]|0;n=o<<16>>16==y<<16>>16;t=g&e;b=a;while(1){r=b+2|0;if(b>>>0>=c>>>0){a=0;w=104;break e}a=s[r>>1]|0;if(!(M(a)|0)){if(n){switch(a<<16>>16){case 125:case 93:case 41:case 59:case 44:{w=104;break e}default:{}}if(t?se(a)|0:0){w=104;break e}}if(!(se(a)|0))break}b=r}f[71]=r;a:do{switch(a<<16>>16){case 101:{if((o<<16>>16==0?Q(r)|0:0)?(S(b+4|0,214,10)|0)==0:0){u();w=93}else w=90;break}case 105:{if(((s[b+4>>1]|0)==109?Q(r)|0:0)?(S(b+6|0,224,8)|0)==0:0){l();w=93}else w=90;break}case 99:{if((((s[b+4>>1]|0)==108?Q(r)|0:0)?(S(b+6|0,70,6)|0)==0:0)?L(s[b+12>>1]|0)|0:0){i[800]=1;w=90}else w=90;break}case 40:{b=f[69]|0;w=o&65535;f[b+(w<<3)>>2]=1;s[398]=o+1<<16>>16;f[b+(w<<3)+4>>2]=k;w=93;break}case 91:{b=f[69]|0;w=o&65535;f[b+(w<<3)>>2]=8;s[398]=o+1<<16>>16;f[b+(w<<3)+4>>2]=k;w=93;break}case 93:if(!(o<<16>>16)){ee();break a}else{s[398]=o+-1<<16>>16;w=93;break a}case 44:{r=s[397]|0;if((!(o<<16>>16==0|r<<16>>16==0)?(f[(f[69]|0)+((o&65535)+-1<<3)>>2]|0)==5:0)?(m=f[(f[70]|0)+((r&65535)+-1<<2)>>2]|0,(f[m+4>>2]|0)==0):0){f[m+4>>2]=p+2;f[71]=b+4;v(1)|0;w=f[71]|0;f[m+16>>2]=w;f[71]=w+-2;w=93}else w=93;break}case 41:{if(!(o<<16>>16)){ee();break a}w=o+-1<<16>>16;s[398]=w;r=s[397]|0;if(r<<16>>16!=0?(f[(f[69]|0)+((w&65535)<<3)>>2]|0)==5:0){c=f[(f[70]|0)+((r&65535)+-1<<2)>>2]|0;if(!(f[c+4>>2]|0))f[c+4>>2]=p+2;f[c+12>>2]=b+4;s[397]=r+-1<<16>>16;w=93}else w=93;break}case 123:{w=f[62]|0;do{if((s[p>>1]|0)==41&(w|0)!=0?(f[w+12>>2]|0)==(p+2|0):0){r=f[63]|0;f[62]=r;if(!r){f[58]=0;break}else{f[r+32>>2]=0;break}}}while(0);b=f[69]|0;w=o&65535;f[b+(w<<3)>>2]=(i[800]|0)==0?2:6;s[398]=o+1<<16>>16;f[b+(w<<3)+4>>2]=k;i[800]=0;w=93;break}case 125:{if(!(o<<16>>16)){ee();break a}k=f[69]|0;w=o+-1<<16>>16;s[398]=w;if((f[k+((w&65535)<<3)>>2]|0)==4){d();w=93}else w=93;break}case 34:case 39:{A(a);w=93;break}case 47:switch(s[b+4>>1]|0){case 47:{F();break a}case 42:{x(1);break a}default:{c=s[p>>1]|0;r:do{if(!($(c)|0)){if(!(c<<16>>16==41?K(f[(f[69]|0)+((o&65535)<<3)+4>>2]|0)|0:0))w=62}else switch(c<<16>>16){case 46:if(((s[p+-2>>1]|0)+-48&65535)<10){w=62;break r}else break r;case 43:if((s[p+-2>>1]|0)==43){w=62;break r}else break r;case 45:if((s[p+-2>>1]|0)==45){w=62;break r}else break r;default:break r}}while(0);r:do{if((w|0)==62){w=0;if(o<<16>>16!=0?(O=f[69]|0,T=(o&65535)+-1|0,c<<16>>16==102?(f[O+(T<<3)>>2]|0)==1:0):0){if(((s[p+-2>>1]|0)==111?C(p+-4|0)|0:0)?B(f[O+(T<<3)+4>>2]|0,178,3)|0:0)break}else w=67;if((w|0)==67?(0,c<<16>>16==125):0){t=f[69]|0;r=o&65535;if(U(f[t+(r<<3)+4>>2]|0)|0)break;if((f[t+(r<<3)>>2]|0)==6)break}if(!(h(p)|0)){switch(c<<16>>16){case 0:break r;case 47:{if(i[799]|0)break r;break}default:{}}w=f[64]|0;if((w|0?p>>>0>=(f[w>>2]|0)>>>0:0)?p>>>0<=(f[w+4>>2]|0)>>>0:0){I();i[799]=0;w=93;break a}t=f[3]|0;r=p;do{if(r>>>0<=t>>>0)break;r=r+-2|0;f[68]=r;c=s[r>>1]|0}while(!(D(c)|0));if(M(c)|0){do{if(r>>>0<=t>>>0)break;r=r+-2|0;f[68]=r}while(M(s[r>>1]|0)|0);if(q(r)|0){I();i[799]=0;w=93;break a}}i[799]=1;w=93;break a}}}while(0);I();i[799]=0;w=93;break a}}case 96:{b=f[69]|0;w=o&65535;f[b+(w<<3)+4>>2]=k;s[398]=o+1<<16>>16;f[b+(w<<3)>>2]=3;d();w=93;break}default:if((a&65535)>127&a<<16>>16!=160|(a<<16>>16==92|(a<<16>>16==95|(a<<16>>16==36|((a+-48&65535)<10|((a|32)+-97&65535)<26)))))w=90;else w=93}}while(0);a:do{if((w|0)==90)while(1){r=r+2|0;w=s[r>>1]|0;if(!((w&65535)>127&w<<16>>16!=160|(w<<16>>16==92|(w<<16>>16==95|(w<<16>>16==36|((w+-48&65535)<10|((w|32)+-97&65535)<26)))))){w=93;break a}f[71]=r}}while(0);if((w|0)==93){w=0;f[68]=f[71]}if(i[798]|0){a=0;break}r=f[68]|0;a:do{if((r|0)==(p|0))if(g&((s[398]|0)==y<<16>>16&e)){a=s[f[71]>>1]|0;if(se(a)|0)break e;else a=1}else a=g;else{if(a<<16>>16==47){a=(i[799]|0)==0;break}if(G(a)|0)a=1;else{switch(a<<16>>16){case 96:case 34:case 39:case 41:case 93:case 125:{a=1;break a}default:{}}a=0}}}while(0);k=r;p=r;o=s[398]|0;g=a;a=f[71]|0}if((w|0)==104)f[71]=r;return a|0}function k(){var e=0,a=0,r=0,c=0,t=0,b=0,k=0,o=0,w=0;w=n;n=n+10240|0;s[397]=0;s[398]=0;f[68]=f[2];i[799]=0;f[67]=0;i[798]=0;f[69]=w+2048;f[70]=w;i[800]=0;r=(f[3]|0)+-2|0;f[71]=r;a=r+(f[65]<<1)|0;f[72]=a;e:while(1){e=r+2|0;f[71]=e;if(r>>>0>=a>>>0){c=89;break}a=s[e>>1]|0;a:do{switch(a<<16>>16){case 9:case 10:case 11:case 12:case 13:case 32:break;case 101:{if(((s[398]|0)==0?Q(e)|0:0)?(S(r+4|0,214,10)|0)==0:0){u();c=88}else c=85;break}case 105:{if(((s[r+4>>1]|0)==109?Q(e)|0:0)?(S(r+6|0,224,8)|0)==0:0){l();c=88}else c=85;break}case 99:{if((((s[r+4>>1]|0)==108?Q(e)|0:0)?(S(r+6|0,70,6)|0)==0:0)?L(s[r+12>>1]|0)|0:0){i[800]=1;c=85}else c=85;break}case 40:{r=f[69]|0;c=s[398]|0;f[r+((c&65535)<<3)>>2]=1;a=f[68]|0;s[398]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=a;c=88;break}case 91:{r=f[69]|0;c=s[398]|0;f[r+((c&65535)<<3)>>2]=8;a=f[68]|0;s[398]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=a;c=88;break}case 93:{e=s[398]|0;if(!(e<<16>>16)){c=21;break e}s[398]=e+-1<<16>>16;c=88;break}case 44:{e=s[397]|0;if(((e<<16>>16!=0?(t=s[398]|0,t<<16>>16!=0):0)?(f[(f[69]|0)+((t&65535)+-1<<3)>>2]|0)==5:0)?(b=f[(f[70]|0)+((e&65535)+-1<<2)>>2]|0,(f[b+4>>2]|0)==0):0){f[b+4>>2]=(f[68]|0)+2;f[71]=r+4;v(1)|0;c=f[71]|0;f[b+16>>2]=c;f[71]=c+-2;c=88}else c=88;break}case 41:{e=s[398]|0;if(!(e<<16>>16)){c=29;break e}s[398]=e+-1<<16>>16;a=s[397]|0;if(a<<16>>16!=0?(f[(f[69]|0)+((e+-1&65535)<<3)>>2]|0)==5:0){e=f[(f[70]|0)+((a&65535)+-1<<2)>>2]|0;if(!(f[e+4>>2]|0))f[e+4>>2]=(f[68]|0)+2;f[e+12>>2]=r+4;s[397]=a+-1<<16>>16;c=88}else c=88;break}case 123:{e=f[68]|0;c=f[62]|0;do{if((s[e>>1]|0)==41&(c|0)!=0?(f[c+12>>2]|0)==(e+2|0):0){a=f[63]|0;f[62]=a;if(!a){f[58]=0;break}else{f[a+32>>2]=0;break}}}while(0);r=f[69]|0;c=s[398]|0;f[r+((c&65535)<<3)>>2]=(i[800]|0)==0?2:6;s[398]=c+1<<16>>16;f[r+((c&65535)<<3)+4>>2]=e;i[800]=0;c=88;break}case 125:{e=s[398]|0;if(!(e<<16>>16)){c=42;break e}c=f[69]|0;s[398]=e+-1<<16>>16;if((f[c+((e+-1&65535)<<3)>>2]|0)==4){d();c=88}else c=88;break}case 34:case 39:{A(a);c=88;break}case 47:switch(s[r+4>>1]|0){case 47:{F();break a}case 42:{x(1);break a}default:{e=f[68]|0;a=s[e>>1]|0;r:do{if(!($(a)|0))if(a<<16>>16==41){r=s[398]|0;if(!(K(f[(f[69]|0)+((r&65535)<<3)+4>>2]|0)|0))c=57}else c=56;else switch(a<<16>>16){case 46:if(((s[e+-2>>1]|0)+-48&65535)<10){c=56;break r}else break r;case 43:if((s[e+-2>>1]|0)==43){c=56;break r}else break r;case 45:if((s[e+-2>>1]|0)==45){c=56;break r}else break r;default:break r}}while(0);if((c|0)==56){r=s[398]|0;c=57}r:do{if((c|0)==57){c=0;if(r<<16>>16!=0?(k=f[69]|0,o=(r&65535)+-1|0,a<<16>>16==102?(f[k+(o<<3)>>2]|0)==1:0):0){if(((s[e+-2>>1]|0)==111?C(e+-4|0)|0:0)?B(f[k+(o<<3)+4>>2]|0,178,3)|0:0)break}else c=62;if((c|0)==62?(0,a<<16>>16==125):0){c=f[69]|0;r=r&65535;if(U(f[c+(r<<3)+4>>2]|0)|0)break;if((f[c+(r<<3)>>2]|0)==6)break}if(!(h(e)|0)){switch(a<<16>>16){case 0:break r;case 47:{if(i[799]|0)break r;break}default:{}}c=f[64]|0;if((c|0?e>>>0>=(f[c>>2]|0)>>>0:0)?e>>>0<=(f[c+4>>2]|0)>>>0:0){I();i[799]=0;c=88;break a}r=f[3]|0;do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[68]=e;a=s[e>>1]|0}while(!(D(a)|0));if(M(a)|0){do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[68]=e}while(M(s[e>>1]|0)|0);if(q(e)|0){I();i[799]=0;c=88;break a}}i[799]=1;c=88;break a}}}while(0);I();i[799]=0;c=88;break a}}case 96:{r=f[69]|0;c=s[398]|0;f[r+((c&65535)<<3)+4>>2]=f[68];s[398]=c+1<<16>>16;f[r+((c&65535)<<3)>>2]=3;d();c=88;break}default:if((a&65535)>127&a<<16>>16!=160|(a<<16>>16==92|(a<<16>>16==95|(a<<16>>16==36|((a+-48&65535)<10|((a|32)+-97&65535)<26)))))c=85;else c=88}}while(0);a:do{if((c|0)==85)while(1){e=e+2|0;c=s[e>>1]|0;if(!((c&65535)>127&c<<16>>16!=160|(c<<16>>16==92|(c<<16>>16==95|(c<<16>>16==36|((c+-48&65535)<10|((c|32)+-97&65535)<26)))))){c=88;break a}f[71]=e}}while(0);if((c|0)==88){c=0;f[68]=f[71]}r=f[71]|0;a=f[72]|0}if((c|0)==21){ee();e=0}else if((c|0)==29){ee();e=0}else if((c|0)==42){ee();e=0}else if((c|0)==89)e=(i[798]|0)==0?(s[397]|s[398])<<16>>16==0:0;n=w;return e|0}function l(){var e=0,a=0,r=0,c=0,t=0,n=0;n=f[71]|0;f[71]=n+12;e=v(1)|0;r=f[71]|0;e:do{if(e<<16>>16!=46){if(!(e<<16>>16==115&r>>>0>(n+12|0)>>>0)){if(!(e<<16>>16==100&r>>>0>(n+10|0)>>>0)){r=0;t=28;break}if(S(r+2|0,32,8)|0){a=r;e=100;r=0;t=60;break}if(!(L(s[r+10>>1]|0)|0)){a=r;e=100;r=0;t=60;break}f[71]=r+10;e=v(1)|0;if(e<<16>>16==42){e=42;c=2;t=62;break}f[71]=r;r=0;t=28;break}if((S(r+2|0,22,10)|0)==0?L(s[r+12>>1]|0)|0:0){f[71]=r+12;e=v(1)|0;a=f[71]|0;if((a|0)!=(r+12|0)){if(e<<16>>16!=102){r=1;t=28;break}if(S(a+2|0,40,6)|0){e=102;r=1;t=60;break}if(!(D(s[a+8>>1]|0)|0)){e=102;r=1;t=60;break}}f[71]=r;r=0;t=28}else{a=r;e=115;r=0;t=60}}else{f[71]=r+2;switch((v(1)|0)<<16>>16){case 109:{e=f[71]|0;if(S(e+2|0,16,6)|0)break e;a=f[68]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;g(n,n,e+8|0,2);break e}case 115:{e=f[71]|0;if(S(e+2|0,22,10)|0)break e;a=f[68]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;f[71]=e+12;e=v(1)|0;r=1;t=28;break e}case 100:{e=f[71]|0;if(S(e+2|0,32,8)|0)break e;a=f[68]|0;if(!(N(a)|0)?(s[a>>1]|0)==46:0)break e;f[71]=e+10;e=v(1)|0;r=2;t=28;break e}default:break e}}}while(0);e:do{if((t|0)==28){if(e<<16>>16==40){a=f[69]|0;c=s[398]|0;f[a+((c&65535)<<3)>>2]=5;e=f[71]|0;s[398]=c+1<<16>>16;f[a+((c&65535)<<3)+4>>2]=e;if((s[f[68]>>1]|0)==46)break;f[71]=e+2;a=v(1)|0;g(n,f[71]|0,0,e);if(!r)e=f[62]|0;else{e=f[62]|0;f[e+28>>2]=(r|0)==1?5:7}c=f[70]|0;n=s[397]|0;s[397]=n+1<<16>>16;f[c+((n&65535)<<2)>>2]=e;switch(a<<16>>16){case 39:{A(39);break}case 34:{A(34);break}case 96:{if(!(y()|0))t=37;break}default:t=37}if((t|0)==37){f[71]=(f[71]|0)+-2;break}e=(f[71]|0)+2|0;f[71]=e;switch((v(1)|0)<<16>>16){case 44:{f[71]=(f[71]|0)+2;v(1)|0;c=f[62]|0;f[c+4>>2]=e;n=f[71]|0;f[c+16>>2]=n;i[c+24>>0]=1;f[71]=n+-2;break e}case 41:{s[398]=(s[398]|0)+-1<<16>>16;n=f[62]|0;f[n+4>>2]=e;f[n+12>>2]=(f[71]|0)+2;i[n+24>>0]=1;s[397]=(s[397]|0)+-1<<16>>16;break e}default:{f[71]=(f[71]|0)+-2;break e}}}if(!((r|0)==0&e<<16>>16==123)){switch(e<<16>>16){case 42:case 39:case 34:{c=r;t=62;break e}default:{}}a=f[71]|0;t=60;break}e=f[71]|0;if(s[398]|0){f[71]=e+-2;break}while(1){if(e>>>0>=(f[72]|0)>>>0)break;e=v(1)|0;if(!(ae(e)|0)){if(e<<16>>16==125){t=50;break}}else A(e);e=(f[71]|0)+2|0;f[71]=e}if((t|0)==50)f[71]=(f[71]|0)+2;c=(v(1)|0)<<16>>16==102;e=f[71]|0;if(c?S(e+2|0,40,6)|0:0){ee();break}f[71]=e+8;e=v(1)|0;if(ae(e)|0){w(n,e,0);break}else{ee();break}}}while(0);if((t|0)==60)if((a|0)==(n+12|0))f[71]=n+10;else{c=r;t=62}do{if((t|0)==62){if(!((e<<16>>16==42|(c|0)!=2)&(s[398]|0)==0)){f[71]=(f[71]|0)+-2;break}e=f[72]|0;a=f[71]|0;while(1){if(a>>>0>=e>>>0){t=69;break}r=s[a>>1]|0;if(ae(r)|0){t=67;break}t=a+2|0;f[71]=t;a=t}if((t|0)==67){w(n,r,c);break}else if((t|0)==69){ee();break}}}while(0);return}function u(){var e=0,a=0,r=0,i=0,c=0,t=0,n=0,k=0,l=0,u=0;k=f[71]|0;l=f[64]|0;f[71]=k+12;a=v(1)|0;e=f[71]|0;if(!((e|0)==(k+12|0)?!(O(a)|0):0))u=3;e:do{if((u|0)==3){a:do{switch(a<<16>>16){case 123:{f[71]=e+2;e=v(1)|0;r=f[71]|0;while(1){if(ae(e)|0){A(e);e=(f[71]|0)+2|0;f[71]=e}else{H(e)|0;e=f[71]|0}v(1)|0;e=p(r,e)|0;if(e<<16>>16==44){f[71]=(f[71]|0)+2;e=v(1)|0}a=r;r=f[71]|0;if(e<<16>>16==125){u=15;break}if((r|0)==(a|0)){u=12;break}if(r>>>0>(f[72]|0)>>>0){u=14;break}}if((u|0)==12){ee();break e}else if((u|0)==14){ee();break e}else if((u|0)==15){f[71]=r+2;u=49;break a}break}case 42:{f[71]=e+2;v(1)|0;u=f[71]|0;p(u,u)|0;u=49;break}case 100:{f[71]=e+14;switch((v(1)|0)<<16>>16){case 97:{a=f[71]|0;if((S(a+2|0,46,8)|0)==0?M(s[a+10>>1]|0)|0:0){f[71]=a+10;v(0)|0;u=21}break}case 102:{u=21;break}case 99:{a=f[71]|0;if(((S(a+2|0,68,8)|0)==0?(l=s[a+10>>1]|0,L(l)|0|l<<16>>16==123):0)?(f[71]=a+10,r=v(1)|0,r<<16>>16!=123):0){n=r;u=30}break}default:{}}r:do{if((u|0)==21?(i=f[71]|0,(S(i+2|0,54,14)|0)==0):0){a=s[i+16>>1]|0;if(!(L(a)|0))switch(a<<16>>16){case 40:case 42:break;default:break r}f[71]=i+16;a=v(1)|0;if(a<<16>>16==42){f[71]=(f[71]|0)+2;a=v(1)|0}if(a<<16>>16!=40){n=a;u=30}}}while(0);if((u|0)==30?(c=f[71]|0,H(n)|0,t=f[71]|0,t>>>0>c>>>0):0){E(e,e+14|0,c,t);f[71]=(f[71]|0)+-2;break e}E(e,e+14|0,0,0);f[71]=e+12;break e}case 97:{f[71]=e+10;v(0)|0;e=f[71]|0;u=34;break}case 102:{u=34;break}case 99:{if((S(e+2|0,68,8)|0)==0?D(s[e+10>>1]|0)|0:0){f[71]=e+10;u=v(1)|0;l=f[71]|0;H(u)|0;u=f[71]|0;E(l,u,l,u);f[71]=(f[71]|0)+-2;break e}f[71]=e+4;e=e+4|0;u=41;break}case 108:case 118:{u=41;break}default:break e}}while(0);if((u|0)==34){f[71]=e+16;e=v(1)|0;if(e<<16>>16==42){f[71]=(f[71]|0)+2;e=v(1)|0}l=f[71]|0;H(e)|0;u=f[71]|0;E(l,u,l,u);f[71]=(f[71]|0)+-2;break}else if((u|0)==41){f[71]=e+6;while(1){a=v(1)|0;e=f[71]|0;if(e>>>0>(f[72]|0)>>>0)break;a=P(a)|0;if((f[71]|0)==(e|0))break;if(a<<16>>16==61)a=b(1)|0;e=f[71]|0;if(a<<16>>16!=44)break;f[71]=e+2}f[71]=e+-2;break}else if((u|0)==49){u=(v(1)|0)<<16>>16==102;e=f[71]|0;if(u?(S(e+2|0,40,6)|0)==0:0){f[71]=e+8;w(k,v(1)|0,0);e=(l|0)==0?236:l+16|0;while(1){e=f[e>>2]|0;if(!e)break e;f[e+12>>2]=0;f[e+8>>2]=0;e=e+16|0}}f[71]=e+-2;break}}}while(0);return}function o(){var e=0,a=0,r=0,i=0,c=0,t=0,n=0;e=f[71]|0;c=(s[e>>1]|0)==123;f[71]=e+2;e=v(1)|0;t=c?125:93;e:while(1){if((t|0)==(e&65535|0))break;i=f[71]|0;if(i>>>0>(f[72]|0)>>>0)break;if((e<<16>>16==46?(s[i+2>>1]|0)==46:0)?(s[i+4>>1]|0)==46:0){f[71]=i+6;e=P(v(1)|0)|0}else n=9;a:do{if((n|0)==9){n=0;do{if(c){do{if(e<<16>>16==91){b(0)|0;f[71]=(f[71]|0)+2;a=i}else{if(ae(e)|0){A(e);f[71]=(f[71]|0)+2;a=i;break}if((e+-48&65535)>=10){H(e)|0;a=f[71]|0;break}e=i;r:while(1){r=e+2|0;a=s[r>>1]|0;i:do{if((a+-48&65535)>=10){switch(a<<16>>16){case 67:case 68:case 70:case 97:case 65:case 99:case 100:case 102:case 46:case 66:case 69:case 79:case 88:case 95:case 98:case 101:case 110:case 111:case 120:break i;case 43:case 45:break;default:break r}switch(s[e>>1]|0){case 69:case 101:break;default:break r}}}while(0);e=r}f[71]=r;a=i}}while(0);e=v(1)|0;if(e<<16>>16==58){f[71]=(f[71]|0)+2;e=P(v(1)|0)|0;break}if(a>>>0>i>>>0)E(i,a,i,a)}else if(e<<16>>16==44){f[71]=i+2;e=v(1)|0;break a}else{e=P(e)|0;break}}while(0);if(e<<16>>16==61)e=b(0)|0;if(e<<16>>16!=44)break e;f[71]=(f[71]|0)+2;e=v(1)|0}}while(0)}return}function h(e){e=e|0;e:do{switch(s[e>>1]|0){case 100:switch(s[e+-2>>1]|0){case 105:{e=B(e+-4|0,76,2)|0;break e}case 108:{e=B(e+-4|0,80,3)|0;break e}default:{e=0;break e}}case 101:switch(s[e+-2>>1]|0){case 115:switch(s[e+-4>>1]|0){case 108:{e=z(e+-6|0,101)|0;break e}case 97:{e=z(e+-6|0,99)|0;break e}default:{e=0;break e}}case 116:{e=B(e+-4|0,86,4)|0;break e}case 117:{e=B(e+-4|0,94,6)|0;break e}default:{e=0;break e}}case 102:{if((s[e+-2>>1]|0)==111?(s[e+-4>>1]|0)==101:0)switch(s[e+-6>>1]|0){case 99:{e=B(e+-8|0,106,6)|0;break e}case 112:{e=B(e+-8|0,118,2)|0;break e}default:{e=0;break e}}else e=0;break}case 107:{e=B(e+-2|0,122,4)|0;break}case 110:{if(z(e+-2|0,105)|0)e=1;else e=B(e+-2|0,130,5)|0;break}case 111:{e=z(e+-2|0,100)|0;break}case 114:{e=B(e+-2|0,140,7)|0;break}case 116:{e=B(e+-2|0,154,4)|0;break}case 119:switch(s[e+-2>>1]|0){case 101:{e=z(e+-4|0,110)|0;break e}case 111:{e=B(e+-4|0,162,3)|0;break e}default:{e=0;break e}}default:e=0}}while(0);return e|0}function w(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,c=0;i=(f[71]|0)+2|0;switch(a<<16>>16){case 39:{A(39);c=5;break}case 34:{A(34);c=5;break}default:ee()}do{if((c|0)==5){g(e,i,f[71]|0,1);if((r|0)>0)f[(f[62]|0)+28>>2]=(r|0)==1?4:6;f[71]=(f[71]|0)+2;c=(v(0)|0)<<16>>16==119;a=f[71]|0;if(((c?(s[a+2>>1]|0)==105:0)?(s[a+4>>1]|0)==116:0)?(s[a+6>>1]|0)==104:0){f[71]=a+8;if((v(1)|0)<<16>>16!=123){f[71]=a;break}r=f[71]|0;i=r;e:while(1){f[71]=i+2;i=v(1)|0;switch(i<<16>>16){case 39:{A(39);f[71]=(f[71]|0)+2;i=v(1)|0;break}case 34:{A(34);f[71]=(f[71]|0)+2;i=v(1)|0;break}default:i=H(i)|0}if(i<<16>>16!=58){c=20;break}f[71]=(f[71]|0)+2;switch((v(1)|0)<<16>>16){case 39:{A(39);break}case 34:{A(34);break}default:{c=24;break e}}f[71]=(f[71]|0)+2;switch((v(1)|0)<<16>>16){case 125:{c=28;break e}case 44:break;default:{c=26;break e}}i=(f[71]|0)+2|0;f[71]=i}if((c|0)==20){f[71]=a;break}else if((c|0)==24){f[71]=a;break}else if((c|0)==26){f[71]=a;break}else if((c|0)==28){c=f[62]|0;f[c+16>>2]=r;f[c+12>>2]=(f[71]|0)+2;break}}f[71]=a+-2}}while(0);return}function d(){var e=0,a=0,r=0;a=f[72]|0;r=f[71]|0;e:while(1){e=r+2|0;if(r>>>0>=a>>>0){a=10;break}switch(s[e>>1]|0){case 96:{a=7;break e}case 36:{if((s[r+4>>1]|0)==123){a=6;break e}break}case 92:{e=r+4|0;break}default:{}}r=e}if((a|0)==6){e=r+4|0;f[71]=e;a=f[69]|0;r=s[398]|0;f[a+((r&65535)<<3)>>2]=4;s[398]=r+1<<16>>16;f[a+((r&65535)<<3)+4>>2]=e}else if((a|0)==7){f[71]=e;a=f[69]|0;r=(s[398]|0)+-1<<16>>16;s[398]=r;if((f[a+((r&65535)<<3)>>2]|0)!=3)ee()}else if((a|0)==10){f[71]=e;ee()}return}function v(e){e=e|0;var a=0,r=0,i=0;r=f[71]|0;e:do{a=s[r>>1]|0;a:do{if(a<<16>>16!=47)if(e)if(L(a)|0)break;else break e;else if(M(a)|0)break;else break e;else switch(s[r+2>>1]|0){case 47:{F();break a}case 42:{x(e);break a}default:{a=47;break e}}}while(0);i=f[71]|0;r=i+2|0;f[71]=r}while(i>>>0<(f[72]|0)>>>0);return a|0}function A(e){e=e|0;var a=0,r=0,i=0,c=0;c=f[72]|0;a=f[71]|0;while(1){i=a+2|0;if(a>>>0>=c>>>0){a=9;break}r=s[i>>1]|0;if(r<<16>>16==e<<16>>16){a=10;break}if(r<<16>>16==92){r=a+4|0;if((s[r>>1]|0)==13){a=a+6|0;a=(s[a>>1]|0)==10?a:r}else a=r}else if(se(r)|0){a=9;break}else a=i}if((a|0)==9){f[71]=i;ee()}else if((a|0)==10)f[71]=i;return}function C(e){e=e|0;var a=0,r=0;a=s[e>>1]|0;if(L(a)|0)r=3;else switch(a<<16>>16){case 41:case 125:case 93:{r=3;break}default:e=0}e:do{if((r|0)==3){r=f[3]|0;while(1){if(e>>>0<=r>>>0)break;e=e+-2|0;if(!(L(a)|0))break;a=s[e>>1]|0}switch(a<<16>>16){case 41:case 125:case 93:{e=1;break e}default:{}}e=(O(a)|0)^1}}while(0);return e|0}function g(e,a,r,s){e=e|0;a=a|0;r=r|0;s=s|0;var c=0,t=0;t=f[66]|0;f[66]=t+36;c=f[62]|0;f[((c|0)==0?232:c+32|0)>>2]=t;f[63]=c;f[62]=t;f[t+8>>2]=e;if(2==(s|0)){e=3;c=r}else{e=1==(s|0)?1:2;c=1==(s|0)?r+2|0:0}f[t+12>>2]=c;f[t+28>>2]=e;f[t>>2]=a;f[t+4>>2]=r;f[t+16>>2]=0;f[t+20>>2]=s;i[t+24>>0]=1==(s|0)&1;f[t+32>>2]=0;return}function p(e,a){e=e|0;a=a|0;var r=0,i=0,c=0,t=0;r=f[71]|0;i=s[r>>1]|0;c=(e|0)==(a|0)?0:e;t=(e|0)==(a|0)?0:a;if(i<<16>>16==97){f[71]=r+4;r=v(1)|0;e=f[71]|0;if(ae(r)|0){A(r);a=(f[71]|0)+2|0;f[71]=a}else{H(r)|0;a=f[71]|0}i=v(1)|0;r=f[71]|0}if((r|0)!=(e|0))E(e,a,c,t);return i|0}function y(){var e=0,a=0,r=0,i=0;i=f[71]|0;r=f[72]|0;a=i;e:while(1){e=a+2|0;if(a>>>0>=r>>>0){a=7;break}switch(s[e>>1]|0){case 96:{a=8;break e}case 92:{e=a+4|0;break}case 36:{if((s[a+4>>1]|0)==123){a=7;break e}break}default:{}}a=e}if((a|0)==7){f[71]=i;e=0}else if((a|0)==8){f[71]=e;e=1}return e|0}function m(){var e=0,a=0,r=0;r=f[72]|0;a=f[71]|0;e:while(1){e=a+2|0;if(a>>>0>=r>>>0){a=6;break}switch(s[e>>1]|0){case 13:case 10:{a=6;break e}case 93:{a=7;break e}case 92:{e=a+4|0;break}default:{}}a=e}if((a|0)==6){f[71]=e;ee();e=0}else if((a|0)==7){f[71]=e;e=93}return e|0}function I(){var e=0,a=0;e:while(1){e=f[71]|0;f[71]=e+2;if(e>>>0>=(f[72]|0)>>>0){a=7;break}switch(s[e+2>>1]|0){case 13:case 10:{a=7;break e}case 47:break e;case 91:{m()|0;break}case 92:{f[71]=e+4;break}default:{}}}if((a|0)==7)ee();return}function U(e){e=e|0;switch(s[e>>1]|0){case 62:{e=(s[e+-2>>1]|0)==61;break}case 41:case 59:{e=1;break}case 104:{e=B(e+-2|0,188,4)|0;break}case 121:{e=B(e+-2|0,196,6)|0;break}case 101:{e=B(e+-2|0,208,3)|0;break}default:e=0}return e|0}function x(e){e=e|0;var a=0,r=0,i=0,c=0,t=0;c=(f[71]|0)+2|0;f[71]=c;r=f[72]|0;while(1){a=c+2|0;if(c>>>0>=r>>>0)break;i=s[a>>1]|0;if(!e?se(i)|0:0)break;if(i<<16>>16==42?(s[c+4>>1]|0)==47:0){t=8;break}c=a}if((t|0)==8){f[71]=a;a=c+4|0}f[71]=a;return}function S(e,a,r){e=e|0;a=a|0;r=r|0;var s=0,f=0;e:do{if(!r)e=0;else{while(1){s=i[e>>0]|0;f=i[a>>0]|0;if(s<<24>>24!=f<<24>>24)break;r=r+-1|0;if(!r){e=0;break e}else{e=e+1|0;a=a+1|0}}e=(s&255)-(f&255)|0}}while(0);return e|0}function O(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:{e=1;break}default:if((e&-8)<<16>>16==40|(e+-58&65535)<6)e=1;else{switch(e<<16>>16){case 91:case 93:case 94:{e=1;break e}default:{}}e=(e+-123&65535)<4}}}while(0);return e|0}function $(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:break;default:if(!((e+-58&65535)<6|(e+-40&65535)<7&e<<16>>16!=41)){switch(e<<16>>16){case 91:case 94:break e;default:{}}return e<<16>>16!=125&(e+-123&65535)<4|0}}}while(0);return 1}function T(e){e=e|0;var a=0;a=s[e>>1]|0;e:do{if((a+-9&65535)>=5){switch(a<<16>>16){case 160:case 32:{a=1;break e}default:{}}if(O(a)|0)return a<<16>>16!=46|(N(e)|0)|0;else a=0}else a=1}while(0);return a|0}function j(e){e=e|0;var a=0,r=0;r=n;n=n+16|0;f[r>>2]=0;f[65]=e;a=f[3]|0;s[a+(e<<1)>>1]=0;f[r>>2]=a+(e<<1)+2;f[66]=a+(e<<1)+2;f[58]=0;f[62]=0;f[60]=0;f[59]=0;f[64]=0;f[61]=0;n=r;return a|0}function B(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,s=0;s=e+(0-r<<1)+2|0;i=f[3]|0;if(s>>>0>=i>>>0?(S(s,a,r<<1)|0)==0:0)if((s|0)==(i|0))i=1;else i=T(e+(0-r<<1)|0)|0;else i=0;return i|0}function E(e,a,r,i){e=e|0;a=a|0;r=r|0;i=i|0;var s=0,c=0;s=f[66]|0;f[66]=s+20;c=f[64]|0;f[((c|0)==0?236:c+16|0)>>2]=s;f[64]=s;f[s>>2]=e;f[s+4>>2]=a;f[s+8>>2]=r;f[s+12>>2]=i;f[s+16>>2]=0;return}function P(e){e=e|0;var a=0;switch(e<<16>>16){case 91:case 123:{o();f[71]=(f[71]|0)+2;break}default:{a=f[71]|0;H(e)|0;e=f[71]|0;if(e>>>0>a>>>0)E(a,e,a,e)}}return v(1)|0}function q(e){e=e|0;switch(s[e>>1]|0){case 107:{e=B(e+-2|0,122,4)|0;break}case 101:{if((s[e+-2>>1]|0)==117)e=B(e+-4|0,94,6)|0;else e=0;break}default:e=0}return e|0}function z(e,a){e=e|0;a=a|0;var r=0;r=f[3]|0;if(r>>>0<=e>>>0?(s[e>>1]|0)==a<<16>>16:0)if((r|0)==(e|0))r=1;else r=D(s[e+-2>>1]|0)|0;else r=0;return r|0}function D(e){e=e|0;e:do{if((e+-9&65535)<5)e=1;else{switch(e<<16>>16){case 32:case 160:{e=1;break e}default:{}}e=e<<16>>16!=46&(O(e)|0)}}while(0);return e|0}function F(){var e=0,a=0,r=0;e=f[72]|0;r=f[71]|0;e:while(1){a=r+2|0;if(r>>>0>=e>>>0)break;switch(s[a>>1]|0){case 13:case 10:break e;default:r=a}}f[71]=a;return}function G(e){e=e|0;e:do{if(((e&-33)+-65&65535)<26|(e+-48&65535)<10)e=1;else{switch(e<<16>>16){case 36:case 95:{e=1;break e}default:{}}e=(e&65535)>127}}while(0);return e|0}function H(e){e=e|0;while(1){if(L(e)|0)break;if(O(e)|0)break;e=(f[71]|0)+2|0;f[71]=e;e=s[e>>1]|0;if(!(e<<16>>16)){e=0;break}}return e|0}function J(){var e=0;e=f[(f[60]|0)+20>>2]|0;switch(e|0){case 1:{e=-1;break}case 2:{e=-2;break}default:e=e-(f[3]|0)>>1}return e|0}function K(e){e=e|0;if(!(B(e,168,5)|0)?!(B(e,178,3)|0):0)e=B(e,184,2)|0;else e=1;return e|0}function L(e){e=e|0;switch(e<<16>>16){case 160:case 9:case 10:case 11:case 12:case 13:case 32:{e=1;break}default:e=0}return e|0}function M(e){e=e|0;switch(e<<16>>16){case 160:case 32:case 12:case 11:case 9:{e=1;break}default:e=0}return e|0}function N(e){e=e|0;if((s[e>>1]|0)==46?(s[e+-2>>1]|0)==46:0)e=(s[e+-4>>1]|0)==46;else e=0;return e|0}function Q(e){e=e|0;if((f[3]|0)==(e|0))e=1;else e=T(e+-2|0)|0;return e|0}function R(){var e=0;e=f[(f[61]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function V(){var e=0;e=f[(f[60]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function W(){var e=0;e=f[(f[61]|0)+8>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function X(){var e=0;e=f[(f[60]|0)+16>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function Y(){var e=0;e=f[(f[60]|0)+4>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function Z(){var e=0;e=f[60]|0;e=f[((e|0)==0?232:e+32|0)>>2]|0;f[60]=e;return(e|0)!=0|0}function _(){var e=0;e=f[61]|0;e=f[((e|0)==0?236:e+16|0)>>2]|0;f[61]=e;return(e|0)!=0|0}function ee(){i[798]=1;f[67]=(f[71]|0)-(f[3]|0)>>1;f[71]=(f[72]|0)+2;return}function ae(e){e=e|0;return e<<16>>16==39|e<<16>>16==34|0}function re(){return(f[(f[60]|0)+8>>2]|0)-(f[3]|0)>>1|0}function ie(){return(f[(f[61]|0)+4>>2]|0)-(f[3]|0)>>1|0}function se(e){e=e|0;return e<<16>>16==13|e<<16>>16==10|0}function fe(){return(f[f[60]>>2]|0)-(f[3]|0)>>1|0}function ce(){return(f[f[61]>>2]|0)-(f[3]|0)>>1|0}function te(){return c[(f[60]|0)+24>>0]|0|0}function ne(e){e=e|0;f[3]=e;return}function be(){return f[(f[60]|0)+28>>2]|0}function ke(){return f[67]|0}function le(e,a){e=e|0;a=a|0;n=e+a+15&-16;return a|0}return{su:le,ai:X,e:ke,ee:ie,ele:R,els:W,es:ce,id:J,ie:Y,ip:te,is:fe,it:be,p:k,re:_,ri:Z,sa:j,se:V,ses:ne,ss:re}}("undefined"!=typeof globalThis?globalThis:self,{},a),r=e.su(i-(2<<17),1040)}const h=c.length+1;e.ses(r),e.sa(h-1),s(c,new Uint16Array(a,r,h)),e.p()||(n=e.e(),o());const w=[],d=[];for(;e.ri();){const a=e.is(),r=e.ie(),i=e.ai(),s=e.id(),f=e.ss(),t=e.se(),n=e.it();let k;e.ip()&&(k=b(-1===s?a:a+1,c.charCodeAt(-1===s?a-1:a)));let l=null;0,w.push({t:n,n:k,s:a,e:r,ss:f,se:t,d:s,a:i,at:l})}for(;e.re();){const a=e.es(),r=e.ee(),i=e.els(),s=e.ele(),f=i<0?void 0:v(i,s),c=v(a,r);d.push({s:a,e:r,ls:i,le:s,n:c,ln:f})}return[w,d];function v(e,a){const r=c.charCodeAt(e);return 34===r||39===r?b(e+1,r):c.slice(e,a)}}function b(e,a){n=e;let r="",i=n;for(;;){n>=c.length&&o();const e=c.charCodeAt(n);if(e===a)break;92===e?(r+=c.slice(i,n),r+=k(),i=n):(8232===e||8233===e||u(e)&&96!==a&&o(),++n)}return r+=c.slice(i,n++),r}function k(){let e=c.charCodeAt(++n);switch(++n,e){case 110:return"\n";case 114:return"\r";case 120:return String.fromCharCode(l(2));case 117:return function(){const e=c.charCodeAt(n);let a;123===e?(++n,a=l(c.indexOf("}",n)-n),++n,a>1114111&&o()):a=l(4);return a<=65535?String.fromCharCode(a):(a-=65536,String.fromCharCode(55296+(a>>10),56320+(1023&a)))}();case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===c.charCodeAt(n)&&++n;case 10:return"";case 56:case 57:o();default:if(e>=48&&e<=55){let a=c.substr(n-1,3).match(/^[0-7]+/)[0],r=parseInt(a,8);return r>255&&(a=a.slice(0,-1),r=parseInt(a,8)),n+=a.length-1,e=c.charCodeAt(n),"0"===a&&56!==e&&57!==e||o(),String.fromCharCode(r)}return u(e)?"":String.fromCharCode(e)}}function l(e){const a=n;let r=0,i=0;for(let a=0;a=97)e=s-97+10;else if(s>=65)e=s-65+10;else{if(!(s>=48&&s<=57))break;e=s-48}if(e>=16)break;i=s,r=16*r+e}else 95!==i&&0!==a||o(),i=s}return 95!==i&&n-a===e||o(),r}function u(e){return 13===e||10===e}function o(){throw Object.assign(Error(`Parse error ${t}:${c.slice(0,n).split("\n").length}:${n-c.lastIndexOf("\n",n-1)}`),{idx:n})} diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.cjs b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.cjs new file mode 100644 index 00000000..331d0787 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.cjs @@ -0,0 +1 @@ +"use strict";exports.initSync=exports.init=exports.ImportType=void 0,exports.parse=parse;var ImportType=exports.ImportType=function(A){return A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase",A}({});const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(E,g="@"){if(!C)return init.then(()=>parse(E,g));const I=E.length+1,i=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;i>0&&C.memory.grow(Math.ceil(i/65536));const D=C.sa(I-1);if("undefined"!=typeof Buffer?Buffer.from(C.memory.buffer,D,2*(I-1)).write(E,"utf16le"):(A?B:Q)(E,new Uint16Array(C.memory.buffer,D,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const G=[],w=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),i=C.ss(),D=C.se();let w;C.ip()&&(w=o(E.slice(-1===I?A-1:A,-1===I?Q+1:Q)));let k=null;G.push({n:w,t:B,s:A,e:Q,ss:i,se:D,d:I,a:g,at:k})}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=B<0?void 0:k(E.slice(B,g)),i=k(E.slice(A,Q));w.push({s:A,e:Q,ls:B,le:g,n:i,ln:I})}function o(A){try{return(0,eval)(A)}catch(A){}}function k(A){if(!A)return A;const Q=A[0];return('"'===Q||"'"===Q)&&o(A)||A}return[G,w]}function Q(A,Q){const B=A.length;let C=0;for(;C>>8}}function B(A,Q){const B=A.length;let C=0;for(;C{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),A=>A.charCodeAt(0));var A},init=exports.init=WebAssembly.compile(E()).then(WebAssembly.instantiate).then(({exports:A})=>{C=A}),initSync=()=>{if(C)return;const A=new WebAssembly.Module(E());C=new WebAssembly.Instance(A).exports};exports.initSync=initSync; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.js b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.js new file mode 100644 index 00000000..5456a5fc --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/dist/lexer.minimal.js @@ -0,0 +1,2 @@ +/* es-module-lexer 2.3.2 */ +export var ImportType=function(A){return A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase",A}({});const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];export function parse(E,g="@"){if(!C)return init.then(()=>parse(E,g));const I=E.length+1,D=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;D>0&&C.memory.grow(Math.ceil(D/65536));const i=C.sa(I-1);if("undefined"!=typeof Buffer?Buffer.from(C.memory.buffer,i,2*(I-1)).write(E,"utf16le"):(A?B:Q)(E,new Uint16Array(C.memory.buffer,i,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const G=[],w=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),D=C.ss(),i=C.se();let w;C.ip()&&(w=o(E.slice(-1===I?A-1:A,-1===I?Q+1:Q)));let k=null;0,G.push({n:w,t:B,s:A,e:Q,ss:D,se:i,d:I,a:g,at:k})}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=B<0?void 0:k(E.slice(B,g)),D=k(E.slice(A,Q));w.push({s:A,e:Q,ls:B,le:g,n:D,ln:I})}function o(A){try{return(0,eval)(A)}catch(A){}}function k(A){if(!A)return A;const Q=A[0];return('"'===Q||"'"===Q)&&o(A)||A}return[G,w]}function Q(A,Q){const B=A.length;let C=0;for(;C>>8}}function B(A,Q){const B=A.length;let C=0;for(;C{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),A=>A.charCodeAt(0));var A};export const init=WebAssembly.compile(E()).then(WebAssembly.instantiate).then(({exports:A})=>{C=A});export const initSync=()=>{if(C)return;const A=new WebAssembly.Module(E());C=new WebAssembly.Instance(A).exports}; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/lexer.js b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/lexer.js new file mode 100644 index 00000000..fae6cab4 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/lexer.js @@ -0,0 +1,1009 @@ +let source, pos, end, + openTokenDepth, + lastTokenPos, + openTokenPosStack, + openClassPosStack, + curDynamicImport, + templateStackDepth, + facade, + lastSlashWasDivision, + nextBraceIsClass, + templateDepth, + templateStack, + imports, + exports, + exportStatementStart, + name; + +function addImport (ss, s, e, d) { + const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined, at: null }; + imports.push(impt); + return impt; +} + +function addExport (s, e, ls, le) { + exports.push({ + s, + e, + ls, + le, + ss: exportStatementStart, + n: s[0] === '"' ? readString(s, '"') : s[0] === "'" ? readString(s, "'") : source.slice(s, e), + ln: ls[0] === '"' ? readString(ls, '"') : ls[0] === "'" ? readString(ls, "'") : source.slice(ls, le) + }); +} + +function readName (impt) { + let { d, s } = impt; + if (d !== -1) + s++; + impt.n = readString(s, source.charCodeAt(s - 1)); +} + +// Note: parsing is based on the _assumption_ that the source is already valid +export function parse (_source, _name) { + openTokenDepth = 0; + curDynamicImport = null; + templateDepth = -1; + lastTokenPos = -1; + lastSlashWasDivision = false; + templateStack = Array(1024); + templateStackDepth = 0; + openTokenPosStack = Array(1024); + openClassPosStack = Array(1024); + nextBraceIsClass = false; + facade = true; + name = _name || '@'; + + imports = []; + exports = []; + + source = _source; + pos = -1; + end = source.length - 1; + let ch = 0; + + // start with a pure "module-only" parser + m: while (pos++ < end) { + ch = source.charCodeAt(pos); + + if (ch === 32 || ch < 14 && ch > 8) + continue; + + switch (ch) { + case 101/*e*/: + if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) { + tryParseExportStatement(); + // export might have been a non-pure declaration + if (!facade) { + lastTokenPos = pos; + break m; + } + } + break; + case 105/*i*/: + if (keywordStart(pos) && source.startsWith('mport', pos + 1)) + tryParseImportStatement(); + break; + case 59/*;*/: + break; + case 47/*/*/: { + const next_ch = source.charCodeAt(pos + 1); + if (next_ch === 47/*/*/) { + lineComment(); + // dont update lastToken + continue; + } + else if (next_ch === 42/***/) { + blockComment(true); + // dont update lastToken + continue; + } + // fallthrough + } + default: + // as soon as we hit a non-module token, we go to main parser + facade = false; + pos--; + break m; + } + lastTokenPos = pos; + } + + while (pos++ < end) { + ch = source.charCodeAt(pos); + + if (ch === 32 || ch < 14 && ch > 8) + continue; + + switch (ch) { + case 101/*e*/: + if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) + tryParseExportStatement(); + break; + case 105/*i*/: + if (keywordStart(pos) && source.startsWith('mport', pos + 1)) + tryParseImportStatement(); + break; + case 99/*c*/: + if (keywordStart(pos) && source.startsWith('lass', pos + 1) && isBrOrWs(source.charCodeAt(pos + 5))) + nextBraceIsClass = true; + break; + case 40/*(*/: + openTokenPosStack[openTokenDepth++] = lastTokenPos; + break; + case 41/*)*/: + if (openTokenDepth === 0) + syntaxError(); + openTokenDepth--; + if (curDynamicImport && curDynamicImport.d === openTokenPosStack[openTokenDepth]) { + if (curDynamicImport.e === 0) + curDynamicImport.e = pos; + curDynamicImport.se = pos; + curDynamicImport = null; + } + break; + case 91/*[*/: + openTokenPosStack[openTokenDepth++] = lastTokenPos; + break; + case 93/*]*/: + if (openTokenDepth === 0) + syntaxError(); + openTokenDepth--; + break; + case 44/*,*/: + if (curDynamicImport && curDynamicImport.e === 0 && curDynamicImport.d === openTokenPosStack[openTokenDepth - 1]) { + curDynamicImport.e = lastTokenPos + 1; + pos++; + commentWhitespace(true); + curDynamicImport.a = pos; + pos--; + } + break; + case 123/*{*/: + // dynamic import followed by { is not a dynamic import (so remove) + // this is a sneaky way to get around { import () {} } v { import () } + // block / object ambiguity without a parser (assuming source is valid) + // se marks the closing paren; e is moved before the first comma for import(a, b) + if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].se === lastTokenPos) { + imports.pop(); + } + openClassPosStack[openTokenDepth] = nextBraceIsClass; + nextBraceIsClass = false; + openTokenPosStack[openTokenDepth++] = lastTokenPos; + break; + case 125/*}*/: + if (openTokenDepth === 0) + syntaxError(); + if (openTokenDepth-- === templateDepth) { + templateDepth = templateStack[--templateStackDepth]; + templateString(); + } + else { + if (templateDepth !== -1 && openTokenDepth < templateDepth) + syntaxError(); + } + break; + case 39/*'*/: + case 34/*"*/: + stringLiteral(ch); + break; + case 47/*/*/: { + const next_ch = source.charCodeAt(pos + 1); + if (next_ch === 47/*/*/) { + lineComment(); + // dont update lastToken + continue; + } + else if (next_ch === 42/***/) { + blockComment(true); + // dont update lastToken + continue; + } + else { + // Division / regex ambiguity handling based on checking backtrack analysis of: + // - what token came previously (lastToken) + // - if a closing brace or paren, what token came before the corresponding + // opening brace or paren (lastOpenTokenIndex) + const lastToken = source.charCodeAt(lastTokenPos); + const lastExport = exports[exports.length - 1]; + if (isExpressionPunctuator(lastToken) && + !(lastToken === 46/*.*/ && (source.charCodeAt(lastTokenPos - 1) >= 48/*0*/ && source.charCodeAt(lastTokenPos - 1) <= 57/*9*/)) && + !(lastToken === 43/*+*/ && source.charCodeAt(lastTokenPos - 1) === 43/*+*/) && !(lastToken === 45/*-*/ && source.charCodeAt(lastTokenPos - 1) === 45/*-*/) || + lastToken === 41/*)*/ && isParenKeyword(openTokenPosStack[openTokenDepth]) || + openTokenDepth > 0 && lastToken === 102/*f*/ && source.charCodeAt(lastTokenPos - 1) === 111/*o*/ && isForOfBinding(lastTokenPos - 2) && isForParen(openTokenPosStack[openTokenDepth - 1]) || + lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) || + lastToken === 47/*/*/ && lastSlashWasDivision || + isExpressionKeyword(lastTokenPos) || + !lastToken) { + regularExpression(); + lastSlashWasDivision = false; + } + else if (lastExport && lastTokenPos >= lastExport.s && lastTokenPos <= lastExport.e) { + // export default /some-regexp/ + regularExpression(); + lastSlashWasDivision = false; + } + else { + lastSlashWasDivision = true; + } + } + break; + } + case 96/*`*/: + templateString(); + break; + } + lastTokenPos = pos; + } + + if (templateDepth !== -1 || openTokenDepth) + syntaxError(); + + return [imports, exports, facade]; +} + +function tryParseImportStatement () { + const startPos = pos; + + pos += 6; + + let ch = commentWhitespace(true); + + switch (ch) { + // dynamic import + case 40/*(*/: + openTokenPosStack[openTokenDepth++] = startPos; + if (source.charCodeAt(lastTokenPos) === 46/*.*/) + return; + // dynamic import indicated by positive d + // try parse a string, to record a safe dynamic import string + pos++; + ch = commentWhitespace(true); + // The specifier start is recorded after leading whitespace/comments so it + // points at the literal, matching the C lexer (src/lexer.c). + const impt = addImport(startPos, pos, 0, startPos); + curDynamicImport = impt; + if (ch === 39/*'*/ || ch === 34/*"*/) { + stringLiteral(ch); + } + else if (ch === 96/*`*/ && noSubstitutionTemplate()) { + // A no-substitution template literal is a constant string, so it is a + // safe specifier exactly like a quoted one. An interpolated template + // leaves noSubstitutionTemplate() false and falls through to the open- + // token machinery, which records the import as unsafe (n stays unset). + } + else { + pos--; + return; + } + pos++; + ch = commentWhitespace(true); + if (ch === 44/*,*/) { + impt.e = pos; + pos++; + ch = commentWhitespace(true); + impt.a = pos; + readName(impt); + pos--; + } + else if (ch === 41/*)*/) { + openTokenDepth--; + impt.e = pos; + impt.se = pos; + readName(impt); + } + else { + pos--; + } + return; + // import.meta + case 46/*.*/: + pos++; + ch = commentWhitespace(true); + // import.meta indicated by d === -2 + if (ch === 109/*m*/ && source.startsWith('eta', pos + 1) && source.charCodeAt(lastTokenPos) !== 46/*.*/) + addImport(startPos, startPos, pos + 4, -2); + return; + + default: + // no space after "import" -> not an import keyword + if (pos === startPos + 6) + break; + case 34/*"*/: + case 39/*'*/: + case 123/*{*/: + case 42/***/: + // import statement only permitted at base-level + if (openTokenDepth !== 0) { + pos--; + return; + } + while (pos < end) { + ch = source.charCodeAt(pos); + if (ch === 39/*'*/ || ch === 34/*"*/) { + readImportString(startPos, ch); + return; + } + pos++; + } + syntaxError(); + } +} + +function tryParseExportStatement () { + const sStartPos = pos; + const prevExport = exports.length; + + pos += 6; + + const curPos = pos; + + let ch = commentWhitespace(true); + + // Only commit the statement start once this is a real export: skipExpression + // re-enters here for an `export`-prefixed identifier (e.g. `exports`) in an + // initializer, which would otherwise clobber the start for later bindings. + if (pos === curPos && !isPunctuator(ch)) + return; + + exportStatementStart = sStartPos; + + switch (ch) { + // export default ... + case 100/*d*/: + addExport(pos, pos + 7, -1, -1); + return; + + // export async? function*? name () { + case 97/*a*/: + pos += 5; + commentWhitespace(true); + // fallthrough + case 102/*f*/: + pos += 8; + ch = commentWhitespace(true); + if (ch === 42/***/) { + pos++; + ch = commentWhitespace(true); + } + const startPos = pos; + ch = readToWsOrPunctuator(ch); + addExport(startPos, pos, startPos, pos); + pos--; + return; + + // export class name ... + case 99/*c*/: + if (source.startsWith('lass', pos + 1) && isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos + 5))) { + pos += 5; + ch = commentWhitespace(true); + const startPos = pos; + ch = readToWsOrPunctuator(ch); + addExport(startPos, pos, startPos, pos); + pos--; + return; + } + pos += 2; + // fallthrough + + // export var/let/const name = ...(, name = ...)+ + case 118/*v*/: + case 109/*l*/: + // destructured initializations not currently supported (skipped for { or [) + // also, lexing names after variable equals is skipped (export var p = function () { ... }, q = 5 skips "q") + pos += 2; + facade = false; + do { + pos++; + ch = commentWhitespace(true); + const startPos = pos; + ch = readToWsOrPunctuator(ch); + // dont yet handle [ { destructurings + if (ch === 123/*{*/ || ch === 91/*[*/) { + pos--; + return; + } + if (pos === startPos) + return; + addExport(startPos, pos, startPos, pos); + ch = commentWhitespace(true); + if (ch === 61/*=*/) { + pos--; + return; + } + } while (ch === 44/*,*/); + pos--; + return; + + + // export {...} + case 123/*{*/: + pos++; + ch = commentWhitespace(true); + while (true) { + const startPos = pos; + readToWsOrPunctuator(ch); + const endPos = pos; + commentWhitespace(true); + ch = readExportAs(startPos, endPos); + // , + if (ch === 44/*,*/) { + pos++; + ch = commentWhitespace(true); + } + if (ch === 125/*}*/) + break; + if (pos === startPos) + return syntaxError(); + if (pos > end) + return syntaxError(); + } + pos++; + ch = commentWhitespace(true); + break; + + // export * + // export * as X + case 42/***/: + pos++; + commentWhitespace(true); + ch = readExportAs(pos, pos); + ch = commentWhitespace(true); + break; + } + + // from ... + if (ch === 102/*f*/ && source.startsWith('rom', pos + 1)) { + pos += 4; + readImportString(sStartPos, commentWhitespace(true)); + + // There were no local names. + for (let i = prevExport; i < exports.length; ++i) { + exports[i].ls = exports[i].le = -1; + exports[i].ln = undefined; + } + } + else { + pos--; + } +} + +/* + * Ported from Acorn + * + * MIT License + + * Copyright (C) 2012-2020 by various contributors (see AUTHORS) + + * 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. + */ +let acornPos; +function readString (start, quote) { + acornPos = start; + let out = '', chunkStart = acornPos; + for (;;) { + if (acornPos >= source.length) syntaxError(); + const ch = source.charCodeAt(acornPos); + if (ch === quote) break; + if (ch === 92) { // '\' + out += source.slice(chunkStart, acornPos); + out += readEscapedChar(); + chunkStart = acornPos; + } + else if (ch === 0x2028 || ch === 0x2029) { + ++acornPos; + } + else { + // Template literals (backtick quote) permit raw line breaks; string + // literals do not. + if (isBr(ch) && quote !== 96/*`*/) syntaxError(); + ++acornPos; + } + } + out += source.slice(chunkStart, acornPos++); + return out; +} + +// Used to read escaped characters + +function readEscapedChar () { + let ch = source.charCodeAt(++acornPos); + ++acornPos; + switch (ch) { + case 110: return '\n'; // 'n' -> '\n' + case 114: return '\r'; // 'r' -> '\r' + case 120: return String.fromCharCode(readHexChar(2)); // 'x' + case 117: return readCodePointToString(); // 'u' + case 116: return '\t'; // 't' -> '\t' + case 98: return '\b'; // 'b' -> '\b' + case 118: return '\u000b'; // 'v' -> '\u000b' + case 102: return '\f'; // 'f' -> '\f' + case 13: if (source.charCodeAt(acornPos) === 10) ++acornPos; // '\r\n' + case 10: // ' \n' + return ''; + case 56: + case 57: + syntaxError(); + default: + if (ch >= 48 && ch <= 55) { + let octalStr = source.substr(acornPos - 1, 3).match(/^[0-7]+/)[0]; + let octal = parseInt(octalStr, 8); + if (octal > 255) { + octalStr = octalStr.slice(0, -1); + octal = parseInt(octalStr, 8); + } + acornPos += octalStr.length - 1; + ch = source.charCodeAt(acornPos); + if (octalStr !== '0' || ch === 56 || ch === 57) + syntaxError(); + return String.fromCharCode(octal); + } + if (isBr(ch)) { + // Unicode new line characters after \ get removed from output in both + // template literals and strings + return ''; + } + return String.fromCharCode(ch); + } +} + +// Used to read character escape sequences ('\x', '\u', '\U'). + +function readHexChar (len) { + const start = acornPos; + let total = 0, lastCode = 0; + for (let i = 0; i < len; ++i, ++acornPos) { + let code = source.charCodeAt(acornPos), val; + + if (code === 95) { + if (lastCode === 95 || i === 0) syntaxError(); + lastCode = code; + continue; + } + + if (code >= 97) val = code - 97 + 10; // a + else if (code >= 65) val = code - 65 + 10; // A + else if (code >= 48 && code <= 57) val = code - 48; // 0-9 + else break; + if (val >= 16) break; + lastCode = code; + total = total * 16 + val; + } + + if (lastCode === 95 || acornPos - start !== len) syntaxError(); + + return total; +} + +// Read a string value, interpreting backslash-escapes. + +function readCodePointToString () { + const ch = source.charCodeAt(acornPos); + let code; + if (ch === 123) { // '{' + ++acornPos; + code = readHexChar(source.indexOf('}', acornPos) - acornPos); + ++acornPos; + if (code > 0x10FFFF) syntaxError(); + } else { + code = readHexChar(4); + } + // UTF-16 Decoding + if (code <= 0xFFFF) return String.fromCharCode(code); + code -= 0x10000; + return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00); +} + +/* + * + */ + +function readExportAs (startPos, endPos) { + let ch = source.charCodeAt(pos); + let ls = startPos, le = endPos; + if (ch === 97 /*a*/) { + pos += 2; + ch = commentWhitespace(true); + startPos = pos; + readToWsOrPunctuator(ch); + endPos = pos; + ch = commentWhitespace(true); + } + if (pos !== startPos) + addExport(startPos, endPos, ls, le); + return ch; +} + +function readImportString (ss, ch) { + const startPos = pos + 1; + if (ch === 39/*'*/ || ch === 34/*"*/) { + stringLiteral(ch); + } + else { + syntaxError(); + return; + } + const impt = addImport(ss, startPos, pos, -1); + readName(impt); + pos++; + ch = commentWhitespace(false); + if (ch !== 119/*w*/ || !source.startsWith('ith', pos + 1)) { + pos--; + return; + } + const attrIndex = pos; + + pos += 4; + ch = commentWhitespace(true); + if (ch !== 123/*{*/) { + pos = attrIndex; + return; + } + const attrStart = pos; + const attrs = []; + do { + pos++; + ch = commentWhitespace(true); + let key, keyStart, keyEnd; + if (ch === 39/*'*/ || ch === 34/*"*/) { + keyStart = pos; + stringLiteral(ch); + keyEnd = pos + 1; + key = readString(keyStart, ch); + pos++; + ch = commentWhitespace(true); + } + else { + keyStart = pos; + ch = readToWsOrPunctuator(ch); + keyEnd = pos; + key = source.slice(keyStart, keyEnd); + } + if (ch !== 58/*:*/) { + pos = attrIndex; + return; + } + pos++; + ch = commentWhitespace(true); + let value, valueStart; + if (ch === 39/*'*/ || ch === 34/*"*/) { + valueStart = pos; + stringLiteral(ch); + value = readString(valueStart, ch); + } + else { + pos = attrIndex; + return; + } + attrs.push([key, value]); + pos++; + ch = commentWhitespace(true); + if (ch === 44/*,*/) { + pos++; + continue; + } + if (ch === 125/*}*/) + break; + pos = attrIndex; + return; + } while (true); + impt.a = attrStart; + impt.at = attrs; + impt.se = pos + 1; +} + +function commentWhitespace (br) { + let ch; + do { + ch = source.charCodeAt(pos); + if (ch === 47/*/*/) { + const next_ch = source.charCodeAt(pos + 1); + if (next_ch === 47/*/*/) + lineComment(); + else if (next_ch === 42/***/) + blockComment(br); + else + return ch; + } + else if (br ? !isBrOrWs(ch): !isWsNotBr(ch)) { + return ch; + } + } while (pos++ < end); + return ch; +} + +function templateString () { + while (pos++ < end) { + const ch = source.charCodeAt(pos); + if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) { + pos++; + templateStack[templateStackDepth++] = templateDepth; + templateDepth = ++openTokenDepth; + return; + } + if (ch === 96/*`*/) + return; + if (ch === 92/*\*/) + pos++; + } + syntaxError(); +} + +// pos AT the opening backtick. A no-substitution template literal (no ${...}) +// is a constant string, so a dynamic import can record it as a safe specifier. +// On success consumes it, leaves pos AT the closing backtick and returns true. +// On a substitution or EOF restores pos and returns false, leaving the literal +// to the main loop's template handling. +function noSubstitutionTemplate () { + const startPos = pos; + while (pos++ < end) { + const ch = source.charCodeAt(pos); + if (ch === 96/*`*/) + return true; + if (ch === 92/*\*/) { + pos++; + continue; + } + if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) + break; + } + pos = startPos; + return false; +} + +function blockComment (br) { + pos++; + while (pos++ < end) { + const ch = source.charCodeAt(pos); + if (!br && isBr(ch)) + return; + if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) { + pos++; + return; + } + } +} + +function lineComment () { + while (pos++ < end) { + const ch = source.charCodeAt(pos); + if (ch === 10/*\n*/ || ch === 13/*\r*/) + return; + } +} + +function stringLiteral (quote) { + while (pos++ < end) { + let ch = source.charCodeAt(pos); + if (ch === quote) + return; + if (ch === 92/*\*/) { + ch = source.charCodeAt(++pos); + if (ch === 13/*\r*/ && source.charCodeAt(pos + 1) === 10/*\n*/) + pos++; + } + else if (isBr(ch)) + break; + } + syntaxError(); +} + +function regexCharacterClass () { + while (pos++ < end) { + let ch = source.charCodeAt(pos); + if (ch === 93/*]*/) + return ch; + if (ch === 92/*\*/) + pos++; + else if (ch === 10/*\n*/ || ch === 13/*\r*/) + break; + } + syntaxError(); +} + +function regularExpression () { + while (pos++ < end) { + let ch = source.charCodeAt(pos); + if (ch === 47/*/*/) + return; + if (ch === 91/*[*/) + ch = regexCharacterClass(); + else if (ch === 92/*\*/) + pos++; + else if (ch === 10/*\n*/ || ch === 13/*\r*/) + break; + } + syntaxError(); +} + +function readToWsOrPunctuator (ch) { + do { + if (isBrOrWs(ch) || isPunctuator(ch)) + return ch; + } while (ch = source.charCodeAt(++pos)); + return ch; +} + +// Note: non-asii BR and whitespace checks omitted for perf / footprint +// if there is a significant user need this can be reconsidered +function isBr (c) { + return c === 13/*\r*/ || c === 10/*\n*/; +} + +function isWsNotBr (c) { + return c === 9 || c === 11 || c === 12 || c === 32 || c === 160; +} + +function isBrOrWs (c) { + return c > 8 && c < 14 || c === 32 || c === 160; +} + +function isBrOrWsOrPunctuatorNotDot (c) { + return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46/*.*/; +} + +function keywordStart (pos) { + return pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1)); +} + +function readPrecedingKeyword (pos, match) { + if (pos < match.length - 1) + return false; + return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length))); +} + +function readPrecedingKeyword1 (pos, ch) { + return source.charCodeAt(pos) === ch && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1))); +} + +// Detects one of case, debugger, delete, do, else, in, instanceof, new, +// return, throw, typeof, void, yield, await +function isExpressionKeyword (pos) { + switch (source.charCodeAt(pos)) { + case 100/*d*/: + switch (source.charCodeAt(pos - 1)) { + case 105/*i*/: + // void + return readPrecedingKeyword(pos - 2, 'vo'); + case 108/*l*/: + // yield + return readPrecedingKeyword(pos - 2, 'yie'); + default: + return false; + } + case 101/*e*/: + switch (source.charCodeAt(pos - 1)) { + case 115/*s*/: + switch (source.charCodeAt(pos - 2)) { + case 108/*l*/: + // else + return readPrecedingKeyword1(pos - 3, 101/*e*/); + case 97/*a*/: + // case + return readPrecedingKeyword1(pos - 3, 99/*c*/); + default: + return false; + } + case 116/*t*/: + // delete + return readPrecedingKeyword(pos - 2, 'dele'); + default: + return false; + } + case 102/*f*/: + if (source.charCodeAt(pos - 1) !== 111/*o*/ || source.charCodeAt(pos - 2) !== 101/*e*/) + return false; + switch (source.charCodeAt(pos - 3)) { + case 99/*c*/: + // instanceof + return readPrecedingKeyword(pos - 4, 'instan'); + case 112/*p*/: + // typeof + return readPrecedingKeyword(pos - 4, 'ty'); + default: + return false; + } + case 110/*n*/: + // in, return + return readPrecedingKeyword1(pos - 1, 105/*i*/) || readPrecedingKeyword(pos - 1, 'retur'); + case 111/*o*/: + // do + return readPrecedingKeyword1(pos - 1, 100/*d*/); + case 114/*r*/: + // debugger + return readPrecedingKeyword(pos - 1, 'debugge'); + case 116/*t*/: + // await + return readPrecedingKeyword(pos - 1, 'awai'); + case 119/*w*/: + switch (source.charCodeAt(pos - 1)) { + case 101/*e*/: + // new + return readPrecedingKeyword1(pos - 2, 110/*n*/); + case 111/*o*/: + // throw + return readPrecedingKeyword(pos - 2, 'thr'); + default: + return false; + } + } + return false; +} + +function isParenKeyword (curPos) { + return source.charCodeAt(curPos) === 101/*e*/ && source.startsWith('whil', curPos - 4) || + source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2) || + source.charCodeAt(curPos - 1) === 105/*i*/ && source.charCodeAt(curPos) === 102/*f*/; +} + +function isForParen (curPos) { + return source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2); +} + +// In valid JS, the for-of `of` keyword always follows a binding, +// which ends with an identifier-tail char, ']', '}', or ')'. +function isForOfBinding (pos) { + const ch = source.charCodeAt(pos); + if (!isBrOrWs(ch) && ch !== 93/*]*/ && ch !== 125/*}*/ && ch !== 41/*)*/) + return false; + while (pos > 0 && isBrOrWs(source.charCodeAt(pos))) + pos--; + const c = source.charCodeAt(pos); + return c === 93/*]*/ || c === 125/*}*/ || c === 41/*)*/ || !isPunctuator(c); +} + +function isPunctuator (ch) { + // 23 possible punctuator endings: !%&()*+,-./:;<=>?[]^{}|~ + return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ || + ch > 39 && ch < 48 || ch > 57 && ch < 64 || + ch === 91/*[*/ || ch === 93/*]*/ || ch === 94/*^*/ || + ch > 122 && ch < 127; +} + +function isExpressionPunctuator (ch) { + // 20 possible expression endings: !%&(*+,-.:;<=>?[^{|~ + return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ || + ch > 39 && ch < 47 && ch !== 41 || ch > 57 && ch < 64 || + ch === 91/*[*/ || ch === 94/*^*/ || ch > 122 && ch < 127 && ch !== 125/*}*/; +} + +function isExpressionTerminator (curPos) { + // detects: + // => ; ) finally catch else + // as all of these followed by a { will indicate a statement brace + switch (source.charCodeAt(curPos)) { + case 62/*>*/: + return source.charCodeAt(curPos - 1) === 61/*=*/; + case 59/*;*/: + case 41/*)*/: + return true; + case 104/*h*/: + return source.startsWith('catc', curPos - 4); + case 121/*y*/: + return source.startsWith('finall', curPos - 6); + case 101/*e*/: + return source.startsWith('els', curPos - 3); + } + return false; +} + +function syntaxError () { + throw Object.assign(new Error(`Parse error ${name}:${source.slice(0, pos).split('\n').length}:${pos - source.lastIndexOf('\n', pos - 1)}`), { idx: pos }); +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/package.json b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/package.json new file mode 100755 index 00000000..b295cec7 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/package.json @@ -0,0 +1,68 @@ +{ + "name": "es-module-lexer", + "version": "2.3.2", + "description": "Lexes ES modules returning their import/export metadata", + "main": "dist/lexer.cjs", + "module": "dist/lexer.js", + "sideEffects": false, + "types": "types/lexer.d.ts", + "exports": { + ".": { + "types": "./types/lexer.d.ts", + "module": "./dist/lexer.js", + "import": "./dist/lexer.js", + "require": "./dist/lexer.cjs" + }, + "./js": { + "types": "./types/lexer.d.ts", + "default": "./dist/lexer.asm.js" + }, + "./minimal": { + "types": "./types/lexer.minimal.d.ts", + "module": "./dist/lexer.minimal.js", + "import": "./dist/lexer.minimal.js", + "require": "./dist/lexer.minimal.cjs" + }, + "./minimal/js": { + "types": "./types/lexer.minimal.d.ts", + "default": "./dist/lexer.minimal.asm.js" + } + }, + "scripts": { + "build": "npm install -g chomp ; chomp build", + "test": "npm install -g chomp ; chomp test" + }, + "author": "Guy Bedford", + "license": "MIT", + "devDependencies": { + "@babel/cli": "^7.29.7", + "@babel/core": "^7.29.7", + "@babel/plugin-transform-modules-commonjs": "^7.29.7", + "@swc/cli": "^0.8.1", + "@swc/core": "^1.15.41", + "@types/node": "^25.9.3", + "kleur": "^4.1.5", + "mocha": "^11.7.6", + "terser": "^5.48.0", + "typescript": "^6.0.3" + }, + "files": [ + "dist", + "types", + "lexer.js" + ], + "type": "module", + "repository": { + "type": "git", + "url": "git+https://github.com/guybedford/es-module-lexer.git" + }, + "bugs": { + "url": "https://github.com/guybedford/es-module-lexer/issues" + }, + "homepage": "https://github.com/guybedford/es-module-lexer#readme", + "directories": { + "lib": "lib", + "test": "test" + }, + "keywords": [] +} diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.d.ts b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.d.ts new file mode 100644 index 00000000..6218ade7 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.d.ts @@ -0,0 +1,227 @@ +export declare enum ImportType { + /** + * A normal static using any syntax variations + * import .. from 'module' + */ + Static = 1, + /** + * A dynamic import expression `import(specifier)` + * or `import(specifier, opts)` + */ + Dynamic = 2, + /** + * An import.meta expression + */ + ImportMeta = 3, + /** + * A source phase import + * import source x from 'module' + */ + StaticSourcePhase = 4, + /** + * A dynamic source phase import + * import.source('module') + */ + DynamicSourcePhase = 5, + /** + * A defer phase import + * import defer * as x from 'module' + */ + StaticDeferPhase = 6, + /** + * A dynamic defer phase import + * import.defer('module') + */ + DynamicDeferPhase = 7 +} +export interface ImportSpecifier { + /** + * Module name + * + * To handle escape sequences in specifier strings, the .n field of imported specifiers will be provided where possible. + * + * For dynamic import expressions, this field will be empty if not a valid JS string. + * For static import expressions, this field will always be populated. + * + * @example + * const [imports1, exports1] = parse(String.raw`import './\u0061\u0062.js'`); + * imports1[0].n; + * // Returns "./ab.js" + * + * const [imports2, exports2] = parse(`import("./ab.js")`); + * imports2[0].n; + * // Returns "./ab.js" + * + * const [imports3, exports3] = parse(`import("./" + "ab.js")`); + * imports3[0].n; + * // Returns undefined + */ + readonly n: string | undefined; + /** + * Type of import statement + */ + readonly t: ImportType; + /** + * Start of module specifier + * + * @example + * const source = `import { a } from 'asdf'`; + * const [imports, exports] = parse(source); + * source.substring(imports[0].s, imports[0].e); + * // Returns "asdf" + */ + readonly s: number; + /** + * End of module specifier + */ + readonly e: number; + /** + * Start of import statement + * + * @example + * const source = `import { a } from 'asdf'`; + * const [imports, exports] = parse(source); + * source.substring(imports[0].ss, imports[0].se); + * // Returns "import { a } from 'asdf';" + */ + readonly ss: number; + /** + * End of import statement + */ + readonly se: number; + /** + * If this import keyword is a dynamic import, this is the start value. + * If this import keyword is a static import, this is -1. + * If this import keyword is an import.meta expresion, this is -2. + */ + readonly d: number; + /** + * If this import has an import attribute, this is the start value. + * Otherwise this is `-1`. + */ + readonly a: number; + /** + * Parsed import attributes as an array of [key, value] tuples. + * If this import has no attributes, this is `null`. + * + * @example + * const source = `import foo from 'bar' with { type: "json" }`; + * const [imports] = parse(source); + * imports[0].at; + * // Returns [['type', 'json']] + * + * @example + * const source = `import foo from 'bar' with { type: "json", integrity: "sha384-..." }`; + * const [imports] = parse(source); + * imports[0].at; + * // Returns [['type', 'json'], ['integrity', 'sha384-...']] + */ + readonly at: ReadonlyArray | null; +} +export interface ExportSpecifier { + /** + * Exported name + * + * @example + * const source = `export default []`; + * const [imports, exports] = parse(source); + * exports[0].n; + * // Returns "default" + * + * @example + * const source = `export const asdf = 42`; + * const [imports, exports] = parse(source); + * exports[0].n; + * // Returns "asdf" + */ + readonly n: string; + /** + * Local name, or undefined. + * + * @example + * const source = `export default []`; + * const [imports, exports] = parse(source); + * exports[0].ln; + * // Returns undefined + * + * @example + * const asdf = 42; + * const source = `export { asdf as a }`; + * const [imports, exports] = parse(source); + * exports[0].ln; + * // Returns "asdf" + */ + readonly ln: string | undefined; + /** + * Start of exported name + * + * @example + * const source = `export default []`; + * const [imports, exports] = parse(source); + * source.substring(exports[0].s, exports[0].e); + * // Returns "default" + * + * @example + * const source = `export { 42 as asdf }`; + * const [imports, exports] = parse(source); + * source.substring(exports[0].s, exports[0].e); + * // Returns "asdf" + */ + readonly s: number; + /** + * End of exported name + */ + readonly e: number; + /** + * Start of local name, or -1. + * + * @example + * const asdf = 42; + * const source = `export { asdf as a }`; + * const [imports, exports] = parse(source); + * source.substring(exports[0].ls, exports[0].le); + * // Returns "asdf" + */ + readonly ls: number; + /** + * End of local name, or -1. + */ + readonly le: number; + /** + * Start of the export statement. + * + * Only the statement start is provided; the statement end is not tracked + * (see https://github.com/guybedford/es-module-lexer/issues/112). Every + * specifier of a statement reports the same start, so `export { a, b }` + * returns the same `ss` for both `a` and `b`. + * + * @example + * const source = `export { a, b } from 'mod'`; + * const [imports, exports] = parse(source); + * source.slice(exports[0].ss, exports[0].ss + 6); + * // Returns "export" + */ + readonly ss: number; +} +export interface ParseError extends Error { + idx: number; +} +/** + * Outputs the list of exports and locations of import specifiers, + * including dynamic import and import meta handling. + * + * @param source Source code to parser + * @param name Optional sourcename + * @returns Tuple contaning imports list and exports list. + */ +export declare function parse(source: string, name?: string): readonly [ + imports: ReadonlyArray, + exports: ReadonlyArray, + facade: boolean, + hasModuleSyntax: boolean +]; +/** + * Wait for init to resolve before calling `parse`. + */ +export declare const init: Promise; +export declare const initSync: () => void; diff --git a/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.minimal.d.ts b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.minimal.d.ts new file mode 100644 index 00000000..8f06edf5 --- /dev/null +++ b/backend/node_modules/.pnpm/es-module-lexer@2.3.2/node_modules/es-module-lexer/types/lexer.minimal.d.ts @@ -0,0 +1,46 @@ +// Type definitions for the es-module-lexer minimal build (es-module-lexer/minimal). +// Auto-generated by build/gen-min-dts.mjs — do not edit. +import { ImportType, ImportSpecifier, ParseError } from './lexer.js'; +export { ImportType, ImportSpecifier, ParseError }; + +/** + * Export specifier — minimal build. + * + * Identical to the full ExportSpecifier except that the export statement start + * (`ss`) is not tracked in the minimal build. + */ +export interface ExportSpecifier { + /** Exported name */ + readonly n: string; + /** Local name, or undefined */ + readonly ln: string | undefined; + /** Start of exported name */ + readonly s: number; + /** End of exported name */ + readonly e: number; + /** Start of local name, or -1 */ + readonly ls: number; + /** End of local name, or -1 */ + readonly le: number; +} + +/** + * Outputs the lexical analysis of the source — minimal build. + * + * Returns a 2-tuple of imports and exports. Unlike the full build, the minimal + * build does not emit the facade / hasModuleSyntax flags, and ImportSpecifier + * `at` is always null (read assertions via `source.slice(a, se - 1)`). + * + * @param source Source code to parse + * @param name Optional sourcename + */ +export declare function parse(source: string, name?: string): readonly [ + imports: ReadonlyArray, + exports: ReadonlyArray +]; + +/** + * Wait for init to resolve before calling `parse`. + */ +export declare const init: Promise; +export declare const initSync: () => void; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/eslint-utils b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/eslint-utils new file mode 120000 index 00000000..404b9e3e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/eslint-utils @@ -0,0 +1 @@ +../../../@eslint-community+eslint-utils@4.10.1_eslint@10.11.0_jiti@2.7.0_/node_modules/@eslint-community/eslint-utils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/regexpp b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/regexpp new file mode 120000 index 00000000..285c0a72 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint-community/regexpp @@ -0,0 +1 @@ +../../../@eslint-community+regexpp@4.12.2/node_modules/@eslint-community/regexpp \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-array b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-array new file mode 120000 index 00000000..303ebb12 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-array @@ -0,0 +1 @@ +../../../@eslint+config-array@0.23.5/node_modules/@eslint/config-array \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-helpers b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-helpers new file mode 120000 index 00000000..8c61a236 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/config-helpers @@ -0,0 +1 @@ +../../../@eslint+config-helpers@0.7.0/node_modules/@eslint/config-helpers \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/core b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/core new file mode 120000 index 00000000..ddfa9368 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/core @@ -0,0 +1 @@ +../../../@eslint+core@1.2.1/node_modules/@eslint/core \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/plugin-kit b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/plugin-kit new file mode 120000 index 00000000..66902000 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@eslint/plugin-kit @@ -0,0 +1 @@ +../../../@eslint+plugin-kit@0.7.3/node_modules/@eslint/plugin-kit \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanfs/node b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanfs/node new file mode 120000 index 00000000..777d9e90 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanfs/node @@ -0,0 +1 @@ +../../../@humanfs+node@0.16.8/node_modules/@humanfs/node \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/module-importer b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/module-importer new file mode 120000 index 00000000..c9dc9679 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/module-importer @@ -0,0 +1 @@ +../../../@humanwhocodes+module-importer@1.0.1/node_modules/@humanwhocodes/module-importer \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/retry b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/retry new file mode 120000 index 00000000..bd3921a0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@humanwhocodes/retry @@ -0,0 +1 @@ +../../../@humanwhocodes+retry@0.4.3/node_modules/@humanwhocodes/retry \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@types/estree b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@types/estree new file mode 120000 index 00000000..fda8efea --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/@types/estree @@ -0,0 +1 @@ +../../../@types+estree@1.0.9/node_modules/@types/estree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ajv b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ajv new file mode 120000 index 00000000..ca60a9ac --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ajv @@ -0,0 +1 @@ +../../ajv@6.15.0/node_modules/ajv \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/cross-spawn b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/cross-spawn new file mode 120000 index 00000000..22d35809 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/cross-spawn @@ -0,0 +1 @@ +../../cross-spawn@7.0.6/node_modules/cross-spawn \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/debug b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/debug new file mode 120000 index 00000000..6b438e1c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/debug @@ -0,0 +1 @@ +../../debug@4.4.3/node_modules/debug \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/escape-string-regexp b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/escape-string-regexp new file mode 120000 index 00000000..78f3fd39 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/escape-string-regexp @@ -0,0 +1 @@ +../../escape-string-regexp@4.0.0/node_modules/escape-string-regexp \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-scope b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-scope new file mode 120000 index 00000000..d62699d3 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-scope @@ -0,0 +1 @@ +../../eslint-scope@9.1.2/node_modules/eslint-scope \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-visitor-keys b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-visitor-keys new file mode 120000 index 00000000..9c535846 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint-visitor-keys @@ -0,0 +1 @@ +../../eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/LICENSE b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/LICENSE new file mode 100644 index 00000000..b607bb36 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/LICENSE @@ -0,0 +1,19 @@ +Copyright OpenJS Foundation and other contributors, + +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/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/README.md b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/README.md new file mode 100644 index 00000000..c1ec107b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/README.md @@ -0,0 +1,366 @@ +[![npm version](https://img.shields.io/npm/v/eslint.svg)](https://www.npmjs.com/package/eslint) +[![Downloads](https://img.shields.io/npm/dm/eslint.svg)](https://www.npmjs.com/package/eslint) +[![Build Status](https://github.com/eslint/eslint/workflows/CI/badge.svg)](https://github.com/eslint/eslint/actions) +
+[![Open Collective Backers](https://img.shields.io/opencollective/backers/eslint)](https://opencollective.com/eslint) +[![Open Collective Sponsors](https://img.shields.io/opencollective/sponsors/eslint)](https://opencollective.com/eslint) + +# ESLint + +[Website](https://eslint.org) | +[Configure ESLint](https://eslint.org/docs/latest/use/configure) | +[Rules](https://eslint.org/docs/rules/) | +[Contribute to ESLint](https://eslint.org/docs/latest/contribute) | +[Report Bugs](https://eslint.org/docs/latest/contribute/report-bugs) | +[Code of Conduct](https://eslint.org/conduct) | +[X](https://x.com/geteslint) | +[Discord](https://eslint.org/chat) | +[Mastodon](https://fosstodon.org/@eslint) | +[Bluesky](https://bsky.app/profile/eslint.org) + +ESLint is a tool for identifying and reporting on patterns found in ECMAScript/JavaScript code. In many ways, it is similar to JSLint and JSHint with a few exceptions: + +- ESLint uses [Espree](https://github.com/eslint/js/tree/main/packages/espree) for JavaScript parsing. +- ESLint uses an AST to evaluate patterns in code. +- ESLint is completely pluggable, every single rule is a plugin and you can add more at runtime. + +## Table of Contents + +1. [Installation and Usage](#installation-and-usage) +1. [Configuration](#configuration) +1. [Version Support](#version-support) +1. [Code of Conduct](#code-of-conduct) +1. [Filing Issues](#filing-issues) +1. [Frequently Asked Questions](#frequently-asked-questions) +1. [Releases](#releases) +1. [Security Policy](#security-policy) +1. [Semantic Versioning Policy](#semantic-versioning-policy) +1. [ESM Dependencies](#esm-dependencies) +1. [License](#license) +1. [Team](#team) +1. [Sponsors](#sponsors) +1. [Technology Sponsors](#technology-sponsors) + +## Installation and Usage + +### Prerequisites + +To use ESLint, you must have [Node.js](https://nodejs.org/) (`^20.19.0`, `^22.13.0`, or `>=24`) installed and built with SSL and ICU support. (If you are using an official Node.js distribution, both SSL and ICU are always built in.) + +If you use ESLint's TypeScript type definitions, TypeScript 5.3 or later is required. + +### npm Installation + +You can install and configure ESLint using this command: + +```shell +npm init @eslint/config@latest +``` + +After that, you can run ESLint on any file or directory like this: + +```shell +npx eslint yourfile.js +``` + +### pnpm Installation + +To use ESLint with pnpm, we recommend setting up a `.npmrc` file with at least the following settings: + +```text +auto-install-peers=true +node-linker=hoisted +``` + +This ensures that pnpm installs dependencies in a way that is more compatible with npm and is less likely to produce errors. + +## Configuration + +You can configure rules in your `eslint.config.js` files as in this example: + +```js +import { defineConfig } from "eslint/config"; + +export default defineConfig([ + { + files: ["**/*.js", "**/*.cjs", "**/*.mjs"], + rules: { + "prefer-const": "warn", + "no-constant-binary-expression": "error", + }, + }, +]); +``` + +The names `"prefer-const"` and `"no-constant-binary-expression"` are the names of [rules](https://eslint.org/docs/rules) in ESLint. The first value is the error level of the rule and can be one of these values: + +- `"off"` or `0` - turn the rule off +- `"warn"` or `1` - turn the rule on as a warning (doesn't affect exit code) +- `"error"` or `2` - turn the rule on as an error (exit code will be 1) + +The three error levels allow you fine-grained control over how ESLint applies rules (for more configuration options and details, see the [configuration docs](https://eslint.org/docs/latest/use/configure)). + +## Version Support + +The ESLint team provides ongoing support for the current version and six months of limited support for the previous version. Limited support includes critical bug fixes, security issues, and compatibility issues only. + +ESLint offers commercial support for both current and previous versions through our partners, [Tidelift][tidelift] and [HeroDevs][herodevs]. + +See [Version Support](https://eslint.org/version-support) for more details. + +## Code of Conduct + +ESLint adheres to the [OpenJS Foundation Code of Conduct](https://eslint.org/conduct). + +## Filing Issues + +Before filing an issue, please be sure to read the guidelines for what you're reporting: + +- [Bug Report](https://eslint.org/docs/latest/contribute/report-bugs) +- [Propose a New Rule](https://eslint.org/docs/latest/contribute/propose-new-rule) +- [Proposing a Rule Change](https://eslint.org/docs/latest/contribute/propose-rule-change) +- [Request a Change](https://eslint.org/docs/latest/contribute/request-change) + +## Frequently Asked Questions + +### Does ESLint support JSX? + +Yes, ESLint natively supports parsing JSX syntax (this must be enabled in [configuration](https://eslint.org/docs/latest/use/configure)). Please note that supporting JSX syntax _is not_ the same as supporting React. React applies specific semantics to JSX syntax that ESLint doesn't recognize. We recommend using [eslint-plugin-react](https://www.npmjs.com/package/eslint-plugin-react) if you are using React and want React semantics. + +### Does Prettier replace ESLint? + +No, ESLint and Prettier have different jobs: ESLint is a linter (looking for problematic patterns) and Prettier is a code formatter. Using both tools is common, refer to [Prettier's documentation](https://prettier.io/docs/en/install#eslint-and-other-linters) to learn how to configure them to work well with each other. + +### What ECMAScript versions does ESLint support? + +ESLint has full support for ECMAScript 3, 5, and every year from 2015 up until the most recent stage 4 specification (the default). You can set your desired ECMAScript syntax and other settings (like global variables) through [configuration](https://eslint.org/docs/latest/use/configure). + +### What about experimental features? + +ESLint's parser only officially supports the latest final ECMAScript standard. We will make changes to core rules in order to avoid crashes on stage 3 ECMAScript syntax proposals (as long as they are implemented using the correct experimental ESTree syntax). We may make changes to core rules to better work with language extensions (such as JSX, Flow, and TypeScript) on a case-by-case basis. + +In other cases (including if rules need to warn on more or fewer cases due to new syntax, rather than just not crashing), we recommend you use other parsers and/or rule plugins. If you are using Babel, you can use [@babel/eslint-parser](https://www.npmjs.com/package/@babel/eslint-parser) and [@babel/eslint-plugin](https://www.npmjs.com/package/@babel/eslint-plugin) to use any option available in Babel. + +Once a language feature has been adopted into the ECMAScript standard (stage 4 according to the [TC39 process](https://tc39.github.io/process-document/)), we will accept issues and pull requests related to the new feature, subject to our [contributing guidelines](https://eslint.org/docs/latest/contribute). Until then, please use the appropriate parser and plugin(s) for your experimental feature. + +### Which Node.js versions does ESLint support? + +ESLint updates the supported Node.js versions with each major release of ESLint. At that time, ESLint's supported Node.js versions are updated to be: + +1. The most recent maintenance release of Node.js +1. The lowest minor version of the Node.js LTS release that includes the features the ESLint team wants to use. +1. The Node.js Current release + +ESLint is also expected to work with Node.js versions released after the Node.js Current release. + +Refer to the [Quick Start Guide](https://eslint.org/docs/latest/use/getting-started#prerequisites) for the officially supported Node.js versions for a given ESLint release. + +### Where to ask for help? + +Open a [discussion](https://github.com/eslint/eslint/discussions) or stop by our [Discord server](https://eslint.org/chat). + +### Why doesn't ESLint lock dependency versions? + +Lock files like `package-lock.json` are helpful for deployed applications. They ensure that dependencies are consistent between environments and across deployments. + +Packages like `eslint` that get published to the npm registry do not include lock files. `npm install eslint` as a user will respect version constraints in ESLint's `package.json`. ESLint and its dependencies will be included in the user's lock file if one exists, but ESLint's own lock file would not be used. + +We intentionally don't lock dependency versions so that we have the latest compatible dependency versions in development and CI that our users get when installing ESLint in a project. + +The Twilio blog has a [deeper dive](https://www.twilio.com/blog/lockfiles-nodejs) to learn more. + +## Releases + +We have scheduled releases every two weeks on Friday or Saturday. You can follow a [release issue](https://github.com/eslint/eslint/issues?q=is%3Aopen+is%3Aissue+label%3Arelease) for updates about the scheduling of any particular release. + +## Security Policy + +ESLint takes security seriously. We work hard to ensure that ESLint is safe for everyone and that security issues are addressed quickly and responsibly. Read the full [security policy](https://github.com/eslint/.github/blob/master/SECURITY.md). + +## Semantic Versioning Policy + +ESLint follows [semantic versioning](https://semver.org). However, due to the nature of ESLint as a code quality tool, it's not always clear when a minor or major version bump occurs. To help clarify this for everyone, we've defined the following semantic versioning policy for ESLint: + +- Patch release (intended to not break your lint build) + - A bug fix in a rule that results in ESLint reporting fewer linting errors. + - A bug fix to the CLI or core (including formatters). + - Improvements to documentation. + - Non-user-facing changes such as refactoring code, adding, deleting, or modifying tests, and increasing test coverage. + - Re-releasing after a failed release (i.e., publishing a release that doesn't work for anyone). +- Minor release (might break your lint build) + - A bug fix that results in ESLint reporting more linting errors (e.g., fixing false negatives in a core rule, or linting additional files that were previously incorrectly skipped). + - A new rule is created. + - A new option to an existing rule that does not result in ESLint reporting more linting errors by default. + - A new addition to an existing rule to support a newly-added language feature (within the last 12 months) that will result in ESLint reporting more linting errors by default. + - An existing rule is deprecated. + - A new CLI capability is created. + - New capabilities to the public API are added (new classes, new methods, new arguments to existing methods, etc.). + - A new formatter is created. + - `eslint:recommended` is updated and will result in strictly fewer linting errors (e.g., rule removals). +- Major release (likely to break your lint build) + - `eslint:recommended` is updated and may result in new linting errors (e.g., rule additions, most rule option updates). + - A new option to an existing rule that results in ESLint reporting more linting errors by default. + - An existing formatter is removed. + - Part of the public API is removed or changed in an incompatible way. The public API includes: + - Rule schemas + - Configuration schema + - Command-line options + - Node.js API + - Rule, formatter, parser, plugin APIs + +According to our policy, any minor update may report more linting errors than the previous release (ex: from a bug fix). As such, we recommend using the tilde (`~`) in `package.json` e.g. `"eslint": "~3.1.0"` to guarantee the results of your builds. + +## ESM Dependencies + +Since ESLint is a CommonJS package, there are restrictions on which ESM-only packages can be used as dependencies. + +Packages that are controlled by the ESLint team and have no external dependencies can be safely loaded synchronously using [`require(esm)`](https://nodejs.org/api/modules.html#loading-ecmascript-modules-using-require) and therefore used in any contexts. + +For external packages, we don't use `require(esm)` because a package could add a top-level `await` and thus break ESLint. We can use an external ESM-only package only in case it is needed only in asynchronous code, in which case it can be loaded using dynamic `import()`. + +These policies don't apply to packages intended for our own usage only, such as `eslint-config-eslint`. + +## License + +MIT License + +Copyright OpenJS Foundation and other contributors, + +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. + +## Team + +These folks keep the project moving and are resources for help. + + + + + +### Technical Steering Committee (TSC) + +The people who manage releases, review feature requests, and meet regularly to ensure ESLint is properly maintained. + +
+ +Nicholas C. Zakas's Avatar
+Nicholas C. Zakas + +		 + +Francesco Trotta's Avatar
+Francesco Trotta + +		 + +Milos Djermanovic's Avatar
+Milos Djermanovic + +
+ +### Reviewers + +The people who review and implement new features. + +
+ +唯然's Avatar
+唯然 + +		 + +Nitin Kumar's Avatar
+Nitin Kumar + +
+ +### Committers + +The people who review and fix bugs and help triage issues. + +
+ +fnx's Avatar
+fnx + +		 + +Sweta Tanwar's Avatar
+Sweta Tanwar + +		 + +Tanuj Kanti's Avatar
+Tanuj Kanti + +		 + +lumir's Avatar
+lumir + +		 + +Pixel's Avatar
+Pixel + +
+ +### Website Team + +Team members who focus specifically on eslint.org + +
+ +Amaresh S M's Avatar
+Amaresh S M + +		 + +Harish's Avatar
+Harish + +		 + +Percy Ma's Avatar
+Percy Ma + +
+ + + + + + +## Sponsors + +The following companies, organizations, and individuals support ESLint's ongoing maintenance and development. [Become a Sponsor](https://eslint.org/donate) +to get your logo on our READMEs and [website](https://eslint.org/sponsors). + +

Platinum Sponsors

+

Automattic

Gold Sponsors

+

Qlty Software Shopify CodeRabbit

Silver Sponsors

+

Vite Liftoff StackBlitz

Bronze Sponsors

+

Cybozu SAP Syntax Icons8 Discord GitBook Citadel AI TestMu AI Open Source Office (Formerly LambdaTest)

+

Technology Sponsors

+Technology sponsors allow us to use their products and services for free as part of a contribution to the open source ecosystem and our work. +

Netlify Algolia 1Password

+ + + +[tidelift]: https://tidelift.com/funding/github/npm/eslint +[herodevs]: https://www.herodevs.com/support/eslint-nes?utm_source=ESLintWebsite&utm_medium=ESLintWebsite&utm_campaign=ESLintNES&utm_id=ESLintNES diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js new file mode 100755 index 00000000..6e485818 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/bin/eslint.js @@ -0,0 +1,211 @@ +#!/usr/bin/env node + +/** + * @fileoverview Main CLI that is run via the eslint command. + * @author Nicholas C. Zakas + */ + +/* eslint no-console:off -- CLI */ + +"use strict"; + +const mod = require("node:module"); + +// to use V8's code cache to speed up instantiation time +mod.enableCompileCache?.(); + +// must do this initialization *before* other requires in order to work +if (process.argv.includes("--debug")) { + require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*"); +} + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Read data from stdin til the end. + * + * Note: See + * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin + * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io + * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html + * - https://github.com/nodejs/node/issues/7439 (historical) + * + * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems + * to read 4096 bytes before blocking and never drains to read further data. + * + * The investigation on the Emacs thread indicates: + * + * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a + * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than + * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for + * > the subprocess to read its end of the pipe, at which time Emacs will + * > write the rest of the stuff. + * @returns {Promise} The read text. + */ +function readStdin() { + return new Promise((resolve, reject) => { + let content = ""; + let chunk = ""; + + process.stdin + .setEncoding("utf8") + .on("readable", () => { + while ((chunk = process.stdin.read()) !== null) { + content += chunk; + } + }) + .on("end", () => resolve(content)) + .on("error", reject); + }); +} + +/** + * Spawns an external command and propagates its exit status. + * @param {string} command The command to run. + * @param {string[]} args The command arguments. + * @throws {Error} If the command cannot be spawned. + * @returns {void} + */ +function spawnExternalCommand(command, args) { + const spawn = require("cross-spawn"); + const result = spawn.sync(command, args, { + encoding: "utf8", + stdio: "inherit", + }); + + if (result.error) { + throw result.error; + } + + if (result.signal) { + process.kill(process.pid, result.signal); + return; + } + + process.exitCode = result.status ?? 0; +} + +/** + * Get the error message of a given value. + * @param {any} error The value to get. + * @returns {string} The error message. + */ +function getErrorMessage(error) { + // Lazy loading because this is used only if an error happened. + const util = require("node:util"); + + // Foolproof -- third-party module might throw non-object. + if (typeof error !== "object" || error === null) { + return String(error); + } + + // Use templates if `error.messageTemplate` is present. + if (typeof error.messageTemplate === "string") { + try { + const template = require(`../messages/${error.messageTemplate}.js`); + + return template(error.messageData || {}); + } catch { + // Ignore template error then fallback to use `error.stack`. + } + } + + // Use the stacktrace if it's an error object. + if (typeof error.stack === "string") { + return error.stack; + } + + // Otherwise, dump the object. + return util.format("%o", error); +} + +/** + * Tracks error messages that are shown to the user so we only ever show the + * same message once. + * @type {Set} + */ +const displayedErrors = new Set(); + +/** + * Tracks whether an unexpected error was caught + * @type {boolean} + */ +let hadFatalError = false; + +/** + * Catch and report unexpected error. + * @param {any} error The thrown error object. + * @returns {void} + */ +function onFatalError(error) { + process.exitCode = 2; + hadFatalError = true; + + const { version } = require("../package.json"); + const message = ` +Oops! Something went wrong! :( + +ESLint: ${version} + +${getErrorMessage(error)}`; + + if (!displayedErrors.has(message)) { + console.error(message); + displayedErrors.add(message); + } +} + +//------------------------------------------------------------------------------ +// Execution +//------------------------------------------------------------------------------ + +(async function main() { + process.on("uncaughtException", onFatalError); + process.on("unhandledRejection", onFatalError); + + // Call the config initializer if `--init` is present. + if (process.argv.includes("--init")) { + // `eslint --init` has been moved to `@eslint/create-config` + console.warn( + "You can also run this command directly using 'npm init @eslint/config@latest'.", + ); + + spawnExternalCommand("npm", ["init", "@eslint/config@latest"]); + return; + } + + // start the MCP server if `--mcp` is present + if (process.argv.includes("--mcp")) { + console.warn( + "You can also run this command directly using 'npx @eslint/mcp@latest'.", + ); + + spawnExternalCommand("npx", ["@eslint/mcp@latest"]); + return; + } + + // Otherwise, call the CLI. + const cli = require("../lib/cli"); + const exitCode = await cli.execute( + process.argv, + process.argv.includes("--stdin") ? await readStdin() : void 0, + ); + + /* + * If an uncaught exception or unhandled rejection was detected in the meantime, + * keep the fatal exit code 2 that is already assigned to `process.exitCode`. + * Without this condition, exit code 2 (unsuccessful execution) could be overwritten with + * 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found). + * This ensures that unexpected errors that seemingly don't affect the success + * of the execution will still cause a non-zero exit code, as it's a common + * practice and the default behavior of Node.js to exit with non-zero + * in case of an uncaught exception or unhandled rejection. + * + * Otherwise, assign the exit code returned from CLI. + */ + if (!hadFatalError) { + process.exitCode = exitCode; + } +})().catch(onFatalError); diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/ecma-version.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/ecma-version.js new file mode 100644 index 00000000..e68d3020 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/ecma-version.js @@ -0,0 +1,16 @@ +/** + * @fileoverview Configuration related to ECMAScript versions + * @author Milos Djermanovic + */ + +"use strict"; + +/** + * The latest ECMAScript version supported by ESLint. + * @type {number} year-based ECMAScript version + */ +const LATEST_ECMA_VERSION = 2026; + +module.exports = { + LATEST_ECMA_VERSION, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/globals.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/globals.js new file mode 100644 index 00000000..23ef52fd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/globals.js @@ -0,0 +1,170 @@ +/** + * @fileoverview Globals for ecmaVersion/sourceType + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Globals +//----------------------------------------------------------------------------- + +const commonjs = { + exports: true, + global: false, + module: false, + require: false, +}; + +const es3 = { + Array: false, + Boolean: false, + constructor: false, + Date: false, + decodeURI: false, + decodeURIComponent: false, + encodeURI: false, + encodeURIComponent: false, + Error: false, + escape: false, + eval: false, + EvalError: false, + Function: false, + hasOwnProperty: false, + Infinity: false, + isFinite: false, + isNaN: false, + isPrototypeOf: false, + Math: false, + NaN: false, + Number: false, + Object: false, + parseFloat: false, + parseInt: false, + propertyIsEnumerable: false, + RangeError: false, + ReferenceError: false, + RegExp: false, + String: false, + SyntaxError: false, + toLocaleString: false, + toString: false, + TypeError: false, + undefined: false, + unescape: false, + URIError: false, + valueOf: false, +}; + +const es5 = { + ...es3, + JSON: false, +}; + +const es2015 = { + ...es5, + ArrayBuffer: false, + DataView: false, + Float32Array: false, + Float64Array: false, + Int16Array: false, + Int32Array: false, + Int8Array: false, + Intl: false, + Map: false, + Promise: false, + Proxy: false, + Reflect: false, + Set: false, + Symbol: false, + Uint16Array: false, + Uint32Array: false, + Uint8Array: false, + Uint8ClampedArray: false, + WeakMap: false, + WeakSet: false, +}; + +// no new globals in ES2016 +const es2016 = { + ...es2015, +}; + +const es2017 = { + ...es2016, + Atomics: false, + SharedArrayBuffer: false, +}; + +// no new globals in ES2018 +const es2018 = { + ...es2017, +}; + +// no new globals in ES2019 +const es2019 = { + ...es2018, +}; + +const es2020 = { + ...es2019, + BigInt: false, + BigInt64Array: false, + BigUint64Array: false, + globalThis: false, +}; + +const es2021 = { + ...es2020, + AggregateError: false, + FinalizationRegistry: false, + WeakRef: false, +}; + +const es2022 = { + ...es2021, +}; + +const es2023 = { + ...es2022, +}; + +const es2024 = { + ...es2023, +}; + +const es2025 = { + ...es2024, + Float16Array: false, + Iterator: false, +}; + +const es2026 = { + ...es2025, + AsyncDisposableStack: false, + DisposableStack: false, + SuppressedError: false, + Temporal: false, +}; + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { + commonjs, + es3, + es5, + es2015, + es2016, + es2017, + es2018, + es2019, + es2020, + es2021, + es2022, + es2023, + es2024, + es2025, + es2026, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/replacements.json b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/replacements.json new file mode 100644 index 00000000..27329c4c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/replacements.json @@ -0,0 +1,26 @@ +{ + "rules": { + "generator-star": ["generator-star-spacing"], + "global-strict": ["strict"], + "no-arrow-condition": ["no-confusing-arrow", "no-constant-condition"], + "no-comma-dangle": ["comma-dangle"], + "no-empty-class": ["no-empty-character-class"], + "no-empty-label": ["no-labels"], + "no-extra-strict": ["strict"], + "no-reserved-keys": ["quote-props"], + "no-space-before-semi": ["semi-spacing"], + "no-wrap-func": ["no-extra-parens"], + "space-after-function-name": ["space-before-function-paren"], + "space-after-keywords": ["keyword-spacing"], + "space-before-function-parentheses": ["space-before-function-paren"], + "space-before-keywords": ["keyword-spacing"], + "space-in-brackets": [ + "object-curly-spacing", + "array-bracket-spacing", + "computed-property-spacing" + ], + "space-return-throw-case": ["keyword-spacing"], + "space-unary-word-ops": ["space-unary-ops"], + "spaced-line-comment": ["spaced-comment"] + } +} diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/rule-type-list.json b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/rule-type-list.json new file mode 100644 index 00000000..05ddd3cb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/conf/rule-type-list.json @@ -0,0 +1,91 @@ +{ + "types": { + "problem": [], + "suggestion": [], + "layout": [] + }, + "deprecated": [], + "removed": [ + { + "removed": "generator-star", + "replacedBy": [{ "rule": { "name": "generator-star-spacing" } }] + }, + { + "removed": "global-strict", + "replacedBy": [{ "rule": { "name": "strict" } }] + }, + { + "removed": "no-arrow-condition", + "replacedBy": [ + { "rule": { "name": "no-confusing-arrow" } }, + { "rule": { "name": "no-constant-condition" } } + ] + }, + { + "removed": "no-comma-dangle", + "replacedBy": [{ "rule": { "name": "comma-dangle" } }] + }, + { + "removed": "no-empty-class", + "replacedBy": [{ "rule": { "name": "no-empty-character-class" } }] + }, + { + "removed": "no-empty-label", + "replacedBy": [{ "rule": { "name": "no-labels" } }] + }, + { + "removed": "no-extra-strict", + "replacedBy": [{ "rule": { "name": "strict" } }] + }, + { + "removed": "no-reserved-keys", + "replacedBy": [{ "rule": { "name": "quote-props" } }] + }, + { + "removed": "no-space-before-semi", + "replacedBy": [{ "rule": { "name": "semi-spacing" } }] + }, + { + "removed": "no-wrap-func", + "replacedBy": [{ "rule": { "name": "no-extra-parens" } }] + }, + { + "removed": "space-after-function-name", + "replacedBy": [{ "rule": { "name": "space-before-function-paren" } }] + }, + { + "removed": "space-after-keywords", + "replacedBy": [{ "rule": { "name": "keyword-spacing" } }] + }, + { + "removed": "space-before-function-parentheses", + "replacedBy": [{ "rule": { "name": "space-before-function-paren" } }] + }, + { + "removed": "space-before-keywords", + "replacedBy": [{ "rule": { "name": "keyword-spacing" } }] + }, + { + "removed": "space-in-brackets", + "replacedBy": [ + { "rule": { "name": "object-curly-spacing" } }, + { "rule": { "name": "array-bracket-spacing" } }, + { "rule": { "name": "computed-property-spacing" } } + ] + }, + { + "removed": "space-return-throw-case", + "replacedBy": [{ "rule": { "name": "keyword-spacing" } }] + }, + { + "removed": "space-unary-word-ops", + "replacedBy": [{ "rule": { "name": "space-unary-ops" } }] + }, + { + "removed": "spaced-line-comment", + "replacedBy": [{ "rule": { "name": "spaced-comment" } }] + }, + { "removed": "valid-jsdoc", "replacedBy": [] }, + { "removed": "require-jsdoc", "replacedBy": [] } + ] +} diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/api.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/api.js new file mode 100644 index 00000000..5de2d65f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/api.js @@ -0,0 +1,39 @@ +/** + * @fileoverview Expose out ESLint and CLI to require. + * @author Ian Christian Myers + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { ESLint } = require("./eslint/eslint"); +const { Linter } = require("./linter"); +const { RuleTester } = require("./rule-tester"); +const { SourceCode } = require("./languages/js/source-code"); + +//----------------------------------------------------------------------------- +// Functions +//----------------------------------------------------------------------------- + +/** + * Loads the correct `ESLint` constructor. + * @returns {Promise} The ESLint constructor. + */ +async function loadESLint() { + return ESLint; +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { + Linter, + loadESLint, + ESLint, + RuleTester, + SourceCode, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/formatters-meta.json b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/formatters-meta.json new file mode 100644 index 00000000..cf320529 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/formatters-meta.json @@ -0,0 +1,18 @@ +[ + { + "name": "html", + "description": "Outputs results to HTML. The `html` formatter is useful for visual presentation in the browser." + }, + { + "name": "json-with-metadata", + "description": "Outputs JSON-serialized results. The `json-with-metadata` provides the same linting results as the [`json`](#json) formatter with additional metadata about the rules applied. The linting results are included in the `results` property and the rules metadata is included in the `metadata` property.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint." + }, + { + "name": "json", + "description": "Outputs JSON-serialized results. The `json` formatter is useful when you want to programmatically work with the CLI's linting results.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint." + }, + { + "name": "stylish", + "description": "Human-readable output format. This is the default formatter." + } +] diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/html.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/html.js new file mode 100644 index 00000000..b6f02cac --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/html.js @@ -0,0 +1,359 @@ +/** + * @fileoverview HTML reporter + * @author Julian Laval + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const encodeHTML = (function () { + const encodeHTMLRules = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'", + }; + const matchHTML = /[&<>"']/gu; + + return function (code) { + return code + ? code.toString().replace(matchHTML, m => encodeHTMLRules[m] || m) + : ""; + }; +})(); + +/** + * Get the final HTML document. + * @param {Object} it data for the document. + * @returns {string} HTML document. + */ +function pageTemplate(it) { + const { reportColor, reportSummary, date, results } = it; + + return ` + + + + + ESLint Report + + + + + +
+

ESLint Report

+
+ ${reportSummary} - Generated on ${date} +
+
+ + + ${results} + +
+ + + +`.trimStart(); +} + +/** + * Given a word and a count, append an s if count is not one. + * @param {string} word A word in its singular form. + * @param {number} count A number controlling whether word should be pluralized. + * @returns {string} The original word with an s on the end if count is not one. + */ +function pluralize(word, count) { + return count === 1 ? word : `${word}s`; +} + +/** + * Renders text along the template of x problems (x errors, x warnings) + * @param {number} totalErrors Total errors + * @param {number} totalWarnings Total warnings + * @returns {string} The formatted string, pluralized where necessary + */ +function renderSummary(totalErrors, totalWarnings) { + const totalProblems = totalErrors + totalWarnings; + let renderedText = `${totalProblems} ${pluralize("problem", totalProblems)}`; + + if (totalProblems !== 0) { + renderedText += ` (${totalErrors} ${pluralize("error", totalErrors)}, ${totalWarnings} ${pluralize("warning", totalWarnings)})`; + } + return renderedText; +} + +/** + * Get the color based on whether there are errors/warnings... + * @param {number} totalErrors Total errors + * @param {number} totalWarnings Total warnings + * @returns {number} The color code (0 = green, 1 = yellow, 2 = red) + */ +function renderColor(totalErrors, totalWarnings) { + if (totalErrors !== 0) { + return 2; + } + if (totalWarnings !== 0) { + return 1; + } + return 0; +} + +/** + * Get HTML (table row) describing a single message. + * @param {Object} it data for the message. + * @returns {string} HTML (table row) describing the message. + */ +function messageTemplate(it) { + const { + parentIndex, + lineNumber, + columnNumber, + severityNumber, + severityName, + message, + ruleUrl, + ruleId, + } = it; + + return ` + + ${lineNumber}:${columnNumber} + ${severityName} + ${encodeHTML(message)} + + ${encodeHTML(ruleId)} + + +`.trimStart(); +} + +/** + * Get HTML (table rows) describing the messages. + * @param {Array} messages Messages. + * @param {number} parentIndex Index of the parent HTML row. + * @param {Object} rulesMeta Dictionary containing metadata for each rule executed by the analysis. + * @returns {string} HTML (table rows) describing the messages. + */ +function renderMessages(messages, parentIndex, rulesMeta) { + /** + * Get HTML (table row) describing a message. + * @param {Object} message Message. + * @returns {string} HTML (table row) describing a message. + */ + return messages + .map(message => { + const lineNumber = message.line || 0; + const columnNumber = message.column || 0; + let ruleUrl; + + if (rulesMeta) { + const meta = rulesMeta[message.ruleId]; + + if (meta && meta.docs && meta.docs.url) { + ruleUrl = meta.docs.url; + } + } + + return messageTemplate({ + parentIndex, + lineNumber, + columnNumber, + severityNumber: message.severity, + severityName: message.severity === 1 ? "Warning" : "Error", + message: message.message, + ruleId: message.ruleId, + ruleUrl, + }); + }) + .join("\n"); +} + +/** + * Get HTML (table row) describing the result for a single file. + * @param {Object} it data for the file. + * @returns {string} HTML (table row) describing the result for the file. + */ +function resultTemplate(it) { + const { color, index, filePath, summary } = it; + + return ` + + + [+] ${encodeHTML(filePath)} + ${encodeHTML(summary)} + + +`.trimStart(); +} + +/** + * Render the results. + * @param {Array} results Test results. + * @param {Object} rulesMeta Dictionary containing metadata for each rule executed by the analysis. + * @returns {string} HTML string describing the results. + */ +function renderResults(results, rulesMeta) { + return results + .map( + (result, index) => + resultTemplate({ + index, + color: renderColor(result.errorCount, result.warningCount), + filePath: result.filePath, + summary: renderSummary( + result.errorCount, + result.warningCount, + ), + }) + renderMessages(result.messages, index, rulesMeta), + ) + .join("\n"); +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = function (results, data) { + let totalErrors, totalWarnings; + + const metaData = data ? data.rulesMeta : {}; + + totalErrors = 0; + totalWarnings = 0; + + // Iterate over results to get totals + results.forEach(result => { + totalErrors += result.errorCount; + totalWarnings += result.warningCount; + }); + + return pageTemplate({ + date: new Date(), + reportColor: renderColor(totalErrors, totalWarnings), + reportSummary: renderSummary(totalErrors, totalWarnings), + results: renderResults(results, metaData), + }); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json-with-metadata.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json-with-metadata.js new file mode 100644 index 00000000..44c785c7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json-with-metadata.js @@ -0,0 +1,16 @@ +/** + * @fileoverview JSON reporter, including rules metadata + * @author Chris Meyer + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = function (results, data) { + return JSON.stringify({ + results, + metadata: data, + }); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json.js new file mode 100644 index 00000000..230f5c58 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/json.js @@ -0,0 +1,13 @@ +/** + * @fileoverview JSON reporter + * @author Burak Yigit Kaya aka BYK + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = function (results) { + return JSON.stringify(results); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/stylish.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/stylish.js new file mode 100644 index 00000000..5b1ffac9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/formatters/stylish.js @@ -0,0 +1,185 @@ +/** + * @fileoverview Stylish reporter + * @author Sindre Sorhus + */ +"use strict"; + +const util = require("node:util"), + table = require("../../shared/text-table"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Returns a styling function based on the color option. + * @param {boolean|undefined} color Indicates whether to use colors. + * @returns {Function} A function that styles text. + */ +function getStyleText(color) { + if (typeof color === "undefined") { + return (format, text) => + util.styleText(format, text, { validateStream: true }); + } + if (color) { + return (format, text) => + util.styleText(format, text, { validateStream: false }); + } + return (_, text) => text; +} + +/** + * Computes the visible width of a string, avoiding the cost of stripping + * VT control characters when the string doesn't contain any. + * + * VT sequences can be introduced either by the 7-bit `ESC` character or by + * the 8-bit `CSI` character, both of which `util.stripVTControlCharacters()` + * removes, so both must be checked before taking the fast path. + * @todo This optimization is not needed in Node.js v24+ because it's baked + * into util.stripVTControlCharacters(). When we update our supported + * Node.js versions we can remove this optimization. + * @param {string} str The string to measure. + * @returns {number} The number of visible characters. + */ +function stringLength(str) { + return str.includes("\u001b") || str.includes("\u009b") + ? util.stripVTControlCharacters(str).length + : str.length; +} + +/** + * Given a word and a count, append an s if count is not one. + * @param {string} word A word in its singular form. + * @param {number} count A number controlling whether word should be pluralized. + * @returns {string} The original word with an s on the end if count is not one. + */ +function pluralize(word, count) { + return count === 1 ? word : `${word}s`; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = function (results, data) { + const styleText = getStyleText(data?.color); + + let output = "\n", + errorCount = 0, + warningCount = 0, + fixableErrorCount = 0, + fixableWarningCount = 0, + summaryColor = "yellow"; + + results.forEach(result => { + const messages = result.messages; + + if (messages.length === 0) { + return; + } + + errorCount += result.errorCount; + warningCount += result.warningCount; + fixableErrorCount += result.fixableErrorCount; + fixableWarningCount += result.fixableWarningCount; + + output += `${styleText("underline", result.filePath)}\n`; + + output += `${table( + messages.map(message => { + let messageType; + + if (message.fatal || message.severity === 2) { + messageType = styleText("red", "error"); + summaryColor = "red"; + } else { + messageType = styleText("yellow", "warning"); + } + + /* + * Strip a trailing period unless it's preceded by a space. + * This is equivalent to `.replace(/([^ ])\.$/u, "$1")` but + * avoids running a regex on every message. + */ + let messageText = message.message; + + if ( + messageText.length > 1 && + messageText.endsWith(".") && + messageText.at(-2) !== " " + ) { + messageText = messageText.slice(0, -1); + } + + return [ + "", + String(message.line || 0), + String(message.column || 0), + messageType, + messageText, + message.ruleId ? styleText("dim", message.ruleId) : "", + ]; + }), + { + align: ["", "r", "l"], + stringLength, + }, + ) + .split("\n") + .map(el => + el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) => + styleText("dim", `${p1}:${p2}`), + ), + ) + .join("\n")}\n\n`; + }); + + const total = errorCount + warningCount; + + /* + * We can't use a single `styleText` call like `styleText([summaryColor, "bold"], text)` here. + * This is a bug in `util.styleText` in Node.js versions earlier than v22.15.0 (https://github.com/nodejs/node/issues/56717). + * As a workaround, we use nested `styleText` calls. + */ + if (total > 0) { + output += `${styleText( + summaryColor, + styleText( + "bold", + [ + "\u2716 ", + total, + pluralize(" problem", total), + " (", + errorCount, + pluralize(" error", errorCount), + ", ", + warningCount, + pluralize(" warning", warningCount), + ")", + ].join(""), + ), + )}\n`; + + if (fixableErrorCount > 0 || fixableWarningCount > 0) { + output += `${styleText( + summaryColor, + styleText( + "bold", + [ + " ", + fixableErrorCount, + pluralize(" error", fixableErrorCount), + " and ", + fixableWarningCount, + pluralize(" warning", fixableWarningCount), + " potentially fixable with the `--fix` option.", + ].join(""), + ), + )}\n`; + } + } + + // Resets output color, for prevent change on top level + return total > 0 ? styleText("reset", output) : ""; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/hash.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/hash.js new file mode 100644 index 00000000..4c306b9b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/hash.js @@ -0,0 +1,35 @@ +/** + * @fileoverview Defining the hashing function in one place. + * @author Michael Ficarra + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const murmur = require("imurmurhash"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Private +//------------------------------------------------------------------------------ + +/** + * hash the given string + * @param {string} str the string to hash + * @returns {string} the hash + */ +function hash(str) { + return murmur(str).result().toString(36); +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = hash; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/lint-result-cache.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/lint-result-cache.js new file mode 100644 index 00000000..1a2c465b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli-engine/lint-result-cache.js @@ -0,0 +1,250 @@ +/** + * @fileoverview Utility for caching lint results. + * @author Kevin Partington + */ +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const fs = require("node:fs"); +const path = require("node:path"); +const fileEntryCache = require("file-entry-cache"); +const stringify = require("json-stable-stringify-without-jsonify"); +const pkg = require("../../package.json"); +const assert = require("../shared/assert"); +const hash = require("./hash"); + +const debug = require("debug")("eslint:lint-result-cache"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @typedef {import("../types").Linter.Config} Config */ + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const configHashCache = new WeakMap(); +const nodeVersion = process && process.version; + +const validCacheStrategies = ["metadata", "content"]; +const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${validCacheStrategies + .map(strategy => `"${strategy}"`) + .join(", ")}`; + +/** + * Tests whether a provided cacheStrategy is valid + * @param {string} cacheStrategy The cache strategy to use + * @returns {boolean} true if `cacheStrategy` is one of `validCacheStrategies`; false otherwise + */ +function isValidCacheStrategy(cacheStrategy) { + return validCacheStrategies.includes(cacheStrategy); +} + +/** + * Calculates the hash of the config + * @param {Config} config The config. + * @returns {string} The hash of the config + */ +function hashOfConfigFor(config) { + if (!configHashCache.has(config)) { + configHashCache.set( + config, + hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`), + ); + } + + return configHashCache.get(config); +} + +//----------------------------------------------------------------------------- +// Public Interface +//----------------------------------------------------------------------------- + +/** + * Lint result cache. This wraps around the file-entry-cache module, + * transparently removing properties that are difficult or expensive to + * serialize and adding them back in on retrieval. + */ +class LintResultCache { + /** + * Creates a new LintResultCache instance. + * @param {string} cacheFileLocation The cache file location. + * @param {"metadata" | "content"} cacheStrategy The cache strategy to use. + */ + constructor(cacheFileLocation, cacheStrategy) { + assert(cacheFileLocation, "Cache file location is required"); + assert(cacheStrategy, "Cache strategy is required"); + assert( + isValidCacheStrategy(cacheStrategy), + invalidCacheStrategyErrorMessage, + ); + + debug("Caching results to %s", cacheFileLocation); + + const useCheckSum = cacheStrategy === "content"; + + debug('Using "%s" strategy to detect changes', cacheStrategy); + + /* + * useModifiedTime: If `true` (default), use mtime and size to determine if the file has changed. + * It corresponds to the "metadata" cache strategy. + * useCheckSum: If `true`, use hash of the content to determine if the file has changed. + * It corresponds to the "content" cache strategy. + * + * For the "content" cache strategy, it is important to set useModifiedTime to `false`. + * Otherwise, file-entry-cache would use _both_ checks to determine if the file has changed, + * which would defeat the purpose of this cache strategy (use cases where the modification time + * of files changes even if their contents have not, e.g., after `git clone`). + */ + this.fileEntryCache = fileEntryCache.create( + path.basename(cacheFileLocation), + path.dirname(cacheFileLocation), + { + useModifiedTime: !useCheckSum, + useCheckSum, + }, + ); + + this.cacheFileLocation = cacheFileLocation; + } + + /** + * Retrieve cached lint results for a given file path, if present in the + * cache. If the file is present and has not been changed, rebuild any + * missing result information. + * @param {string} filePath The file for which to retrieve lint results. + * @param {Config} config The config of the file. + * @returns {Object|null} The rebuilt lint results, or null if the file is + * changed or not in the filesystem. + */ + getCachedLintResults(filePath, config) { + const cachedResults = this.getValidCachedLintResults(filePath, config); + + if (!cachedResults) { + return cachedResults; + } + + /* + * Shallow clone the object to ensure that any properties added or modified afterwards + * will not be accidentally stored in the cache file when `reconcile()` is called. + * https://github.com/eslint/eslint/issues/13507 + * All intentional changes to the cache file must be done through `setCachedLintResults()`. + */ + const results = { ...cachedResults }; + + // If source is present but null, need to reread the file from the filesystem. + if (results.source === null) { + debug( + "Rereading cached result source from filesystem: %s", + filePath, + ); + results.source = fs.readFileSync(filePath, "utf-8"); + } + + return results; + } + + /** + * Retrieve cached lint results for a given file path, if present in the + * cache and still valid. + * @param {string} filePath The file for which to retrieve lint results. + * @param {Config} config The config of the file. + * @returns {Object|null} The cached lint results if present in the cache + * and still valid; null otherwise. + */ + getValidCachedLintResults(filePath, config) { + /* + * Cached lint results are valid if and only if: + * 1. The file is present in the filesystem + * 2. The file has not changed since the time it was previously linted + * 3. The ESLint configuration has not changed since the time the file + * was previously linted + * If any of these are not true, we will not reuse the lint results. + */ + const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath); + + if (fileDescriptor.notFound) { + debug("File not found on the file system: %s", filePath); + return null; + } + + if (!fileDescriptor.changed && !fileDescriptor.meta.data) { + debug("Legacy cache entry found: %s", filePath); + return null; + } + + const hashOfConfig = hashOfConfigFor(config); + const changed = + fileDescriptor.changed || + fileDescriptor.meta.data.hashOfConfig !== hashOfConfig; + + if (changed) { + debug("Cache entry not found or no longer valid: %s", filePath); + return null; + } + + return fileDescriptor.meta.data.results; + } + + /** + * Set the cached lint results for a given file path, after removing any + * information that will be both unnecessary and difficult to serialize. + * Avoids caching results with an "output" property (meaning fixes were + * applied), to prevent potentially incorrect results if fixes are not + * written to disk. + * @param {string} filePath The file for which to set lint results. + * @param {Config} config The config of the file. + * @param {Object} result The lint result to be set for the file. + * @returns {void} + */ + setCachedLintResults(filePath, config, result) { + if (result && Object.hasOwn(result, "output")) { + return; + } + + const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath); + + if (fileDescriptor && !fileDescriptor.notFound) { + debug("Updating cached result: %s", filePath); + + // Serialize the result, except that we want to remove the file source if present. + const resultToSerialize = Object.assign({}, result); + + /* + * Set result.source to null. + * In `getCachedLintResults`, if source is explicitly null, we will + * read the file from the filesystem to set the value again. + */ + if (Object.hasOwn(resultToSerialize, "source")) { + resultToSerialize.source = null; + } + + // remove legacy properties set by a previous version of ESLint, if present + if (fileDescriptor.meta.hashOfConfig) { + delete fileDescriptor.meta.results; + delete fileDescriptor.meta.hashOfConfig; + } + + fileDescriptor.meta.data = { + results: resultToSerialize, + hashOfConfig: hashOfConfigFor(config), + }; + } + } + + /** + * Persists the in-memory cache to disk. + * @returns {void} + */ + reconcile() { + debug("Persisting cached results: %s", this.cacheFileLocation); + this.fileEntryCache.reconcile(); + } +} + +module.exports = LintResultCache; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli.js new file mode 100644 index 00000000..d926ef59 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/cli.js @@ -0,0 +1,522 @@ +/** + * @fileoverview Main CLI object. + * @author Nicholas C. Zakas + */ + +"use strict"; + +/* + * NOTE: The CLI object should *not* call process.exit() directly. It should only return + * exit codes. This allows other programs to use the CLI object and still control + * when the program exits. + */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const fs = require("node:fs"), + { mkdir, stat, writeFile } = require("node:fs/promises"), + path = require("node:path"), + { pathToFileURL } = require("node:url"), + { ESLint, locateConfigFileToUse } = require("./eslint/eslint"), + createCLIOptions = require("./options"), + log = require("./shared/logging"), + RuntimeInfo = require("./shared/runtime-info"), + translateOptions = require("./shared/translate-cli-options"); +const { getCacheFile } = require("./eslint/eslint-helpers"); +const { SuppressionsService } = require("./services/suppressions-service"); +const debug = require("debug")("eslint:cli"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("./options").ParsedCLIOptions} ParsedCLIOptions */ +/** @typedef {import("./types").ESLint.LintResult} LintResult */ +/** @typedef {import("./types").ESLint.ResultsMeta} ResultsMeta */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Count error messages. + * @param {LintResult[]} results The lint results. + * @returns {{errorCount:number;fatalErrorCount:number,warningCount:number}} The number of error messages. + */ +function countErrors(results) { + let errorCount = 0; + let fatalErrorCount = 0; + let warningCount = 0; + + for (const result of results) { + errorCount += result.errorCount; + fatalErrorCount += result.fatalErrorCount; + warningCount += result.warningCount; + } + + return { errorCount, fatalErrorCount, warningCount }; +} + +/** + * Creates an options module from the provided CLI options and encodes it as a data URL. + * @param {ParsedCLIOptions} options The CLI options. + * @returns {URL} The URL of the options module. + */ +function createOptionsModule(options) { + const translateOptionsFileURL = new URL( + "./shared/translate-cli-options.js", + pathToFileURL(__filename), + ).href; + const optionsSrc = + `import translateOptions from ${JSON.stringify(translateOptionsFileURL)};\n` + + `export default await translateOptions(${JSON.stringify(options)});\n`; + + // Base64 encoding is typically shorter than URL encoding + return new URL( + `data:text/javascript;base64,${Buffer.from(optionsSrc).toString("base64")}`, + ); +} + +/** + * Check if a given file path is a directory or not. + * @param {string} filePath The path to a file to check. + * @returns {Promise} `true` if the given path is a directory. + */ +async function isDirectory(filePath) { + try { + return (await stat(filePath)).isDirectory(); + } catch (error) { + if (error.code === "ENOENT" || error.code === "ENOTDIR") { + return false; + } + throw error; + } +} + +/** + * Outputs the results of the linting. + * @param {ESLint} engine The ESLint instance to use. + * @param {LintResult[]} results The results to print. + * @param {string} format The name of the formatter to use or the path to the formatter. + * @param {string} outputFile The path for the output file. + * @param {ResultsMeta} resultsMeta Warning count and max threshold. + * @returns {Promise} True if the printing succeeds, false if not. + * @private + */ +async function printResults(engine, results, format, outputFile, resultsMeta) { + let formatter; + + try { + formatter = await engine.loadFormatter(format); + } catch (e) { + log.error(e.message); + return false; + } + + const output = await formatter.format(results, resultsMeta); + + if (outputFile) { + const filePath = path.resolve(process.cwd(), outputFile); + + if (await isDirectory(filePath)) { + log.error( + "Cannot write to output file path, it is a directory: %s", + outputFile, + ); + return false; + } + + try { + await mkdir(path.dirname(filePath), { recursive: true }); + await writeFile(filePath, output); + } catch (ex) { + log.error("There was a problem writing the output file:\n%s", ex); + return false; + } + } else if (output) { + log.info(output); + } + + return true; +} + +/** + * Validates the `--concurrency` flag value. + * @param {string} concurrency The `--concurrency` flag value to validate. + * @returns {void} + * @throws {Error} If the `--concurrency` flag value is invalid. + */ +function validateConcurrency(concurrency) { + if ( + concurrency === void 0 || + concurrency === "auto" || + concurrency === "off" + ) { + return; + } + + const concurrencyValue = Number(concurrency); + + if (!Number.isInteger(concurrencyValue) || concurrencyValue < 1) { + throw new Error( + `Option concurrency: '${concurrency}' is not a positive integer, 'auto' or 'off'.`, + ); + } +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Encapsulates all CLI behavior for eslint. Makes it easier to test as well as + * for other Node.js programs to effectively run the CLI. + */ +const cli = { + /** + * Calculates the command string for the --inspect-config operation. + * @param {string} configFile The path to the config file to inspect. + * @returns {Promise} The command string to execute. + */ + async calculateInspectConfigFlags(configFile) { + // find the config file + const { configFilePath, basePath } = await locateConfigFileToUse({ + cwd: process.cwd(), + configFile, + }); + + return ["--config", configFilePath, "--basePath", basePath]; + }, + + /** + * Executes the CLI based on an array of arguments that is passed in. + * @param {string|Array|Object} args The arguments to process. + * @param {string} [text] The text to lint (used for TTY). + * @returns {Promise} The exit code for the operation. + */ + async execute(args, text) { + if (Array.isArray(args)) { + debug("CLI args: %o", args.slice(2)); + } + + const CLIOptions = createCLIOptions(); + + /** @type {ParsedCLIOptions} */ + let options; + + try { + options = CLIOptions.parse(args); + validateConcurrency(options.concurrency); + } catch (error) { + log.error(error.message); + return 2; + } + + const files = options._; + const useStdin = typeof text === "string"; + + if (options.help) { + log.info(CLIOptions.generateHelp()); + return 0; + } + if (options.version) { + log.info(RuntimeInfo.version()); + return 0; + } + if (options.envInfo) { + try { + log.info(RuntimeInfo.environment()); + return 0; + } catch (err) { + debug("Error retrieving environment info"); + log.error(err.message); + return 2; + } + } + + if (options.printConfig) { + if (files.length) { + log.error( + "The --print-config option must be used with exactly one file name.", + ); + return 2; + } + if (useStdin) { + log.error( + "The --print-config option is not available for piped-in code.", + ); + return 2; + } + + const engine = new ESLint(await translateOptions(options)); + const fileConfig = await engine.calculateConfigForFile( + options.printConfig, + ); + + log.info(JSON.stringify(fileConfig, null, " ")); + return 0; + } + + if (options.inspectConfig) { + log.info( + "You can also run this command directly using 'npx @eslint/config-inspector@latest' in the same directory as your configuration file.", + ); + + try { + const flatOptions = await translateOptions(options); + const spawn = require("cross-spawn"); + const flags = await cli.calculateInspectConfigFlags( + flatOptions.overrideConfigFile, + ); + + spawn.sync( + "npx", + ["@eslint/config-inspector@latest", ...flags], + { encoding: "utf8", stdio: "inherit" }, + ); + } catch (error) { + log.error(error); + return 2; + } + + return 0; + } + + debug("Running on %s", useStdin ? "text" : "files"); + + if (options.fix && options.fixDryRun) { + log.error( + "The --fix option and the --fix-dry-run option cannot be used together.", + ); + return 2; + } + if (useStdin && options.fix) { + log.error( + "The --fix option is not available for piped-in code; use --fix-dry-run instead.", + ); + return 2; + } + if (options.fixType && !options.fix && !options.fixDryRun) { + log.error( + "The --fix-type option requires either --fix or --fix-dry-run.", + ); + return 2; + } + + if ( + options.reportUnusedDisableDirectives && + options.reportUnusedDisableDirectivesSeverity !== void 0 + ) { + log.error( + "The --report-unused-disable-directives option and the --report-unused-disable-directives-severity option cannot be used together.", + ); + return 2; + } + + if (options.ext) { + // Passing `--ext ""` results in `options.ext` being an empty array. + if (options.ext.length === 0) { + log.error("The --ext option value cannot be empty."); + return 2; + } + + // Passing `--ext ,ts` results in an empty string at index 0. Passing `--ext ts,,tsx` results in an empty string at index 1. + const emptyStringIndex = options.ext.indexOf(""); + + if (emptyStringIndex >= 0) { + log.error( + `The --ext option arguments cannot be empty strings. Found an empty string at index ${emptyStringIndex}.`, + ); + return 2; + } + } + + if (options.suppressAll && options.suppressRule) { + log.error( + "The --suppress-all option and the --suppress-rule option cannot be used together.", + ); + return 2; + } + + if (options.suppressAll && options.pruneSuppressions) { + log.error( + "The --suppress-all option and the --prune-suppressions option cannot be used together.", + ); + return 2; + } + + if (options.suppressRule && options.pruneSuppressions) { + log.error( + "The --suppress-rule option and the --prune-suppressions option cannot be used together.", + ); + return 2; + } + + if ( + useStdin && + (options.suppressAll || + options.suppressRule || + options.pruneSuppressions) + ) { + log.error( + "The --suppress-all, --suppress-rule, and --prune-suppressions options cannot be used with piped-in code.", + ); + return 2; + } + + /** @type {ESLint} */ + let engine; + + if (options.concurrency !== "off") { + const optionsURL = createOptionsModule(options); + engine = await ESLint.fromOptionsModule(optionsURL); + } else { + const eslintOptions = await translateOptions(options); + engine = new ESLint(eslintOptions); + } + let results; + + if (useStdin) { + results = await engine.lintText(text, { + filePath: options.stdinFilename, + }); + } else { + results = await engine.lintFiles(files); + } + + if (options.fix) { + debug("Fix mode enabled - applying fixes"); + await ESLint.outputFixes(results); + } + + let unusedSuppressions = {}; + + if (!useStdin) { + const suppressionsFileLocation = getCacheFile( + options.suppressionsLocation || + SuppressionsService.DEFAULT_SUPPRESSIONS_FILENAME, + process.cwd(), + { + prefix: "suppressions_", + }, + ); + + if ( + options.suppressionsLocation && + !fs.existsSync(suppressionsFileLocation) && + !options.suppressAll && + !options.suppressRule + ) { + log.error( + "The suppressions file does not exist. Please run the command with `--suppress-all` or `--suppress-rule` to create it.", + ); + return 2; + } + + if ( + options.suppressAll || + options.suppressRule || + options.pruneSuppressions || + fs.existsSync(suppressionsFileLocation) + ) { + const suppressions = new SuppressionsService({ + filePath: suppressionsFileLocation, + cwd: process.cwd(), + }); + + if (options.suppressAll || options.suppressRule) { + await suppressions.suppress(results, options.suppressRule); + } + + if (options.pruneSuppressions) { + await suppressions.prune(results); + } + + const suppressionResults = suppressions.applySuppressions( + results, + await suppressions.load(), + ); + + results = suppressionResults.results; + unusedSuppressions = suppressionResults.unused; + } + } + + let resultsToPrint = results; + + if (options.quiet) { + debug("Quiet mode enabled - filtering out warnings"); + resultsToPrint = ESLint.getErrorResults(resultsToPrint); + } + + const resultCounts = countErrors(results); + const tooManyWarnings = + options.maxWarnings >= 0 && + resultCounts.warningCount > options.maxWarnings; + const resultsMeta = /** @type {ResultsMeta} */ ({}); + + /* + * `--color` was set, `options.color` is `true`. + * `--no-color` was set, `options.color` is `false`. + * Neither option was provided, `options.color` is omitted, so `undefined`. + */ + if (options.color !== void 0) { + debug("Color setting for output: %s", options.color); + resultsMeta.color = options.color; + } + + if (tooManyWarnings) { + resultsMeta.maxWarningsExceeded = { + maxWarnings: options.maxWarnings, + foundWarnings: resultCounts.warningCount, + }; + } + + if ( + await printResults( + engine, + resultsToPrint, + options.format, + options.outputFile, + resultsMeta, + ) + ) { + // Errors and warnings from the original unfiltered results should determine the exit code + const shouldExitForFatalErrors = + options.exitOnFatalError && resultCounts.fatalErrorCount > 0; + + if (!resultCounts.errorCount && tooManyWarnings) { + log.error( + "ESLint found too many warnings (maximum: %s).", + options.maxWarnings, + ); + } + + if (!options.passOnUnprunedSuppressions) { + const unusedSuppressionsCount = + Object.keys(unusedSuppressions).length; + + if (unusedSuppressionsCount > 0) { + log.error( + "There are suppressions left that do not occur anymore. To resolve this, re-run the command with `--prune-suppressions` to remove unused suppressions. To ignore unused suppressions, use `--pass-on-unpruned-suppressions`.", + ); + debug("%O", unusedSuppressions); + + return 2; + } + } + + if (shouldExitForFatalErrors) { + return 2; + } + + return resultCounts.errorCount || tooManyWarnings ? 1 : 0; + } + + return 2; + }, +}; + +module.exports = cli; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config-api.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config-api.js new file mode 100644 index 00000000..15762594 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config-api.js @@ -0,0 +1,18 @@ +/** + * @fileoverview exports for config helpers + * @author Nicholas C. Zakas + */ + +"use strict"; + +const { + defineConfig, + globalIgnores, + includeIgnoreFile, +} = require("@eslint/config-helpers"); + +module.exports = { + defineConfig, + globalIgnores, + includeIgnoreFile, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config-loader.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config-loader.js new file mode 100644 index 00000000..edf9c611 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config-loader.js @@ -0,0 +1,678 @@ +/** + * @fileoverview Utility to load config files + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const path = require("node:path"); +const fs = require("node:fs/promises"); +const findUp = require("find-up"); +const { pathToFileURL } = require("node:url"); +const debug = require("debug")("eslint:config-loader"); +const { FlatConfigArray } = require("./flat-config-array"); +const { WarningService } = require("../services/warning-service"); + +//----------------------------------------------------------------------------- +// Types +//----------------------------------------------------------------------------- + +/** @typedef {import("../types").Linter.Config} Config */ + +/** + * @typedef {Object} ConfigLoaderOptions + * @property {string|false|undefined} configFile The path to the config file to use. + * @property {string} cwd The current working directory. + * @property {boolean} ignoreEnabled Indicates if ignore patterns should be honored. + * @property {Config|Array} [baseConfig] The base config to use. + * @property {Array} [defaultConfigs] The default configs to use. + * @property {Array} [ignorePatterns] The ignore patterns to use. + * @property {Config|Array} [overrideConfig] The override config to use. + * @property {boolean} [hasUnstableNativeNodeJsTSConfigFlag] The flag to indicate whether the `unstable_native_nodejs_ts_config` flag is enabled. + * @property {WarningService} [warningService] The warning service to use. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const FLAT_CONFIG_FILENAMES = [ + "eslint.config.js", + "eslint.config.mjs", + "eslint.config.cjs", + "eslint.config.ts", + "eslint.config.mts", + "eslint.config.cts", +]; + +const importedConfigFileModificationTime = new Map(); + +/** + * Asserts that the given file path is valid. + * @param {string} filePath The file path to check. + * @returns {void} + * @throws {Error} If `filePath` is not a non-empty string. + */ +function assertValidFilePath(filePath) { + if (!filePath || typeof filePath !== "string") { + throw new Error("'filePath' must be a non-empty string"); + } +} + +/** + * Asserts that a configuration exists. A configuration exists if any + * of the following are true: + * - `configFilePath` is defined. + * - `useConfigFile` is `false`. + * @param {string|undefined} configFilePath The path to the config file. + * @param {ConfigLoaderOptions} loaderOptions The options to use when loading configuration files. + * @returns {void} + * @throws {Error} If no configuration exists. + */ +function assertConfigurationExists(configFilePath, loaderOptions) { + const { configFile: useConfigFile } = loaderOptions; + + if (!configFilePath && useConfigFile !== false) { + const error = new Error("Could not find config file."); + + error.messageTemplate = "config-file-missing"; + throw error; + } +} + +/** + * Check if the file is a TypeScript file. + * @param {string} filePath The file path to check. + * @returns {boolean} `true` if the file is a TypeScript file, `false` if it's not. + */ +function isFileTS(filePath) { + const fileExtension = path.extname(filePath); + + return /^\.[mc]?ts$/u.test(fileExtension); +} + +/** + * Check if ESLint is running in Bun. + * @returns {boolean} `true` if the ESLint is running Bun, `false` if it's not. + */ +function isRunningInBun() { + return !!globalThis.Bun; +} + +/** + * Check if ESLint is running in Deno. + * @returns {boolean} `true` if the ESLint is running in Deno, `false` if it's not. + */ +function isRunningInDeno() { + return !!globalThis.Deno; +} + +/** + * Checks if native TypeScript support is + * enabled in the current Node.js process. + * + * This function determines if the + * {@linkcode NodeJS.ProcessFeatures.typescript | typescript} + * feature is present in the + * {@linkcode process.features} object + * and if its value is either "strip" or "transform". + * @returns {boolean} `true` if native TypeScript support is enabled, otherwise `false`. + * @since 9.24.0 + */ +function isNativeTypeScriptSupportEnabled() { + return ( + // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it's still an experimental feature. + ["strip", "transform"].includes(process.features.typescript) + ); +} + +/** + * Load the TypeScript configuration file. + * @param {string} filePath The absolute file path to load. + * @param {URL} fileURL The file URL to load. + * @param {number} mtime The last modified timestamp of the file. + * @returns {Promise} The configuration loaded from the file. + * @since 9.24.0 + */ +async function loadTypeScriptConfigFileWithJiti(filePath, fileURL, mtime) { + const { createJiti, version: jitiVersion } = + // eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing + await ConfigLoader.loadJiti().catch(() => { + throw new Error( + "The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.", + ); + }); + + // Ensure the version is at least 2.2.0. + const [jitiMajor, jitiMinor] = jitiVersion + .split(".") + .map(versionPart => Number(versionPart)); + if (jitiMajor < 2 || (jitiMajor === 2 && jitiMinor < 2)) { + throw new Error( + "You are using an outdated version of the 'jiti' library. Please update to the latest version of 'jiti' to ensure compatibility and access to the latest features.", + ); + } + + /* + * Disabling `moduleCache` allows us to reload a + * config file when the last modified timestamp changes. + */ + const jitiOptions = { + moduleCache: false, + }; + + const jiti = createJiti(__filename, jitiOptions); + const config = await jiti.import(fileURL.href); + + importedConfigFileModificationTime.set(filePath, mtime); + + return config?.default ?? config; +} + +/** + * Dynamically imports a module from the given file path. + * @param {string} filePath The absolute file path of the module to import. + * @param {URL} fileURL The file URL to load. + * @param {number} mtime The last modified timestamp of the file. + * @returns {Promise} - A {@linkcode Promise | promise} that resolves to the imported ESLint config. + * @since 9.24.0 + */ +async function dynamicImportConfig(filePath, fileURL, mtime) { + const module = await import(fileURL.href); + + importedConfigFileModificationTime.set(filePath, mtime); + + return module.default; +} + +/** + * Load the config array from the given filename. + * @param {string} filePath The filename to load from. + * @param {boolean} hasUnstableNativeNodeJsTSConfigFlag The flag to indicate whether the `unstable_native_nodejs_ts_config` flag is enabled. + * @returns {Promise} The config loaded from the config file. + */ +async function loadConfigFile(filePath, hasUnstableNativeNodeJsTSConfigFlag) { + debug("Loading config from %s", filePath); + + const fileURL = pathToFileURL(filePath); + + debug("Config file URL is %s", fileURL); + + const mtime = (await fs.stat(filePath)).mtime.getTime(); + + /* + * Append a query with the config file's modification time (`mtime`) in order + * to import the current version of the config file. Without the query, `import()` would + * cache the config file module by the pathname only, and then always return + * the same version (the one that was actual when the module was imported for the first time). + * + * This ensures that the config file module is loaded and executed again + * if it has been changed since the last time it was imported. + * If it hasn't been changed, `import()` will just return the cached version. + * + * Note that we should not overuse queries (e.g., by appending the current time + * to always reload the config file module) as that could cause memory leaks + * because entries are never removed from the import cache. + */ + fileURL.searchParams.append("mtime", mtime); + + /* + * With queries, we can bypass the import cache. However, when import-ing a CJS module, + * Node.js uses the require infrastructure under the hood. That includes the require cache, + * which caches the config file module by its file path (queries have no effect). + * Therefore, we also need to clear the require cache before importing the config file module. + * In order to get the same behavior with ESM and CJS config files, in particular - to reload + * the config file only if it has been changed, we track file modification times and clear + * the require cache only if the file has been changed. + */ + if (importedConfigFileModificationTime.get(filePath) !== mtime) { + delete require.cache?.[filePath]; + } + + const isTS = isFileTS(filePath); + const isBun = isRunningInBun(); + const isDeno = isRunningInDeno(); + + /* + * If we are dealing with a TypeScript file, then we need to use `jiti` to load it + * in Node.js. Deno and Bun both allow native importing of TypeScript files. + * + * When Node.js supports native TypeScript imports, we can remove this check. + */ + + if (isTS) { + if (hasUnstableNativeNodeJsTSConfigFlag) { + if (isNativeTypeScriptSupportEnabled()) { + return await dynamicImportConfig(filePath, fileURL, mtime); + } + + if (!("typescript" in process.features)) { + throw new Error( + "The unstable_native_nodejs_ts_config flag is not supported in older versions of Node.js.", + ); + } + + throw new Error( + "The unstable_native_nodejs_ts_config flag is enabled, but native TypeScript support is not enabled in the current Node.js process. You need to either enable native TypeScript support by passing --experimental-strip-types or remove the unstable_native_nodejs_ts_config flag.", + ); + } + + if (!isDeno && !isBun) { + return await loadTypeScriptConfigFileWithJiti( + filePath, + fileURL, + mtime, + ); + } + } + + // fallback to normal runtime behavior + + return await dynamicImportConfig(filePath, fileURL, mtime); +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * Encapsulates the loading and caching of configuration files when looking up + * from the file being linted. + */ +class ConfigLoader { + /** + * Map of config file paths to the config arrays for those directories. + * @type {Map>} + */ + #configArrays = new Map(); + + /** + * Map of absolute directory names to the config file paths for those directories. + * @type {Map>} + */ + #configFilePaths = new Map(); + + /** + * The options to use when loading configuration files. + * @type {ConfigLoaderOptions} + */ + #options; + + /** + * Creates a new instance. + * @param {ConfigLoaderOptions} options The options to use when loading configuration files. + */ + constructor(options) { + this.#options = options.warningService + ? options + : { ...options, warningService: new WarningService() }; + } + + /** + * Determines which config file to use. This is determined by seeing if an + * override config file was specified, and if so, using it; otherwise, as long + * as override config file is not explicitly set to `false`, it will search + * upwards from `fromDirectory` for an `eslint.config.*` file. + * @param {string} fromDirectory The directory from which to start searching. + * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for + * the config file. + */ + async #locateConfigFileToUse(fromDirectory) { + // check cache first + if (this.#configFilePaths.has(fromDirectory)) { + return this.#configFilePaths.get(fromDirectory); + } + + const resultPromise = ConfigLoader.locateConfigFileToUse({ + useConfigFile: this.#options.configFile, + cwd: this.#options.cwd, + fromDirectory, + }); + + // ensure `ConfigLoader.locateConfigFileToUse` is called only once for `fromDirectory` + this.#configFilePaths.set(fromDirectory, resultPromise); + + // Unwrap the promise. This is primarily for the sync `getCachedConfigArrayForPath` method. + const result = await resultPromise; + + this.#configFilePaths.set(fromDirectory, result); + + return result; + } + + /** + * Calculates the config array for this run based on inputs. + * @param {string} configFilePath The absolute path to the config file to use if not overridden. + * @param {string} basePath The base path to use for relative paths in the config file. + * @returns {Promise} The config array for `eslint`. + */ + async #calculateConfigArray(configFilePath, basePath) { + // check for cached version first + if (this.#configArrays.has(configFilePath)) { + return this.#configArrays.get(configFilePath); + } + + const configsPromise = ConfigLoader.calculateConfigArray( + configFilePath, + basePath, + this.#options, + ); + + // ensure `ConfigLoader.calculateConfigArray` is called only once for `configFilePath` + this.#configArrays.set(configFilePath, configsPromise); + + // Unwrap the promise. This is primarily for the sync `getCachedConfigArrayForPath` method. + const configs = await configsPromise; + + this.#configArrays.set(configFilePath, configs); + + return configs; + } + + /** + * Returns the config file path for the given directory or file. This will either use + * the override config file that was specified in the constructor options or + * search for a config file from the directory. + * @param {string} fileOrDirPath The file or directory path to get the config file path for. + * @returns {Promise} The config file path or `undefined` if not found. + * @throws {Error} If `fileOrDirPath` is not a non-empty string. + * @throws {Error} If `fileOrDirPath` is not an absolute path. + */ + async findConfigFileForPath(fileOrDirPath) { + assertValidFilePath(fileOrDirPath); + + const absoluteDirPath = path.resolve( + this.#options.cwd, + path.dirname(fileOrDirPath), + ); + const { configFilePath } = + await this.#locateConfigFileToUse(absoluteDirPath); + + return configFilePath; + } + + /** + * Returns a configuration object for the given file based on the CLI options. + * This is the same logic used by the ESLint CLI executable to determine + * configuration for each file it processes. + * @param {string} filePath The path of the file or directory to retrieve config for. + * @returns {Promise} A configuration object for the file. + * @throws {Error} If no configuration for `filePath` exists. + */ + async loadConfigArrayForFile(filePath) { + assertValidFilePath(filePath); + + debug("Calculating config for file %s", filePath); + + const configFilePath = await this.findConfigFileForPath(filePath); + + assertConfigurationExists(configFilePath, this.#options); + + return this.loadConfigArrayForDirectory(filePath); + } + + /** + * Returns a configuration object for the given directory based on the CLI options. + * This is the same logic used by the ESLint CLI executable to determine + * configuration for each file it processes. + * @param {string} dirPath The path of the directory to retrieve config for. + * @returns {Promise} A configuration object for the directory. + */ + async loadConfigArrayForDirectory(dirPath) { + assertValidFilePath(dirPath); + + debug("Calculating config for directory %s", dirPath); + + const absoluteDirPath = path.resolve( + this.#options.cwd, + path.dirname(dirPath), + ); + const { configFilePath, basePath } = + await this.#locateConfigFileToUse(absoluteDirPath); + + debug( + "Using config file %s and base path %s", + configFilePath, + basePath, + ); + return this.#calculateConfigArray(configFilePath, basePath); + } + + /** + * Returns a configuration array for the given file based on the CLI options. + * This is a synchronous operation and does not read any files from disk. It's + * intended to be used in locations where we know the config file has already + * been loaded and we just need to get the configuration for a file. + * @param {string} filePath The path of the file to retrieve a config object for. + * @returns {FlatConfigArray} A configuration object for the file. + * @throws {Error} If `filePath` is not a non-empty string. + * @throws {Error} If `filePath` is not an absolute path. + * @throws {Error} If the config file was not already loaded. + */ + getCachedConfigArrayForFile(filePath) { + assertValidFilePath(filePath); + + debug("Looking up cached config for %s", filePath); + + return this.getCachedConfigArrayForPath(path.dirname(filePath)); + } + + /** + * Returns a configuration array for the given directory based on the CLI options. + * This is a synchronous operation and does not read any files from disk. It's + * intended to be used in locations where we know the config file has already + * been loaded and we just need to get the configuration for a file. + * @param {string} fileOrDirPath The path of the directory to retrieve a config object for. + * @returns {FlatConfigArray} A configuration object for the directory. + * @throws {Error} If `dirPath` is not a non-empty string. + * @throws {Error} If `dirPath` is not an absolute path. + * @throws {Error} If the config file was not already loaded. + */ + getCachedConfigArrayForPath(fileOrDirPath) { + assertValidFilePath(fileOrDirPath); + + debug("Looking up cached config for %s", fileOrDirPath); + + const absoluteDirPath = path.resolve(this.#options.cwd, fileOrDirPath); + + if (!this.#configFilePaths.has(absoluteDirPath)) { + throw new Error(`Could not find config file for ${fileOrDirPath}`); + } + + const configFilePathInfo = this.#configFilePaths.get(absoluteDirPath); + + if (typeof configFilePathInfo.then === "function") { + throw new Error( + `Config file path for ${fileOrDirPath} has not yet been calculated or an error occurred during the calculation`, + ); + } + + const { configFilePath } = configFilePathInfo; + + const configArray = this.#configArrays.get(configFilePath); + + if (!configArray || typeof configArray.then === "function") { + throw new Error( + `Config array for ${fileOrDirPath} has not yet been calculated or an error occurred during the calculation`, + ); + } + + return configArray; + } + + /** + * Used to import the jiti dependency. This method is exposed internally for testing purposes. + * @returns {Promise<{createJiti: Function|undefined, version: string;}>} A promise that fulfills with an object containing the jiti module's createJiti function and version. + */ + static async loadJiti() { + const { createJiti } = await import("jiti"); + const version = require("jiti/package.json").version; + return { createJiti, version }; + } + + /** + * Determines which config file to use. This is determined by seeing if an + * override config file was specified, and if so, using it; otherwise, as long + * as override config file is not explicitly set to `false`, it will search + * upwards from `fromDirectory` for an `eslint.config.*` file. + * This method is exposed internally for testing purposes. + * @param {Object} [options] the options object + * @param {string|false|undefined} options.useConfigFile The path to the config file to use. + * @param {string} options.cwd Path to a directory that should be considered as the current working directory. + * @param {string} [options.fromDirectory] The directory from which to start searching. Defaults to `cwd`. + * @returns {Promise<{configFilePath:string|undefined,basePath:string}>} Location information for + * the config file. + */ + static async locateConfigFileToUse({ + useConfigFile, + cwd, + fromDirectory = cwd, + }) { + // determine where to load config file from + let configFilePath; + let basePath = cwd; + + if (typeof useConfigFile === "string") { + debug("Override config file path is %s", useConfigFile); + configFilePath = path.resolve(cwd, useConfigFile); + basePath = cwd; + } else if (useConfigFile !== false) { + debug("Searching for eslint.config.js"); + configFilePath = await findUp(FLAT_CONFIG_FILENAMES, { + cwd: fromDirectory, + }); + + if (configFilePath) { + basePath = path.dirname(configFilePath); + } + } + + return { + configFilePath, + basePath, + }; + } + + /** + * Calculates the config array for this run based on inputs. + * This method is exposed internally for testing purposes. + * @param {string} configFilePath The absolute path to the config file to use if not overridden. + * @param {string} basePath The base path to use for relative paths in the config file. + * @param {ConfigLoaderOptions} options The options to use when loading configuration files. + * @returns {Promise} The config array for `eslint`. + */ + static async calculateConfigArray(configFilePath, basePath, options) { + const { + cwd, + baseConfig, + ignoreEnabled, + ignorePatterns, + overrideConfig, + hasUnstableNativeNodeJsTSConfigFlag = false, + defaultConfigs = [], + warningService, + } = options; + + debug( + "Calculating config array from config file %s and base path %s", + configFilePath, + basePath, + ); + + const configs = new FlatConfigArray(baseConfig || [], { + basePath, + shouldIgnore: ignoreEnabled, + }); + + // load config file + if (configFilePath) { + debug("Loading config file %s", configFilePath); + const fileConfig = await loadConfigFile( + configFilePath, + hasUnstableNativeNodeJsTSConfigFlag, + ); + + /* + * It's possible that a config file could be empty or else + * have an empty object or array. In this case, we want to + * warn the user that they have an empty config. + * + * An empty CommonJS file exports an empty object while + * an empty ESM file exports undefined. + */ + + let emptyConfig = typeof fileConfig === "undefined"; + + debug( + "Config file %s is %s", + configFilePath, + emptyConfig ? "empty" : "not empty", + ); + + if (!emptyConfig) { + if (Array.isArray(fileConfig)) { + if (fileConfig.length === 0) { + debug( + "Config file %s is an empty array", + configFilePath, + ); + emptyConfig = true; + } else { + configs.push(...fileConfig); + } + } else { + if ( + typeof fileConfig === "object" && + fileConfig !== null && + Object.keys(fileConfig).length === 0 + ) { + debug( + "Config file %s is an empty object", + configFilePath, + ); + emptyConfig = true; + } else { + configs.push(fileConfig); + } + } + } + + if (emptyConfig) { + warningService.emitEmptyConfigWarning(configFilePath); + } + } + + // add in any configured defaults + configs.push(...defaultConfigs); + + // append command line ignore patterns + if (ignorePatterns && ignorePatterns.length > 0) { + /* + * Ignore patterns are added to the end of the config array + * so they can override default ignores. + */ + configs.push({ + basePath: cwd, + ignores: ignorePatterns, + }); + } + + if (overrideConfig) { + if (Array.isArray(overrideConfig)) { + configs.push(...overrideConfig); + } else { + configs.push(overrideConfig); + } + } + + await configs.normalize(); + + return configs; + } +} + +module.exports = { ConfigLoader }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config.js new file mode 100644 index 00000000..723fe30a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/config.js @@ -0,0 +1,837 @@ +/** + * @fileoverview The `Config` class + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { deepMergeArrays } = require("../shared/deep-merge-arrays"); +const { flatConfigSchema, hasMethod } = require("./flat-config-schema"); +const { ObjectSchema } = require("@eslint/config-array"); +const ruleReplacements = require("../../conf/replacements.json"); + +//----------------------------------------------------------------------------- +// Typedefs +//----------------------------------------------------------------------------- + +/** + * @import { RuleDefinition } from "@eslint/core"; + * @import { Linter } from "eslint"; + */ + +//----------------------------------------------------------------------------- +// Private Members +//------------------------------------------------------------------------------ + +// JSON schema that disallows passing any options +const noOptionsSchema = Object.freeze({ + type: "array", + minItems: 0, + maxItems: 0, +}); + +const severities = new Map([ + [0, 0], + [1, 1], + [2, 2], + ["off", 0], + ["warn", 1], + ["error", 2], +]); + +/** + * A collection of compiled validators for rules that have already + * been validated. + * @type {WeakMap} + */ +const validators = new WeakMap(); + +/** + * The shared ajv instance, constructed on first use. + * + * `ajv` pulls in a large dependency graph (~40 modules) that's only needed + * once a rule's options actually need schema validation, so it's constructed + * lazily instead of eagerly at module load time. + * @type {import("ajv").Ajv|undefined} + */ +let ajv; + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +/** + * Gets the shared ajv instance, constructing it on first use. + * @returns {import("ajv").Ajv} The ajv instance. + */ +function getAjv() { + if (!ajv) { + ajv = require("../shared/ajv")(); + } + return ajv; +} + +/** + * Throws a helpful error when a rule cannot be found. + * @param {Object} ruleId The rule identifier. + * @param {string} ruleId.pluginName The ID of the rule to find. + * @param {string} ruleId.ruleName The ID of the rule to find. + * @param {Object} config The config to search in. + * @throws {TypeError} For missing plugin or rule. + * @returns {void} + */ +function throwRuleNotFoundError({ pluginName, ruleName }, config) { + const ruleId = pluginName === "@" ? ruleName : `${pluginName}/${ruleName}`; + + const errorMessageHeader = `Key "rules": Key "${ruleId}"`; + + let errorMessage = `${errorMessageHeader}: Could not find plugin "${pluginName}" in configuration.`; + + const missingPluginErrorMessage = errorMessage; + + // if the plugin exists then we need to check if the rule exists + if (config.plugins && config.plugins[pluginName]) { + const replacementRuleName = ruleReplacements.rules[ruleName]; + + if (pluginName === "@" && replacementRuleName) { + errorMessage = `${errorMessageHeader}: Rule "${ruleName}" was removed and replaced by "${replacementRuleName}".`; + } else { + errorMessage = `${errorMessageHeader}: Could not find "${ruleName}" in plugin "${pluginName}".`; + + // otherwise, let's see if we can find the rule name elsewhere + for (const [otherPluginName, otherPlugin] of Object.entries( + config.plugins, + )) { + if (otherPlugin.rules && otherPlugin.rules[ruleName]) { + errorMessage += ` Did you mean "${otherPluginName}/${ruleName}"?`; + break; + } + } + } + + // falls through to throw error + } + + const error = new TypeError(errorMessage); + + if (errorMessage === missingPluginErrorMessage) { + error.messageTemplate = "config-plugin-missing"; + error.messageData = { pluginName, ruleId }; + } + + throw error; +} + +/** + * The error type when a rule has an invalid `meta.schema`. + */ +class InvalidRuleOptionsSchemaError extends Error { + /** + * Creates a new instance. + * @param {string} ruleId Id of the rule that has an invalid `meta.schema`. + * @param {Error} processingError Error caught while processing the `meta.schema`. + */ + constructor(ruleId, processingError) { + super( + `Error while processing options validation schema of rule '${ruleId}': ${processingError.message}`, + { cause: processingError }, + ); + this.code = "ESLINT_INVALID_RULE_OPTIONS_SCHEMA"; + } +} + +/** + * Parses a ruleId into its plugin and rule parts. + * @param {string} ruleId The rule ID to parse. + * @returns {{pluginName:string,ruleName:string}} The plugin and rule + * parts of the ruleId; + */ +function parseRuleId(ruleId) { + let pluginName, ruleName; + + // distinguish between core rules and plugin rules + if (ruleId.includes("/")) { + // mimic scoped npm packages + if (ruleId.startsWith("@")) { + pluginName = ruleId.slice(0, ruleId.lastIndexOf("/")); + } else { + pluginName = ruleId.slice(0, ruleId.indexOf("/")); + } + + ruleName = ruleId.slice(pluginName.length + 1); + } else { + pluginName = "@"; + ruleName = ruleId; + } + + return { + pluginName, + ruleName, + }; +} + +/** + * Retrieves a rule instance from a given config based on the ruleId. + * @param {string} ruleId The rule ID to look for. + * @param {Linter.Config} config The config to search. + * @returns {RuleDefinition|undefined} The rule if found + * or undefined if not. + */ +function getRuleFromConfig(ruleId, config) { + const { pluginName, ruleName } = parseRuleId(ruleId); + + return config.plugins?.[pluginName]?.rules?.[ruleName]; +} + +/** + * Gets a complete options schema for a rule. + * @param {RuleDefinition} rule A rule object + * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`. + * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`. + */ +function getRuleOptionsSchema(rule) { + if (!rule.meta) { + return { ...noOptionsSchema }; // default if `meta.schema` is not specified + } + + const schema = rule.meta.schema; + + if (typeof schema === "undefined") { + return { ...noOptionsSchema }; // default if `meta.schema` is not specified + } + + // `schema:false` is an allowed explicit opt-out of options validation for the rule + if (schema === false) { + return null; + } + + if (typeof schema !== "object" || schema === null) { + throw new TypeError("Rule's `meta.schema` must be an array or object"); + } + + // ESLint-specific array form needs to be converted into a valid JSON Schema definition + if (Array.isArray(schema)) { + if (schema.length) { + return { + type: "array", + items: schema, + minItems: 0, + maxItems: schema.length, + }; + } + + // `schema:[]` is an explicit way to specify that the rule does not accept any options + return { ...noOptionsSchema }; + } + + // `schema:` is assumed to be a valid JSON Schema definition + return schema; +} + +/** + * Splits a plugin identifier in the form a/b/c into two parts: a/b and c. + * @param {string} identifier The identifier to parse. + * @returns {{objectName: string, pluginName: string}} The parts of the plugin + * name. + */ +function splitPluginIdentifier(identifier) { + const parts = identifier.split("/"); + + return { + objectName: parts.pop(), + pluginName: parts.join("/"), + }; +} + +/** + * Normalizes a language name by replacing the built-in `@/` plugin prefix with `js/`. + * @param {string} languageName The language name to normalize. + * @returns {string} The normalized language name. + */ +function normalizeLanguageName(languageName) { + return languageName.startsWith("@/") + ? `js/${languageName.slice(2)}` + : languageName; +} + +/** + * Checks if a rule's `meta.languages` supports the given language. + * @param {Array|undefined} ruleLangs The rule's `meta.languages` array. + * @param {string} configLanguageName The normalized language name from the config (e.g., "js/js"). + * @param {Array} validPluginNames The valid plugin name aliases for the config's plugin + * (normalized plugin name plus its `meta.namespace` if defined). + * @returns {boolean} `true` if the rule supports the language, `false` otherwise. + */ +function doesRuleSupportLanguage( + ruleLangs, + configLanguageName, + validPluginNames, +) { + // If no languages specified, works with all languages (backward compatible) + if (!ruleLangs) { + return true; + } + + const { objectName: configLangPart } = + splitPluginIdentifier(configLanguageName); + + for (const langEntry of ruleLangs) { + // Skip non-string entries + if (typeof langEntry !== "string") { + continue; + } + + // "*" matches any language + if (langEntry === "*") { + return true; + } + + // Direct match + if (langEntry === configLanguageName) { + return true; + } + + const { pluginName: rulePluginPart, objectName: ruleLangPart } = + splitPluginIdentifier(langEntry); + + // "plugin/*" wildcard - matches any language from that plugin (by name or namespace) + if (ruleLangPart === "*") { + if (validPluginNames.includes(rulePluginPart)) { + return true; + } + } else { + // Match by plugin name or namespace, with exact language part + if ( + validPluginNames.includes(rulePluginPart) && + ruleLangPart === configLangPart + ) { + return true; + } + } + } + + return false; +} + +/** + * Returns the name of an object in the config by reading its `meta` key. + * @param {Object} object The object to check. + * @returns {string?} The name of the object if found or `null` if there + * is no name. + */ +function getObjectId(object) { + // first check old-style name + let name = object.name; + + if (!name) { + if (!object.meta) { + return null; + } + + name = object.meta.name; + + if (!name) { + return null; + } + } + + // now check for old-style version + let version = object.version; + + if (!version) { + version = object.meta && object.meta.version; + } + + // if there's a version then append that + if (version) { + return `${name}@${version}`; + } + + return name; +} + +/** + * Asserts that a value is not a function. + * @param {any} value The value to check. + * @param {string} key The key of the value in the object. + * @param {string} objectKey The key of the object being checked. + * @returns {void} + * @throws {TypeError} If the value is a function. + */ +function assertNotFunction(value, key, objectKey) { + if (typeof value === "function") { + const error = new TypeError( + `Cannot serialize key "${key}" in "${objectKey}": Function values are not supported.`, + ); + + error.messageTemplate = "config-serialize-function"; + error.messageData = { key, objectKey }; + + throw error; + } +} + +/** + * Converts a languageOptions object to a JSON representation. + * @param {Record} languageOptions The options to create a JSON + * representation of. + * @param {string} objectKey The key of the object being converted. + * @returns {Record} The JSON representation of the languageOptions. + * @throws {TypeError} If a function is found in the languageOptions. + */ +function languageOptionsToJSON(languageOptions, objectKey = "languageOptions") { + if (typeof languageOptions.toJSON === "function") { + const result = languageOptions.toJSON(); + + assertNotFunction(result, "toJSON", objectKey); + + return result; + } + + const result = {}; + + for (const [key, value] of Object.entries(languageOptions)) { + if (value) { + if (typeof value === "object") { + const name = getObjectId(value); + + if (typeof value.toJSON === "function") { + result[key] = value.toJSON(); + assertNotFunction(result[key], key, objectKey); + } else if (name && hasMethod(value)) { + result[key] = name; + } else { + result[key] = languageOptionsToJSON(value, key); + } + continue; + } + + assertNotFunction(value, key, objectKey); + } + + result[key] = value; + } + + return result; +} + +/** + * Gets or creates a validator for a rule. + * @param {Object} rule The rule to get a validator for. + * @param {string} ruleId The ID of the rule (for error reporting). + * @returns {Function|null} A validation function or `null` if no validation is needed. + * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid. + */ +function getOrCreateValidator(rule, ruleId) { + if (!validators.has(rule)) { + try { + const schema = getRuleOptionsSchema(rule); + + if (schema) { + validators.set(rule, getAjv().compile(schema)); + } + } catch (err) { + throw new InvalidRuleOptionsSchemaError(ruleId, err); + } + } + + return validators.get(rule); +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * Represents a normalized configuration object. + */ +class Config { + /** + * The name to use for the language when serializing to JSON. + * @type {string|undefined} + */ + #languageName; + + /** + * The name to use for the processor when serializing to JSON. + * @type {string|undefined} + */ + #processorName; + + /** + * Cache of rule definitions by rule ID. Rule lookups involve string + * parsing and multiple property accesses, so the results are cached + * because they're requested repeatedly for the same rule IDs. + * @type {Map} + */ + #ruleDefinitions = new Map(); + + /** + * Creates a new instance. + * @param {Object} config The configuration object. + */ + constructor(config) { + const { plugins, language, languageOptions, processor, ...otherKeys } = + config; + + // Validate config object + const schema = new ObjectSchema(flatConfigSchema); + + schema.validate(config); + + // first, copy all the other keys over + Object.assign(this, otherKeys); + + // ensure that a language is specified + if (!language) { + throw new TypeError("Key 'language' is required."); + } + + // copy the rest over + this.plugins = plugins; + this.language = language; + + // Check language value + const { + pluginName: languagePluginName, + objectName: localLanguageName, + } = splitPluginIdentifier(language); + + this.#languageName = language; + + if ( + !plugins || + !plugins[languagePluginName] || + !plugins[languagePluginName].languages || + !plugins[languagePluginName].languages[localLanguageName] + ) { + throw new TypeError( + `Key "language": Could not find "${localLanguageName}" in plugin "${languagePluginName}".`, + ); + } + + this.language = + plugins[languagePluginName].languages[localLanguageName]; + + if (this.language.defaultLanguageOptions ?? languageOptions) { + this.languageOptions = flatConfigSchema.languageOptions.merge( + this.language.defaultLanguageOptions, + languageOptions, + ); + } else { + this.languageOptions = {}; + } + + // Validate language options + try { + this.language.validateLanguageOptions(this.languageOptions); + } catch (error) { + throw new TypeError(`Key "languageOptions": ${error.message}`, { + cause: error, + }); + } + + // Normalize language options if necessary + if (this.language.normalizeLanguageOptions) { + this.languageOptions = this.language.normalizeLanguageOptions( + this.languageOptions, + ); + } + + // Check processor value + if (processor) { + this.processor = processor; + + if (typeof processor === "string") { + const { pluginName, objectName: localProcessorName } = + splitPluginIdentifier(processor); + + this.#processorName = processor; + + if ( + !plugins || + !plugins[pluginName] || + !plugins[pluginName].processors || + !plugins[pluginName].processors[localProcessorName] + ) { + throw new TypeError( + `Key "processor": Could not find "${localProcessorName}" in plugin "${pluginName}".`, + ); + } + + this.processor = + plugins[pluginName].processors[localProcessorName]; + } else if (typeof processor === "object") { + this.#processorName = getObjectId(processor); + this.processor = processor; + } else { + throw new TypeError( + "Key 'processor' must be a string or an object.", + ); + } + } + + // Process the rules + if (this.rules) { + this.#normalizeRulesConfig(); + this.validateRulesConfig(this.rules); + } + } + + /** + * Converts the configuration to a JSON representation. + * @returns {Record} The JSON representation of the configuration. + * @throws {Error} If the configuration cannot be serialized. + */ + toJSON() { + if (this.processor && !this.#processorName) { + throw new Error( + "Could not serialize processor object (missing 'meta' object).", + ); + } + + if (!this.#languageName) { + throw new Error( + "Could not serialize language object (missing 'meta' object).", + ); + } + + return { + ...this, + plugins: Object.entries(this.plugins).map(([namespace, plugin]) => { + const pluginId = getObjectId(plugin); + + if (!pluginId) { + return namespace; + } + + return `${namespace}:${pluginId}`; + }), + language: this.#languageName, + languageOptions: languageOptionsToJSON(this.languageOptions), + processor: this.#processorName, + }; + } + + /** + * Gets a rule configuration by its ID. + * @param {string} ruleId The ID of the rule to get. + * @returns {RuleDefinition|undefined} The rule definition from the plugin, or `undefined` if the rule is not found. + */ + getRuleDefinition(ruleId) { + if (this.#ruleDefinitions.has(ruleId)) { + return this.#ruleDefinitions.get(ruleId); + } + + const rule = getRuleFromConfig(ruleId, this); + + this.#ruleDefinitions.set(ruleId, rule); + return rule; + } + + /** + * Normalizes the rules configuration. Ensures that each rule config is + * an array and that the severity is a number. Applies meta.defaultOptions. + * This function modifies `this.rules`. + * @returns {void} + */ + #normalizeRulesConfig() { + for (const [ruleId, originalConfig] of Object.entries(this.rules)) { + // ensure rule config is an array + let ruleConfig = Array.isArray(originalConfig) + ? originalConfig + : [originalConfig]; + + // normalize severity + ruleConfig[0] = severities.get(ruleConfig[0]); + + const rule = this.getRuleDefinition(ruleId); + + // apply meta.defaultOptions + const slicedOptions = ruleConfig.slice(1); + const mergedOptions = deepMergeArrays( + rule?.meta?.defaultOptions, + slicedOptions, + ); + + if (mergedOptions.length) { + ruleConfig = [ruleConfig[0], ...mergedOptions]; + } + + this.rules[ruleId] = ruleConfig; + } + } + + /** + * Validates all of the rule configurations in the given rules config + * against the plugins in this instance. This is used primarily to + * validate inline configuration rules while inting. + * @param {Object} rulesConfig The rules config to validate. + * @returns {void} + * @throws {Error} If a rule's configuration does not match its schema. + * @throws {TypeError} If the rulesConfig is not provided or is invalid. + * @throws {InvalidRuleOptionsSchemaError} If a rule's `meta.schema` is invalid. + * @throws {TypeError} If a rule is not found in the plugins. + * @throws {TypeError} If a rule does not support the current language. + */ + validateRulesConfig(rulesConfig) { + if (!rulesConfig) { + throw new TypeError("Config is required for validation."); + } + + // Normalize "@/" prefix to "js/" for matching and user-facing messages + const normalizedLanguageName = normalizeLanguageName( + this.#languageName, + ); + + // Compute valid plugin name aliases for the config's language plugin once + const { pluginName: configPluginName } = splitPluginIdentifier( + normalizedLanguageName, + ); + const configPlugin = + this.plugins[configPluginName] ?? + (configPluginName === "js" ? this.plugins["@"] : void 0); + const validPluginNames = configPlugin?.meta?.namespace + ? [configPluginName, configPlugin.meta.namespace] + : [configPluginName]; + const unsupportedLanguageRules = []; + + for (const [ruleId, ruleOptions] of Object.entries(rulesConfig)) { + // check for edge case + if (ruleId === "__proto__") { + continue; + } + + /* + * If a rule is disabled, we don't do any validation. This allows + * users to safely set any value to 0 or "off" without worrying + * that it will cause a validation error. + * + * Note: ruleOptions is always an array at this point because + * this validation occurs after FlatConfigArray has merged and + * normalized values. + */ + if (ruleOptions[0] === 0) { + continue; + } + + const rule = this.getRuleDefinition(ruleId); + + if (!rule) { + throwRuleNotFoundError(parseRuleId(ruleId), this); + } + + // Validate meta.languages structure if present (only for enabled rules) + if (rule.meta?.languages !== void 0) { + if (!Array.isArray(rule.meta.languages)) { + throw new TypeError( + `Key "rules": Key "${ruleId}": Key "meta": Key "languages": Expected an array.`, + ); + } + + for (const lang of rule.meta.languages) { + if (typeof lang !== "string") { + throw new TypeError( + `Key "rules": Key "${ruleId}": Key "meta": Key "languages": Expected each element to be a string.`, + ); + } + } + } + + // Check if the rule supports the current language + if ( + !doesRuleSupportLanguage( + rule.meta?.languages, + normalizedLanguageName, + validPluginNames, + ) + ) { + unsupportedLanguageRules.push(ruleId); + } + + const validateRule = getOrCreateValidator(rule, ruleId); + + if (validateRule) { + validateRule(ruleOptions.slice(1)); + + if (validateRule.errors) { + throw new Error( + `Key "rules": Key "${ruleId}":\n${validateRule.errors + .map(error => { + if ( + error.keyword === "additionalProperties" && + error.schema === false && + typeof error.parentSchema?.properties === + "object" && + typeof error.params?.additionalProperty === + "string" + ) { + const expectedProperties = Object.keys( + error.parentSchema.properties, + ).map(property => `"${property}"`); + + return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n\t\tUnexpected property "${error.params.additionalProperty}". Expected properties: ${expectedProperties.join(", ")}.\n`; + } + + return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`; + }) + .join("")}`, + ); + } + } + } + + if (unsupportedLanguageRules.length > 0) { + const error = new TypeError( + `Key "rules": The following rules do not support the language "${normalizedLanguageName}":\n${unsupportedLanguageRules.map(ruleId => `\t- "${ruleId}"`).join("\n")}`, + ); + + error.messageTemplate = "rule-unsupported-language"; + error.messageData = { + ruleIds: unsupportedLanguageRules, + language: normalizedLanguageName, + }; + throw error; + } + } + + /** + * Gets a complete options schema for a rule. + * @param {RuleDefinition} ruleDefinition A rule definition object. + * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`. + * @returns {Object|null} JSON Schema for the rule's options. `null` if `meta.schema` is `false`. + */ + static getRuleOptionsSchema(ruleDefinition) { + return getRuleOptionsSchema(ruleDefinition); + } + + /** + * Normalizes the severity value of a rule's configuration to a number + * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally + * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0), + * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array + * whose first element is one of the above values. Strings are matched case-insensitively. + * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0. + */ + static getRuleNumericSeverity(ruleConfig) { + const severityValue = Array.isArray(ruleConfig) + ? ruleConfig[0] + : ruleConfig; + + if (severities.has(severityValue)) { + return severities.get(severityValue); + } + + if (typeof severityValue === "string") { + return severities.get(severityValue.toLowerCase()) ?? 0; + } + + return 0; + } +} + +module.exports = { Config }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/default-config.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/default-config.js new file mode 100644 index 00000000..aebf6e93 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/default-config.js @@ -0,0 +1,78 @@ +/** + * @fileoverview Default configuration + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const Rules = require("../rules"); + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const sharedDefaultConfig = [ + // intentionally empty config to ensure these files are globbed by default + { + files: ["**/*.js", "**/*.mjs"], + }, + { + files: ["**/*.cjs"], + languageOptions: { + sourceType: "commonjs", + ecmaVersion: "latest", + }, + }, +]; + +exports.defaultConfig = Object.freeze([ + { + plugins: { + "@": { + languages: { + js: require("../languages/js"), + }, + + /* + * Because we try to delay loading rules until absolutely + * necessary, a proxy allows us to hook into the lazy-loading + * aspect of the rules map while still keeping all of the + * relevant configuration inside of the config array. + */ + rules: new Proxy( + {}, + { + get(target, property) { + return Rules.get(property); + }, + + has(target, property) { + return Rules.has(property); + }, + }, + ), + }, + }, + language: "@/js", + linterOptions: { + reportUnusedDisableDirectives: 1, + }, + }, + + // default ignores are listed here + { + ignores: ["**/node_modules/", ".git/"], + }, + + ...sharedDefaultConfig, +]); + +exports.defaultRuleTesterConfig = Object.freeze([ + { files: ["**"] }, // Make sure the default config matches for all files + + ...sharedDefaultConfig, +]); diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-array.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-array.js new file mode 100644 index 00000000..aaa97db2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-array.js @@ -0,0 +1,217 @@ +/** + * @fileoverview Flat Config Array + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { ConfigArray, ConfigArraySymbol } = require("@eslint/config-array"); +const { flatConfigSchema } = require("./flat-config-schema"); +const { defaultConfig } = require("./default-config"); +const { Config } = require("./config"); + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +/** + * Fields that are considered metadata and not part of the config object. + */ +const META_FIELDS = new Set(["name", "basePath"]); + +/** + * Wraps a config error with details about where the error occurred. + * @param {Error} error The original error. + * @param {number} originalLength The original length of the config array. + * @param {number} baseLength The length of the base config. + * @returns {TypeError} The new error with details. + */ +function wrapConfigErrorWithDetails(error, originalLength, baseLength) { + let location = "user-defined"; + let configIndex = error.index; + + /* + * A config array is set up in this order: + * 1. Base config + * 2. Original configs + * 3. User-defined configs + * 4. CLI-defined configs + * + * So we need to adjust the index to account for the base config. + * + * - If the index is less than the base length, it's in the base config + * (as specified by `baseConfig` argument to `FlatConfigArray` constructor). + * - If the index is greater than the base length but less than the original + * length + base length, it's in the original config. The original config + * is passed to the `FlatConfigArray` constructor as the first argument. + * - Otherwise, it's in the user-defined config, which is loaded from the + * config file and merged with any command-line options. + */ + if (error.index < baseLength) { + location = "base"; + } else if (error.index < originalLength + baseLength) { + location = "original"; + configIndex = error.index - baseLength; + } else { + configIndex = error.index - originalLength - baseLength; + } + + return new TypeError( + `${error.message.slice(0, -1)} at ${location} index ${configIndex}.`, + { cause: error }, + ); +} + +const originalBaseConfig = Symbol("originalBaseConfig"); +const originalLength = Symbol("originalLength"); +const baseLength = Symbol("baseLength"); + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * Represents an array containing configuration information for ESLint. + */ +class FlatConfigArray extends ConfigArray { + /** + * Creates a new instance. + * @param {*[]} configs An array of configuration information. + * @param {{basePath: string, shouldIgnore: boolean, baseConfig: FlatConfig}} options The options + * to use for the config array instance. + */ + constructor( + configs, + { basePath, shouldIgnore = true, baseConfig = defaultConfig } = {}, + ) { + super(configs, { + basePath, + schema: flatConfigSchema, + }); + + /** + * The original length of the array before any modifications. + * @type {number} + */ + this[originalLength] = this.length; + + if (baseConfig[Symbol.iterator]) { + this.unshift(...baseConfig); + } else { + this.unshift(baseConfig); + } + + /** + * The length of the array after applying the base config. + * @type {number} + */ + this[baseLength] = this.length - this[originalLength]; + + /** + * The base config used to build the config array. + * @type {Array} + */ + this[originalBaseConfig] = baseConfig; + Object.defineProperty(this, originalBaseConfig, { writable: false }); + + /** + * Determines if `ignores` fields should be honored. + * If true, then all `ignores` fields are honored. + * if false, then only `ignores` fields in the baseConfig are honored. + * @type {boolean} + */ + this.shouldIgnore = shouldIgnore; + Object.defineProperty(this, "shouldIgnore", { writable: false }); + } + + /** + * Normalizes the array by calling the superclass method and catching/rethrowing + * any ConfigError exceptions with additional details. + * @param {any} [context] The context to use to normalize the array. + * @returns {Promise} A promise that resolves when the array is normalized. + */ + normalize(context) { + return super.normalize(context).catch(error => { + if (error.name === "ConfigError") { + throw wrapConfigErrorWithDetails( + error, + this[originalLength], + this[baseLength], + ); + } + + throw error; + }); + } + + /** + * Normalizes the array by calling the superclass method and catching/rethrowing + * any ConfigError exceptions with additional details. + * @param {any} [context] The context to use to normalize the array. + * @returns {FlatConfigArray} The current instance. + * @throws {TypeError} If the config is invalid. + */ + normalizeSync(context) { + try { + return super.normalizeSync(context); + } catch (error) { + if (error.name === "ConfigError") { + throw wrapConfigErrorWithDetails( + error, + this[originalLength], + this[baseLength], + ); + } + + throw error; + } + } + + /* eslint-disable class-methods-use-this -- Desired as instance method */ + /** + * Replaces a config with another config to allow us to put strings + * in the config array that will be replaced by objects before + * normalization. + * @param {Object} config The config to preprocess. + * @returns {Object} The preprocessed config. + */ + [ConfigArraySymbol.preprocessConfig](config) { + /* + * If a config object has `ignores` and no other non-meta fields, then it's an object + * for global ignores. If `shouldIgnore` is false, that object shouldn't apply, + * so we'll remove its `ignores`. + */ + if ( + !this.shouldIgnore && + !this[originalBaseConfig].includes(config) && + config.ignores && + Object.keys(config).filter(key => !META_FIELDS.has(key)).length === + 1 + ) { + /* eslint-disable-next-line no-unused-vars -- need to strip off other keys */ + const { ignores, ...otherKeys } = config; + + return otherKeys; + } + + return config; + } + + /** + * Finalizes the config by replacing plugin references with their objects + * and validating rule option schemas. + * @param {Object} config The config to finalize. + * @returns {Object} The finalized config. + * @throws {TypeError} If the config is invalid. + */ + [ConfigArraySymbol.finalizeConfig](config) { + return new Config(config); + } + /* eslint-enable class-methods-use-this -- Desired as instance method */ +} + +exports.FlatConfigArray = FlatConfigArray; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-schema.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-schema.js new file mode 100644 index 00000000..7bf052df --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/config/flat-config-schema.js @@ -0,0 +1,601 @@ +/** + * @fileoverview Flat config schema + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { normalizeSeverityToNumber } = require("../shared/severity"); + +//----------------------------------------------------------------------------- +// Type Definitions +//----------------------------------------------------------------------------- + +/** + * @typedef ObjectPropertySchema + * @property {Function|string} merge The function or name of the function to call + * to merge multiple objects with this property. + * @property {Function|string} validate The function or name of the function to call + * to validate the value of this property. + */ + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const ruleSeverities = new Map([ + [0, 0], + ["off", 0], + [1, 1], + ["warn", 1], + [2, 2], + ["error", 2], +]); + +/** + * Check if a value is a non-null object. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is a non-null object. + */ +function isNonNullObject(value) { + return typeof value === "object" && value !== null; +} + +/** + * Check if a value is a non-null non-array object. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is a non-null non-array object. + */ +function isNonArrayObject(value) { + return isNonNullObject(value) && !Array.isArray(value); +} + +/** + * Check if a value is undefined. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is undefined. + */ +function isUndefined(value) { + return typeof value === "undefined"; +} + +/** + * Deeply merges two non-array objects. + * @param {Object} first The base object. + * @param {Object} second The overrides object. + * @param {Map>} [mergeMap] Maps the combination of first and second arguments to a merged result. + * @returns {Object} An object with properties from both first and second. + */ +function deepMerge(first, second, mergeMap = new Map()) { + let secondMergeMap = mergeMap.get(first); + + if (secondMergeMap) { + const result = secondMergeMap.get(second); + + if (result) { + // If this combination of first and second arguments has been already visited, return the previously created result. + return result; + } + } else { + secondMergeMap = new Map(); + mergeMap.set(first, secondMergeMap); + } + + /* + * First create a result object where properties from the second object + * overwrite properties from the first. This sets up a baseline to use + * later rather than needing to inspect and change every property + * individually. + */ + const result = { + ...first, + ...second, + }; + + delete result.__proto__; // eslint-disable-line no-proto -- don't merge own property "__proto__" + + // Store the pending result for this combination of first and second arguments. + secondMergeMap.set(second, result); + + for (const key of Object.keys(second)) { + // avoid hairy edge case + if ( + key === "__proto__" || + !Object.prototype.propertyIsEnumerable.call(first, key) + ) { + continue; + } + + const firstValue = first[key]; + const secondValue = second[key]; + + if (isNonArrayObject(firstValue) && isNonArrayObject(secondValue)) { + result[key] = deepMerge(firstValue, secondValue, mergeMap); + } else if (isUndefined(secondValue)) { + result[key] = firstValue; + } + } + + return result; +} + +/** + * Normalizes the rule options config for a given rule by ensuring that + * it is an array and that the first item is 0, 1, or 2. + * @param {Array|string|number} ruleOptions The rule options config. + * @returns {Array} An array of rule options. + */ +function normalizeRuleOptions(ruleOptions) { + const finalOptions = Array.isArray(ruleOptions) + ? ruleOptions.slice(0) + : [ruleOptions]; + + finalOptions[0] = ruleSeverities.get(finalOptions[0]); + return structuredClone(finalOptions); +} + +/** + * Determines if an object has any methods. + * @param {Object} object The object to check. + * @returns {boolean} `true` if the object has any methods. + */ +function hasMethod(object) { + for (const key of Object.keys(object)) { + if (typeof object[key] === "function") { + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Assertions +//----------------------------------------------------------------------------- + +/** + * The error type when a rule's options are configured with an invalid type. + */ +class InvalidRuleOptionsError extends Error { + /** + * @param {string} ruleId Rule name being configured. + * @param {any} value The invalid value. + */ + constructor(ruleId, value) { + super( + `Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`, + ); + this.messageTemplate = "invalid-rule-options"; + this.messageData = { ruleId, value }; + } +} + +/** + * Validates that a value is a valid rule options entry. + * @param {string} ruleId Rule name being configured. + * @param {any} value The value to check. + * @returns {void} + * @throws {InvalidRuleOptionsError} If the value isn't a valid rule options. + */ +function assertIsRuleOptions(ruleId, value) { + if ( + typeof value !== "string" && + typeof value !== "number" && + !Array.isArray(value) + ) { + throw new InvalidRuleOptionsError(ruleId, value); + } +} + +/** + * The error type when a rule's severity is invalid. + */ +class InvalidRuleSeverityError extends Error { + /** + * @param {string} ruleId Rule name being configured. + * @param {any} value The invalid value. + */ + constructor(ruleId, value) { + super( + `Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`, + ); + this.messageTemplate = "invalid-rule-severity"; + this.messageData = { ruleId, value }; + } +} + +/** + * Validates that a value is valid rule severity. + * @param {string} ruleId Rule name being configured. + * @param {any} value The value to check. + * @returns {void} + * @throws {InvalidRuleSeverityError} If the value isn't a valid rule severity. + */ +function assertIsRuleSeverity(ruleId, value) { + const severity = ruleSeverities.get(value); + + if (typeof severity === "undefined") { + throw new InvalidRuleSeverityError(ruleId, value); + } +} + +/** + * Validates that a given string matches the "pluginName/memberPlaceholder" pattern. + * @param {string} value The string to check. + * @param {string} memberPlaceholder The placeholder for the member portion of the expected format in the error message. + * @returns {void} + * @throws {TypeError} If the string doesn't match the expected pattern. + */ +function assertIsPluginMemberName(value, memberPlaceholder) { + if (!/[\w\-@$]+(?:\/[\w\-$]+)+$/iu.test(value)) { + throw new TypeError( + `Expected string in the form "pluginName/${memberPlaceholder}" but found "${value}".`, + ); + } +} + +/** + * Validates that a value is an object. + * @param {any} value The value to check. + * @returns {void} + * @throws {TypeError} If the value isn't an object. + */ +function assertIsObject(value) { + if (!isNonNullObject(value)) { + throw new TypeError("Expected an object."); + } +} + +/** + * The error type when there's an eslintrc-style options in a flat config. + */ +class IncompatibleKeyError extends Error { + /** + * @param {string} key The invalid key. + */ + constructor(key) { + super( + "This appears to be in eslintrc format rather than flat config format.", + ); + this.messageTemplate = "eslintrc-incompat"; + this.messageData = { key }; + } +} + +/** + * The error type when there's an eslintrc-style plugins array found. + */ +class IncompatiblePluginsError extends Error { + /** + * Creates a new instance. + * @param {Array} plugins The plugins array. + */ + constructor(plugins) { + super( + "This appears to be in eslintrc format (array of strings) rather than flat config format (object).", + ); + this.messageTemplate = "eslintrc-plugins"; + this.messageData = { plugins }; + } +} + +//----------------------------------------------------------------------------- +// Low-Level Schemas +//----------------------------------------------------------------------------- + +/** @type {ObjectPropertySchema} */ +const booleanSchema = { + merge: "replace", + validate: "boolean", +}; + +const ALLOWED_SEVERITIES = new Set(["error", "warn", "off", 2, 1, 0]); + +/** @type {ObjectPropertySchema} */ +const disableDirectiveSeveritySchema = { + merge(first, second) { + const value = second === void 0 ? first : second; + + if (typeof value === "boolean") { + return value ? "warn" : "off"; + } + + return normalizeSeverityToNumber(value); + }, + validate(value) { + if (!(ALLOWED_SEVERITIES.has(value) || typeof value === "boolean")) { + throw new TypeError( + 'Expected one of: "error", "warn", "off", 0, 1, 2, or a boolean.', + ); + } + }, +}; + +/** @type {ObjectPropertySchema} */ +const unusedInlineConfigsSeveritySchema = { + merge(first, second) { + const value = second === void 0 ? first : second; + + return normalizeSeverityToNumber(value); + }, + validate(value) { + if (!ALLOWED_SEVERITIES.has(value)) { + throw new TypeError( + 'Expected one of: "error", "warn", "off", 0, 1, or 2.', + ); + } + }, +}; + +/** @type {ObjectPropertySchema} */ +const deepObjectAssignSchema = { + merge(first = {}, second = {}) { + return deepMerge(first, second); + }, + validate: "object", +}; + +//----------------------------------------------------------------------------- +// High-Level Schemas +//----------------------------------------------------------------------------- + +/** @type {ObjectPropertySchema} */ +const languageOptionsSchema = { + merge(first = {}, second = {}) { + const result = deepMerge(first, second); + + for (const [key, value] of Object.entries(result)) { + /* + * Special case: Because the `parser` property is an object, it should + * not be deep merged. Instead, it should be replaced if it exists in + * the second object. To make this more generic, we just check for + * objects with methods and replace them if they exist in the second + * object. + */ + if (isNonArrayObject(value)) { + if (hasMethod(value)) { + result[key] = second[key] ?? first[key]; + continue; + } + + // for other objects, make sure we aren't reusing the same object + result[key] = { ...result[key] }; + continue; + } + } + + return result; + }, + validate: "object", +}; + +/** @type {ObjectPropertySchema} */ +const languageSchema = { + merge: "replace", + validate(value) { + assertIsPluginMemberName(value, "languageName"); + }, +}; + +/** @type {ObjectPropertySchema} */ +const pluginsSchema = { + merge(first = {}, second = {}) { + const keys = new Set([...Object.keys(first), ...Object.keys(second)]); + const result = {}; + + // manually validate that plugins are not redefined + for (const key of keys) { + // avoid hairy edge case + if (key === "__proto__") { + continue; + } + + if (key in first && key in second && first[key] !== second[key]) { + throw new TypeError(`Cannot redefine plugin "${key}".`); + } + + result[key] = second[key] || first[key]; + } + + return result; + }, + validate(value) { + // first check the value to be sure it's an object + if (value === null || typeof value !== "object") { + throw new TypeError("Expected an object."); + } + + // make sure it's not an array, which would mean eslintrc-style is used + if (Array.isArray(value)) { + throw new IncompatiblePluginsError(value); + } + + // second check the keys to make sure they are objects + for (const key of Object.keys(value)) { + // avoid hairy edge case + if (key === "__proto__") { + continue; + } + + if (value[key] === null || typeof value[key] !== "object") { + throw new TypeError(`Key "${key}": Expected an object.`); + } + } + }, +}; + +/** @type {ObjectPropertySchema} */ +const processorSchema = { + merge: "replace", + validate(value) { + if (typeof value === "string") { + assertIsPluginMemberName(value, "processorName"); + } else if (value && typeof value === "object") { + if ( + typeof value.preprocess !== "function" || + typeof value.postprocess !== "function" + ) { + throw new TypeError( + "Object must have a preprocess() and a postprocess() method.", + ); + } + } else { + throw new TypeError("Expected an object or a string."); + } + }, +}; + +/** @type {ObjectPropertySchema} */ +const rulesSchema = { + merge(first = {}, second = {}) { + const result = { + ...first, + ...second, + }; + + for (const ruleId of Object.keys(result)) { + try { + // avoid hairy edge case + if (ruleId === "__proto__") { + /* eslint-disable-next-line no-proto -- Though deprecated, may still be present */ + delete result.__proto__; + continue; + } + + result[ruleId] = normalizeRuleOptions(result[ruleId]); + + /* + * If either rule config is missing, then the correct + * config is already present and we just need to normalize + * the severity. + */ + if (!(ruleId in first) || !(ruleId in second)) { + continue; + } + + const firstRuleOptions = normalizeRuleOptions(first[ruleId]); + const secondRuleOptions = normalizeRuleOptions(second[ruleId]); + + /* + * If the second rule config only has a severity (length of 1), + * then use that severity and keep the rest of the options from + * the first rule config. + */ + if (secondRuleOptions.length === 1) { + result[ruleId] = [ + secondRuleOptions[0], + ...firstRuleOptions.slice(1), + ]; + continue; + } + + /* + * In any other situation, then the second rule config takes + * precedence. That means the value at `result[ruleId]` is + * already correct and no further work is necessary. + */ + } catch (ex) { + throw new Error(`Key "${ruleId}": ${ex.message}`, { + cause: ex, + }); + } + } + + return result; + }, + + validate(value) { + assertIsObject(value); + + /* + * We are not checking the rule schema here because there is no + * guarantee that the rule definition is present at this point. Instead + * we wait and check the rule schema during the finalization step + * of calculating a config. + */ + for (const ruleId of Object.keys(value)) { + // avoid hairy edge case + if (ruleId === "__proto__") { + continue; + } + + const ruleOptions = value[ruleId]; + + assertIsRuleOptions(ruleId, ruleOptions); + + if (Array.isArray(ruleOptions)) { + assertIsRuleSeverity(ruleId, ruleOptions[0]); + } else { + assertIsRuleSeverity(ruleId, ruleOptions); + } + } + }, +}; + +/** + * Creates a schema that always throws an error. Useful for warning + * about eslintrc-style keys. + * @param {string} key The eslintrc key to create a schema for. + * @returns {ObjectPropertySchema} The schema. + */ +function createEslintrcErrorSchema(key) { + return { + merge: "replace", + validate() { + throw new IncompatibleKeyError(key); + }, + }; +} + +const eslintrcKeys = [ + "env", + "extends", + "globals", + "ignorePatterns", + "noInlineConfig", + "overrides", + "parser", + "parserOptions", + "reportUnusedDisableDirectives", + "root", +]; + +//----------------------------------------------------------------------------- +// Full schema +//----------------------------------------------------------------------------- + +const flatConfigSchema = { + // eslintrc-style keys that should always error + ...Object.fromEntries( + eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)]), + ), + + // flat config keys + settings: deepObjectAssignSchema, + linterOptions: { + schema: { + noInlineConfig: booleanSchema, + reportUnusedDisableDirectives: disableDirectiveSeveritySchema, + reportUnusedInlineConfigs: unusedInlineConfigsSeveritySchema, + }, + }, + language: languageSchema, + languageOptions: languageOptionsSchema, + processor: processorSchema, + plugins: pluginsSchema, + rules: rulesSchema, +}; + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { + flatConfigSchema, + hasMethod, + assertIsRuleSeverity, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint-helpers.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint-helpers.js new file mode 100644 index 00000000..0810f225 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint-helpers.js @@ -0,0 +1,1440 @@ +/** + * @fileoverview Helper functions for ESLint class + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const path = require("node:path"); +const fs = require("node:fs"); +const { isMainThread, threadId } = require("node:worker_threads"); +const fsp = fs.promises; +const isGlob = require("is-glob"); +const hash = require("../cli-engine/hash"); +const minimatch = require("minimatch"); +const globParent = require("glob-parent"); +const { Linter } = require("../linter"); +const { getShorthandName } = require("../shared/naming"); +const { calculateStatsPerFile } = require("../shared/message-counts"); +const LintResultCache = require("../cli-engine/lint-result-cache"); +const { ConfigLoader } = require("../config/config-loader"); +const createDebug = require("debug"); +const { SuppressionsService } = require("../services/suppressions-service.js"); + +//----------------------------------------------------------------------------- +// Fixup references +//----------------------------------------------------------------------------- + +const Minimatch = minimatch.Minimatch; +const MINIMATCH_OPTIONS = { dot: true }; +const hrtimeBigint = process.hrtime.bigint; + +//----------------------------------------------------------------------------- +// Types +//----------------------------------------------------------------------------- + +/** + * @import { ESLintOptions } from "./eslint.js"; + * @import { Config as CalculatedConfig } from "../config/config.js"; + * @import { FlatConfigArray } from "../config/flat-config-array.js"; + * @import { WarningService } from "../services/warning-service.js"; + * @import { Retrier } from "@humanwhocodes/retry"; + */ + +/** @typedef {import("../types").Linter.Config} Config */ +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../types").ESLint.LintResult} LintResult */ +/** @typedef {import("../types").ESLint.Plugin} Plugin */ + +/** + * @typedef {Object} GlobSearch + * @property {Array} patterns The normalized patterns to use for a search. + * @property {Array} rawPatterns The patterns as entered by the user + * before doing any normalization. + */ + +//------------------------------------------------------------------------------ +// Debug Helpers +//------------------------------------------------------------------------------ + +// Add %t formatter to print bigint nanosecond times in milliseconds. +createDebug.formatters.t = timeDiff => + `${(timeDiff + 500_000n) / 1_000_000n} ms`; + +const debug = createDebug( + `eslint:eslint-helpers${isMainThread ? "" : `:thread-${threadId}`}`, +); + +//----------------------------------------------------------------------------- +// Errors +//----------------------------------------------------------------------------- + +/** + * The error type when no files match a glob. + */ +class NoFilesFoundError extends Error { + /** + * @param {string} pattern The glob pattern which was not found. + * @param {boolean} globEnabled If `false` then the pattern was a glob pattern, but glob was disabled. + */ + constructor(pattern, globEnabled) { + super( + `No files matching '${pattern}' were found${!globEnabled ? " (glob was disabled)" : ""}.`, + ); + this.messageTemplate = "file-not-found"; + this.messageData = { pattern, globDisabled: !globEnabled }; + } +} + +/** + * The error type when a search fails to match multiple patterns. + */ +class UnmatchedSearchPatternsError extends Error { + /** + * @param {Object} options The options for the error. + * @param {string} options.basePath The directory that was searched. + * @param {Array} options.unmatchedPatterns The glob patterns + * which were not found. + * @param {Array} options.patterns The glob patterns that were + * searched. + * @param {Array} options.rawPatterns The raw glob patterns that + * were searched. + */ + constructor({ basePath, unmatchedPatterns, patterns, rawPatterns }) { + super( + `No files matching '${rawPatterns}' in '${basePath}' were found.`, + ); + this.basePath = basePath; + this.unmatchedPatterns = unmatchedPatterns; + this.patterns = patterns; + this.rawPatterns = rawPatterns; + } +} + +/** + * The error type when there are files matched by a glob, but all of them have been ignored. + */ +class AllFilesIgnoredError extends Error { + /** + * @param {string} pattern The glob pattern which was not found. + */ + constructor(pattern) { + super(`All files matched by '${pattern}' are ignored.`); + this.messageTemplate = "all-matched-files-ignored"; + this.messageData = { pattern }; + } +} + +//----------------------------------------------------------------------------- +// General Helpers +//----------------------------------------------------------------------------- + +/** + * Check if a given value is a non-empty string or not. + * @param {any} value The value to check. + * @returns {boolean} `true` if `value` is a non-empty string. + */ +function isNonEmptyString(value) { + return typeof value === "string" && value.trim() !== ""; +} + +/** + * Check if a given value is an array of non-empty strings or not. + * @param {any} value The value to check. + * @returns {boolean} `true` if `value` is an array of non-empty strings. + */ +function isArrayOfNonEmptyString(value) { + return ( + Array.isArray(value) && !!value.length && value.every(isNonEmptyString) + ); +} + +/** + * Check if a given value is an empty array or an array of non-empty strings. + * @param {any} value The value to check. + * @returns {boolean} `true` if `value` is an empty array or an array of non-empty + * strings. + */ +function isEmptyArrayOrArrayOfNonEmptyString(value) { + return Array.isArray(value) && value.every(isNonEmptyString); +} + +/** + * Check if a given value is a positive integer. + * @param {unknown} value The value to check. + * @returns {boolean} `true` if `value` is a positive integer. + */ +function isPositiveInteger(value) { + return Number.isInteger(value) && value > 0; +} + +//----------------------------------------------------------------------------- +// File-related Helpers +//----------------------------------------------------------------------------- + +/** + * Normalizes slashes in a file pattern to posix-style. + * @param {string} pattern The pattern to replace slashes in. + * @returns {string} The pattern with slashes normalized. + */ +function normalizeToPosix(pattern) { + return pattern.replace(/\\/gu, "/"); +} + +/** + * Check if a string is a glob pattern or not. + * @param {string} pattern A glob pattern. + * @returns {boolean} `true` if the string is a glob pattern. + */ +function isGlobPattern(pattern) { + return isGlob(path.sep === "\\" ? normalizeToPosix(pattern) : pattern); +} + +/** + * Determines if a given glob pattern will return any results. + * Used primarily to help with useful error messages. + * @param {Object} options The options for the function. + * @param {string} options.basePath The directory to search. + * @param {string} options.pattern An absolute path glob pattern to match. + * @returns {Promise} True if there is a glob match, false if not. + */ +async function globMatch({ basePath, pattern }) { + let found = false; + const { hfs } = await import("@humanfs/node"); + const patternToUse = normalizeToPosix(path.relative(basePath, pattern)); + + const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS); + + const walkSettings = { + directoryFilter(entry) { + return !found && matcher.match(entry.path, true); + }, + + entryFilter(entry) { + if (found || entry.isDirectory) { + return false; + } + + if (matcher.match(entry.path)) { + found = true; + return true; + } + + return false; + }, + }; + + if (await hfs.isDirectory(basePath)) { + return hfs + .walk(basePath, walkSettings) + .next() + .then(() => found); + } + + return found; +} + +/** + * Searches a directory looking for matching glob patterns. This uses + * the config array's logic to determine if a directory or file should + * be ignored, so it is consistent with how ignoring works throughout + * ESLint. + * @param {Object} options The options for this function. + * @param {string} options.basePath The directory to search. + * @param {Array} options.patterns An array of absolute path glob patterns + * to match. + * @param {Array} options.rawPatterns An array of glob patterns + * as the user inputted them. Used for errors. + * @param {ConfigLoader} options.configLoader The config array to use for + * determining what to ignore. + * @param {boolean} options.errorOnUnmatchedPattern Determines if an error + * should be thrown when a pattern is unmatched. + * @returns {Promise>} An array of matching file paths + * or an empty array if there are no matches. + * @throws {UnmatchedSearchPatternsError} If there is a pattern that doesn't + * match any files. + */ +async function globSearch({ + basePath, + patterns, + rawPatterns, + configLoader, + errorOnUnmatchedPattern, +}) { + if (patterns.length === 0) { + return []; + } + + /* + * In this section we are converting the patterns into Minimatch + * instances for performance reasons. Because we are doing the same + * matches repeatedly, it's best to compile those patterns once and + * reuse them multiple times. + * + * To do that, we convert any patterns with an absolute path into a + * relative path and normalize it to Posix-style slashes. We also keep + * track of the relative patterns to map them back to the original + * patterns, which we need in order to throw an error if there are any + * unmatched patterns. + */ + const relativeToPatterns = new Map(); + const matchers = patterns.map((pattern, i) => { + const patternToUse = normalizeToPosix(path.relative(basePath, pattern)); + + relativeToPatterns.set(patternToUse, patterns[i]); + + return new Minimatch(patternToUse, MINIMATCH_OPTIONS); + }); + + /* + * We track unmatched patterns because we may want to throw an error when + * they occur. To start, this set is initialized with all of the patterns. + * Every time a match occurs, the pattern is removed from the set, making + * it easy to tell if we have any unmatched patterns left at the end of + * search. + */ + const unmatchedPatterns = new Set([...relativeToPatterns.keys()]); + const { hfs } = await import("@humanfs/node"); + + const walk = hfs.walk(basePath, { + async directoryFilter(entry) { + if (!matchers.some(matcher => matcher.match(entry.path, true))) { + return false; + } + + const absolutePath = path.resolve(basePath, entry.path); + const configs = + await configLoader.loadConfigArrayForDirectory(absolutePath); + + return !configs.isDirectoryIgnored(absolutePath); + }, + async entryFilter(entry) { + const absolutePath = path.resolve(basePath, entry.path); + + // entries may be directories or files so filter out directories + if (entry.isDirectory) { + return false; + } + + const configs = + await configLoader.loadConfigArrayForFile(absolutePath); + const config = configs.getConfig(absolutePath); + + /* + * Optimization: We need to track when patterns are left unmatched + * and so we use `unmatchedPatterns` to do that. There is a bit of + * complexity here because the same file can be matched by more than + * one pattern. So, when we start, we actually need to test every + * pattern against every file. Once we know there are no remaining + * unmatched patterns, then we can switch to just looking for the + * first matching pattern for improved speed. + */ + const matchesPattern = + unmatchedPatterns.size > 0 + ? matchers.reduce((previousValue, matcher) => { + const pathMatches = matcher.match(entry.path); + + /* + * We updated the unmatched patterns set only if the path + * matches and the file has a config. If the file has no + * config, that means there wasn't a match for the + * pattern so it should not be removed. + * + * Performance note: `getConfig()` aggressively caches + * results so there is no performance penalty for calling + * it multiple times with the same argument. + */ + if (pathMatches && config) { + unmatchedPatterns.delete(matcher.pattern); + } + + return pathMatches || previousValue; + }, false) + : matchers.some(matcher => matcher.match(entry.path)); + + return matchesPattern && config !== void 0; + }, + }); + + const filePaths = []; + + if (await hfs.isDirectory(basePath)) { + for await (const entry of walk) { + filePaths.push(path.resolve(basePath, entry.path)); + } + } + + // now check to see if we have any unmatched patterns + if (errorOnUnmatchedPattern && unmatchedPatterns.size > 0) { + throw new UnmatchedSearchPatternsError({ + basePath, + unmatchedPatterns: [...unmatchedPatterns].map(pattern => + relativeToPatterns.get(pattern), + ), + patterns, + rawPatterns, + }); + } + + return filePaths; +} + +/** + * Throws an error for unmatched patterns. The error will only contain information about the first one. + * Checks to see if there are any ignored results for a given search. + * @param {Object} options The options for this function. + * @param {string} options.basePath The directory to search. + * @param {Array} options.patterns An array of glob patterns + * that were used in the original search. + * @param {Array} options.rawPatterns An array of glob patterns + * as the user inputted them. Used for errors. + * @param {Array} options.unmatchedPatterns A non-empty array of absolute path glob patterns + * that were unmatched in the original search. + * @returns {Promise} Always throws an error. + * @throws {NoFilesFoundError} If the first unmatched pattern + * doesn't match any files even when there are no ignores. + * @throws {AllFilesIgnoredError} If the first unmatched pattern + * matches some files when there are no ignores. + */ +async function throwErrorForUnmatchedPatterns({ + basePath, + patterns, + rawPatterns, + unmatchedPatterns, +}) { + const pattern = unmatchedPatterns[0]; + const rawPattern = rawPatterns[patterns.indexOf(pattern)]; + + const patternHasMatch = await globMatch({ + basePath, + pattern, + }); + + if (patternHasMatch) { + throw new AllFilesIgnoredError(rawPattern); + } + + // if we get here there are truly no matches + throw new NoFilesFoundError(rawPattern, true); +} + +/** + * Performs multiple glob searches in parallel. + * @param {Object} options The options for this function. + * @param {Map} options.searches + * A map of absolute path glob patterns to match. + * @param {ConfigLoader} options.configLoader The config loader to use for + * determining what to ignore. + * @param {boolean} options.errorOnUnmatchedPattern Determines if an + * unmatched glob pattern should throw an error. + * @returns {Promise>} An array of matching file paths + * or an empty array if there are no matches. + */ +async function globMultiSearch({ + searches, + configLoader, + errorOnUnmatchedPattern, +}) { + /* + * For convenience, we normalized the search map into an array of objects. + * Next, we filter out all searches that have no patterns. This happens + * primarily for the cwd, which is prepopulated in the searches map as an + * optimization. However, if it has no patterns, it means all patterns + * occur outside of the cwd and we can safely filter out that search. + */ + const normalizedSearches = [...searches] + .map(([basePath, { patterns, rawPatterns }]) => ({ + basePath, + patterns, + rawPatterns, + })) + .filter(({ patterns }) => patterns.length > 0); + + const results = await Promise.allSettled( + normalizedSearches.map(({ basePath, patterns, rawPatterns }) => + globSearch({ + basePath, + patterns, + rawPatterns, + configLoader, + errorOnUnmatchedPattern, + }), + ), + ); + + /* + * The first loop handles errors from the glob searches. Since we can't + * use `await` inside `flatMap`, we process errors separately in this loop. + * This results in two iterations over `results`, but since the length is + * less than or equal to the number of globs and directories passed on the + * command line, the performance impact should be minimal. + */ + for (let i = 0; i < results.length; i++) { + const result = results[i]; + const currentSearch = normalizedSearches[i]; + + if (result.status === "fulfilled") { + continue; + } + + // if we make it here then there was an error + const error = result.reason; + + // unexpected errors should be re-thrown + if (!error.basePath) { + throw error; + } + + if (errorOnUnmatchedPattern) { + await throwErrorForUnmatchedPatterns({ + ...currentSearch, + unmatchedPatterns: error.unmatchedPatterns, + }); + } + } + + // second loop for `fulfilled` results + return results.flatMap(result => result.value); +} + +/** + * Finds all files matching the options specified. + * @param {Object} args The arguments objects. + * @param {Array} args.patterns An array of glob patterns. + * @param {boolean} args.globInputPaths true to interpret glob patterns, + * false to not interpret glob patterns. + * @param {string} args.cwd The current working directory to find from. + * @param {ConfigLoader} args.configLoader The config loader for the current run. + * @param {boolean} args.errorOnUnmatchedPattern Determines if an unmatched pattern + * should throw an error. + * @returns {Promise>} The fully resolved file paths. + * @throws {AllFilesIgnoredError} If there are no results due to an ignore pattern. + * @throws {NoFilesFoundError} If no files matched the given patterns. + */ +async function findFiles({ + patterns, + globInputPaths, + cwd, + configLoader, + errorOnUnmatchedPattern, +}) { + const results = []; + const missingPatterns = []; + let globbyPatterns = []; + let rawPatterns = []; + const searches = new Map([ + [cwd, { patterns: globbyPatterns, rawPatterns: [] }], + ]); + + /* + * This part is a bit involved because we need to account for + * the different ways that the patterns can match directories. + * For each different way, we need to decide if we should look + * for a config file or just use the default config. (Directories + * without a config file always use the default config.) + * + * Here are the cases: + * + * 1. A directory is passed directly (e.g., "subdir"). In this case, we + * can assume that the user intends to lint this directory and we should + * not look for a config file in the parent directory, because the only + * reason to do that would be to ignore this directory (which we already + * know we don't want to do). Instead, we use the default config until we + * get to the directory that was passed, at which point we start looking + * for config files again. + * + * 2. A dot (".") or star ("*"). In this case, we want to read + * the config file in the current directory because the user is + * explicitly asking to lint the current directory. Note that "." + * will traverse into subdirectories while "*" will not. + * + * 3. A directory is passed in the form of "subdir/subsubdir". + * In this case, we don't want to look for a config file in the + * parent directory ("subdir"). We can skip looking for a config + * file until `entry.depth` is greater than 1 because there's no + * way that the pattern can match `entry.path` yet. + * + * 4. A directory glob pattern is passed (e.g., "subd*"). We want + * this case to act like case 2 because it's unclear whether or not + * any particular directory is meant to be traversed. + * + * 5. A recursive glob pattern is passed (e.g., "**"). We want this + * case to act like case 2. + */ + + // check to see if we have explicit files and directories + const filePaths = patterns.map(filePath => path.resolve(cwd, filePath)); + const stats = await Promise.all( + filePaths.map(filePath => fsp.stat(filePath).catch(() => {})), + ); + + const promises = []; + stats.forEach((stat, index) => { + const filePath = filePaths[index]; + const pattern = normalizeToPosix(patterns[index]); + + if (stat) { + // files are added directly to the list + if (stat.isFile()) { + results.push(filePath); + promises.push(configLoader.loadConfigArrayForFile(filePath)); + } + + // directories need extensions attached + if (stat.isDirectory()) { + if (!searches.has(filePath)) { + searches.set(filePath, { patterns: [], rawPatterns: [] }); + } + ({ patterns: globbyPatterns, rawPatterns } = + searches.get(filePath)); + + globbyPatterns.push(`${normalizeToPosix(filePath)}/**`); + rawPatterns.push(pattern); + } + + return; + } + + // save patterns for later use based on whether globs are enabled + if (globInputPaths && isGlobPattern(pattern)) { + /* + * We are grouping patterns by their glob parent. This is done to + * make it easier to determine when a config file should be loaded. + */ + + const basePath = path.resolve(cwd, globParent(pattern)); + + if (!searches.has(basePath)) { + searches.set(basePath, { patterns: [], rawPatterns: [] }); + } + ({ patterns: globbyPatterns, rawPatterns } = + searches.get(basePath)); + + globbyPatterns.push(filePath); + rawPatterns.push(pattern); + } else { + missingPatterns.push(pattern); + } + }); + + // there were patterns that didn't match anything, tell the user + if (errorOnUnmatchedPattern && missingPatterns.length) { + throw new NoFilesFoundError(missingPatterns[0], globInputPaths); + } + + // now we are safe to do the search + promises.push( + globMultiSearch({ + searches, + configLoader, + errorOnUnmatchedPattern, + }), + ); + const globbyResults = (await Promise.all(promises)).at(-1); + + return [...new Set([...results, ...globbyResults])]; +} + +/** + * Return the absolute path of a file named `"__placeholder__.js"` in a given directory. + * This is used as a replacement for a missing file path. + * @param {string} cwd An absolute directory path. + * @returns {string} The absolute path of a file named `"__placeholder__.js"` in the given directory. + */ +function getPlaceholderPath(cwd) { + return path.join(cwd, "__placeholder__.js"); +} + +//----------------------------------------------------------------------------- +// Results-related Helpers +//----------------------------------------------------------------------------- + +/** + * Checks if the given message is an error message. + * @param {LintMessage} message The message to check. + * @returns {boolean} Whether or not the message is an error message. + * @private + */ +function isErrorMessage(message) { + return message.severity === 2; +} + +/** + * Returns result with warning by ignore settings + * @param {string} filePath Absolute file path of checked code + * @param {string} baseDir Absolute path of base directory + * @param {"ignored"|"external"|"unconfigured"} configStatus A status that determines why the file is ignored + * @returns {LintResult} Result with single warning + * @private + */ +function createIgnoreResult(filePath, baseDir, configStatus) { + let message; + + switch (configStatus) { + case "external": + message = "File ignored because outside of base path."; + break; + case "unconfigured": + message = + "File ignored because no matching configuration was supplied."; + break; + default: + { + const isInNodeModules = + baseDir && + path + .dirname(path.relative(baseDir, filePath)) + .split(path.sep) + .includes("node_modules"); + + if (isInNodeModules) { + message = + 'File ignored by default because it is located under the node_modules directory. Use ignore pattern "!**/node_modules/" to disable file ignore settings or use "--no-warn-ignored" to suppress this warning.'; + } else { + message = + 'File ignored because of a matching ignore pattern. Use "--no-ignore" to disable file ignore settings or use "--no-warn-ignored" to suppress this warning.'; + } + } + break; + } + + return { + filePath, + messages: [ + { + ruleId: null, + fatal: false, + severity: 1, + message, + }, + ], + suppressedMessages: [], + errorCount: 0, + warningCount: 1, + fatalErrorCount: 0, + fixableErrorCount: 0, + fixableWarningCount: 0, + }; +} + +//----------------------------------------------------------------------------- +// Options-related Helpers +//----------------------------------------------------------------------------- + +/** + * Check if a given value is a valid fix type or not. + * @param {any} x The value to check. + * @returns {boolean} `true` if `x` is valid fix type. + */ +function isFixType(x) { + return ( + x === "directive" || + x === "problem" || + x === "suggestion" || + x === "layout" + ); +} + +/** + * Check if a given value is an array of fix types or not. + * @param {any} x The value to check. + * @returns {boolean} `true` if `x` is an array of fix types. + */ +function isFixTypeArray(x) { + return Array.isArray(x) && x.every(isFixType); +} + +/** + * The error for invalid options. + */ +class ESLintInvalidOptionsError extends Error { + constructor(messages) { + super(`Invalid Options:\n- ${messages.join("\n- ")}`); + this.code = "ESLINT_INVALID_OPTIONS"; + Error.captureStackTrace(this, ESLintInvalidOptionsError); + } +} + +/** + * Validates and normalizes options for the wrapped CLIEngine instance. + * @param {ESLintOptions} options The options to process. + * @throws {ESLintInvalidOptionsError} If of any of a variety of type errors. + * @returns {ESLintOptions} The normalized options. + */ +function processOptions({ + allowInlineConfig = true, // ← we cannot use `overrideConfig.noInlineConfig` instead because `allowInlineConfig` has side-effect that suppress warnings that show inline configs are ignored. + baseConfig = null, + cache = false, + cacheLocation = ".eslintcache", + cacheStrategy = "metadata", + concurrency = "off", + cwd = process.cwd(), + errorOnUnmatchedPattern = true, + fix = false, + fixTypes = null, // ← should be null by default because if it's an array then it suppresses rules that don't have the `meta.type` property. + flags = [], + globInputPaths = true, + ignore = true, + ignorePatterns = null, + overrideConfig = null, + overrideConfigFile = null, + plugins = {}, + stats = false, + warnIgnored = true, + passOnNoPatterns = false, + ruleFilter = () => true, + applySuppressions = false, + suppressionsLocation = SuppressionsService.DEFAULT_SUPPRESSIONS_FILENAME, + ...unknownOptions +}) { + const errors = []; + const unknownOptionKeys = Object.keys(unknownOptions); + + if (unknownOptionKeys.length >= 1) { + errors.push(`Unknown options: ${unknownOptionKeys.join(", ")}`); + if (unknownOptionKeys.includes("cacheFile")) { + errors.push( + "'cacheFile' has been removed. Please use the 'cacheLocation' option instead.", + ); + } + if (unknownOptionKeys.includes("configFile")) { + errors.push( + "'configFile' has been removed. Please use the 'overrideConfigFile' option instead.", + ); + } + if (unknownOptionKeys.includes("envs")) { + errors.push("'envs' has been removed."); + } + if (unknownOptionKeys.includes("extensions")) { + errors.push("'extensions' has been removed."); + } + if (unknownOptionKeys.includes("resolvePluginsRelativeTo")) { + errors.push("'resolvePluginsRelativeTo' has been removed."); + } + if (unknownOptionKeys.includes("globals")) { + errors.push( + "'globals' has been removed. Please use the 'overrideConfig.languageOptions.globals' option instead.", + ); + } + if (unknownOptionKeys.includes("ignorePath")) { + errors.push("'ignorePath' has been removed."); + } + if (unknownOptionKeys.includes("ignorePattern")) { + errors.push( + "'ignorePattern' has been removed. Please use the 'overrideConfig.ignorePatterns' option instead.", + ); + } + if (unknownOptionKeys.includes("parser")) { + errors.push( + "'parser' has been removed. Please use the 'overrideConfig.languageOptions.parser' option instead.", + ); + } + if (unknownOptionKeys.includes("parserOptions")) { + errors.push( + "'parserOptions' has been removed. Please use the 'overrideConfig.languageOptions.parserOptions' option instead.", + ); + } + if (unknownOptionKeys.includes("rules")) { + errors.push( + "'rules' has been removed. Please use the 'overrideConfig.rules' option instead.", + ); + } + if (unknownOptionKeys.includes("rulePaths")) { + errors.push( + "'rulePaths' has been removed. Please define your rules using plugins.", + ); + } + if (unknownOptionKeys.includes("reportUnusedDisableDirectives")) { + errors.push( + "'reportUnusedDisableDirectives' has been removed. Please use the 'overrideConfig.linterOptions.reportUnusedDisableDirectives' option instead.", + ); + } + } + if (typeof allowInlineConfig !== "boolean") { + errors.push("'allowInlineConfig' must be a boolean."); + } + if (typeof baseConfig !== "object") { + errors.push("'baseConfig' must be an object or null."); + } + if (typeof cache !== "boolean") { + errors.push("'cache' must be a boolean."); + } + if (!isNonEmptyString(cacheLocation)) { + errors.push("'cacheLocation' must be a non-empty string."); + } + if (cacheStrategy !== "metadata" && cacheStrategy !== "content") { + errors.push('\'cacheStrategy\' must be any of "metadata", "content".'); + } + if ( + concurrency !== "off" && + concurrency !== "auto" && + !isPositiveInteger(concurrency) + ) { + errors.push( + '\'concurrency\' must be a positive integer, "auto", or "off".', + ); + } + if (!isNonEmptyString(cwd) || !path.isAbsolute(cwd)) { + errors.push("'cwd' must be an absolute path."); + } + if (typeof errorOnUnmatchedPattern !== "boolean") { + errors.push("'errorOnUnmatchedPattern' must be a boolean."); + } + if (typeof fix !== "boolean" && typeof fix !== "function") { + errors.push("'fix' must be a boolean or a function."); + } + if (fixTypes !== null && !isFixTypeArray(fixTypes)) { + errors.push( + '\'fixTypes\' must be an array of any of "directive", "problem", "suggestion", and "layout".', + ); + } + if (!isEmptyArrayOrArrayOfNonEmptyString(flags)) { + errors.push("'flags' must be an array of non-empty strings."); + } + if (typeof globInputPaths !== "boolean") { + errors.push("'globInputPaths' must be a boolean."); + } + if (typeof ignore !== "boolean") { + errors.push("'ignore' must be a boolean."); + } + if ( + !isEmptyArrayOrArrayOfNonEmptyString(ignorePatterns) && + ignorePatterns !== null + ) { + errors.push( + "'ignorePatterns' must be an array of non-empty strings or null.", + ); + } + if (typeof overrideConfig !== "object") { + errors.push("'overrideConfig' must be an object or null."); + } + if ( + !isNonEmptyString(overrideConfigFile) && + overrideConfigFile !== null && + overrideConfigFile !== true + ) { + errors.push( + "'overrideConfigFile' must be a non-empty string, null, or true.", + ); + } + if (typeof passOnNoPatterns !== "boolean") { + errors.push("'passOnNoPatterns' must be a boolean."); + } + if (typeof plugins !== "object") { + errors.push("'plugins' must be an object or null."); + } else if (plugins !== null && Object.keys(plugins).includes("")) { + errors.push("'plugins' must not include an empty string."); + } + if (Array.isArray(plugins)) { + errors.push( + "'plugins' doesn't add plugins to configuration to load. Please use the 'overrideConfig.plugins' option instead.", + ); + } + if (typeof stats !== "boolean") { + errors.push("'stats' must be a boolean."); + } + if (typeof warnIgnored !== "boolean") { + errors.push("'warnIgnored' must be a boolean."); + } + if (typeof ruleFilter !== "function") { + errors.push("'ruleFilter' must be a function."); + } + if (typeof applySuppressions !== "boolean") { + errors.push("'applySuppressions' must be a boolean."); + } + if (!isNonEmptyString(suppressionsLocation)) { + errors.push("'suppressionsLocation' must be a non-empty string."); + } + if (errors.length > 0) { + throw new ESLintInvalidOptionsError(errors); + } + + return { + allowInlineConfig, + baseConfig, + cache, + cacheLocation, + cacheStrategy, + concurrency, + + // when overrideConfigFile is true that means don't do config file lookup + configFile: overrideConfigFile === true ? false : overrideConfigFile, + overrideConfig, + cwd: path.normalize(cwd), + errorOnUnmatchedPattern, + fix, + fixTypes, + flags: [...flags], + globInputPaths, + ignore, + ignorePatterns, + stats, + passOnNoPatterns, + warnIgnored, + ruleFilter, + applySuppressions, + suppressionsLocation, + }; +} + +/** + * Loads ESLint constructor options from an options module. + * @param {string} optionsURL The URL string of the options module to load. + * @returns {Promise} ESLint constructor options. + */ +async function loadOptionsFromModule(optionsURL) { + return (await import(optionsURL)).default; +} + +//----------------------------------------------------------------------------- +// Cache-related helpers +//----------------------------------------------------------------------------- + +/** + * return the cacheFile to be used by eslint, based on whether the provided parameter is + * a directory or looks like a directory (ends in `path.sep`), in which case the file + * name will be the `cacheFile/.cache_hashOfCWD` + * + * if cacheFile points to a file or looks like a file then in will just use that file + * @param {string} cacheFile The name of file to be used to store the cache + * @param {string} cwd Current working directory + * @param {Object} options The options + * @param {string} [options.prefix] The prefix to use for the cache file + * @returns {string} the resolved path to the cache file + */ +function getCacheFile(cacheFile, cwd, { prefix = ".cache_" } = {}) { + /* + * make sure the path separators are normalized for the environment/os + * keeping the trailing path separator if present + */ + const normalizedCacheFile = path.normalize(cacheFile); + + const resolvedCacheFile = path.resolve(cwd, normalizedCacheFile); + const looksLikeADirectory = normalizedCacheFile.slice(-1) === path.sep; + + /** + * return the name for the cache file in case the provided parameter is a directory + * @returns {string} the resolved path to the cacheFile + */ + function getCacheFileForDirectory() { + return path.join(resolvedCacheFile, `${prefix}${hash(cwd)}`); + } + + let fileStats; + + try { + fileStats = fs.lstatSync(resolvedCacheFile); + } catch { + fileStats = null; + } + + /* + * in case the file exists we need to verify if the provided path + * is a directory or a file. If it is a directory we want to create a file + * inside that directory + */ + if (fileStats) { + /* + * is a directory or is a file, but the original file the user provided + * looks like a directory but `path.resolve` removed the `last path.sep` + * so we need to still treat this like a directory + */ + if (fileStats.isDirectory() || looksLikeADirectory) { + return getCacheFileForDirectory(); + } + + // is file so just use that file + return resolvedCacheFile; + } + + /* + * here we known the file or directory doesn't exist, + * so we will try to infer if its a directory if it looks like a directory + * for the current operating system. + */ + + // if the last character passed is a path separator we assume is a directory + if (looksLikeADirectory) { + return getCacheFileForDirectory(); + } + + return resolvedCacheFile; +} + +/** + * Creates a new lint result cache. + * @param {ESLintOptions} eslintOptions The processed ESLint options. + * @param {string} cacheFilePath The path to the cache file. + * @returns {?LintResultCache} A new lint result cache or `null`. + */ +function createLintResultCache({ cache, cacheStrategy }, cacheFilePath) { + return cache ? new LintResultCache(cacheFilePath, cacheStrategy) : null; +} + +//----------------------------------------------------------------------------- +// Lint helpers +//----------------------------------------------------------------------------- + +/** + * Checks whether a message's rule type should be fixed. + * @param {LintMessage} message The message to check. + * @param {CalculatedConfig} config The config for the file that generated the message. + * @param {string[]} fixTypes An array of fix types to check. + * @returns {boolean} Whether the message should be fixed. + */ +function shouldMessageBeFixed(message, config, fixTypes) { + if (!message.ruleId) { + return fixTypes.has("directive"); + } + + const rule = message.ruleId && config.getRuleDefinition(message.ruleId); + + return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type)); +} + +/** + * Creates a fixer function based on the provided fix, fixTypesSet, and config. + * @param {Function|boolean} fix The original fix option. + * @param {Set} fixTypesSet A set of fix types to filter messages for fixing. + * @param {CalculatedConfig} config The config for the file that generated the message. + * @returns {Function|boolean} The fixer function or the original fix value. + */ +function getFixerForFixTypes(fix, fixTypesSet, config) { + if (!fix || !fixTypesSet) { + return fix; + } + + const originalFix = typeof fix === "function" ? fix : () => true; + + return message => + shouldMessageBeFixed(message, config, fixTypesSet) && + originalFix(message); +} + +/** + * Processes a source code using ESLint. + * @param {Object} config The config object. + * @param {string} config.text The source code to verify. + * @param {string} config.cwd The path to the current working directory. + * @param {string|undefined} config.filePath The path to the file of `text`. If this is undefined, it uses ``. + * @param {FlatConfigArray} config.configs The config. + * @param {boolean} config.fix If `true` then it does fix. + * @param {boolean} config.allowInlineConfig If `true` then it uses directive comments. + * @param {Function} config.ruleFilter A predicate function to filter which rules should be run. + * @param {boolean} config.stats If `true`, then if reports extra statistics with the lint results. + * @param {Linter} config.linter The linter instance to verify. + * @returns {LintResult} The result of linting. + * @private + */ +function verifyText({ + text, + cwd, + filePath: providedFilePath, + configs, + fix, + allowInlineConfig, + ruleFilter, + stats, + linter, +}) { + const startTime = hrtimeBigint(); + + const filePath = providedFilePath || ""; + + /* + * Verify. + * `config.extractConfig(filePath)` requires an absolute path, but `linter` + * doesn't know CWD, so it gives `linter` an absolute path always. + */ + const filePathToVerify = + filePath === "" ? getPlaceholderPath(cwd) : filePath; + const { fixed, messages, output } = linter.verifyAndFix(text, configs, { + allowInlineConfig, + filename: filePathToVerify, + fix, + ruleFilter, + stats, + + /** + * Check if the linter should adopt a given code block or not. + * @param {string} blockFilename The virtual filename of a code block. + * @returns {boolean} `true` if the linter should adopt the code block. + */ + filterCodeBlock(blockFilename) { + return configs.getConfig(blockFilename) !== void 0; + }, + }); + + // Tweak and return. + const result = { + filePath: filePath === "" ? filePath : path.resolve(filePath), + messages, + suppressedMessages: linter.getSuppressedMessages(), + ...calculateStatsPerFile(messages), + }; + + if (fixed) { + result.output = output; + } + + if ( + result.errorCount + result.warningCount > 0 && + typeof result.output === "undefined" + ) { + result.source = text; + } + + if (stats) { + result.stats = { + times: linter.getTimes(), + fixPasses: linter.getFixPassCount(), + }; + } + + const endTime = hrtimeBigint(); + debug('File "%s" linted in %t', filePath, endTime - startTime); + + return result; +} + +/** + * Lints a single file. + * @param {string} filePath File path to lint. + * @param {FlatConfigArray} configs The config array for the file. + * @param {ESLintOptions} eslintOptions The processed ESLint options. + * @param {Linter} linter The linter instance to use. + * @param {?LintResultCache} lintResultCache The result cache or `null`. + * @param {?{ duration: bigint; }} readFileCounter Used to keep track of the time spent reading files. + * @param {Retrier} [retrier] Used to retry linting on certain errors. + * @param {AbortController} [controller] Used to stop linting when an error occurs. + * @returns {Promise} The lint result. + */ +async function lintFile( + filePath, + configs, + eslintOptions, + linter, + lintResultCache, + readFileCounter, + retrier, + controller, +) { + const config = configs.getConfig(filePath); + const { + allowInlineConfig, + cwd, + fix, + fixTypes, + ruleFilter, + stats, + warnIgnored, + } = eslintOptions; + const fixTypesSet = fixTypes ? new Set(fixTypes) : null; + + /* + * If a filename was entered that cannot be matched + * to a config, then notify the user. + */ + if (!config) { + if (warnIgnored) { + const configStatus = configs.getConfigStatus(filePath); + + return createIgnoreResult(filePath, cwd, configStatus); + } + + return void 0; + } + + // Skip if there is cached result. + if (lintResultCache) { + const cachedResult = lintResultCache.getCachedLintResults( + filePath, + config, + ); + + if (cachedResult) { + const hadMessages = + cachedResult.messages && cachedResult.messages.length > 0; + + if (hadMessages && fix) { + debug( + "Reprocessing cached file to allow autofix: %s", + filePath, + ); + } else { + debug("Skipping file since it hasn't changed: %s", filePath); + return cachedResult; + } + } + } + + // set up fixer for fixTypes if necessary + const fixer = getFixerForFixTypes(fix, fixTypesSet, config); + + /** + * Reads the file and lints its content. + * @returns {Promise} A lint result. + */ + async function readAndVerifyFile() { + const readFileEnterTime = hrtimeBigint(); + const text = await fsp.readFile(filePath, { + encoding: "utf8", + signal: controller?.signal, + }); + const readFileExitTime = hrtimeBigint(); + const readFileDuration = readFileExitTime - readFileEnterTime; + debug('File "%s" read in %t', filePath, readFileDuration); + if (readFileCounter) { + readFileCounter.duration += readFileDuration; + } + + // fail immediately if an error occurred in another file + controller?.signal.throwIfAborted(); + + // do the linting + return verifyText({ + text, + filePath, + configs, + cwd, + fix: fixer, + allowInlineConfig, + ruleFilter, + stats, + linter, + }); + } + + // Use the retrier if provided, otherwise just call the function. + const readAndVerifyFilePromise = retrier + ? retrier.retry(readAndVerifyFile, { signal: controller?.signal }) + : readAndVerifyFile(); + + return readAndVerifyFilePromise.catch(error => { + controller?.abort(error); + throw error; + }); +} + +/** + * Retrieves flags from the environment variable ESLINT_FLAGS. + * @param {string[]} flags The flags defined via the API. + * @returns {string[]} The merged flags to use. + */ +function mergeEnvironmentFlags(flags) { + if (!process.env.ESLINT_FLAGS) { + return flags; + } + + const envFlags = process.env.ESLINT_FLAGS.trim().split(/\s*,\s*/gu); + return Array.from(new Set([...envFlags, ...flags])); +} + +/** + * Creates a new linter instance. + * @param {ESLintOptions} eslintOptions The processed ESLint options. + * @param {WarningService} warningService The warning service to use. + * @returns {Linter} The linter instance. + */ +function createLinter({ cwd, flags }, warningService) { + return new Linter({ + configType: "flat", + cwd, + flags: mergeEnvironmentFlags(flags), + warningService, + }); +} + +/** + * Creates default configs with the specified plugins. + * @param {Record | undefined} optionPlugins The plugins specified in the ESLint options. + * @returns {Config[]} The default configs. + */ +function createDefaultConfigs(optionPlugins) { + const defaultConfigs = []; + + // Add plugins + if (optionPlugins) { + const plugins = {}; + + for (const [pluginName, plugin] of Object.entries(optionPlugins)) { + plugins[getShorthandName(pluginName, "eslint-plugin")] = plugin; + } + + defaultConfigs.push({ plugins }); + } + + return defaultConfigs; +} + +/** + * Creates a config loader. + * @param {ESLintOptions} eslintOptions The processed ESLint options. + * @param {Config[]} defaultConfigs The default configs. + * @param {Linter} linter The linter instance. + * @param {WarningService} warningService The warning service to use. + * @returns {ConfigLoader} The config loader. + */ +function createConfigLoader( + { + cwd, + baseConfig, + overrideConfig, + configFile, + ignore: ignoreEnabled, + ignorePatterns, + }, + defaultConfigs, + linter, + warningService, +) { + const configLoaderOptions = { + cwd, + baseConfig, + overrideConfig, + configFile, + ignoreEnabled, + ignorePatterns, + defaultConfigs, + hasUnstableNativeNodeJsTSConfigFlag: linter.hasFlag( + "unstable_native_nodejs_ts_config", + ), + warningService, + }; + + return new ConfigLoader(configLoaderOptions); +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { + createDebug, + + findFiles, + + isNonEmptyString, + isArrayOfNonEmptyString, + + createIgnoreResult, + isErrorMessage, + getPlaceholderPath, + + processOptions, + loadOptionsFromModule, + + getCacheFile, + createLintResultCache, + + getFixerForFixTypes, + verifyText, + lintFile, + createLinter, + createDefaultConfigs, + createConfigLoader, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint.js new file mode 100644 index 00000000..c6a358d9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/eslint.js @@ -0,0 +1,1398 @@ +/** + * @fileoverview Main class using flat config + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { existsSync } = require("node:fs"); +const fs = require("node:fs/promises"); +const os = require("node:os"); +const path = require("node:path"); +const { pathToFileURL } = require("node:url"); +const { SHARE_ENV, Worker } = require("node:worker_threads"); +const { version } = require("../../package.json"); +const { defaultConfig } = require("../config/default-config"); +const timing = require("../linter/timing"); + +const { + createDebug, + + findFiles, + getCacheFile, + + isNonEmptyString, + isArrayOfNonEmptyString, + + createIgnoreResult, + isErrorMessage, + getPlaceholderPath, + + processOptions, + loadOptionsFromModule, + + getFixerForFixTypes, + verifyText, + lintFile, + createLinter, + createLintResultCache, + createDefaultConfigs, + createConfigLoader, +} = require("./eslint-helpers"); +const { Retrier } = require("@humanwhocodes/retry"); +const { ConfigLoader } = require("../config/config-loader"); +const { WarningService } = require("../services/warning-service"); +const { SuppressionsService } = require("../services/suppressions-service"); +const { Config } = require("../config/config.js"); +const { + getShorthandName, + getNamespaceFromTerm, + normalizePackageName, +} = require("../shared/naming.js"); +const { resolve } = require("../shared/relative-module-resolver.js"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +// For VSCode IntelliSense +/** + * @import { Config as CalculatedConfig } from "../config/config.js"; + * @import { FlatConfigArray } from "../config/flat-config-array.js"; + * @import { RuleDefinition, RulesMeta } from "@eslint/core"; + * @import { WorkerLintResults } from "./worker.js"; + */ + +/** @typedef {import("../types").Linter.Config} Config */ +/** @typedef {import("../types").ESLint.DeprecatedRuleUse} DeprecatedRuleInfo */ +/** @typedef {import("../types").ESLint.Options} ESLintOptions */ +/** @typedef {import("../types").ESLint.LintResult} LintResult */ +/** @typedef {import("../types").ESLint.Plugin} Plugin */ +/** @typedef {import("../types").ESLint.ResultsMeta} ResultsMeta */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const hrtimeBigint = process.hrtime.bigint; + +const debug = createDebug("eslint:eslint"); +const privateMembers = new WeakMap(); +const removedFormatters = new Set([ + "checkstyle", + "codeframe", + "compact", + "jslint-xml", + "junit", + "table", + "tap", + "unix", + "visualstudio", +]); +const fileRetryCodes = new Set(["ENFILE", "EMFILE"]); + +/** + * Create rulesMeta object. + * @param {Map} rules a map of rules from which to generate the object. + * @returns {Record} metadata for all enabled rules. + */ +function createRulesMeta(rules) { + return Array.from(rules).reduce((retVal, [id, rule]) => { + retVal[id] = rule.meta; + return retVal; + }, {}); +} + +/** + * Gets the replacement rule names from a deprecated rule's metadata. + * @param {RulesMeta} meta The rule metadata. + * @returns {string[]} Replacement rule names. + */ +function getDeprecatedRuleReplacements(meta) { + if (typeof meta.deprecated !== "object") { + return meta.replacedBy || []; + } + + const { replacedBy } = meta.deprecated; + + if (!Array.isArray(replacedBy)) { + return []; + } + + return replacedBy.map(replacement => { + if (typeof replacement !== "object" || replacement === null) { + return ""; + } + + const pluginName = replacement.plugin?.name; + const ruleName = replacement.rule?.name; + + return `${typeof pluginName === "string" ? `${getShorthandName(pluginName, "eslint-plugin")}/` : ""}${typeof ruleName === "string" ? ruleName : ""}`; + }); +} + +/** @type {WeakMap} */ +const usedDeprecatedRulesCache = new WeakMap(); + +/** + * Create used deprecated rule list. + * @param {ESLint} eslint The ESLint instance. + * @param {string} maybeFilePath The absolute path to a lint target file or `""`. + * @returns {DeprecatedRuleInfo[]} The used deprecated rule list. + */ +function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) { + const { + options: { cwd }, + configLoader, + } = privateMembers.get(eslint); + const filePath = path.isAbsolute(maybeFilePath) + ? maybeFilePath + : getPlaceholderPath(cwd); + const configs = configLoader.getCachedConfigArrayForFile(filePath); + const config = configs.getConfig(filePath); + + // Most files use the same config, so cache it. + if (config && !usedDeprecatedRulesCache.has(config)) { + const retv = []; + + if (config.rules) { + for (const [ruleId, ruleConf] of Object.entries(config.rules)) { + if (Config.getRuleNumericSeverity(ruleConf) === 0) { + continue; + } + const rule = config.getRuleDefinition(ruleId); + const meta = rule && rule.meta; + + if (meta && meta.deprecated) { + const usesNewFormat = typeof meta.deprecated === "object"; + + retv.push({ + ruleId, + replacedBy: getDeprecatedRuleReplacements(meta), + info: usesNewFormat ? meta.deprecated : void 0, + }); + } + } + } + + usedDeprecatedRulesCache.set(config, Object.freeze(retv)); + } + + return config ? usedDeprecatedRulesCache.get(config) : Object.freeze([]); +} + +/** + * Processes the linting results generated by a CLIEngine linting report to + * match the ESLint class's API. + * @param {ESLint} eslint The ESLint instance. + * @param {LintResult[]} results The linting results to process. + * @returns {LintResult[]} The processed linting results. + */ +function processLintReport(eslint, results) { + const descriptor = { + configurable: true, + enumerable: true, + get() { + return getOrFindUsedDeprecatedRules(eslint, this.filePath); + }, + }; + + for (const result of results) { + Object.defineProperty(result, "usedDeprecatedRules", descriptor); + } + + return results; +} + +/** + * An Array.prototype.sort() compatible compare function to order results by their file path. + * @param {LintResult} a The first lint result. + * @param {LintResult} b The second lint result. + * @returns {number} An integer representing the order in which the two results should occur. + */ +function compareResultsByFilePath(a, b) { + if (a.filePath < b.filePath) { + return -1; + } + + if (a.filePath > b.filePath) { + return 1; + } + + return 0; +} + +/** + * Determines which config file to use. This is determined by seeing if an + * override config file was passed, and if so, using it; otherwise, as long + * as override config file is not explicitly set to `false`, it will search + * upwards from the cwd for an `eslint.config.*` file. + * + * This function is used primarily by the `--inspect-config` option. For now, + * we will maintain the existing behavior, which is to search up from the cwd. + * @param {{ configFile: string | undefined; cwd: string; }} options Config file location options. + * @returns {Promise<{configFilePath:string|undefined;basePath:string}>} Location information for + * the config file. + */ +async function locateConfigFileToUse({ configFile, cwd }) { + const configLoader = new ConfigLoader({ + cwd, + configFile, + }); + + const configFilePath = await configLoader.findConfigFileForPath( + path.join(cwd, "__placeholder__.js"), + ); + + if (!configFilePath) { + throw new Error("No ESLint configuration file was found."); + } + + return { + configFilePath, + basePath: configFile ? cwd : path.dirname(configFilePath), + }; +} + +/** + * Creates an error to be thrown when an array of results passed to `getRulesMetaForResults` was not created by the current engine. + * @param {Error|undefined} cause The original error that led to this symptom error being thrown. Might not always be available. + * @returns {TypeError} An error object. + */ +function createExtraneousResultsError(cause) { + return new TypeError( + "Results object was not created from this ESLint instance.", + { + cause, + }, + ); +} + +/** + * Maximum number of files assumed to be best handled by one worker thread. + * This value is a heuristic estimation that can be adjusted if required. + */ +const AUTO_FILES_PER_WORKER = 50; + +/** + * Calculates the number of worker threads to run for "auto" concurrency depending on the number of + * files that need to be processed. + * + * The number of worker threads is calculated as the number of files that need to be processed + * (`processableFileCount`) divided by the number of files assumed to be best handled by one worker + * thread (`AUTO_FILES_PER_WORKER`), rounded up to the next integer. + * Two adjustments are made to this calculation: first, the number of workers is capped at half the + * number of available CPU cores (`maxWorkers`); second, a value of 1 is converted to 0. + * The following table shows the relationship between the number of files to be processed and the + * number of workers: + * + * Files to be processed | Workers + * -------------------------------------------------------------------|----------------- + * 0 | 0 + * 1, 2, …, AUTO_FILES_PER_WORKER | 0 (there's no 1) + * AUTO_FILES_PER_WORKER + 1, …, AUTO_FILES_PER_WORKER * 2 | 2 + * AUTO_FILES_PER_WORKER * 2 + 1, …, AUTO_FILES_PER_WORKER * 3 | 3 + * ⋯ | ⋯ + * AUTO_FILES_PER_WORKER * (𝑛 - 1) + 1, …, AUTO_FILES_PER_WORKER * 𝑛 | 𝑛 + * ⋯ | ⋯ + * AUTO_FILES_PER_WORKER * (maxWorkers - 1) + 1, … | maxWorkers + * + * The number of files to be processed should be determined by the calling function. + * @param {number} processableFileCount The number of files that need to be processed. + * @param {number} maxWorkers The maximum number of workers to run. + * @returns {number} The number of worker threads to run. + */ +function getWorkerCountFor(processableFileCount, maxWorkers) { + let workerCount = Math.ceil(processableFileCount / AUTO_FILES_PER_WORKER); + if (workerCount > maxWorkers) { + workerCount = maxWorkers; + } + if (workerCount <= 1) { + workerCount = 0; + } + return workerCount; +} + +/** + * Returns true if a file has no valid cached results or if it needs to be reprocessed because there are violations that may need fixing. + * This function will access the filesystem. + * @param {LintResultCache} lintResultCache The lint result cache. + * @param {boolean} fix The fix option. + * @param {string} filePath The file for which to retrieve lint results. + * @param {Config} config The config of the file. + * @returns {boolean} True if the file needs to be reprocessed. + */ +function needsReprocessing(lintResultCache, fix, filePath, config) { + const results = lintResultCache.getValidCachedLintResults(filePath, config); + + // This reflects the reprocessing logic of the `lintFile` helper function. + return !results || (fix && results.messages && results.messages.length > 0); +} + +/** + * Calculates the number of worker threads to run for "auto" concurrency. + * + * The number of worker threads depends on the number files that need to be processed. + * Typically, this includes all non-ignored files. + * In a cached run with "metadata" strategy, files with a valid cached result aren't counted. + * @param {ESLint} eslint ESLint instance. + * @param {string[]} filePaths File paths to lint. + * @param {number} maxWorkers The maximum number of workers to run. + * @returns {number} The number of worker threads to run for "auto" concurrency. + */ +function calculateAutoWorkerCount(eslint, filePaths, maxWorkers) { + const startTime = hrtimeBigint(); + const { + configLoader, + lintResultCache, + options: { cacheStrategy, fix }, + } = privateMembers.get(eslint); + /** True if cache is not used or if strategy is "content". */ + const countAllMatched = !lintResultCache || cacheStrategy === "content"; + + let processableFileCount = 0; + let remainingFiles = filePaths.length; + + /** The number of workers if none of the remaining files were to be counted. */ + let lowWorkerCount = 0; + + /* + * Rather than counting all files to be processed in advance, we stop iterating as soon as we reach + * a point where adding more files doesn't change the number of workers anymore. + */ + for (const filePath of filePaths) { + /** The number of workers if all of the remaining files were to be counted. */ + const highWorkerCount = getWorkerCountFor( + processableFileCount + remainingFiles, + maxWorkers, + ); + if (lowWorkerCount >= highWorkerCount) { + // The highest possible number of workers has been reached, so stop counting. + break; + } + remainingFiles--; + const configs = configLoader.getCachedConfigArrayForFile(filePath); + const config = configs.getConfig(filePath); + if (!config) { + // file is ignored + continue; + } + if ( + countAllMatched || + needsReprocessing(lintResultCache, fix, filePath, config) + ) { + processableFileCount++; + lowWorkerCount = getWorkerCountFor( + processableFileCount, + maxWorkers, + ); + } + } + debug( + "%d file(s) to process counted in %t", + processableFileCount, + hrtimeBigint() - startTime, + ); + return lowWorkerCount; +} + +/** + * Calculates the number of workers to run based on the concurrency setting and the number of files to lint. + * @param {ESLint} eslint The ESLint instance. + * @param {string[]} filePaths File paths to lint. + * @param {{ availableParallelism: () => number }} [os] Node.js `os` module, or a mock for testing. + * @returns {number} The effective number of worker threads to be started. A value of zero disables multithread linting. + */ +function calculateWorkerCount( + eslint, + filePaths, + { availableParallelism } = os, +) { + const { concurrency } = privateMembers.get(eslint).options; + switch (concurrency) { + case "off": + return 0; + case "auto": { + const maxWorkers = availableParallelism() >> 1; + return calculateAutoWorkerCount(eslint, filePaths, maxWorkers); + } + default: { + const workerCount = Math.min(concurrency, filePaths.length); + return workerCount > 1 ? workerCount : 0; + } + } +} + +// Used internally. Do not expose. +const disableCloneabilityCheck = Symbol( + "Do not check for uncloneable options.", +); + +/** + * The smallest net linting ratio that doesn't trigger a poor concurrency warning. + * The net linting ratio is defined as the net linting duration divided by the thread's total runtime, + * where the net linting duration is the total linting time minus the time spent on I/O-intensive operations: + * **Net Linting Ratio** = (**Linting Time** – **I/O Time**) / **Thread Runtime**. + * - **Linting Time**: Total time spent linting files + * - **I/O Time**: Portion of linting time spent loading configs and reading files + * - **Thread Runtime**: End-to-end execution time of the thread + * + * This value is a heuristic estimation that can be adjusted if required. + */ +const LOW_NET_LINTING_RATIO = 0.7; + +/** + * Runs worker threads to lint files. + * @param {string[]} filePaths File paths to lint. + * @param {number} workerCount The number of worker threads to run. + * @param {ESLintOptions | string} eslintOptionsOrURL The unprocessed ESLint options or the URL of the options module. + * @param {() => void} warnOnLowNetLintingRatio A function to call if the net linting ratio is low. + * @returns {Promise} Lint results. + */ +async function runWorkers( + filePaths, + workerCount, + eslintOptionsOrURL, + warnOnLowNetLintingRatio, +) { + const fileCount = filePaths.length; + const results = Array(fileCount); + const workerURL = pathToFileURL(path.join(__dirname, "./worker.js")); + const filePathIndexArray = new Uint32Array( + new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT), + ); + const abortController = new AbortController(); + const abortSignal = abortController.signal; + const workerOptions = { + env: SHARE_ENV, + workerData: { + eslintOptionsOrURL, + filePathIndexArray, + filePaths, + }, + }; + + let worstNetLintingRatio = 1; + + /** + * A promise executor function that starts a worker thread on each invocation. + * @param {() => void} resolve_ Called when the worker thread terminates successfully. + * @param {(error: Error) => void} reject Called when the worker thread terminates with an error. + * @returns {void} + */ + function workerExecutor(resolve_, reject) { + const workerStartTime = hrtimeBigint(); + const worker = new Worker(workerURL, workerOptions); + worker.once( + "message", + (/** @type {WorkerLintResults} */ indexedResults) => { + const workerDuration = hrtimeBigint() - workerStartTime; + + // The net linting ratio provides an approximate measure of worker thread efficiency, defined as the net linting duration divided by the thread's total runtime. + const netLintingRatio = + Number(indexedResults.netLintingDuration) / + Number(workerDuration); + + worstNetLintingRatio = Math.min( + worstNetLintingRatio, + netLintingRatio, + ); + + if (timing.enabled && indexedResults.timings) { + timing.mergeData(indexedResults.timings); + } + + for (const result of indexedResults) { + const { index } = result; + delete result.index; + results[index] = result; + } + resolve_(); + }, + ); + worker.once("error", error => { + abortController.abort(error); + reject(error); + }); + abortSignal.addEventListener("abort", () => worker.terminate()); + } + + const promises = Array(workerCount); + for (let index = 0; index < workerCount; ++index) { + promises[index] = new Promise(workerExecutor); + } + + try { + await Promise.all(promises); + } catch (error) { + /* + * If any worker fails, suppress timing display in the main thread + * to avoid printing partial or misleading timing output. + */ + timing.disableDisplay(); + throw error; + } + + if (worstNetLintingRatio < LOW_NET_LINTING_RATIO) { + warnOnLowNetLintingRatio(); + } + + return results; +} + +/** + * Lint files in multithread mode. + * @param {ESLint} eslint ESLint instance. + * @param {string[]} filePaths File paths to lint. + * @param {number} workerCount The number of worker threads to run. + * @param {ESLintOptions | string} eslintOptionsOrURL The unprocessed ESLint options or the URL of the options module. + * @param {() => void} warnOnLowNetLintingRatio A function to call if the net linting ratio is low. + * @returns {Promise} Lint results. + */ +async function lintFilesWithMultithreading( + eslint, + filePaths, + workerCount, + eslintOptionsOrURL, + warnOnLowNetLintingRatio, +) { + const { configLoader, lintResultCache } = privateMembers.get(eslint); + + const results = await runWorkers( + filePaths, + workerCount, + eslintOptionsOrURL, + warnOnLowNetLintingRatio, + ); + // Persist the cache to disk. + if (lintResultCache) { + results.forEach((result, index) => { + if (result) { + const filePath = filePaths[index]; + const configs = + configLoader.getCachedConfigArrayForFile(filePath); + const config = configs.getConfig(filePath); + + if (config) { + /* + * Store the lint result in the LintResultCache. + * NOTE: The LintResultCache will remove the file source and any + * other properties that are difficult to serialize, and will + * hydrate those properties back in on future lint runs. + */ + lintResultCache.setCachedLintResults( + filePath, + config, + result, + ); + } + } + }); + } + return results; +} + +/** + * Lint files in single-thread mode. + * @param {ESLint} eslint ESLint instance. + * @param {string[]} filePaths File paths to lint. + * @returns {Promise} Lint results. + */ +async function lintFilesWithoutMultithreading(eslint, filePaths) { + const { + configLoader, + linter, + lintResultCache, + options: eslintOptions, + } = privateMembers.get(eslint); + + const controller = new AbortController(); + const retrier = new Retrier(error => fileRetryCodes.has(error.code), { + concurrency: 100, + }); + + /* + * Because we need to process multiple files, including reading from disk, + * it is most efficient to start by reading each file via promises so that + * they can be done in parallel. Then, we can lint the returned text. This + * ensures we are waiting the minimum amount of time in between lints. + */ + const results = await Promise.all( + filePaths.map(async filePath => { + const configs = configLoader.getCachedConfigArrayForFile(filePath); + const config = configs.getConfig(filePath); + + const result = await lintFile( + filePath, + configs, + eslintOptions, + linter, + lintResultCache, + null, + retrier, + controller, + ); + + if (config) { + /* + * Store the lint result in the LintResultCache. + * NOTE: The LintResultCache will remove the file source and any + * other properties that are difficult to serialize, and will + * hydrate those properties back in on future lint runs. + */ + lintResultCache?.setCachedLintResults(filePath, config, result); + } + + return result; + }), + ); + return results; +} + +/** + * Throws an error if the given options are not cloneable. + * @param {ESLintOptions} options The options to check. + * @returns {void} + * @throws {TypeError} If the options are not cloneable. + */ +function validateOptionCloneability(options) { + try { + structuredClone(options); + return; + } catch { + // continue + } + const uncloneableOptionKeys = Object.keys(options) + .filter(key => { + try { + structuredClone(options[key]); + } catch { + return true; + } + return false; + }) + .sort(); + const error = new TypeError( + `The ${uncloneableOptionKeys.length === 1 ? "option" : "options"} ${new Intl.ListFormat("en-US").format(uncloneableOptionKeys.map(key => `"${key}"`))} cannot be cloned. When concurrency is enabled, all options must be cloneable values (JSON values). Remove uncloneable options or use an options module.`, + ); + error.code = "ESLINT_UNCLONEABLE_OPTIONS"; + throw error; +} + +//----------------------------------------------------------------------------- +// Main API +//----------------------------------------------------------------------------- + +/** + * Primary Node.js API for ESLint. + */ +class ESLint { + /** + * The type of configuration used by this class. + * @type {string} + */ + static configType = "flat"; + + /** + * The loader to use for finding config files. + * @type {ConfigLoader} + */ + #configLoader; + + /** + * The unprocessed options or the URL of the options module. Only set when concurrency is enabled. + * @type {ESLintOptions | string | undefined} + */ + #optionsOrURL; + + /** + * Creates a new instance of the main ESLint API. + * @param {ESLintOptions} options The options for this instance. + */ + constructor(options = {}) { + const processedOptions = processOptions(options); + if ( + !options[disableCloneabilityCheck] && + processedOptions.concurrency !== "off" + ) { + validateOptionCloneability(options); + + // Save the unprocessed options in an instance field to pass to worker threads in `lintFiles()`. + this.#optionsOrURL = options; + } + const warningService = new WarningService(); + const linter = createLinter(processedOptions, warningService); + + const cacheFilePath = getCacheFile( + processedOptions.cacheLocation, + processedOptions.cwd, + ); + + const lintResultCache = createLintResultCache( + processedOptions, + cacheFilePath, + ); + + let suppressionsService = null; + if (processedOptions.applySuppressions) { + const suppressionsFilePath = getCacheFile( + processedOptions.suppressionsLocation, + processedOptions.cwd, + { prefix: "suppressions_" }, + ); + suppressionsService = new SuppressionsService({ + filePath: suppressionsFilePath, + cwd: processedOptions.cwd, + }); + } + + const defaultConfigs = createDefaultConfigs(options.plugins); + + this.#configLoader = createConfigLoader( + processedOptions, + defaultConfigs, + linter, + warningService, + ); + + privateMembers.set(this, { + options: processedOptions, + linter, + cacheFilePath, + lintResultCache, + defaultConfigs, + configs: null, + configLoader: this.#configLoader, + warningService, + suppressionsService, + }); + + // Check for the .eslintignore file, and warn if it's present. + if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) { + warningService.emitESLintIgnoreWarning(); + } + } + + /** + * The version text. + * @type {string} + */ + static get version() { + return version; + } + + /** + * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint. + * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present. + * @type {FlatConfigArray} + */ + static get defaultConfig() { + return defaultConfig; + } + + /** + * Outputs fixes from the given results to files. + * @param {LintResult[]} results The lint results. + * @returns {Promise} Returns a promise that is used to track side effects. + */ + static async outputFixes(results) { + if (!Array.isArray(results)) { + throw new Error("'results' must be an array"); + } + + const retrier = new Retrier(error => fileRetryCodes.has(error.code), { + concurrency: 100, + }); + + await Promise.all( + results + .filter(result => { + if (typeof result !== "object" || result === null) { + throw new Error("'results' must include only objects"); + } + return ( + typeof result.output === "string" && + path.isAbsolute(result.filePath) + ); + }) + .map(r => + retrier.retry(() => fs.writeFile(r.filePath, r.output)), + ), + ); + } + + /** + * Returns results that only contains errors. + * @param {LintResult[]} results The results to filter. + * @returns {LintResult[]} The filtered results. + */ + static getErrorResults(results) { + const filtered = []; + + results.forEach(result => { + const filteredMessages = result.messages.filter(isErrorMessage); + const filteredSuppressedMessages = + result.suppressedMessages.filter(isErrorMessage); + + if (filteredMessages.length > 0) { + filtered.push({ + ...result, + messages: filteredMessages, + suppressedMessages: filteredSuppressedMessages, + errorCount: filteredMessages.length, + warningCount: 0, + fixableErrorCount: result.fixableErrorCount, + fixableWarningCount: 0, + }); + } + }); + + return filtered; + } + + /** + * Creates a new ESLint instance using options loaded from a module. + * @param {URL} optionsURL The URL of the options module. + * @returns {ESLint} The new ESLint instance. + */ + static async fromOptionsModule(optionsURL) { + if (!(optionsURL instanceof URL)) { + throw new TypeError("Argument must be a URL object"); + } + const optionsURLString = optionsURL.href; + const loadedOptions = await loadOptionsFromModule(optionsURLString); + const options = { ...loadedOptions, [disableCloneabilityCheck]: true }; + const eslint = new ESLint(options); + + if (options.concurrency !== "off") { + // Save the options module URL in an instance field to pass to worker threads in `lintFiles()`. + eslint.#optionsOrURL = optionsURLString; + } + return eslint; + } + + /** + * Returns meta objects for each rule represented in the lint results. + * @param {LintResult[]} results The results to fetch rules meta for. + * @returns {Record} A mapping of ruleIds to rule meta objects. + * @throws {TypeError} When the results object wasn't created from this ESLint instance. + * @throws {TypeError} When a plugin or rule is missing. + */ + getRulesMetaForResults(results) { + // short-circuit simple case + if (results.length === 0) { + return {}; + } + + const resultRules = new Map(); + const { + configLoader, + options: { cwd }, + } = privateMembers.get(this); + + for (const result of results) { + /* + * Normalize filename for . + */ + const filePath = + result.filePath === "" + ? getPlaceholderPath(cwd) + : result.filePath; + const allMessages = result.messages.concat( + result.suppressedMessages, + ); + + for (const { ruleId } of allMessages) { + if (!ruleId) { + continue; + } + + /* + * All of the plugin and rule information is contained within the + * calculated config for the given file. + */ + let configs; + + try { + configs = + configLoader.getCachedConfigArrayForFile(filePath); + } catch (err) { + throw createExtraneousResultsError(err); + } + + const config = configs.getConfig(filePath); + + if (!config) { + throw createExtraneousResultsError(); + } + const rule = config.getRuleDefinition(ruleId); + + // ignore unknown rules + if (rule) { + resultRules.set(ruleId, rule); + } + } + } + + return createRulesMeta(resultRules); + } + + /** + * Indicates if the given feature flag is enabled for this instance. + * @param {string} flag The feature flag to check. + * @returns {boolean} `true` if the feature flag is enabled, `false` if not. + */ + hasFlag(flag) { + // note: Linter does validation of the flags + return privateMembers.get(this).linter.hasFlag(flag); + } + + /** + * Executes the current configuration on an array of file and directory names. + * @param {string|string[]} patterns An array of file and directory names. + * @returns {Promise} The results of linting the file patterns given. + */ + async lintFiles(patterns) { + let normalizedPatterns = patterns; + const { + cacheFilePath, + lintResultCache, + options: eslintOptions, + warningService, + suppressionsService, + } = privateMembers.get(this); + + /* + * Special cases: + * 1. `patterns` is an empty string + * 2. `patterns` is an empty array + * + * In both cases, we use the cwd as the directory to lint. + */ + if ( + patterns === "" || + (Array.isArray(patterns) && patterns.length === 0) + ) { + /* + * Special case: If `passOnNoPatterns` is true, then we just exit + * without doing any work. + */ + if (eslintOptions.passOnNoPatterns) { + return []; + } + + normalizedPatterns = ["."]; + } else { + if ( + !isNonEmptyString(patterns) && + !isArrayOfNonEmptyString(patterns) + ) { + throw new Error( + "'patterns' must be a non-empty string or an array of non-empty strings", + ); + } + + if (typeof patterns === "string") { + normalizedPatterns = [patterns]; + } + } + + debug("Using file patterns: %s", normalizedPatterns); + + const { concurrency, cwd, globInputPaths, errorOnUnmatchedPattern } = + eslintOptions; + + // Delete cache file; should this be done here? + if (!lintResultCache && cacheFilePath) { + debug("Deleting cache file at %s", cacheFilePath); + + try { + if (existsSync(cacheFilePath)) { + await fs.unlink(cacheFilePath); + } + } catch (error) { + if (existsSync(cacheFilePath)) { + throw error; + } + } + } + + const startTime = hrtimeBigint(); + const filePaths = await findFiles({ + patterns: normalizedPatterns, + cwd, + globInputPaths, + configLoader: this.#configLoader, + errorOnUnmatchedPattern, + }); + debug( + "%d file(s) found in %t", + filePaths.length, + hrtimeBigint() - startTime, + ); + + /** @type {LintResult[]} */ + let results; + + // The value of `module.exports.calculateWorkerCount` can be overridden in tests. + const workerCount = module.exports.calculateWorkerCount( + this, + filePaths, + ); + if (workerCount) { + debug("Linting using %d worker thread(s).", workerCount); + let poorConcurrencyNotice; + if (workerCount <= 2) { + poorConcurrencyNotice = "disable concurrency"; + } else { + if (concurrency === "auto") { + poorConcurrencyNotice = + "disable concurrency or use a numeric concurrency setting"; + } else { + poorConcurrencyNotice = "reduce or disable concurrency"; + } + } + results = await lintFilesWithMultithreading( + this, + filePaths, + workerCount, + this.#optionsOrURL, + () => + warningService.emitPoorConcurrencyWarning( + poorConcurrencyNotice, + ), + ); + } else { + debug("Linting in single-thread mode."); + results = await lintFilesWithoutMultithreading(this, filePaths); + } + + // Persist the cache to disk. + if (lintResultCache) { + lintResultCache.reconcile(); + } + + const unsuppressedResults = results.filter(result => !!result); + + if (!eslintOptions.applySuppressions) { + return processLintReport(this, unsuppressedResults); + } + + const { results: suppressedResults } = + suppressionsService.applySuppressions( + unsuppressedResults, + await suppressionsService.load(), + ); + + return processLintReport(this, suppressedResults); + } + + /** + * Executes the current configuration on text. + * @param {string} code A string of JavaScript code to lint. + * @param {Object} [options] The options. + * @param {string} [options.filePath] The path to the file of the source code. + * @param {boolean} [options.warnIgnored] When set to true, warn if given filePath is an ignored path. + * @returns {Promise} The results of linting the string of code given. + */ + async lintText(code, options = {}) { + // Parameter validation + + if (typeof code !== "string") { + throw new Error("'code' must be a string"); + } + + if (typeof options !== "object") { + throw new Error("'options' must be an object, null, or undefined"); + } + + // Options validation + + const { filePath, warnIgnored, ...unknownOptions } = options || {}; + + const unknownOptionKeys = Object.keys(unknownOptions); + + if (unknownOptionKeys.length > 0) { + throw new Error( + `'options' must not include the unknown option(s): ${unknownOptionKeys.join(", ")}`, + ); + } + + if (filePath !== void 0 && !isNonEmptyString(filePath)) { + throw new Error( + "'options.filePath' must be a non-empty string or undefined", + ); + } + + if ( + typeof warnIgnored !== "boolean" && + typeof warnIgnored !== "undefined" + ) { + throw new Error( + "'options.warnIgnored' must be a boolean or undefined", + ); + } + + // Now we can get down to linting + + const { + linter, + options: eslintOptions, + suppressionsService, + } = privateMembers.get(this); + const { + allowInlineConfig, + cwd, + fix, + fixTypes, + warnIgnored: constructorWarnIgnored, + ruleFilter, + stats, + } = eslintOptions; + const results = []; + const startTime = hrtimeBigint(); + const fixTypesSet = fixTypes ? new Set(fixTypes) : null; + const resolvedFilename = path.resolve( + cwd, + filePath || "__placeholder__.js", + ); + const configs = + await this.#configLoader.loadConfigArrayForFile(resolvedFilename); + const configStatus = + configs?.getConfigStatus(resolvedFilename) ?? "unconfigured"; + + // Clear the last used config arrays. + if (resolvedFilename && configStatus !== "matched") { + const shouldWarnIgnored = + typeof warnIgnored === "boolean" + ? warnIgnored + : constructorWarnIgnored; + + if (shouldWarnIgnored) { + results.push( + createIgnoreResult(resolvedFilename, cwd, configStatus), + ); + } + } else { + const config = configs.getConfig(resolvedFilename); + const fixer = getFixerForFixTypes(fix, fixTypesSet, config); + + // Do lint. + results.push( + verifyText({ + text: code, + filePath: resolvedFilename.endsWith("__placeholder__.js") + ? "" + : resolvedFilename, + configs, + cwd, + fix: fixer, + allowInlineConfig, + ruleFilter, + stats, + linter, + }), + ); + } + + debug("Linting complete in %t", hrtimeBigint() - startTime); + + if (!filePath || !eslintOptions.applySuppressions) { + return processLintReport(this, results); + } + + const { results: suppressedResults } = + suppressionsService.applySuppressions( + results, + await suppressionsService.load(), + ); + return processLintReport(this, suppressedResults); + } + + /** + * Returns the formatter representing the given formatter name. + * @param {string} [name] The name of the formatter to load. + * The following values are allowed: + * - `undefined` ... Load `stylish` builtin formatter. + * - A builtin formatter name ... Load the builtin formatter. + * - A third-party formatter name: + * - `foo` → `eslint-formatter-foo` + * - `@foo` → `@foo/eslint-formatter` + * - `@foo/bar` → `@foo/eslint-formatter-bar` + * - A file path ... Load the file. + * @returns {Promise} A promise resolving to the formatter object. + * This promise will be rejected if the given formatter was not found or not + * a function. + */ + async loadFormatter(name = "stylish") { + if (typeof name !== "string") { + throw new Error("'name' must be a string"); + } + + // replace \ with / for Windows compatibility + const normalizedFormatName = name.replace(/\\/gu, "/"); + const namespace = getNamespaceFromTerm(normalizedFormatName); + + // grab our options + const { cwd } = privateMembers.get(this).options; + + let formatterPath; + let isBuiltInFormatter = false; + + // if there's a slash, then it's a file (TODO: this check seems dubious for scoped npm packages) + if (!namespace && normalizedFormatName.includes("/")) { + formatterPath = path.resolve(cwd, normalizedFormatName); + } else { + try { + const npmFormat = normalizePackageName( + normalizedFormatName, + "eslint-formatter", + ); + + // TODO: This is pretty dirty...would be nice to clean up at some point. + formatterPath = resolve(npmFormat, getPlaceholderPath(cwd)); + } catch { + formatterPath = path.resolve( + __dirname, + "../", + "cli-engine", + "formatters", + `${normalizedFormatName}.js`, + ); + isBuiltInFormatter = true; + } + } + + let formatter; + + try { + formatter = (await import(pathToFileURL(formatterPath))).default; + } catch (ex) { + // check for formatters that have been removed + if (isBuiltInFormatter && removedFormatters.has(name)) { + ex.message = `The ${name} formatter is no longer part of core ESLint. Install it manually with \`npm install -D eslint-formatter-${name}\``; + } else { + ex.message = `There was a problem loading formatter: ${formatterPath}\nError: ${ex.message}`; + } + + throw ex; + } + + if (typeof formatter !== "function") { + throw new TypeError( + `Formatter must be a function, but got a ${typeof formatter}.`, + ); + } + + const eslint = this; + + return { + /** + * The main formatter method. + * @param {LintResult[]} results The lint results to format. + * @param {ResultsMeta} resultsMeta Warning count and max threshold. + * @returns {string} The formatted lint results. + */ + format(results, resultsMeta) { + let rulesMeta = null; + + results.sort(compareResultsByFilePath); + + return formatter(results, { + ...resultsMeta, + cwd, + get rulesMeta() { + if (!rulesMeta) { + rulesMeta = eslint.getRulesMetaForResults(results); + } + + return rulesMeta; + }, + }); + }, + }; + } + + /** + * Returns a configuration object for the given file based on the CLI options. + * This is the same logic used by the ESLint CLI executable to determine + * configuration for each file it processes. + * @param {string} filePath The path of the file to retrieve a config object for. + * @returns {Promise} A configuration object for the file + * or `undefined` if there is no configuration data for the object. + */ + async calculateConfigForFile(filePath) { + if (!isNonEmptyString(filePath)) { + throw new Error("'filePath' must be a non-empty string"); + } + const options = privateMembers.get(this).options; + const absolutePath = path.resolve(options.cwd, filePath); + const configs = + await this.#configLoader.loadConfigArrayForFile(absolutePath); + + if (!configs) { + const error = new Error("Could not find config file."); + + error.messageTemplate = "config-file-missing"; + throw error; + } + + return configs.getConfig(absolutePath); + } + + /** + * Finds the config file being used by this instance based on the options + * passed to the constructor. + * @param {string} [filePath] The path of the file to find the config file for. + * @returns {Promise} The path to the config file being used or + * `undefined` if no config file is being used. + */ + async findConfigFile(filePath) { + const options = privateMembers.get(this).options; + + /* + * Because the new config lookup scheme skips the current directory + * and looks into the parent directories, we need to use a placeholder + * directory to ensure the file in cwd is checked. + */ + const fakeCwd = path.join(options.cwd, "__placeholder__"); + + return this.#configLoader + .findConfigFileForPath(filePath ?? fakeCwd) + .catch(() => void 0); + } + + /** + * Checks if a given path is ignored by ESLint. + * @param {string} filePath The path of the file to check. + * @returns {Promise} Whether or not the given path is ignored. + */ + async isPathIgnored(filePath) { + const config = await this.calculateConfigForFile(filePath); + + return config === void 0; + } +} + +/** + * Returns whether flat config should be used. + * @returns {Promise} Whether flat config should be used. + */ +async function shouldUseFlatConfig() { + return true; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + ESLint, + shouldUseFlatConfig, + locateConfigFileToUse, + calculateWorkerCount, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/index.js new file mode 100644 index 00000000..a3cb6a40 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/index.js @@ -0,0 +1,7 @@ +"use strict"; + +const { ESLint } = require("./eslint"); + +module.exports = { + ESLint, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/worker.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/worker.js new file mode 100644 index 00000000..7001bf21 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/eslint/worker.js @@ -0,0 +1,173 @@ +/** + * @fileoverview Worker thread for multithread linting. + * @author Francesco Trotta + */ + +"use strict"; + +const hrtimeBigint = process.hrtime.bigint; + +const startTime = hrtimeBigint(); + +// eslint-disable-next-line n/no-unsupported-features/node-builtins -- enable V8's code cache if supported +require("node:module").enableCompileCache?.(); + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { parentPort, threadId, workerData } = require("node:worker_threads"); +const { + createConfigLoader, + createDebug, + createDefaultConfigs, + createLinter, + createLintResultCache, + getCacheFile, + lintFile, + loadOptionsFromModule, + processOptions, +} = require("./eslint-helpers"); +const { WarningService } = require("../services/warning-service"); +const timing = require("../linter/timing"); + +const depsLoadedTime = hrtimeBigint(); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @typedef {import("../types").ESLint.LintResult} LintResult */ +/** @typedef {import("../types").ESLint.Options} ESLintOptions */ +/** @typedef {LintResult & { index?: number; }} IndexedLintResult */ +/** @typedef {IndexedLintResult[] & { netLintingDuration: bigint; timings?: Record; }} WorkerLintResults */ +/** + * @typedef {Object} WorkerData - Data passed to the worker thread. + * @property {ESLintOptions | string} eslintOptionsOrURL - The unprocessed ESLint options or the URL of the options module. + * @property {Uint32Array} filePathIndexArray - Shared counter used to track the next file to lint. + * @property {string[]} filePaths - File paths to lint. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const debug = createDebug(`eslint:worker:thread-${threadId}`); + +//------------------------------------------------------------------------------ +// Main +//------------------------------------------------------------------------------ + +/* + * Prevent timing module from printing profiling output from worker threads. + * The main thread is responsible for displaying any aggregated timings. + */ +timing.disableDisplay(); + +debug("Dependencies loaded in %t", depsLoadedTime - startTime); + +(async () => { + /** @type {WorkerData} */ + const { eslintOptionsOrURL, filePathIndexArray, filePaths } = workerData; + const eslintOptions = + typeof eslintOptionsOrURL === "object" + ? eslintOptionsOrURL + : await loadOptionsFromModule(eslintOptionsOrURL); + const processedESLintOptions = processOptions(eslintOptions); + + const warningService = new WarningService(); + + // These warnings are always emitted by the controlling thread. + warningService.emitEmptyConfigWarning = + warningService.emitInactiveFlagWarning = () => {}; + + const linter = createLinter(processedESLintOptions, warningService); + + const cacheFilePath = getCacheFile( + processedESLintOptions.cacheLocation, + processedESLintOptions.cwd, + ); + + const lintResultCache = createLintResultCache( + processedESLintOptions, + cacheFilePath, + ); + const defaultConfigs = createDefaultConfigs(eslintOptions.plugins); + + const configLoader = createConfigLoader( + processedESLintOptions, + defaultConfigs, + linter, + warningService, + ); + + /** @type {WorkerLintResults} */ + const indexedResults = []; + let loadConfigTotalDuration = 0n; + const readFileCounter = { duration: 0n }; + + const lintingStartTime = hrtimeBigint(); + debug( + "Linting started %t after dependencies loaded", + lintingStartTime - depsLoadedTime, + ); + + for (;;) { + const fileLintingStartTime = hrtimeBigint(); + + // It seems hard to produce an arithmetic overflow under realistic conditions here. + const index = Atomics.add(filePathIndexArray, 0, 1); + + const filePath = filePaths[index]; + if (!filePath) { + break; + } + + const loadConfigEnterTime = hrtimeBigint(); + const configs = await configLoader.loadConfigArrayForFile(filePath); + const loadConfigExitTime = hrtimeBigint(); + const loadConfigDuration = loadConfigExitTime - loadConfigEnterTime; + debug( + 'Config array for file "%s" loaded in %t', + filePath, + loadConfigDuration, + ); + loadConfigTotalDuration += loadConfigDuration; + + /** @type {IndexedLintResult} */ + const result = await lintFile( + filePath, + configs, + processedESLintOptions, + linter, + lintResultCache, + readFileCounter, + ); + if (result) { + result.index = index; + indexedResults.push(result); + } + + const fileLintingEndTime = hrtimeBigint(); + debug( + 'File "%s" processed in %t', + filePath, + fileLintingEndTime - fileLintingStartTime, + ); + } + + const lintingDuration = hrtimeBigint() - lintingStartTime; + + /* + * The net linting duration is the total linting time minus the time spent loading configs and reading files. + * It captures the processing time dedicated to computation-intensive tasks that are highly parallelizable and not repeated across threads. + */ + indexedResults.netLintingDuration = + lintingDuration - loadConfigTotalDuration - readFileCounter.duration; + + if (timing.enabled) { + indexedResults.timings = timing.getData(); + } + + parentPort.postMessage(indexedResults); +})(); diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/index.js new file mode 100644 index 00000000..e27f8638 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/index.js @@ -0,0 +1,336 @@ +/** + * @fileoverview JavaScript Language Object + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { SourceCode } = require("./source-code"); +const createDebug = require("debug"); +const astUtils = require("../../shared/ast-utils"); +const espree = require("espree"); +const eslintScope = require("eslint-scope"); +const evk = require("eslint-visitor-keys"); +const { validateLanguageOptions } = require("./validate-language-options"); +const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version"); + +//----------------------------------------------------------------------------- +// Type Definitions +//----------------------------------------------------------------------------- + +/** @typedef {import("@eslint/core").File} File */ +/** @typedef {import("@eslint/core").Language} Language */ +/** @typedef {import("@eslint/core").OkParseResult} OkParseResult */ +/** @typedef {import("../../types").Linter.LanguageOptions} JSLanguageOptions */ + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const debug = createDebug("eslint:languages:js"); +const DEFAULT_ECMA_VERSION = 5; +const parserSymbol = Symbol.for("eslint.RuleTester.parser"); + +/** + * Analyze scope of the given AST. + * @param {ASTNode} ast The `Program` node to analyze. + * @param {JSLanguageOptions} languageOptions The parser options. + * @param {Record} visitorKeys The visitor keys. + * @returns {ScopeManager} The analysis result. + */ +function analyzeScope(ast, languageOptions, visitorKeys) { + const parserOptions = languageOptions.parserOptions; + const ecmaFeatures = parserOptions.ecmaFeatures || {}; + const ecmaVersion = languageOptions.ecmaVersion || DEFAULT_ECMA_VERSION; + + return eslintScope.analyze(ast, { + ignoreEval: true, + nodejsScope: ecmaFeatures.globalReturn, + impliedStrict: ecmaFeatures.impliedStrict, + ecmaVersion: typeof ecmaVersion === "number" ? ecmaVersion : 6, + sourceType: languageOptions.sourceType || "script", + childVisitorKeys: visitorKeys || evk.KEYS, + fallback: evk.getKeys, + jsx: ecmaFeatures.jsx, + }); +} + +/** + * Determines if a given object is Espree. + * @param {Object} parser The parser to check. + * @returns {boolean} `true` if the parser is Espree or `false` if not. + */ +function isEspree(parser) { + return !!(parser === espree || parser[parserSymbol] === espree); +} + +/** + * Normalize ECMAScript version from the initial config into languageOptions (year) + * format. + * @param {any} [ecmaVersion] ECMAScript version from the initial config + * @returns {number} normalized ECMAScript version + */ +function normalizeEcmaVersionForLanguageOptions(ecmaVersion) { + switch (ecmaVersion) { + case 3: + return 3; + + // void 0 = no ecmaVersion specified so use the default + case 5: + case void 0: + return 5; + + default: + if (typeof ecmaVersion === "number") { + return ecmaVersion >= 2015 ? ecmaVersion : ecmaVersion + 2009; + } + } + + /* + * We default to the latest supported ecmaVersion for everything else. + * Remember, this is for languageOptions.ecmaVersion, which sets the version + * that is used for a number of processes inside of ESLint. It's normally + * safe to assume people want the latest unless otherwise specified. + */ + return LATEST_ECMA_VERSION; +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * @type {Language} + */ +module.exports = { + fileType: "text", + lineStart: 1, + columnStart: 0, + nodeTypeKey: "type", + visitorKeys: evk.KEYS, + + defaultLanguageOptions: { + sourceType: "module", + ecmaVersion: "latest", + parser: espree, + parserOptions: {}, + }, + + validateLanguageOptions, + + /** + * Normalizes the language options. + * @param {Object} languageOptions The language options to normalize. + * @returns {Object} The normalized language options. + */ + normalizeLanguageOptions(languageOptions) { + languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions( + languageOptions.ecmaVersion, + ); + + // Espree expects this information to be passed in + if (isEspree(languageOptions.parser)) { + const parserOptions = languageOptions.parserOptions; + + if (languageOptions.sourceType) { + parserOptions.sourceType = languageOptions.sourceType; + + if ( + parserOptions.sourceType === "module" && + parserOptions.ecmaFeatures && + parserOptions.ecmaFeatures.globalReturn + ) { + parserOptions.ecmaFeatures.globalReturn = false; + } + } + } + + return languageOptions; + }, + + /** + * Determines if a given node matches a given selector class. + * @param {string} className The class name to check. + * @param {ASTNode} node The node to check. + * @param {Array} ancestry The ancestry of the node. + * @returns {boolean} `true` if there's a match, `false` if not. + * @throws {Error} When an unknown class name is passed. + */ + matchesSelectorClass(className, node, ancestry) { + /* + * Copyright (c) 2013, Joel Feenstra + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the ESQuery nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL JOEL FEENSTRA BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + switch (className.toLowerCase()) { + case "statement": + if (node.type.slice(-9) === "Statement") { + return true; + } + + // fallthrough: interface Declaration <: Statement { } + + case "declaration": + return node.type.slice(-11) === "Declaration"; + + case "pattern": + if (node.type.slice(-7) === "Pattern") { + return true; + } + + // fallthrough: interface Expression <: Node, Pattern { } + + case "expression": + return ( + node.type.slice(-10) === "Expression" || + node.type.slice(-7) === "Literal" || + (node.type === "Identifier" && + (ancestry.length === 0 || + ancestry[0].type !== "MetaProperty")) || + node.type === "MetaProperty" + ); + + case "function": + return ( + node.type === "FunctionDeclaration" || + node.type === "FunctionExpression" || + node.type === "ArrowFunctionExpression" + ); + + default: + throw new Error(`Unknown class name: ${className}`); + } + }, + + /** + * Parses the given file into an AST. + * @param {File} file The virtual file to parse. + * @param {Object} options Additional options passed from ESLint. + * @param {JSLanguageOptions} options.languageOptions The language options. + * @returns {Object} The result of parsing. + */ + parse(file, { languageOptions }) { + // Note: BOM already removed + const { body: text, path: filePath } = file; + const textToParse = text.replace( + astUtils.shebangPattern, + (match, captured) => `//${captured}`, + ); + const { ecmaVersion, sourceType, parser } = languageOptions; + const parserOptions = Object.assign( + { ecmaVersion, sourceType }, + languageOptions.parserOptions, + { + loc: true, + range: true, + tokens: true, + comment: true, + eslintVisitorKeys: true, + eslintScopeManager: true, + filePath, + }, + ); + + /* + * Check for parsing errors first. If there's a parsing error, nothing + * else can happen. However, a parsing error does not throw an error + * from this method - it's just considered a fatal error message, a + * problem that ESLint identified just like any other. + */ + try { + debug("Parsing:", filePath); + const parseResult = + typeof parser.parseForESLint === "function" + ? parser.parseForESLint(textToParse, parserOptions) + : { ast: parser.parse(textToParse, parserOptions) }; + + debug("Parsing successful:", filePath); + + const { + ast, + services: parserServices = {}, + visitorKeys = evk.KEYS, + scopeManager, + } = parseResult; + + return { + ok: true, + ast, + parserServices, + visitorKeys, + scopeManager, + }; + } catch (ex) { + // If the message includes a leading line number, strip it: + const message = ex.message.replace(/^line \d+:/iu, "").trim(); + + debug("%s\n%s", message, ex.stack); + + return { + ok: false, + errors: [ + { + message, + line: ex.lineNumber, + column: ex.column, + }, + ], + }; + } + }, + + /** + * Creates a new `SourceCode` object from the given information. + * @param {File} file The virtual file to create a `SourceCode` object from. + * @param {OkParseResult} parseResult The result returned from `parse()`. + * @param {Object} options Additional options passed from ESLint. + * @param {JSLanguageOptions} options.languageOptions The language options. + * @returns {SourceCode} The new `SourceCode` object. + */ + createSourceCode(file, parseResult, { languageOptions }) { + const { body: text, path: filePath, bom: hasBOM } = file; + const { ast, parserServices, visitorKeys } = parseResult; + + debug("Scope analysis:", filePath); + const scopeManager = + parseResult.scopeManager || + analyzeScope(ast, languageOptions, visitorKeys); + + debug("Scope analysis successful:", filePath); + + return new SourceCode({ + text, + ast, + hasBOM, + parserServices, + scopeManager, + visitorKeys, + }); + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/index.js new file mode 100644 index 00000000..f4003e39 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/index.js @@ -0,0 +1,7 @@ +"use strict"; + +const SourceCode = require("./source-code"); + +module.exports = { + SourceCode, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/source-code.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/source-code.js new file mode 100644 index 00000000..a76954af --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/source-code.js @@ -0,0 +1,1178 @@ +/** + * @fileoverview Abstraction of JavaScript source code. + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const TokenStore = require("./token-store"), + astUtils = require("../../../shared/ast-utils"), + Traverser = require("../../../shared/traverser"), + globals = require("../../../../conf/globals"), + { directivesPattern } = require("../../../shared/directives"), + CodePathAnalyzer = require("../../../linter/code-path-analysis/code-path-analyzer"), + { + ConfigCommentParser, + VisitNodeStep, + CallMethodStep, + Directive, + } = require("@eslint/plugin-kit"); + +//------------------------------------------------------------------------------ +// Type Definitions +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").ScopeManager} ScopeManager */ +/** @typedef {import("@eslint/core").SourceCode} ISourceCode */ +/** @typedef {import("@eslint/core").Directive} IDirective */ +/** @typedef {import("@eslint/core").TraversalStep} ITraversalStep */ + +//------------------------------------------------------------------------------ +// Private +//------------------------------------------------------------------------------ + +const commentParser = new ConfigCommentParser(); + +/** + * Validates that the given AST has the required information. + * @param {ASTNode} ast The Program node of the AST to check. + * @throws {TypeError} If the AST doesn't contain the correct information. + * @returns {void} + * @private + */ +function validate(ast) { + if (!ast) { + throw new TypeError(`Unexpected empty AST. (${ast})`); + } + + if (!ast.tokens) { + throw new TypeError("AST is missing the tokens array."); + } + + if (!ast.comments) { + throw new TypeError("AST is missing the comments array."); + } + + if (!ast.loc) { + throw new TypeError("AST is missing location information."); + } + + if (!ast.range) { + throw new TypeError("AST is missing range information"); + } +} + +/** + * Retrieves globals for the given ecmaVersion. + * @param {number} ecmaVersion The version to retrieve globals for. + * @returns {Object} The globals for the given ecmaVersion. + */ +function getGlobalsForEcmaVersion(ecmaVersion) { + switch (ecmaVersion) { + case 3: + return globals.es3; + + case 5: + return globals.es5; + + default: + if (ecmaVersion < 2015) { + return globals[`es${ecmaVersion + 2009}`]; + } + + return globals[`es${ecmaVersion}`]; + } +} + +/** + * Merges two sorted lists into a larger sorted list in O(n) time. + * @param {Token[]} tokens The list of tokens. + * @param {Token[]} comments The list of comments. + * @returns {Token[]} A sorted list of tokens and comments. + * @private + */ +function sortedMerge(tokens, comments) { + const result = []; + let tokenIndex = 0; + let commentIndex = 0; + + while (tokenIndex < tokens.length || commentIndex < comments.length) { + if ( + commentIndex >= comments.length || + (tokenIndex < tokens.length && + tokens[tokenIndex].range[0] < comments[commentIndex].range[0]) + ) { + result.push(tokens[tokenIndex++]); + } else { + result.push(comments[commentIndex++]); + } + } + + return result; +} + +/** + * Normalizes a value for a global in a config + * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in + * a global directive comment + * @returns {("readonly"|"writable"|"off")} The value normalized as a string + * @throws {Error} if global value is invalid + */ +function normalizeConfigGlobal(configuredValue) { + switch (configuredValue) { + case "off": + return "off"; + + case true: + case "true": + case "writeable": + case "writable": + return "writable"; + + case null: + case false: + case "false": + case "readable": + case "readonly": + return "readonly"; + + default: + throw new Error( + `'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`, + ); + } +} + +/** + * Determines if two nodes or tokens overlap. + * @param {ASTNode|Token} first The first node or token to check. + * @param {ASTNode|Token} second The second node or token to check. + * @returns {boolean} True if the two nodes or tokens overlap. + * @private + */ +function nodesOrTokensOverlap(first, second) { + return ( + (first.range[0] <= second.range[0] && + first.range[1] >= second.range[0]) || + (second.range[0] <= first.range[0] && second.range[1] >= first.range[0]) + ); +} + +/** + * Performs binary search to find the line number containing a given character index. + * Returns the lower bound - the index of the first element greater than the target. + * **Please note that the `lineStartIndices` should be sorted in ascending order**. + * - Time Complexity: O(log n) - Significantly faster than linear search for large files. + * @param {number[]} lineStartIndices Sorted array of line start indices. + * @param {number} target The character index to find the line number for. + * @returns {number} The 1-based line number for the target index. + * @private + */ +function findLineNumberBinarySearch(lineStartIndices, target) { + let low = 0; + let high = lineStartIndices.length; + + while (low < high) { + const mid = ((low + high) / 2) | 0; // Use bitwise OR to floor the division + + if (target < lineStartIndices[mid]) { + high = mid; + } else { + low = mid + 1; + } + } + + return low; +} + +//----------------------------------------------------------------------------- +// Directive Comments +//----------------------------------------------------------------------------- + +/** + * Ensures that variables representing built-in properties of the Global Object, + * and any globals declared by special block comments, are present in the global + * scope. + * @param {ScopeManager} scopeManager Scope manager. + * @param {Object|undefined} configGlobals The globals declared in configuration + * @param {Object|undefined} inlineGlobals The globals declared in the source code + * @returns {void} + */ +function addDeclaredGlobals( + scopeManager, + configGlobals = Object.create(null), + inlineGlobals = Object.create(null), +) { + const finalGlobals = { __proto__: null, ...configGlobals }; + + for (const [name, data] of Object.entries(inlineGlobals)) { + finalGlobals[name] = data.value; + } + + const names = Object.keys(finalGlobals).filter( + name => finalGlobals[name] !== "off", + ); + + scopeManager.addGlobals(names); + + const globalScope = scopeManager.scopes[0]; + + for (const name of names) { + const variable = globalScope.set.get(name); + + variable.eslintImplicitGlobalSetting = configGlobals[name]; + variable.eslintExplicitGlobal = !!inlineGlobals[name]; + variable.eslintExplicitGlobalComments = inlineGlobals[name]?.comments; + variable.writeable = finalGlobals[name] === "writable"; + } +} + +/** + * Sets the given variable names as exported so they won't be triggered by + * the `no-unused-vars` rule. + * @param {eslint.Scope} globalScope The global scope to define exports in. + * @param {Record} variables An object whose keys are the variable + * names to export. + * @returns {void} + */ +function markExportedVariables(globalScope, variables) { + Object.keys(variables).forEach(name => { + const variable = globalScope.set.get(name); + + if (variable) { + variable.eslintUsed = true; + variable.eslintExported = true; + } + }); +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +const caches = Symbol("caches"); + +/** + * Represents parsed source code. + * @implements {ISourceCode} + */ +class SourceCode extends TokenStore { + /** + * The cache of steps that were taken while traversing the source code. + * @type {Array} + */ + #steps; + + /** + * Creates a new instance. + * @param {string|Object} textOrConfig The source code text or config object. + * @param {string} textOrConfig.text The source code text. + * @param {ASTNode} textOrConfig.ast The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. + * @param {boolean} textOrConfig.hasBOM Indicates if the text has a Unicode BOM. + * @param {Object|null} textOrConfig.parserServices The parser services. + * @param {ScopeManager|null} textOrConfig.scopeManager The scope of this source code. + * @param {Object|null} textOrConfig.visitorKeys The visitor keys to traverse AST. + * @param {ASTNode} [astIfNoConfig] The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. + */ + constructor(textOrConfig, astIfNoConfig) { + let text, hasBOM, ast, parserServices, scopeManager, visitorKeys; + + // Process overloading of arguments + if (typeof textOrConfig === "string") { + text = textOrConfig; + ast = astIfNoConfig; + hasBOM = false; + } else if (typeof textOrConfig === "object" && textOrConfig !== null) { + text = textOrConfig.text; + ast = textOrConfig.ast; + hasBOM = textOrConfig.hasBOM; + parserServices = textOrConfig.parserServices; + scopeManager = textOrConfig.scopeManager; + visitorKeys = textOrConfig.visitorKeys; + } + + validate(ast); + super(ast.tokens, ast.comments); + + /** + * General purpose caching for the class. + */ + this[caches] = new Map([ + ["scopes", new WeakMap()], + ["vars", new Map()], + ["configNodes", void 0], + ["isGlobalReference", new WeakMap()], + ]); + + /** + * Indicates if the AST is ESTree compatible. + * @type {boolean} + */ + this.isESTree = ast.type === "Program"; + + /* + * Backwards compatibility for BOM handling. + * + * The `hasBOM` property has been available on the `SourceCode` object + * for a long time and is used to indicate if the source contains a BOM. + * The linter strips the BOM and just passes the `hasBOM` property to the + * `SourceCode` constructor to make it easier for languages to not deal with + * the BOM. + * + * However, the text passed in to the `SourceCode` constructor might still + * have a BOM if the constructor is called outside of the linter, so we still + * need to check for the BOM in the text. + */ + const textHasBOM = text.charCodeAt(0) === 0xfeff; + + /** + * The flag to indicate that the source code has Unicode BOM. + * @type {boolean} + */ + this.hasBOM = textHasBOM || !!hasBOM; + + /** + * The original text source code. + * BOM was stripped from this text. + * @type {string} + */ + this.text = textHasBOM ? text.slice(1) : text; + + /** + * The parsed AST for the source code. + * @type {ASTNode} + */ + this.ast = ast; + + /** + * The parser services of this source code. + * @type {Object} + */ + this.parserServices = parserServices || {}; + + /** + * The scope of this source code. + * @type {ScopeManager|null} + */ + this.scopeManager = scopeManager || null; + + /** + * The visitor keys to traverse AST. + * @type {Object} + */ + this.visitorKeys = visitorKeys || Traverser.DEFAULT_VISITOR_KEYS; + + // Check the source text for the presence of a shebang since it is parsed as a standard line comment. + const shebangMatched = this.text.match(astUtils.shebangPattern); + const hasShebang = + shebangMatched && + ast.comments.length && + ast.comments[0].value === shebangMatched[1]; + + if (hasShebang) { + ast.comments[0].type = "Shebang"; + } + + this.tokensAndComments = sortedMerge(ast.tokens, ast.comments); + + /** + * The source code split into lines according to ECMA-262 specification. + * This is done to avoid each rule needing to do so separately. + * @type {string[]} + */ + this.lines = []; + + /** + * @type {number[]} + */ + this.lineStartIndices = [0]; + + const lineEndingPattern = astUtils.createGlobalLinebreakMatcher(); + let match; + + /* + * Previously, this was implemented using a regex that + * matched a sequence of non-linebreak characters followed by a + * linebreak, then adding the lengths of the matches. However, + * this caused a catastrophic backtracking issue when the end + * of a file contained a large number of non-newline characters. + * To avoid this, the current implementation just matches newlines + * and uses match.index to get the correct line start indices. + */ + while ((match = lineEndingPattern.exec(this.text))) { + this.lines.push( + this.text.slice(this.lineStartIndices.at(-1), match.index), + ); + this.lineStartIndices.push(match.index + match[0].length); + } + this.lines.push(this.text.slice(this.lineStartIndices.at(-1))); + + // don't allow further modification of this object + Object.freeze(this); + Object.freeze(this.lines); + } + + /** + * Split the source code into multiple lines based on the line delimiters. + * @param {string} text Source code as a string. + * @returns {string[]} Array of source code lines. + * @public + */ + static splitLines(text) { + return text.split(astUtils.createGlobalLinebreakMatcher()); + } + + /** + * Gets the source code for the given node. + * @param {ASTNode} [node] The AST node to get the text for. + * @param {number} [beforeCount] The number of characters before the node to retrieve. + * @param {number} [afterCount] The number of characters after the node to retrieve. + * @returns {string} The text representing the AST node. + * @public + */ + getText(node, beforeCount, afterCount) { + if (node) { + return this.text.slice( + Math.max(node.range[0] - (beforeCount || 0), 0), + node.range[1] + (afterCount || 0), + ); + } + return this.text; + } + + /** + * Gets the entire source text split into an array of lines. + * @returns {string[]} The source text as an array of lines. + * @public + */ + getLines() { + return this.lines; + } + + /** + * Retrieves an array containing all comments in the source code. + * @returns {ASTNode[]} An array of comment nodes. + * @public + */ + getAllComments() { + return this.ast.comments; + } + + /** + * Gets the deepest node containing a range index. + * @param {number} index Range index of the desired node. + * @returns {ASTNode} The node if found or null if not found. + * @public + */ + getNodeByRangeIndex(index) { + let result = null; + + Traverser.traverse(this.ast, { + visitorKeys: this.visitorKeys, + enter(node) { + if (node.range[0] <= index && index < node.range[1]) { + result = node; + } else { + this.skip(); + } + }, + leave(node) { + if (node === result) { + this.break(); + } + }, + }); + + return result; + } + + /** + * Determines if two nodes or tokens have at least one whitespace character + * between them. Order does not matter. Returns false if the given nodes or + * tokens overlap. + * @param {ASTNode|Token} first The first node or token to check between. + * @param {ASTNode|Token} second The second node or token to check between. + * @returns {boolean} True if there is a whitespace character between + * any of the tokens found between the two given nodes or tokens. + * @public + */ + isSpaceBetween(first, second) { + if (nodesOrTokensOverlap(first, second)) { + return false; + } + + const [startingNodeOrToken, endingNodeOrToken] = + first.range[1] <= second.range[0] + ? [first, second] + : [second, first]; + const firstToken = + this.getLastToken(startingNodeOrToken) || startingNodeOrToken; + const finalToken = + this.getFirstToken(endingNodeOrToken) || endingNodeOrToken; + let currentToken = firstToken; + + while (currentToken !== finalToken) { + const nextToken = this.getTokenAfter(currentToken, { + includeComments: true, + }); + + if (currentToken.range[1] !== nextToken.range[0]) { + return true; + } + + currentToken = nextToken; + } + + return false; + } + + /** + * Converts a source text index into a (line, column) pair. + * @param {number} index The index of a character in a file. + * @throws {TypeError|RangeError} If non-numeric index or index out of range. + * @returns {{line: number, column: number}} A {line, column} location object with 1-indexed line and 0-indexed column. + * @public + */ + getLocFromIndex(index) { + if (typeof index !== "number") { + throw new TypeError("Expected `index` to be a number."); + } + + if (index < 0 || index > this.text.length) { + throw new RangeError( + `Index out of range (requested index ${index}, but source text has length ${this.text.length}).`, + ); + } + + /* + * For an argument of this.text.length, return the location one "spot" past the last character + * of the file. If the last character is a linebreak, the location will be column 0 of the next + * line; otherwise, the location will be in the next column on the same line. + * + * See getIndexFromLoc for the motivation for this special case. + */ + if (index === this.text.length) { + return { + line: this.lines.length, + column: this.lines.at(-1).length, + }; + } + + /* + * To figure out which line index is on, determine the last place at which index could + * be inserted into lineStartIndices to keep the list sorted. + */ + const lineNumber = + index >= this.lineStartIndices.at(-1) + ? this.lineStartIndices.length + : findLineNumberBinarySearch(this.lineStartIndices, index); + + return { + line: lineNumber, + column: index - this.lineStartIndices[lineNumber - 1], + }; + } + + /** + * Converts a (line, column) pair into a range index. + * @param {Object} loc A line/column location + * @param {number} loc.line The line number of the location (1-indexed) + * @param {number} loc.column The column number of the location (0-indexed) + * @throws {TypeError|RangeError} If `loc` is not an object with a numeric + * `line` and `column`, if the `line` is less than or equal to zero or + * the line or column is out of the expected range. + * @returns {number} The range index of the location in the file. + * @public + */ + getIndexFromLoc(loc) { + if ( + loc === null || + typeof loc !== "object" || + typeof loc.line !== "number" || + typeof loc.column !== "number" + ) { + throw new TypeError( + "Expected `loc` to be an object with numeric `line` and `column` properties.", + ); + } + + if (loc.line <= 0) { + throw new RangeError( + `Line number out of range (line ${loc.line} requested). Line numbers should be 1-based.`, + ); + } + + if (loc.line > this.lineStartIndices.length) { + throw new RangeError( + `Line number out of range (line ${loc.line} requested, but only ${this.lineStartIndices.length} lines present).`, + ); + } + + if (loc.column < 0) { + throw new RangeError( + `Invalid column number (column ${loc.column} requested).`, + ); + } + + const lineStartIndex = this.lineStartIndices[loc.line - 1]; + const lineEndIndex = + loc.line === this.lineStartIndices.length + ? this.text.length + : this.lineStartIndices[loc.line]; + const positionIndex = lineStartIndex + loc.column; + + /* + * By design, getIndexFromLoc({ line: lineNum, column: 0 }) should return the start index of + * the given line, provided that the line number is valid element of this.lines. Since the + * last element of this.lines is an empty string for files with trailing newlines, add a + * special case where getting the index for the first location after the end of the file + * will return the length of the file, rather than throwing an error. This allows rules to + * use getIndexFromLoc consistently without worrying about edge cases at the end of a file. + */ + if ( + (loc.line === this.lineStartIndices.length && + positionIndex > lineEndIndex) || + (loc.line < this.lineStartIndices.length && + positionIndex >= lineEndIndex) + ) { + throw new RangeError( + `Column number out of range (column ${loc.column} requested, but the length of line ${loc.line} is ${lineEndIndex - lineStartIndex}).`, + ); + } + + return positionIndex; + } + + /** + * Gets the scope for the given node + * @param {ASTNode} currentNode The node to get the scope of + * @returns {Scope} The scope information for this node + * @throws {TypeError} If the `currentNode` argument is missing. + */ + getScope(currentNode) { + if (!currentNode) { + throw new TypeError("Missing required argument: node."); + } + + // check cache first + const cache = this[caches].get("scopes"); + const cachedScope = cache.get(currentNode); + + if (cachedScope) { + return cachedScope; + } + + // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope. + const inner = currentNode.type !== "Program"; + + for (let node = currentNode; node; node = node.parent) { + const scope = this.scopeManager.acquire(node, inner); + + if (scope) { + if (scope.type === "function-expression-name") { + cache.set(currentNode, scope.childScopes[0]); + return scope.childScopes[0]; + } + + cache.set(currentNode, scope); + return scope; + } + } + + cache.set(currentNode, this.scopeManager.scopes[0]); + return this.scopeManager.scopes[0]; + } + + /** + * Get the variables that `node` defines. + * This is a convenience method that passes through + * to the same method on the `scopeManager`. + * @param {ASTNode} node The node for which the variables are obtained. + * @returns {Array} An array of variable nodes representing + * the variables that `node` defines. + */ + getDeclaredVariables(node) { + return this.scopeManager.getDeclaredVariables(node); + } + + /* eslint-disable class-methods-use-this -- node is owned by SourceCode */ + /** + * Gets all the ancestors of a given node + * @param {ASTNode} node The node + * @returns {Array} All the ancestor nodes in the AST, not including the provided node, starting + * from the root node at index 0 and going inwards to the parent node. + * @throws {TypeError} When `node` is missing. + */ + getAncestors(node) { + if (!node) { + throw new TypeError("Missing required argument: node."); + } + + const ancestorsStartingAtParent = []; + + for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) { + ancestorsStartingAtParent.push(ancestor); + } + + return ancestorsStartingAtParent.reverse(); + } + + /** + * Determines whether the given identifier node is a reference to a global variable. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} True if the identifier is a reference to a global variable. + */ + isGlobalReference(node) { + if (!node) { + throw new TypeError("Missing required argument: node."); + } + + const cache = this[caches].get("isGlobalReference"); + + if (cache.has(node)) { + return cache.get(node); + } + + if (node.type !== "Identifier") { + cache.set(node, false); + return false; + } + + const variable = this.scopeManager.scopes[0].set.get(node.name); + + if (!variable || variable.defs.length > 0) { + cache.set(node, false); + return false; + } + + const result = variable.references.some( + ({ identifier }) => identifier === node, + ); + cache.set(node, result); + return result; + } + + /** + * Returns the location of the given node or token. + * @param {ASTNode|Token} nodeOrToken The node or token to get the location of. + * @returns {SourceLocation} The location of the node or token. + */ + getLoc(nodeOrToken) { + return nodeOrToken.loc; + } + + /** + * Returns the range of the given node or token. + * @param {ASTNode|Token} nodeOrToken The node or token to get the range of. + * @returns {[number, number]} The range of the node or token. + */ + getRange(nodeOrToken) { + return nodeOrToken.range; + } + + /* eslint-enable class-methods-use-this -- node is owned by SourceCode */ + + /** + * Marks a variable as used in the current scope + * @param {string} name The name of the variable to mark as used. + * @param {ASTNode} [refNode] The closest node to the variable reference. + * @returns {boolean} True if the variable was found and marked as used, false if not. + */ + markVariableAsUsed(name, refNode = this.ast) { + const currentScope = this.getScope(refNode); + let initialScope = currentScope; + + /* + * When we are in an ESM or CommonJS module, we need to start searching + * from the top-level scope, not the global scope. For ESM the top-level + * scope is the module scope; for CommonJS the top-level scope is the + * outer function scope. + * + * Without this check, we might miss a variable declared with `var` at + * the top-level because it won't exist in the global scope. + */ + if ( + currentScope.type === "global" && + currentScope.childScopes.length > 0 && + // top-level scopes refer to a `Program` node + currentScope.childScopes[0].block === this.ast + ) { + initialScope = currentScope.childScopes[0]; + } + + for (let scope = initialScope; scope; scope = scope.upper) { + const variable = scope.variables.find( + scopeVar => scopeVar.name === name, + ); + + if (variable) { + variable.eslintUsed = true; + return true; + } + } + + return false; + } + + /** + * Returns an array of all inline configuration nodes found in the + * source code. + * @returns {Array} An array of all inline configuration nodes. + */ + getInlineConfigNodes() { + // check the cache first + let configNodes = this[caches].get("configNodes"); + + if (configNodes) { + return configNodes; + } + + // calculate fresh config nodes + configNodes = this.ast.comments.filter(comment => { + // shebang comments are never directives + if (comment.type === "Shebang") { + return false; + } + + const directive = commentParser.parseDirective(comment.value); + + if (!directive) { + return false; + } + + if (!directivesPattern.test(directive.label)) { + return false; + } + + // only certain comment types are supported as line comments + return ( + comment.type !== "Line" || + !!/^eslint-disable-(?:next-)?line$/u.test(directive.label) + ); + }); + + this[caches].set("configNodes", configNodes); + + return configNodes; + } + + /** + * Returns an all directive nodes that enable or disable rules along with any problems + * encountered while parsing the directives. + * @returns {{problems:Array,directives:Array}} Information + * that ESLint needs to further process the directives. + */ + getDisableDirectives() { + // check the cache first + const cachedDirectives = this[caches].get("disableDirectives"); + + if (cachedDirectives) { + return cachedDirectives; + } + + const problems = []; + const directives = []; + + this.getInlineConfigNodes().forEach(comment => { + // Step 1: Parse the directive + const { + label, + value, + justification: justificationPart, + } = commentParser.parseDirective(comment.value); + + // Step 2: Extract the directive value + const lineCommentSupported = + /^eslint-disable-(?:next-)?line$/u.test(label); + + if (comment.type === "Line" && !lineCommentSupported) { + return; + } + + // Step 3: Validate the directive does not span multiple lines + if ( + label === "eslint-disable-line" && + comment.loc.start.line !== comment.loc.end.line + ) { + const message = `${label} comment should not span multiple lines.`; + + problems.push({ + ruleId: null, + message, + loc: comment.loc, + }); + return; + } + + // Step 4: Extract the directive value and create the Directive object + switch (label) { + case "eslint-disable": + case "eslint-enable": + case "eslint-disable-next-line": + case "eslint-disable-line": { + const directiveType = label.slice("eslint-".length); + + directives.push( + new Directive({ + type: directiveType, + node: comment, + value, + justification: justificationPart, + }), + ); + } + + // no default + } + }); + + const result = { problems, directives }; + + this[caches].set("disableDirectives", result); + + return result; + } + + /** + * Applies language options sent in from the core. + * @param {Object} languageOptions The language options for this run. + * @returns {void} + */ + applyLanguageOptions(languageOptions) { + /* + * Add configured globals and language globals + * + * Using Object.assign instead of object spread for performance reasons + * https://github.com/eslint/eslint/issues/16302 + */ + const configGlobals = Object.assign( + Object.create(null), // https://github.com/eslint/eslint/issues/18363 + getGlobalsForEcmaVersion(languageOptions.ecmaVersion), + languageOptions.sourceType === "commonjs" + ? globals.commonjs + : void 0, + languageOptions.globals, + ); + + /* + * `normalizeConfigGlobal` will throw an error if a configured global value is invalid. However, these errors would + * typically be caught when validating a config anyway (validity for inline global comments is checked separately). + */ + for (const [name, value] of Object.entries(configGlobals)) { + configGlobals[name] = normalizeConfigGlobal(value); + } + + const varsCache = this[caches].get("vars"); + + varsCache.set("configGlobals", configGlobals); + } + + /** + * Applies configuration found inside of the source code. This method is only + * called when ESLint is running with inline configuration allowed. + * @returns {{problems:Array,configs:{config:FlatConfigArray,loc:Location}}} Information + * that ESLint needs to further process the inline configuration. + */ + applyInlineConfig() { + const problems = []; + const configs = []; + const exportedVariables = Object.create(null); + const inlineGlobals = Object.create(null); + + this.getInlineConfigNodes().forEach(comment => { + const { label, value } = commentParser.parseDirective( + comment.value, + ); + + switch (label) { + case "exported": + Object.assign( + exportedVariables, + commentParser.parseListConfig(value), + ); + break; + + case "globals": + case "global": + for (const [id, idSetting] of Object.entries( + commentParser.parseStringConfig(value), + )) { + let normalizedValue; + + try { + normalizedValue = normalizeConfigGlobal(idSetting); + } catch (err) { + problems.push({ + ruleId: null, + loc: comment.loc, + message: err.message, + }); + continue; + } + + if (inlineGlobals[id]) { + inlineGlobals[id].comments.push(comment); + inlineGlobals[id].value = normalizedValue; + } else { + inlineGlobals[id] = { + comments: [comment], + value: normalizedValue, + }; + } + } + break; + + case "eslint": { + const parseResult = + commentParser.parseJSONLikeConfig(value); + + if (parseResult.ok) { + configs.push({ + config: { + rules: parseResult.config, + }, + loc: comment.loc, + }); + } else { + problems.push({ + ruleId: null, + loc: comment.loc, + message: parseResult.error.message, + }); + } + + break; + } + case "eslint-env": { + problems.push({ + ruleId: null, + loc: comment.loc, + message: + "/* eslint-env */ comments are no longer supported.", + }); + break; + } + + // no default + } + }); + + // save all the new variables for later + const varsCache = this[caches].get("vars"); + + varsCache.set("inlineGlobals", inlineGlobals); + varsCache.set("exportedVariables", exportedVariables); + + return { + configs, + problems, + }; + } + + /** + * Called by ESLint core to indicate that it has finished providing + * information. We now add in all the missing variables and ensure that + * state-changing methods cannot be called by rules. + * @returns {void} + */ + finalize() { + const varsCache = this[caches].get("vars"); + const configGlobals = varsCache.get("configGlobals"); + const inlineGlobals = varsCache.get("inlineGlobals"); + const exportedVariables = varsCache.get("exportedVariables"); + const globalScope = this.scopeManager.scopes[0]; + + addDeclaredGlobals(this.scopeManager, configGlobals, inlineGlobals); + + if (exportedVariables) { + markExportedVariables(globalScope, exportedVariables); + } + } + + /** + * Traverse the source code and return the steps that were taken. + * @returns {Array} The steps that were taken while traversing the source code. + */ + traverse() { + // Because the AST doesn't mutate, we can cache the steps + if (this.#steps) { + return this.#steps; + } + + const steps = (this.#steps = []); + + /* + * This logic works for any AST, not just ESTree. Because ESLint has allowed + * custom parsers to return any AST, we need to ensure that the traversal + * logic works for any AST. + */ + let analyzer = { + enterNode(node) { + steps.push( + new VisitNodeStep({ + target: node, + phase: 1, + args: [node], + }), + ); + }, + leaveNode(node) { + steps.push( + new VisitNodeStep({ + target: node, + phase: 2, + args: [node], + }), + ); + }, + emit(eventName, args) { + steps.push( + new CallMethodStep({ + target: eventName, + args, + }), + ); + }, + }; + + /* + * We do code path analysis for ESTree only. Code path analysis is not + * necessary for other ASTs, and it's also not possible to do for other + * ASTs because the necessary information is not available. + * + * Generally speaking, we can tell that the AST is an ESTree if it has a + * Program node at the top level. This is not a perfect heuristic, but it + * is good enough for now. + */ + if (this.isESTree) { + analyzer = new CodePathAnalyzer(analyzer); + } + + /* + * The actual AST traversal is done by the `Traverser` class. This class + * is responsible for walking the AST and calling the appropriate methods + * on the `analyzer` object, which is appropriate for the given AST. + */ + Traverser.traverse(this.ast, { + enter(node, parent) { + // save the parent node on a property for backwards compatibility + node.parent = parent; + + analyzer.enterNode(node); + }, + leave(node) { + analyzer.leaveNode(node); + }, + visitorKeys: this.visitorKeys, + }); + + return steps; + } +} + +module.exports = SourceCode; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-comment-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-comment-cursor.js new file mode 100644 index 00000000..56f920a4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-comment-cursor.js @@ -0,0 +1,61 @@ +/** + * @fileoverview Define the cursor which iterates tokens and comments in reverse. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Cursor = require("./cursor"); +const utils = require("./utils"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The cursor which iterates tokens and comments in reverse. + */ +module.exports = class BackwardTokenCommentCursor extends Cursor { + /** + * Initializes this cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + */ + constructor(tokens, comments, indexMap, startLoc, endLoc) { + super(); + this.tokens = tokens; + this.comments = comments; + this.tokenIndex = utils.getLastIndex(tokens, indexMap, endLoc); + this.commentIndex = utils.search(comments, endLoc) - 1; + this.border = startLoc; + } + + /** @inheritdoc */ + moveNext() { + const token = + this.tokenIndex >= 0 ? this.tokens[this.tokenIndex] : null; + const comment = + this.commentIndex >= 0 ? this.comments[this.commentIndex] : null; + + if (token && (!comment || token.range[1] > comment.range[1])) { + this.current = token; + this.tokenIndex -= 1; + } else if (comment) { + this.current = comment; + this.commentIndex -= 1; + } else { + this.current = null; + } + + return ( + Boolean(this.current) && + (this.border === -1 || this.current.range[0] >= this.border) + ); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-cursor.js new file mode 100644 index 00000000..b6b2e120 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/backward-token-cursor.js @@ -0,0 +1,57 @@ +/** + * @fileoverview Define the cursor which iterates tokens only in reverse. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Cursor = require("./cursor"); +const { getLastIndex, getFirstIndex } = require("./utils"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The cursor which iterates tokens only in reverse. + */ +module.exports = class BackwardTokenCursor extends Cursor { + /** + * Initializes this cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + */ + constructor(tokens, comments, indexMap, startLoc, endLoc) { + super(); + this.tokens = tokens; + this.index = getLastIndex(tokens, indexMap, endLoc); + this.indexEnd = getFirstIndex(tokens, indexMap, startLoc); + } + + /** @inheritdoc */ + moveNext() { + if (this.index >= this.indexEnd) { + this.current = this.tokens[this.index]; + this.index -= 1; + return true; + } + return false; + } + + /* + * + * Shorthand for performance. + * + */ + + /** @inheritdoc */ + getOneToken() { + return this.index >= this.indexEnd ? this.tokens[this.index] : null; + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursor.js new file mode 100644 index 00000000..e640d23f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursor.js @@ -0,0 +1,76 @@ +/** + * @fileoverview Define the abstract class about cursors which iterate tokens. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The abstract class about cursors which iterate tokens. + * + * This class has 2 abstract methods. + * + * - `current: Token | Comment | null` ... The current token. + * - `moveNext(): boolean` ... Moves this cursor to the next token. If the next token didn't exist, it returns `false`. + * + * This is similar to ES2015 Iterators. + * However, Iterators were slow (at 2017-01), so I created this class as similar to C# IEnumerable. + * + * There are the following known sub classes. + * + * - ForwardTokenCursor .......... The cursor which iterates tokens only. + * - BackwardTokenCursor ......... The cursor which iterates tokens only in reverse. + * - ForwardTokenCommentCursor ... The cursor which iterates tokens and comments. + * - BackwardTokenCommentCursor .. The cursor which iterates tokens and comments in reverse. + * - DecorativeCursor + * - FilterCursor ............ The cursor which ignores the specified tokens. + * - SkipCursor .............. The cursor which ignores the first few tokens. + * - LimitCursor ............. The cursor which limits the count of tokens. + * + */ +module.exports = class Cursor { + /** + * Initializes this cursor. + */ + constructor() { + this.current = null; + } + + /** + * Gets the first token. + * This consumes this cursor. + * @returns {Token|Comment} The first token or null. + */ + getOneToken() { + return this.moveNext() ? this.current : null; + } + + /** + * Gets the first tokens. + * This consumes this cursor. + * @returns {(Token|Comment)[]} All tokens. + */ + getAllTokens() { + const tokens = []; + + while (this.moveNext()) { + tokens.push(this.current); + } + + return tokens; + } + + /** + * Moves this cursor to the next token. + * @returns {boolean} `true` if the next token exists. + * @abstract + */ + /* c8 ignore next */ + // eslint-disable-next-line class-methods-use-this -- Unused + moveNext() { + throw new Error("Not implemented."); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursors.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursors.js new file mode 100644 index 00000000..1e9c084c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/cursors.js @@ -0,0 +1,120 @@ +/** + * @fileoverview Define 2 token factories; forward and backward. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const BackwardTokenCommentCursor = require("./backward-token-comment-cursor"); +const BackwardTokenCursor = require("./backward-token-cursor"); +const FilterCursor = require("./filter-cursor"); +const ForwardTokenCommentCursor = require("./forward-token-comment-cursor"); +const ForwardTokenCursor = require("./forward-token-cursor"); +const LimitCursor = require("./limit-cursor"); +const SkipCursor = require("./skip-cursor"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * The cursor factory. + * @private + */ +class CursorFactory { + /** + * Initializes this cursor. + * @param {Function} TokenCursor The class of the cursor which iterates tokens only. + * @param {Function} TokenCommentCursor The class of the cursor which iterates the mix of tokens and comments. + */ + constructor(TokenCursor, TokenCommentCursor) { + this.TokenCursor = TokenCursor; + this.TokenCommentCursor = TokenCommentCursor; + } + + /** + * Creates a base cursor instance that can be decorated by createCursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {boolean} includeComments The flag to iterate comments as well. + * @returns {Cursor} The created base cursor. + */ + createBaseCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + includeComments, + ) { + const Cursor = includeComments + ? this.TokenCommentCursor + : this.TokenCursor; + + return new Cursor(tokens, comments, indexMap, startLoc, endLoc); + } + + /** + * Creates a cursor that iterates tokens with normalized options. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {boolean} includeComments The flag to iterate comments as well. + * @param {Function|null} filter The predicate function to choose tokens. + * @param {number} skip The count of tokens the cursor skips. + * @param {number} count The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility. + * @returns {Cursor} The created cursor. + */ + createCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + includeComments, + filter, + skip, + count, + ) { + let cursor = this.createBaseCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + includeComments, + ); + + if (filter) { + cursor = new FilterCursor(cursor, filter); + } + if (skip >= 1) { + cursor = new SkipCursor(cursor, skip); + } + if (count >= 0) { + cursor = new LimitCursor(cursor, count); + } + + return cursor; + } +} + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +module.exports = { + forward: new CursorFactory(ForwardTokenCursor, ForwardTokenCommentCursor), + backward: new CursorFactory( + BackwardTokenCursor, + BackwardTokenCommentCursor, + ), +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/decorative-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/decorative-cursor.js new file mode 100644 index 00000000..3a1d21ec --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/decorative-cursor.js @@ -0,0 +1,38 @@ +/** + * @fileoverview Define the abstract class about cursors which manipulate another cursor. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Cursor = require("./cursor"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The abstract class about cursors which manipulate another cursor. + */ +module.exports = class DecorativeCursor extends Cursor { + /** + * Initializes this cursor. + * @param {Cursor} cursor The cursor to be decorated. + */ + constructor(cursor) { + super(); + this.cursor = cursor; + } + + /** @inheritdoc */ + moveNext() { + const retv = this.cursor.moveNext(); + + this.current = this.cursor.current; + + return retv; + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/filter-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/filter-cursor.js new file mode 100644 index 00000000..1e2ec996 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/filter-cursor.js @@ -0,0 +1,42 @@ +/** + * @fileoverview Define the cursor which ignores specified tokens. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const DecorativeCursor = require("./decorative-cursor"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The decorative cursor which ignores specified tokens. + */ +module.exports = class FilterCursor extends DecorativeCursor { + /** + * Initializes this cursor. + * @param {Cursor} cursor The cursor to be decorated. + * @param {Function} predicate The predicate function to decide tokens this cursor iterates. + */ + constructor(cursor, predicate) { + super(cursor); + this.predicate = predicate; + } + + /** @inheritdoc */ + moveNext() { + const predicate = this.predicate; + + while (super.moveNext()) { + if (predicate(this.current)) { + return true; + } + } + return false; + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-comment-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-comment-cursor.js new file mode 100644 index 00000000..d4a1439f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-comment-cursor.js @@ -0,0 +1,65 @@ +/** + * @fileoverview Define the cursor which iterates tokens and comments. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Cursor = require("./cursor"); +const { getFirstIndex, search } = require("./utils"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The cursor which iterates tokens and comments. + */ +module.exports = class ForwardTokenCommentCursor extends Cursor { + /** + * Initializes this cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + */ + constructor(tokens, comments, indexMap, startLoc, endLoc) { + super(); + this.tokens = tokens; + this.comments = comments; + this.tokenIndex = getFirstIndex(tokens, indexMap, startLoc); + this.commentIndex = search(comments, startLoc); + this.border = endLoc; + } + + /** @inheritdoc */ + moveNext() { + const token = + this.tokenIndex < this.tokens.length + ? this.tokens[this.tokenIndex] + : null; + const comment = + this.commentIndex < this.comments.length + ? this.comments[this.commentIndex] + : null; + + if (token && (!comment || token.range[0] < comment.range[0])) { + this.current = token; + this.tokenIndex += 1; + } else if (comment) { + this.current = comment; + this.commentIndex += 1; + } else { + this.current = null; + } + + return ( + Boolean(this.current) && + (this.border === -1 || this.current.range[1] <= this.border) + ); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-cursor.js new file mode 100644 index 00000000..5ca2290f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/forward-token-cursor.js @@ -0,0 +1,62 @@ +/** + * @fileoverview Define the cursor which iterates tokens only. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Cursor = require("./cursor"); +const { getFirstIndex, getLastIndex } = require("./utils"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The cursor which iterates tokens only. + */ +module.exports = class ForwardTokenCursor extends Cursor { + /** + * Initializes this cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + */ + constructor(tokens, comments, indexMap, startLoc, endLoc) { + super(); + this.tokens = tokens; + this.index = getFirstIndex(tokens, indexMap, startLoc); + this.indexEnd = getLastIndex(tokens, indexMap, endLoc); + } + + /** @inheritdoc */ + moveNext() { + if (this.index <= this.indexEnd) { + this.current = this.tokens[this.index]; + this.index += 1; + return true; + } + return false; + } + + /* + * + * Shorthand for performance. + * + */ + + /** @inheritdoc */ + getOneToken() { + return this.index <= this.indexEnd ? this.tokens[this.index] : null; + } + + /** @inheritdoc */ + getAllTokens() { + return this.tokens.slice(this.index, this.indexEnd + 1); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/index.js new file mode 100644 index 00000000..7564ed36 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/index.js @@ -0,0 +1,695 @@ +/** + * @fileoverview Object to handle access and retrieval of tokens. + * @author Brandon Mills + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { isCommentToken } = require("@eslint-community/eslint-utils"); +const assert = require("../../../../shared/assert"); +const cursors = require("./cursors"); +const ForwardTokenCursor = require("./forward-token-cursor"); +const PaddedTokenCursor = require("./padded-token-cursor"); +const utils = require("./utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const TOKENS = Symbol("tokens"); +const COMMENTS = Symbol("comments"); +const INDEX_MAP = Symbol("indexMap"); + +/** + * Creates the map from locations to indices in `tokens`. + * + * The first/last location of tokens is mapped to the index of the token. + * The first/last location of comments is mapped to the index of the next token of each comment. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @returns {Object} The map from locations to indices in `tokens`. + * @private + */ +function createIndexMap(tokens, comments) { + const map = Object.create(null); + let tokenIndex = 0; + let commentIndex = 0; + let nextStart; + let range; + + while (tokenIndex < tokens.length || commentIndex < comments.length) { + nextStart = + commentIndex < comments.length + ? comments[commentIndex].range[0] + : Number.MAX_SAFE_INTEGER; + while ( + tokenIndex < tokens.length && + (range = tokens[tokenIndex].range)[0] < nextStart + ) { + map[range[0]] = tokenIndex; + map[range[1] - 1] = tokenIndex; + tokenIndex += 1; + } + + nextStart = + tokenIndex < tokens.length + ? tokens[tokenIndex].range[0] + : Number.MAX_SAFE_INTEGER; + while ( + commentIndex < comments.length && + (range = comments[commentIndex].range)[0] < nextStart + ) { + map[range[0]] = tokenIndex; + map[range[1] - 1] = tokenIndex; + commentIndex += 1; + } + } + + return map; +} + +/** + * Creates the cursor iterates tokens with options. + * @param {CursorFactory} factory The cursor factory to initialize cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {number|Function|Object} [opts=0] The option object. If this is a number then it's `opts.skip`. If this is a function then it's `opts.filter`. + * @param {boolean} [opts.includeComments=false] The flag to iterate comments as well. + * @param {Function|null} [opts.filter=null] The predicate function to choose tokens. + * @param {number} [opts.skip=0] The count of tokens the cursor skips. + * @returns {Cursor} The created cursor. + * @private + */ +function createCursorWithSkip( + factory, + tokens, + comments, + indexMap, + startLoc, + endLoc, + opts, +) { + let includeComments = false; + let skip = 0; + let filter = null; + + if (typeof opts === "number") { + skip = opts | 0; + } else if (typeof opts === "function") { + filter = opts; + } else if (opts) { + includeComments = !!opts.includeComments; + skip = opts.skip | 0; + filter = opts.filter || null; + } + assert(skip >= 0, "options.skip should be zero or a positive integer."); + assert( + !filter || typeof filter === "function", + "options.filter should be a function.", + ); + + return factory.createCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + includeComments, + filter, + skip, + -1, + ); +} + +/** + * Creates the cursor iterates tokens with options. + * @param {CursorFactory} factory The cursor factory to initialize cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {number|Function|Object} [opts=0] The option object. If this is a number then it's `opts.count`. If this is a function then it's `opts.filter`. + * @param {boolean} [opts.includeComments] The flag to iterate comments as well. + * @param {Function|null} [opts.filter=null] The predicate function to choose tokens. + * @param {number} [opts.count=0] The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility. + * @returns {Cursor} The created cursor. + * @private + */ +function createCursorWithCount( + factory, + tokens, + comments, + indexMap, + startLoc, + endLoc, + opts, +) { + let includeComments = false; + let count = 0; + let countExists = false; + let filter = null; + + if (typeof opts === "number") { + count = opts | 0; + countExists = true; + } else if (typeof opts === "function") { + filter = opts; + } else if (opts) { + includeComments = !!opts.includeComments; + count = opts.count | 0; + countExists = typeof opts.count === "number"; + filter = opts.filter || null; + } + assert(count >= 0, "options.count should be zero or a positive integer."); + assert( + !filter || typeof filter === "function", + "options.filter should be a function.", + ); + + return factory.createCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + includeComments, + filter, + 0, + countExists ? count : -1, + ); +} + +/** + * Creates the cursor iterates tokens with options. + * This is overload function of the below. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {Function|Object} opts The option object. If this is a function then it's `opts.filter`. + * @param {boolean} [opts.includeComments] The flag to iterate comments as well. + * @param {Function|null} [opts.filter=null] The predicate function to choose tokens. + * @param {number} [opts.count=0] The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility. + * @returns {Cursor} The created cursor. + * @private + */ +/** + * Creates the cursor iterates tokens with options. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {number} [beforeCount=0] The number of tokens before the node to retrieve. + * @param {boolean} [afterCount=0] The number of tokens after the node to retrieve. + * @returns {Cursor} The created cursor. + * @private + */ +function createCursorWithPadding( + tokens, + comments, + indexMap, + startLoc, + endLoc, + beforeCount, + afterCount, +) { + if ( + typeof beforeCount === "undefined" && + typeof afterCount === "undefined" + ) { + return new ForwardTokenCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + ); + } + if (typeof beforeCount === "number" || typeof beforeCount === "undefined") { + return new PaddedTokenCursor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + beforeCount | 0, + afterCount | 0, + ); + } + return createCursorWithCount( + cursors.forward, + tokens, + comments, + indexMap, + startLoc, + endLoc, + beforeCount, + ); +} + +/** + * Gets comment tokens that are adjacent to the current cursor position. + * @param {Cursor} cursor A cursor instance. + * @returns {Array} An array of comment tokens adjacent to the current cursor position. + * @private + */ +function getAdjacentCommentTokensFromCursor(cursor) { + const tokens = []; + let currentToken = cursor.getOneToken(); + + while (currentToken && isCommentToken(currentToken)) { + tokens.push(currentToken); + currentToken = cursor.getOneToken(); + } + + return tokens; +} + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The token store. + * + * This class provides methods to get tokens by locations as fast as possible. + * The methods are a part of public API, so we should be careful if it changes this class. + * + * People can get tokens in O(1) by the hash map which is mapping from the location of tokens/comments to tokens. + * Also people can get a mix of tokens and comments in O(log k), the k is the number of comments. + * Assuming that comments to be much fewer than tokens, this does not make hash map from token's locations to comments to reduce memory cost. + * This uses binary-searching instead for comments. + */ +module.exports = class TokenStore { + /** + * Initializes this token store. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + */ + constructor(tokens, comments) { + this[TOKENS] = tokens; + this[COMMENTS] = comments; + this[INDEX_MAP] = createIndexMap(tokens, comments); + } + + //-------------------------------------------------------------------------- + // Gets single token. + //-------------------------------------------------------------------------- + + /** + * Gets the token starting at the specified index. + * @param {number} offset Index of the start of the token's range. + * @param {Object} [options=0] The option object. + * @param {boolean} [options.includeComments=false] The flag to iterate comments as well. + * @returns {Token|null} The token starting at index, or null if no such token. + */ + getTokenByRangeStart(offset, options) { + const includeComments = options && options.includeComments; + const token = cursors.forward + .createBaseCursor( + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + offset, + -1, + includeComments, + ) + .getOneToken(); + + if (token && token.range[0] === offset) { + return token; + } + return null; + } + + /** + * Gets the first token of the given node. + * @param {ASTNode} node The AST node. + * @param {number|Function|Object} [options=0] The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. + * @param {boolean} [options.includeComments=false] The flag to iterate comments as well. + * @param {Function|null} [options.filter=null] The predicate function to choose tokens. + * @param {number} [options.skip=0] The count of tokens the cursor skips. + * @returns {Token|null} An object representing the token. + */ + getFirstToken(node, options) { + return createCursorWithSkip( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[0], + node.range[1], + options, + ).getOneToken(); + } + + /** + * Gets the last token of the given node. + * @param {ASTNode} node The AST node. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken() + * @returns {Token|null} An object representing the token. + */ + getLastToken(node, options) { + return createCursorWithSkip( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[0], + node.range[1], + options, + ).getOneToken(); + } + + /** + * Gets the token that precedes a given node or token. + * @param {ASTNode|Token|Comment} node The AST node or token. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken() + * @returns {Token|null} An object representing the token. + */ + getTokenBefore(node, options) { + return createCursorWithSkip( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + -1, + node.range[0], + options, + ).getOneToken(); + } + + /** + * Gets the token that follows a given node or token. + * @param {ASTNode|Token|Comment} node The AST node or token. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken() + * @returns {Token|null} An object representing the token. + */ + getTokenAfter(node, options) { + return createCursorWithSkip( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[1], + -1, + options, + ).getOneToken(); + } + + /** + * Gets the first token between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken() + * @returns {Token|null} An object representing the token. + */ + getFirstTokenBetween(left, right, options) { + return createCursorWithSkip( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + left.range[1], + right.range[0], + options, + ).getOneToken(); + } + + /** + * Gets the last token between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken() + * @returns {Token|null} An object representing the token. + */ + getLastTokenBetween(left, right, options) { + return createCursorWithSkip( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + left.range[1], + right.range[0], + options, + ).getOneToken(); + } + + //-------------------------------------------------------------------------- + // Gets multiple tokens. + //-------------------------------------------------------------------------- + + /** + * Gets the first `count` tokens of the given node. + * @param {ASTNode} node The AST node. + * @param {number|Function|Object} [options=0] The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. + * @param {boolean} [options.includeComments=false] The flag to iterate comments as well. + * @param {Function|null} [options.filter=null] The predicate function to choose tokens. + * @param {number} [options.count=0] The maximum count of tokens the cursor iterates. + * @returns {Token[]} Tokens. + */ + getFirstTokens(node, options) { + return createCursorWithCount( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[0], + node.range[1], + options, + ).getAllTokens(); + } + + /** + * Gets the last `count` tokens of the given node. + * @param {ASTNode} node The AST node. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens() + * @returns {Token[]} Tokens. + */ + getLastTokens(node, options) { + return createCursorWithCount( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[0], + node.range[1], + options, + ) + .getAllTokens() + .reverse(); + } + + /** + * Gets the `count` tokens that precedes a given node or token. + * @param {ASTNode|Token|Comment} node The AST node or token. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens() + * @returns {Token[]} Tokens. + */ + getTokensBefore(node, options) { + return createCursorWithCount( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + -1, + node.range[0], + options, + ) + .getAllTokens() + .reverse(); + } + + /** + * Gets the `count` tokens that follows a given node or token. + * @param {ASTNode|Token|Comment} node The AST node or token. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens() + * @returns {Token[]} Tokens. + */ + getTokensAfter(node, options) { + return createCursorWithCount( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[1], + -1, + options, + ).getAllTokens(); + } + + /** + * Gets the first `count` tokens between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens() + * @returns {Token[]} Tokens between left and right. + */ + getFirstTokensBetween(left, right, options) { + return createCursorWithCount( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + left.range[1], + right.range[0], + options, + ).getAllTokens(); + } + + /** + * Gets the last `count` tokens between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens() + * @returns {Token[]} Tokens between left and right. + */ + getLastTokensBetween(left, right, options) { + return createCursorWithCount( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + left.range[1], + right.range[0], + options, + ) + .getAllTokens() + .reverse(); + } + + /** + * Gets all tokens that are related to the given node. + * @param {ASTNode} node The AST node. + * @param {Function|Object} options The option object. If this is a function then it's `options.filter`. + * @param {boolean} [options.includeComments=false] The flag to iterate comments as well. + * @param {Function|null} [options.filter=null] The predicate function to choose tokens. + * @param {number} [options.count=0] The maximum count of tokens the cursor iterates. + * @returns {Token[]} Array of objects representing tokens. + */ + /** + * Gets all tokens that are related to the given node. + * @param {ASTNode} node The AST node. + * @param {number} [beforeCount=0] The number of tokens before the node to retrieve. + * @param {number} [afterCount=0] The number of tokens after the node to retrieve. + * @returns {Token[]} Array of objects representing tokens. + */ + getTokens(node, beforeCount, afterCount) { + return createCursorWithPadding( + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + node.range[0], + node.range[1], + beforeCount, + afterCount, + ).getAllTokens(); + } + + /** + * Gets all of the tokens between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {Function|Object} options The option object. If this is a function then it's `options.filter`. + * @param {boolean} [options.includeComments=false] The flag to iterate comments as well. + * @param {Function|null} [options.filter=null] The predicate function to choose tokens. + * @param {number} [options.count=0] The maximum count of tokens the cursor iterates. + * @returns {Token[]} Tokens between left and right. + */ + /** + * Gets all of the tokens between two non-overlapping nodes. + * @param {ASTNode|Token|Comment} left Node before the desired token range. + * @param {ASTNode|Token|Comment} right Node after the desired token range. + * @param {number} [padding=0] Number of extra tokens on either side of center. + * @returns {Token[]} Tokens between left and right. + */ + getTokensBetween(left, right, padding) { + return createCursorWithPadding( + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + left.range[1], + right.range[0], + padding, + padding, + ).getAllTokens(); + } + + //-------------------------------------------------------------------------- + // Others. + //-------------------------------------------------------------------------- + + /** + * Checks whether any comments exist or not between the given 2 nodes. + * @param {ASTNode} left The node to check. + * @param {ASTNode} right The node to check. + * @returns {boolean} `true` if one or more comments exist. + */ + commentsExistBetween(left, right) { + const index = utils.search(this[COMMENTS], left.range[1]); + + return ( + index < this[COMMENTS].length && + this[COMMENTS][index].range[1] <= right.range[0] + ); + } + + /** + * Gets all comment tokens directly before the given node or token. + * @param {ASTNode|token} nodeOrToken The AST node or token to check for adjacent comment tokens. + * @returns {Array} An array of comments in occurrence order. + */ + getCommentsBefore(nodeOrToken) { + const cursor = createCursorWithCount( + cursors.backward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + -1, + nodeOrToken.range[0], + { includeComments: true }, + ); + + return getAdjacentCommentTokensFromCursor(cursor).reverse(); + } + + /** + * Gets all comment tokens directly after the given node or token. + * @param {ASTNode|token} nodeOrToken The AST node or token to check for adjacent comment tokens. + * @returns {Array} An array of comments in occurrence order. + */ + getCommentsAfter(nodeOrToken) { + const cursor = createCursorWithCount( + cursors.forward, + this[TOKENS], + this[COMMENTS], + this[INDEX_MAP], + nodeOrToken.range[1], + -1, + { includeComments: true }, + ); + + return getAdjacentCommentTokensFromCursor(cursor); + } + + /** + * Gets all comment tokens inside the given node. + * @param {ASTNode} node The AST node to get the comments for. + * @returns {Array} An array of comments in occurrence order. + */ + getCommentsInside(node) { + return this.getTokens(node, { + includeComments: true, + filter: isCommentToken, + }); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/limit-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/limit-cursor.js new file mode 100644 index 00000000..301d7f54 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/limit-cursor.js @@ -0,0 +1,39 @@ +/** + * @fileoverview Define the cursor which limits the number of tokens. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const DecorativeCursor = require("./decorative-cursor"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The decorative cursor which limits the number of tokens. + */ +module.exports = class LimitCursor extends DecorativeCursor { + /** + * Initializes this cursor. + * @param {Cursor} cursor The cursor to be decorated. + * @param {number} count The count of tokens this cursor iterates. + */ + constructor(cursor, count) { + super(cursor); + this.count = count; + } + + /** @inheritdoc */ + moveNext() { + if (this.count > 0) { + this.count -= 1; + return super.moveNext(); + } + return false; + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/padded-token-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/padded-token-cursor.js new file mode 100644 index 00000000..3d3ce04f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/padded-token-cursor.js @@ -0,0 +1,45 @@ +/** + * @fileoverview Define the cursor which iterates tokens only, with inflated range. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const ForwardTokenCursor = require("./forward-token-cursor"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The cursor which iterates tokens only, with inflated range. + * This is for the backward compatibility of padding options. + */ +module.exports = class PaddedTokenCursor extends ForwardTokenCursor { + /** + * Initializes this cursor. + * @param {Token[]} tokens The array of tokens. + * @param {Comment[]} comments The array of comments. + * @param {Object} indexMap The map from locations to indices in `tokens`. + * @param {number} startLoc The start location of the iteration range. + * @param {number} endLoc The end location of the iteration range. + * @param {number} beforeCount The number of tokens this cursor iterates before start. + * @param {number} afterCount The number of tokens this cursor iterates after end. + */ + constructor( + tokens, + comments, + indexMap, + startLoc, + endLoc, + beforeCount, + afterCount, + ) { + super(tokens, comments, indexMap, startLoc, endLoc); + this.index = Math.max(0, this.index - beforeCount); + this.indexEnd = Math.min(tokens.length - 1, this.indexEnd + afterCount); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/skip-cursor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/skip-cursor.js new file mode 100644 index 00000000..6bc43d85 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/skip-cursor.js @@ -0,0 +1,41 @@ +/** + * @fileoverview Define the cursor which ignores the first few tokens. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const DecorativeCursor = require("./decorative-cursor"); + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * The decorative cursor which ignores the first few tokens. + */ +module.exports = class SkipCursor extends DecorativeCursor { + /** + * Initializes this cursor. + * @param {Cursor} cursor The cursor to be decorated. + * @param {number} count The count of tokens this cursor skips. + */ + constructor(cursor, count) { + super(cursor); + this.count = count; + } + + /** @inheritdoc */ + moveNext() { + while (this.count > 0) { + this.count -= 1; + if (!super.moveNext()) { + return false; + } + } + return super.moveNext(); + } +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/utils.js new file mode 100644 index 00000000..ee7f36f6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/source-code/token-store/utils.js @@ -0,0 +1,130 @@ +/** + * @fileoverview Define utility functions for token store. + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Finds the index of the first token which is after the given location. + * If it was not found, this returns `tokens.length`. + * @param {(Token|Comment)[]} tokens It searches the token in this list. + * @param {number} location The location to search. + * @returns {number} The found index or `tokens.length`. + */ +function search(tokens, location) { + for ( + let minIndex = 0, maxIndex = tokens.length - 1; + minIndex <= maxIndex; + ) { + /* + * Calculate the index in the middle between minIndex and maxIndex. + * `| 0` is used to round a fractional value down to the nearest integer: this is similar to + * using `Math.trunc()` or `Math.floor()`, but performance tests have shown this method to + * be faster. + */ + const index = ((minIndex + maxIndex) / 2) | 0; + const token = tokens[index]; + const tokenStartLocation = token.range[0]; + + if (location <= tokenStartLocation) { + if (index === minIndex) { + return index; + } + maxIndex = index; + } else { + minIndex = index + 1; + } + } + return tokens.length; +} + +/** + * Gets the index of the `startLoc` in `tokens`. + * `startLoc` can be the value of `node.range[1]`, so this checks about `startLoc - 1` as well. + * @param {(Token|Comment)[]} tokens The tokens to find an index. + * @param {Object} indexMap The map from locations to indices. + * @param {number} startLoc The location to get an index. + * @returns {number} The index. + */ +function getFirstIndex(tokens, indexMap, startLoc) { + if (startLoc === -1) { + return 0; + } + if (startLoc in indexMap) { + return indexMap[startLoc]; + } + if (startLoc - 1 in indexMap) { + const index = indexMap[startLoc - 1]; + const token = tokens[index]; + + // If the mapped index is out of bounds, the returned cursor index will point after the end of the tokens array. + if (!token) { + return tokens.length; + } + + /* + * For the map of "comment's location -> token's index", it points the next token of a comment. + * In that case, +1 is unnecessary. + */ + if (token.range[0] >= startLoc) { + return index; + } + return index + 1; + } + + // Program node that doesn't start/end with a token or comment + if (startLoc === 0) { + return 0; + } + return tokens.length; +} +/** + * Gets the index of the `endLoc` in `tokens`. + * The information of end locations are recorded at `endLoc - 1` in `indexMap`, so this checks about `endLoc - 1` as well. + * @param {(Token|Comment)[]} tokens The tokens to find an index. + * @param {Object} indexMap The map from locations to indices. + * @param {number} endLoc The location to get an index. + * @returns {number} The index. + */ +function getLastIndex(tokens, indexMap, endLoc) { + if (endLoc === -1) { + return tokens.length - 1; + } + if (endLoc in indexMap) { + return indexMap[endLoc] - 1; + } + if (endLoc - 1 in indexMap) { + const index = indexMap[endLoc - 1]; + const token = tokens[index]; + + // If the mapped index is out of bounds, the returned cursor index will point before the end of the tokens array. + if (!token) { + return tokens.length - 1; + } + + /* + * For the map of "comment's location -> token's index", it points the next token of a comment. + * In that case, -1 is necessary. + */ + if (token.range[1] > endLoc) { + return index - 1; + } + return index; + } + + // Program node that doesn't start/end with a token or comment + if (endLoc === 0) { + return -1; + } + return tokens.length - 1; +} + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +module.exports = { search, getFirstIndex, getLastIndex }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/validate-language-options.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/validate-language-options.js new file mode 100644 index 00000000..23ed2666 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/languages/js/validate-language-options.js @@ -0,0 +1,196 @@ +/** + * @fileoverview The schema to validate language options + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Data +//----------------------------------------------------------------------------- + +const globalVariablesValues = new Set([ + true, + "true", + "writable", + "writeable", + false, + "false", + "readonly", + "readable", + null, + "off", +]); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Check if a value is a non-null object. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is a non-null object. + */ +function isNonNullObject(value) { + return typeof value === "object" && value !== null; +} + +/** + * Check if a value is a non-null non-array object. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is a non-null non-array object. + */ +function isNonArrayObject(value) { + return isNonNullObject(value) && !Array.isArray(value); +} + +/** + * Check if a value is undefined. + * @param {any} value The value to check. + * @returns {boolean} `true` if the value is undefined. + */ +function isUndefined(value) { + return typeof value === "undefined"; +} + +//----------------------------------------------------------------------------- +// Schemas +//----------------------------------------------------------------------------- + +/** + * Validates the ecmaVersion property. + * @param {string|number} ecmaVersion The value to check. + * @returns {void} + * @throws {TypeError} If the value is invalid. + */ +function validateEcmaVersion(ecmaVersion) { + if (isUndefined(ecmaVersion)) { + throw new TypeError( + 'Key "ecmaVersion": Expected an "ecmaVersion" property.', + ); + } + + if (typeof ecmaVersion !== "number" && ecmaVersion !== "latest") { + throw new TypeError( + 'Key "ecmaVersion": Expected a number or "latest".', + ); + } +} + +/** + * Validates the sourceType property. + * @param {string} sourceType The value to check. + * @returns {void} + * @throws {TypeError} If the value is invalid. + */ +function validateSourceType(sourceType) { + if ( + typeof sourceType !== "string" || + !/^(?:script|module|commonjs)$/u.test(sourceType) + ) { + throw new TypeError( + 'Key "sourceType": Expected "script", "module", or "commonjs".', + ); + } +} + +/** + * Validates the globals property. + * @param {Object} globals The value to check. + * @returns {void} + * @throws {TypeError} If the value is invalid. + */ +function validateGlobals(globals) { + if (!isNonArrayObject(globals)) { + throw new TypeError('Key "globals": Expected an object.'); + } + + for (const key of Object.keys(globals)) { + // avoid hairy edge case + if (key === "__proto__") { + continue; + } + + if (key !== key.trim()) { + throw new TypeError( + `Key "globals": Global "${key}" has leading or trailing whitespace.`, + ); + } + + if (!globalVariablesValues.has(globals[key])) { + throw new TypeError( + `Key "globals": Key "${key}": Expected "readonly", "writable", or "off".`, + ); + } + } +} + +/** + * Validates the parser property. + * @param {Object} parser The value to check. + * @returns {void} + * @throws {TypeError} If the value is invalid. + */ +function validateParser(parser) { + if ( + !parser || + typeof parser !== "object" || + (typeof parser.parse !== "function" && + typeof parser.parseForESLint !== "function") + ) { + throw new TypeError( + 'Key "parser": Expected object with parse() or parseForESLint() method.', + ); + } +} + +/** + * Validates the language options. + * @param {Object} languageOptions The language options to validate. + * @returns {void} + * @throws {TypeError} If the language options are invalid. + */ +function validateLanguageOptions(languageOptions) { + if (!isNonArrayObject(languageOptions)) { + throw new TypeError("Expected an object."); + } + + const { + ecmaVersion, + sourceType, + globals, + parser, + parserOptions, + ...otherOptions + } = languageOptions; + + if ("ecmaVersion" in languageOptions) { + validateEcmaVersion(ecmaVersion); + } + + if ("sourceType" in languageOptions) { + validateSourceType(sourceType); + } + + if ("globals" in languageOptions) { + validateGlobals(globals); + } + + if ("parser" in languageOptions) { + validateParser(parser); + } + + if ("parserOptions" in languageOptions) { + if (!isNonArrayObject(parserOptions)) { + throw new TypeError('Key "parserOptions": Expected an object.'); + } + } + + const otherOptionKeys = Object.keys(otherOptions); + + if (otherOptionKeys.length > 0) { + throw new TypeError(`Unexpected key "${otherOptionKeys[0]}" found.`); + } +} + +module.exports = { validateLanguageOptions }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/apply-disable-directives.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/apply-disable-directives.js new file mode 100644 index 00000000..845f7ee0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/apply-disable-directives.js @@ -0,0 +1,591 @@ +/** + * @fileoverview A module that filters reported problems based on `eslint-disable` and `eslint-enable` comments + * @author Teddy Katz + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("@eslint/core").Language} Language */ +/** @typedef {import("@eslint/core").Position} Position */ +/** @typedef {import("@eslint/core").RulesConfig} RulesConfig */ + +//------------------------------------------------------------------------------ +// Module Definition +//------------------------------------------------------------------------------ + +const escapeRegExp = require("escape-string-regexp"); +const { Config } = require("../config/config.js"); + +/** + * Compares the locations of two objects in a source file + * @param {Position} itemA The first object + * @param {Position} itemB The second object + * @returns {number} A value less than 1 if itemA appears before itemB in the source file, greater than 1 if + * itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location. + */ +function compareLocations(itemA, itemB) { + return itemA.line - itemB.line || itemA.column - itemB.column; +} + +/** + * Groups a set of directives into sub-arrays by their parent comment. + * @param {Iterable} directives Unused directives to be removed. + * @returns {Directive[][]} Directives grouped by their parent comment. + */ +function groupByParentDirective(directives) { + const groups = new Map(); + + for (const directive of directives) { + const { + unprocessedDirective: { parentDirective }, + } = directive; + + if (groups.has(parentDirective)) { + groups.get(parentDirective).push(directive); + } else { + groups.set(parentDirective, [directive]); + } + } + + return [...groups.values()]; +} + +/** + * Creates removal details for a set of directives within the same comment. + * @param {Directive[]} directives Unused directives to be removed. + * @param {{node: Token, value: string}} parentDirective Data about the backing directive. + * @param {SourceCode} sourceCode The source code object for the file being linted. + * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems. + */ +function createIndividualDirectivesRemoval( + directives, + parentDirective, + sourceCode, +) { + /* + * Get the list of the rules text without any surrounding whitespace. In order to preserve the original + * formatting, we don't want to change that whitespace. + * + * // eslint-disable-line rule-one , rule-two , rule-three -- comment + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ + const listText = parentDirective.value.trim(); + + // Calculate where it starts in the source code text + const listStart = sourceCode.text.indexOf( + listText, + sourceCode.getRange(parentDirective.node)[0], + ); + + /* + * We can assume that `listText` contains multiple elements. + * Otherwise, this function wouldn't be called - if there is + * only one rule in the list, then the whole comment must be removed. + */ + + return directives.map(directive => { + const { ruleId } = directive; + + const regex = new RegExp( + String.raw`(?:^|\s*,\s*)(?['"]?)${escapeRegExp(ruleId)}\k(?:\s*,\s*|$)`, + "u", + ); + const match = regex.exec(listText); + const matchedText = match[0]; + const matchStart = listStart + match.index; + const matchEnd = matchStart + matchedText.length; + + const firstIndexOfComma = matchedText.indexOf(","); + const lastIndexOfComma = matchedText.lastIndexOf(","); + + let removalStart, removalEnd; + + if (firstIndexOfComma !== lastIndexOfComma) { + /* + * Since there are two commas, this must one of the elements in the middle of the list. + * Matched range starts where the previous rule name ends, and ends where the next rule name starts. + * + * // eslint-disable-line rule-one , rule-two , rule-three -- comment + * ^^^^^^^^^^^^^^ + * + * We want to remove only the content between the two commas, and also one of the commas. + * + * // eslint-disable-line rule-one , rule-two , rule-three -- comment + * ^^^^^^^^^^^ + */ + removalStart = matchStart + firstIndexOfComma; + removalEnd = matchStart + lastIndexOfComma; + } else { + /* + * This is either the first element or the last element. + * + * If this is the first element, matched range starts where the first rule name starts + * and ends where the second rule name starts. This is exactly the range we want + * to remove so that the second rule name will start where the first one was starting + * and thus preserve the original formatting. + * + * // eslint-disable-line rule-one , rule-two , rule-three -- comment + * ^^^^^^^^^^^ + * + * Similarly, if this is the last element, we've already matched the range we want to + * remove. The previous rule name will end where the last one was ending, relative + * to the content on the right side. + * + * // eslint-disable-line rule-one , rule-two , rule-three -- comment + * ^^^^^^^^^^^^^ + */ + removalStart = matchStart; + removalEnd = matchEnd; + } + + return { + description: `'${ruleId}'`, + fix: { + range: [removalStart, removalEnd], + text: "", + }, + unprocessedDirective: directive.unprocessedDirective, + }; + }); +} + +/** + * Creates a description of deleting an entire unused disable directive. + * @param {Directive[]} directives Unused directives to be removed. + * @param {Token} node The backing Comment token. + * @param {SourceCode} sourceCode The source code object for the file being linted. + * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output problem. + */ +function createDirectiveRemoval(directives, node, sourceCode) { + const range = sourceCode.getRange(node); + const ruleIds = directives + .filter(directive => directive.ruleId) + .map(directive => `'${directive.ruleId}'`); + + return { + description: + ruleIds.length <= 2 + ? ruleIds.join(" or ") + : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`, + fix: { + range, + text: " ", + }, + unprocessedDirective: directives[0].unprocessedDirective, + }; +} + +/** + * Parses details from directives to create output Problems. + * @param {Iterable} allDirectives Unused directives to be removed. + * @param {SourceCode} sourceCode The source code object for the file being linted. + * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems. + */ +function processUnusedDirectives(allDirectives, sourceCode) { + const directiveGroups = groupByParentDirective(allDirectives); + + return directiveGroups.flatMap(directives => { + const { parentDirective } = directives[0].unprocessedDirective; + const remainingRuleIds = new Set(parentDirective.ruleIds); + + for (const directive of directives) { + remainingRuleIds.delete(directive.ruleId); + } + + return remainingRuleIds.size + ? createIndividualDirectivesRemoval( + directives, + parentDirective, + sourceCode, + ) + : [ + createDirectiveRemoval( + directives, + parentDirective.node, + sourceCode, + ), + ]; + }); +} + +/** + * Collect eslint-enable comments that are removing suppressions by eslint-disable comments. + * @param {Directive[]} directives The directives to check. + * @returns {Set} The used eslint-enable comments + */ +function collectUsedEnableDirectives(directives) { + /** + * A Map of `eslint-enable` keyed by ruleIds that may be marked as used. + * If `eslint-enable` does not have a ruleId, the key will be `null`. + * @type {Map} + */ + const enabledRules = new Map(); + + /** + * A Set of `eslint-enable` marked as used. + * It is also the return value of `collectUsedEnableDirectives` function. + * @type {Set} + */ + const usedEnableDirectives = new Set(); + + /* + * Checks the directives backwards to see if the encountered `eslint-enable` is used by the previous `eslint-disable`, + * and if so, stores the `eslint-enable` in `usedEnableDirectives`. + */ + for (let index = directives.length - 1; index >= 0; index--) { + const directive = directives[index]; + + if (directive.type === "disable") { + if (enabledRules.size === 0) { + continue; + } + if (directive.ruleId === null) { + // If encounter `eslint-disable` without ruleId, + // mark all `eslint-enable` currently held in enabledRules as used. + // e.g. + // /* eslint-disable */ <- current directive + // /* eslint-enable rule-id1 */ <- used + // /* eslint-enable rule-id2 */ <- used + // /* eslint-enable */ <- used + for (const enableDirective of enabledRules.values()) { + usedEnableDirectives.add(enableDirective); + } + enabledRules.clear(); + } else { + const enableDirective = enabledRules.get(directive.ruleId); + + if (enableDirective) { + // If encounter `eslint-disable` with ruleId, and there is an `eslint-enable` with the same ruleId in enabledRules, + // mark `eslint-enable` with ruleId as used. + // e.g. + // /* eslint-disable rule-id */ <- current directive + // /* eslint-enable rule-id */ <- used + usedEnableDirectives.add(enableDirective); + } else { + const enabledDirectiveWithoutRuleId = + enabledRules.get(null); + + if (enabledDirectiveWithoutRuleId) { + // If encounter `eslint-disable` with ruleId, and there is no `eslint-enable` with the same ruleId in enabledRules, + // mark `eslint-enable` without ruleId as used. + // e.g. + // /* eslint-disable rule-id */ <- current directive + // /* eslint-enable */ <- used + usedEnableDirectives.add(enabledDirectiveWithoutRuleId); + } + } + } + } else if (directive.type === "enable") { + if (directive.ruleId === null) { + // If encounter `eslint-enable` without ruleId, the `eslint-enable` that follows it are unused. + // So clear enabledRules. + // e.g. + // /* eslint-enable */ <- current directive + // /* eslint-enable rule-id *// <- unused + // /* eslint-enable */ <- unused + enabledRules.clear(); + enabledRules.set(null, directive); + } else { + enabledRules.set(directive.ruleId, directive); + } + } + } + return usedEnableDirectives; +} + +/** + * This is the same as the exported function, except that it + * doesn't handle disable-line and disable-next-line directives, and it always reports unused + * disable directives. + * @param {Object} options options for applying directives. This is the same as the options + * for the exported function, except that `reportUnusedDisableDirectives` is not supported + * (this function always reports unused disable directives). + * @returns {{problems: LintMessage[], unusedDirectives: LintMessage[]}} An object with a list + * of problems (including suppressed ones) and unused eslint-disable directives + */ +function applyDirectives(options) { + // Fast path: without directives there's nothing to suppress or report. + if (options.directives.length === 0) { + return { + problems: options.problems.slice(), + unusedDirectives: [], + }; + } + + const problems = []; + const usedDisableDirectives = new Set(); + const { sourceCode } = options; + + for (const problem of options.problems) { + let disableDirectivesForProblem = []; + let nextDirectiveIndex = 0; + + while ( + nextDirectiveIndex < options.directives.length && + compareLocations(options.directives[nextDirectiveIndex], problem) <= + 0 + ) { + const directive = options.directives[nextDirectiveIndex++]; + + if ( + directive.ruleId === null || + directive.ruleId === problem.ruleId + ) { + switch (directive.type) { + case "disable": + disableDirectivesForProblem.push(directive); + break; + + case "enable": + disableDirectivesForProblem = []; + break; + + // no default + } + } + } + + if (disableDirectivesForProblem.length > 0) { + const suppressions = disableDirectivesForProblem.map(directive => ({ + kind: "directive", + justification: directive.unprocessedDirective.justification, + })); + + if (problem.suppressions) { + problem.suppressions = + problem.suppressions.concat(suppressions); + } else { + problem.suppressions = suppressions; + usedDisableDirectives.add(disableDirectivesForProblem.at(-1)); + } + } + + problems.push(problem); + } + + const unusedDisableDirectivesToReport = options.directives.filter( + directive => + directive.type === "disable" && + !usedDisableDirectives.has(directive) && + !options.rulesToIgnore.has(directive.ruleId), + ); + + const unusedEnableDirectivesToReport = new Set( + options.directives.filter( + directive => + directive.unprocessedDirective.type === "enable" && + !options.rulesToIgnore.has(directive.ruleId), + ), + ); + + /* + * If directives has the eslint-enable directive, + * check whether the eslint-enable comment is used. + */ + if (unusedEnableDirectivesToReport.size > 0) { + for (const directive of collectUsedEnableDirectives( + options.directives, + )) { + unusedEnableDirectivesToReport.delete(directive); + } + } + + const processed = processUnusedDirectives( + unusedDisableDirectivesToReport, + sourceCode, + ).concat( + processUnusedDirectives(unusedEnableDirectivesToReport, sourceCode), + ); + const columnOffset = options.language.columnStart === 1 ? 0 : 1; + const lineOffset = options.language.lineStart === 1 ? 0 : 1; + + const unusedDirectives = processed.map( + ({ description, fix, unprocessedDirective }) => { + const { parentDirective, type, line, column } = + unprocessedDirective; + + let message; + + if (type === "enable") { + message = description + ? `Unused eslint-enable directive (no matching eslint-disable directives were found for ${description}).` + : "Unused eslint-enable directive (no matching eslint-disable directives were found)."; + } else { + message = description + ? `Unused eslint-disable directive (no problems were reported from ${description}).` + : "Unused eslint-disable directive (no problems were reported)."; + } + + const loc = sourceCode.getLoc(parentDirective.node); + + return { + ruleId: null, + message, + line: + type === "disable-next-line" + ? loc.start.line + lineOffset + : line, + column: + type === "disable-next-line" + ? loc.start.column + columnOffset + : column, + severity: + options.reportUnusedDisableDirectives === "warn" ? 1 : 2, + ...(options.disableFixes ? {} : { fix }), + }; + }, + ); + + return { problems, unusedDirectives }; +} + +/** + * Given a list of directive comments (i.e. metadata about eslint-disable and eslint-enable comments) and a list + * of reported problems, adds the suppression information to the problems. + * @param {Object} options Information about directives and problems + * @param {Language} options.language The language being linted. + * @param {SourceCode} options.sourceCode The source code object for the file being linted. + * @param {{ + * type: ("disable"|"enable"|"disable-line"|"disable-next-line"), + * ruleId: (string|null), + * line: number, + * column: number, + * justification: string + * }} options.directives Directive comments found in the file, with one-based columns. + * Two directive comments can only have the same location if they also have the same type (e.g. a single eslint-disable + * comment for two different rules is represented as two directives). + * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems + * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns. + * @param {"off" | "warn" | "error"} options.reportUnusedDisableDirectives If `"warn"` or `"error"`, adds additional problems for unused directives + * @param {RulesConfig} options.configuredRules The rules configuration. + * @param {Function} options.ruleFilter A predicate function to filter which rules should be executed. + * @param {boolean} options.disableFixes If true, it doesn't make `fix` properties. + * @returns {{ruleId: (string|null), line: number, column: number, suppressions?: {kind: string, justification: string}}[]} + * An object with a list of reported problems, the suppressed of which contain the suppression information. + */ +module.exports = ({ + language, + sourceCode, + directives, + disableFixes, + problems, + configuredRules, + ruleFilter, + reportUnusedDisableDirectives = "off", +}) => { + const blockDirectives = directives + .filter( + directive => + directive.type === "disable" || directive.type === "enable", + ) + .map(directive => + Object.assign({}, directive, { unprocessedDirective: directive }), + ) + .sort(compareLocations); + + const lineDirectives = directives + .flatMap(directive => { + switch (directive.type) { + case "disable": + case "enable": + return []; + + case "disable-line": + return [ + { + type: "disable", + line: directive.line, + column: 1, + ruleId: directive.ruleId, + unprocessedDirective: directive, + }, + { + type: "enable", + line: directive.line + 1, + column: 0, + ruleId: directive.ruleId, + unprocessedDirective: directive, + }, + ]; + + case "disable-next-line": + return [ + { + type: "disable", + line: directive.line + 1, + column: 1, + ruleId: directive.ruleId, + unprocessedDirective: directive, + }, + { + type: "enable", + line: directive.line + 2, + column: 0, + ruleId: directive.ruleId, + unprocessedDirective: directive, + }, + ]; + + default: + throw new TypeError( + `Unrecognized directive type '${directive.type}'`, + ); + } + }) + .sort(compareLocations); + + // This determines a list of rules that are not being run by the given ruleFilter, if present. + const rulesToIgnore = + configuredRules && ruleFilter + ? new Set( + Object.keys(configuredRules).filter(ruleId => { + const severity = Config.getRuleNumericSeverity( + configuredRules[ruleId], + ); + + // Ignore for disabled rules. + if (severity === 0) { + return false; + } + + return !ruleFilter({ severity, ruleId }); + }), + ) + : new Set(); + + // If no ruleId is supplied that means this directive is applied to all rules, so we can't determine if it's unused if any rules are filtered out. + if (rulesToIgnore.size > 0) { + rulesToIgnore.add(null); + } + + const blockDirectivesResult = applyDirectives({ + language, + sourceCode, + problems, + directives: blockDirectives, + disableFixes, + reportUnusedDisableDirectives, + rulesToIgnore, + }); + const lineDirectivesResult = applyDirectives({ + language, + sourceCode, + problems: blockDirectivesResult.problems, + directives: lineDirectives, + disableFixes, + reportUnusedDisableDirectives, + rulesToIgnore, + }); + + return reportUnusedDisableDirectives !== "off" + ? lineDirectivesResult.problems + .concat(blockDirectivesResult.unusedDirectives) + .concat(lineDirectivesResult.unusedDirectives) + .sort(compareLocations) + : lineDirectivesResult.problems; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-analyzer.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-analyzer.js new file mode 100644 index 00000000..eef58e28 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-analyzer.js @@ -0,0 +1,835 @@ +/** + * @fileoverview A class of the code path analyzer. + * @author Toru Nagashima + */ + +/* eslint internal-rules/no-debug-template-literals: ["error", { methods: ["dump"] }] -- Check calls to `debug.dump`. */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const assert = require("../../shared/assert"), + { breakableTypePattern } = require("../../shared/ast-utils"), + CodePath = require("./code-path"), + CodePathSegment = require("./code-path-segment"), + IdGenerator = require("./id-generator"), + debug = require("./debug-helpers"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given node is a `case` node (not `default` node). + * @param {ASTNode} node A `SwitchCase` node to check. + * @returns {boolean} `true` if the node is a `case` node (not `default` node). + */ +function isCaseNode(node) { + return Boolean(node.test); +} + +/** + * Checks if a given node appears as the value of a PropertyDefinition node. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a PropertyDefinition value, + * false if not. + */ +function isPropertyDefinitionValue(node) { + const parent = node.parent; + + return ( + parent && parent.type === "PropertyDefinition" && parent.value === node + ); +} + +/** + * Checks whether the given logical operator is taken into account for the code + * path analysis. + * @param {string} operator The operator found in the LogicalExpression node + * @returns {boolean} `true` if the operator is "&&" or "||" or "??" + */ +function isHandledLogicalOperator(operator) { + return operator === "&&" || operator === "||" || operator === "??"; +} + +/** + * Checks whether the given assignment operator is a logical assignment operator. + * Logical assignments are taken into account for the code path analysis + * because of their short-circuiting semantics. + * @param {string} operator The operator found in the AssignmentExpression node + * @returns {boolean} `true` if the operator is "&&=" or "||=" or "??=" + */ +function isLogicalAssignmentOperator(operator) { + return operator === "&&=" || operator === "||=" || operator === "??="; +} + +/** + * Gets the label if the parent node of a given node is a LabeledStatement. + * @param {ASTNode} node A node to get. + * @returns {string|null} The label or `null`. + */ +function getLabel(node) { + if (node.parent.type === "LabeledStatement") { + return node.parent.label.name; + } + return null; +} + +/** + * Checks whether a given logical expression node takes different paths for the + * `true` and `false` cases. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is a test of a choice statement. + */ +function isForkingByTrueOrFalse(node) { + const parent = node.parent; + + switch (parent.type) { + case "ConditionalExpression": + case "IfStatement": + case "WhileStatement": + case "DoWhileStatement": + case "ForStatement": + return parent.test === node; + + case "LogicalExpression": + return isHandledLogicalOperator(parent.operator); + + case "AssignmentExpression": + return isLogicalAssignmentOperator(parent.operator); + + default: + return false; + } +} + +/** + * Gets the boolean value of a given literal node. + * + * This is used to detect infinite loops (e.g. `while (true) {}`). + * Statements preceded by an infinite loop are unreachable if the loop didn't + * have any `break` statement. + * @param {ASTNode} node A node to get. + * @returns {boolean|undefined} a boolean value if the node is a Literal node, + * otherwise `undefined`. + */ +function getBooleanValueIfSimpleConstant(node) { + if (node.type === "Literal") { + return Boolean(node.value); + } + return void 0; +} + +/** + * Checks that a given identifier node is a reference or not. + * + * This is used to detect the first throwable node in a `try` block. + * @param {ASTNode} node An Identifier node to check. + * @returns {boolean} `true` if the node is a reference. + */ +function isIdentifierReference(node) { + const parent = node.parent; + + switch (parent.type) { + case "LabeledStatement": + case "BreakStatement": + case "ContinueStatement": + case "ArrayPattern": + case "RestElement": + case "ImportSpecifier": + case "ImportDefaultSpecifier": + case "ImportNamespaceSpecifier": + case "CatchClause": + return false; + + case "FunctionDeclaration": + case "FunctionExpression": + case "ArrowFunctionExpression": + case "ClassDeclaration": + case "ClassExpression": + case "VariableDeclarator": + return parent.id !== node; + + case "Property": + case "PropertyDefinition": + case "MethodDefinition": + return parent.key !== node || parent.computed || parent.shorthand; + + case "AssignmentPattern": + return parent.key !== node; + + default: + return true; + } +} + +/** + * Updates the current segment with the head segment. + * This is similar to local branches and tracking branches of git. + * + * To separate the current and the head is in order to not make useless segments. + * + * In this process, both "onCodePathSegmentStart" and "onCodePathSegmentEnd" + * events are fired. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function forwardCurrentToHead(analyzer, node) { + const codePath = analyzer.codePath; + const state = CodePath.getState(codePath); + const currentSegments = state.currentSegments; + const headSegments = state.headSegments; + const end = Math.max(currentSegments.length, headSegments.length); + let i, currentSegment, headSegment; + + // Fires leaving events. + for (i = 0; i < end; ++i) { + currentSegment = currentSegments[i]; + headSegment = headSegments[i]; + + if (currentSegment !== headSegment && currentSegment) { + const eventName = currentSegment.reachable + ? "onCodePathSegmentEnd" + : "onUnreachableCodePathSegmentEnd"; + + debug.dump("%s %s", eventName, currentSegment.id); + + analyzer.emit(eventName, [currentSegment, node]); + } + } + + // Update state. + state.currentSegments = headSegments; + + // Fires entering events. + for (i = 0; i < end; ++i) { + currentSegment = currentSegments[i]; + headSegment = headSegments[i]; + + if (currentSegment !== headSegment && headSegment) { + const eventName = headSegment.reachable + ? "onCodePathSegmentStart" + : "onUnreachableCodePathSegmentStart"; + + debug.dump("%s %s", eventName, headSegment.id); + CodePathSegment.markUsed(headSegment); + analyzer.emit(eventName, [headSegment, node]); + } + } +} + +/** + * Updates the current segment with an empty array. + * This is called when a code path ends. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function leaveFromCurrentSegment(analyzer, node) { + const state = CodePath.getState(analyzer.codePath); + const currentSegments = state.currentSegments; + + for (let i = 0; i < currentSegments.length; ++i) { + const currentSegment = currentSegments[i]; + const eventName = currentSegment.reachable + ? "onCodePathSegmentEnd" + : "onUnreachableCodePathSegmentEnd"; + + debug.dump("%s %s", eventName, currentSegment.id); + + analyzer.emit(eventName, [currentSegment, node]); + } + + state.currentSegments = []; +} + +/** + * Updates the code path due to the position of a given node in the parent node + * thereof. + * + * For example, if the node is `parent.consequent`, this creates a fork from the + * current path. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function preprocess(analyzer, node) { + const codePath = analyzer.codePath; + const state = CodePath.getState(codePath); + const parent = node.parent; + + switch (parent.type) { + // The `arguments.length == 0` case is in `postprocess` function. + case "CallExpression": + if ( + parent.optional === true && + parent.arguments.length >= 1 && + parent.arguments[0] === node + ) { + state.makeOptionalRight(); + } + break; + case "MemberExpression": + if (parent.optional === true && parent.property === node) { + state.makeOptionalRight(); + } + break; + + case "LogicalExpression": + if ( + parent.right === node && + isHandledLogicalOperator(parent.operator) + ) { + state.makeLogicalRight(); + } + break; + + case "AssignmentExpression": + if ( + parent.right === node && + isLogicalAssignmentOperator(parent.operator) + ) { + state.makeLogicalRight(); + } + break; + + case "ConditionalExpression": + case "IfStatement": + /* + * Fork if this node is at `consequent`/`alternate`. + * `popForkContext()` exists at `IfStatement:exit` and + * `ConditionalExpression:exit`. + */ + if (parent.consequent === node) { + state.makeIfConsequent(); + } else if (parent.alternate === node) { + state.makeIfAlternate(); + } + break; + + case "SwitchCase": + if (parent.consequent[0] === node) { + state.makeSwitchCaseBody(false, !parent.test); + } + break; + + case "TryStatement": + if (parent.handler === node) { + state.makeCatchBlock(); + } else if (parent.finalizer === node) { + state.makeFinallyBlock(); + } + break; + + case "WhileStatement": + if (parent.test === node) { + state.makeWhileTest(getBooleanValueIfSimpleConstant(node)); + } else { + assert(parent.body === node); + state.makeWhileBody(); + } + break; + + case "DoWhileStatement": + if (parent.body === node) { + state.makeDoWhileBody(); + } else { + assert(parent.test === node); + state.makeDoWhileTest(getBooleanValueIfSimpleConstant(node)); + } + break; + + case "ForStatement": + if (parent.test === node) { + state.makeForTest(getBooleanValueIfSimpleConstant(node)); + } else if (parent.update === node) { + state.makeForUpdate(); + } else if (parent.body === node) { + state.makeForBody(); + } + break; + + case "ForInStatement": + case "ForOfStatement": + if (parent.left === node) { + state.makeForInOfLeft(); + } else if (parent.right === node) { + state.makeForInOfRight(); + } else { + assert(parent.body === node); + state.makeForInOfBody(); + } + break; + + case "AssignmentPattern": + /* + * Fork if this node is at `right`. + * `left` is executed always, so it uses the current path. + * `popForkContext()` exists at `AssignmentPattern:exit`. + */ + if (parent.right === node) { + state.pushForkContext(); + state.forkBypassPath(); + state.forkPath(); + } + break; + + default: + break; + } +} + +/** + * Updates the code path due to the type of a given node in entering. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function processCodePathToEnter(analyzer, node) { + let codePath = analyzer.codePath; + let state = codePath && CodePath.getState(codePath); + const parent = node.parent; + + /** + * Creates a new code path and trigger the onCodePathStart event + * based on the currently selected node. + * @param {string} origin The reason the code path was started. + * @returns {void} + */ + function startCodePath(origin) { + if (codePath) { + // Emits onCodePathSegmentStart events if updated. + forwardCurrentToHead(analyzer, node); + debug.dumpState(node, state, false); + } + + // Create the code path of this scope. + codePath = analyzer.codePath = new CodePath({ + id: analyzer.idGenerator.next(), + origin, + upper: codePath, + onLooped: analyzer.onLooped, + }); + state = CodePath.getState(codePath); + + // Emits onCodePathStart events. + debug.dump("onCodePathStart %s", codePath.id); + analyzer.emit("onCodePathStart", [codePath, node]); + } + + /* + * Special case: The right side of class field initializer is considered + * to be its own function, so we need to start a new code path in this + * case. + */ + if (isPropertyDefinitionValue(node)) { + startCodePath("class-field-initializer"); + + /* + * Intentional fall through because `node` needs to also be + * processed by the code below. For example, if we have: + * + * class Foo { + * a = () => {} + * } + * + * In this case, we also need start a second code path. + */ + } + + switch (node.type) { + case "Program": + startCodePath("program"); + break; + + case "FunctionDeclaration": + case "FunctionExpression": + case "ArrowFunctionExpression": + startCodePath("function"); + break; + + case "StaticBlock": + startCodePath("class-static-block"); + break; + + case "ChainExpression": + state.pushChainContext(); + break; + case "CallExpression": + if (node.optional === true) { + state.makeOptionalNode(); + } + break; + case "MemberExpression": + if (node.optional === true) { + state.makeOptionalNode(); + } + break; + + case "LogicalExpression": + if (isHandledLogicalOperator(node.operator)) { + state.pushChoiceContext( + node.operator, + isForkingByTrueOrFalse(node), + ); + } + break; + + case "AssignmentExpression": + if (isLogicalAssignmentOperator(node.operator)) { + state.pushChoiceContext( + node.operator.slice(0, -1), // removes `=` from the end + isForkingByTrueOrFalse(node), + ); + } + break; + + case "ConditionalExpression": + case "IfStatement": + state.pushChoiceContext("test", false); + break; + + case "SwitchStatement": + state.pushSwitchContext( + node.cases.some(isCaseNode), + getLabel(node), + ); + break; + + case "TryStatement": + state.pushTryContext(Boolean(node.finalizer)); + break; + + case "SwitchCase": + /* + * Fork if this node is after the 1st node in `cases`. + * It's similar to `else` blocks. + * The next `test` node is processed in this path. + */ + if (parent.discriminant !== node && parent.cases[0] !== node) { + state.forkPath(); + } + break; + + case "WhileStatement": + case "DoWhileStatement": + case "ForStatement": + case "ForInStatement": + case "ForOfStatement": + state.pushLoopContext(node.type, getLabel(node)); + break; + + case "LabeledStatement": + if (!breakableTypePattern.test(node.body.type)) { + state.pushBreakContext(false, node.label.name); + } + break; + + default: + break; + } + + // Emits onCodePathSegmentStart events if updated. + forwardCurrentToHead(analyzer, node); + debug.dumpState(node, state, false); +} + +/** + * Updates the code path due to the type of a given node in leaving. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function processCodePathToExit(analyzer, node) { + const codePath = analyzer.codePath; + const state = CodePath.getState(codePath); + let dontForward = false; + + switch (node.type) { + case "ChainExpression": + state.popChainContext(); + break; + + case "IfStatement": + case "ConditionalExpression": + state.popChoiceContext(); + break; + + case "LogicalExpression": + if (isHandledLogicalOperator(node.operator)) { + state.popChoiceContext(); + } + break; + + case "AssignmentExpression": + if (isLogicalAssignmentOperator(node.operator)) { + state.popChoiceContext(); + } + break; + + case "SwitchStatement": + state.popSwitchContext(); + break; + + case "SwitchCase": + /* + * This is the same as the process at the 1st `consequent` node in + * `preprocess` function. + * Must do if this `consequent` is empty. + */ + if (node.consequent.length === 0) { + state.makeSwitchCaseBody(true, !node.test); + } + if (state.forkContext.reachable) { + dontForward = true; + } + break; + + case "TryStatement": + state.popTryContext(); + break; + + case "BreakStatement": + forwardCurrentToHead(analyzer, node); + state.makeBreak(node.label && node.label.name); + dontForward = true; + break; + + case "ContinueStatement": + forwardCurrentToHead(analyzer, node); + state.makeContinue(node.label && node.label.name); + dontForward = true; + break; + + case "ReturnStatement": + forwardCurrentToHead(analyzer, node); + state.makeReturn(); + dontForward = true; + break; + + case "ThrowStatement": + forwardCurrentToHead(analyzer, node); + state.makeThrow(); + dontForward = true; + break; + + case "Identifier": + if (isIdentifierReference(node)) { + state.makeFirstThrowablePathInTryOrCatchBlock(); + dontForward = true; + } + break; + + case "CallExpression": + case "ImportExpression": + case "MemberExpression": + case "NewExpression": + state.makeFirstThrowablePathInTryOrCatchBlock(); + break; + + case "YieldExpression": + state.makeYield(); + break; + + case "WhileStatement": + case "DoWhileStatement": + case "ForStatement": + case "ForInStatement": + case "ForOfStatement": + state.popLoopContext(); + break; + + case "AssignmentPattern": + state.popForkContext(); + break; + + case "LabeledStatement": + if (!breakableTypePattern.test(node.body.type)) { + state.popBreakContext(); + } + break; + + default: + break; + } + + // Emits onCodePathSegmentStart events if updated. + if (!dontForward) { + forwardCurrentToHead(analyzer, node); + } + debug.dumpState(node, state, true); +} + +/** + * Updates the code path to finalize the current code path. + * @param {CodePathAnalyzer} analyzer The instance. + * @param {ASTNode} node The current AST node. + * @returns {void} + */ +function postprocess(analyzer, node) { + /** + * Ends the code path for the current node. + * @returns {void} + */ + function endCodePath() { + let codePath = analyzer.codePath; + + // Mark the current path as the final node. + CodePath.getState(codePath).makeFinal(); + + // Emits onCodePathSegmentEnd event of the current segments. + leaveFromCurrentSegment(analyzer, node); + + // Emits onCodePathEnd event of this code path. + debug.dump("onCodePathEnd %s", codePath.id); + analyzer.emit("onCodePathEnd", [codePath, node]); + debug.dumpDot(codePath); + + codePath = analyzer.codePath = analyzer.codePath.upper; + if (codePath) { + debug.dumpState(node, CodePath.getState(codePath), true); + } + } + + switch (node.type) { + case "Program": + case "FunctionDeclaration": + case "FunctionExpression": + case "ArrowFunctionExpression": + case "StaticBlock": { + endCodePath(); + break; + } + + // The `arguments.length >= 1` case is in `preprocess` function. + case "CallExpression": + if (node.optional === true && node.arguments.length === 0) { + CodePath.getState(analyzer.codePath).makeOptionalRight(); + } + break; + + default: + break; + } + + /* + * Special case: The right side of class field initializer is considered + * to be its own function, so we need to end a code path in this + * case. + * + * We need to check after the other checks in order to close the + * code paths in the correct order for code like this: + * + * + * class Foo { + * a = () => {} + * } + * + * In this case, the ArrowFunctionExpression code path is closed first, + * and then we need to close the code path for the PropertyDefinition + * value. + */ + if (isPropertyDefinitionValue(node)) { + endCodePath(); + } +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * The class to analyze code paths. + * This class implements the EventGenerator interface. + */ +class CodePathAnalyzer { + /** + * @param {EventGenerator} eventGenerator An event generator to wrap. + */ + constructor(eventGenerator) { + this.original = eventGenerator; + this.emit = eventGenerator.emit; + this.codePath = null; + this.idGenerator = new IdGenerator("s"); + this.currentNode = null; + this.onLooped = this.onLooped.bind(this); + } + + /** + * Does the process to enter a given AST node. + * This updates state of analysis and calls `enterNode` of the wrapped. + * @param {ASTNode} node A node which is entering. + * @returns {void} + */ + enterNode(node) { + this.currentNode = node; + + // Updates the code path due to node's position in its parent node. + if (node.parent) { + preprocess(this, node); + } + + /* + * Updates the code path. + * And emits onCodePathStart/onCodePathSegmentStart events. + */ + processCodePathToEnter(this, node); + + // Emits node events. + this.original.enterNode(node); + + this.currentNode = null; + } + + /** + * Does the process to leave a given AST node. + * This updates state of analysis and calls `leaveNode` of the wrapped. + * @param {ASTNode} node A node which is leaving. + * @returns {void} + */ + leaveNode(node) { + this.currentNode = node; + + /* + * Updates the code path. + * And emits onCodePathStart/onCodePathSegmentStart events. + */ + processCodePathToExit(this, node); + + // Emits node events. + this.original.leaveNode(node); + + // Emits the last onCodePathStart/onCodePathSegmentStart events. + postprocess(this, node); + + this.currentNode = null; + } + + /** + * This is called on a code path looped. + * Then this raises a looped event. + * @param {CodePathSegment} fromSegment A segment of prev. + * @param {CodePathSegment} toSegment A segment of next. + * @returns {void} + */ + onLooped(fromSegment, toSegment) { + if (fromSegment.reachable && toSegment.reachable) { + debug.dump( + "onCodePathSegmentLoop %s -> %s", + fromSegment.id, + toSegment.id, + ); + this.emit("onCodePathSegmentLoop", [ + fromSegment, + toSegment, + this.currentNode, + ]); + } + } +} + +module.exports = CodePathAnalyzer; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-segment.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-segment.js new file mode 100644 index 00000000..fa495018 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-segment.js @@ -0,0 +1,262 @@ +/** + * @fileoverview The CodePathSegment class. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const debug = require("./debug-helpers"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given segment is reachable. + * @param {CodePathSegment} segment A segment to check. + * @returns {boolean} `true` if the segment is reachable. + */ +function isReachable(segment) { + return segment.reachable; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * A code path segment. + * + * Each segment is arranged in a series of linked lists (implemented by arrays) + * that keep track of the previous and next segments in a code path. In this way, + * you can navigate between all segments in any code path so long as you have a + * reference to any segment in that code path. + * + * When first created, the segment is in a detached state, meaning that it knows the + * segments that came before it but those segments don't know that this new segment + * follows it. Only when `CodePathSegment#markUsed()` is called on a segment does it + * officially become part of the code path by updating the previous segments to know + * that this new segment follows. + */ +class CodePathSegment { + /** + * Creates a new instance. + * @param {string} id An identifier. + * @param {CodePathSegment[]} allPrevSegments An array of the previous segments. + * This array includes unreachable segments. + * @param {boolean} reachable A flag which shows this is reachable. + */ + constructor(id, allPrevSegments, reachable) { + /** + * The identifier of this code path. + * Rules use it to store additional information of each rule. + * @type {string} + */ + this.id = id; + + /** + * An array of the next reachable segments. + * @type {CodePathSegment[]} + */ + this.nextSegments = []; + + /** + * An array of the previous reachable segments. + * @type {CodePathSegment[]} + */ + this.prevSegments = allPrevSegments.filter(isReachable); + + /** + * An array of all next segments including reachable and unreachable. + * @type {CodePathSegment[]} + */ + this.allNextSegments = []; + + /** + * An array of all previous segments including reachable and unreachable. + * @type {CodePathSegment[]} + */ + this.allPrevSegments = allPrevSegments; + + /** + * A flag which shows this is reachable. + * @type {boolean} + */ + this.reachable = reachable; + + // Internal data. + Object.defineProperty(this, "internal", { + value: { + // determines if the segment has been attached to the code path + used: false, + + // array of previous segments coming from the end of a loop + loopedPrevSegments: [], + }, + }); + + /* c8 ignore start */ + if (debug.enabled) { + this.internal.nodes = []; + } /* c8 ignore stop */ + } + + /** + * Checks a given previous segment is coming from the end of a loop. + * @param {CodePathSegment} segment A previous segment to check. + * @returns {boolean} `true` if the segment is coming from the end of a loop. + */ + isLoopedPrevSegment(segment) { + return this.internal.loopedPrevSegments.includes(segment); + } + + /** + * Creates the root segment. + * @param {string} id An identifier. + * @returns {CodePathSegment} The created segment. + */ + static newRoot(id) { + return new CodePathSegment(id, [], true); + } + + /** + * Creates a new segment and appends it after the given segments. + * @param {string} id An identifier. + * @param {CodePathSegment[]} allPrevSegments An array of the previous segments + * to append to. + * @returns {CodePathSegment} The created segment. + */ + static newNext(id, allPrevSegments) { + return new CodePathSegment( + id, + CodePathSegment.flattenUnusedSegments(allPrevSegments), + allPrevSegments.some(isReachable), + ); + } + + /** + * Creates an unreachable segment and appends it after the given segments. + * @param {string} id An identifier. + * @param {CodePathSegment[]} allPrevSegments An array of the previous segments. + * @returns {CodePathSegment} The created segment. + */ + static newUnreachable(id, allPrevSegments) { + const segment = new CodePathSegment( + id, + CodePathSegment.flattenUnusedSegments(allPrevSegments), + false, + ); + + /* + * In `if (a) return a; foo();` case, the unreachable segment preceded by + * the return statement is not used but must not be removed. + */ + CodePathSegment.markUsed(segment); + + return segment; + } + + /** + * Creates a segment that follows given segments. + * This factory method does not connect with `allPrevSegments`. + * But this inherits `reachable` flag. + * @param {string} id An identifier. + * @param {CodePathSegment[]} allPrevSegments An array of the previous segments. + * @returns {CodePathSegment} The created segment. + */ + static newDisconnected(id, allPrevSegments) { + return new CodePathSegment(id, [], allPrevSegments.some(isReachable)); + } + + /** + * Marks a given segment as used. + * + * And this function registers the segment into the previous segments as a next. + * @param {CodePathSegment} segment A segment to mark. + * @returns {void} + */ + static markUsed(segment) { + if (segment.internal.used) { + return; + } + segment.internal.used = true; + + let i; + + if (segment.reachable) { + /* + * If the segment is reachable, then it's officially part of the + * code path. This loops through all previous segments to update + * their list of next segments. Because the segment is reachable, + * it's added to both `nextSegments` and `allNextSegments`. + */ + for (i = 0; i < segment.allPrevSegments.length; ++i) { + const prevSegment = segment.allPrevSegments[i]; + + prevSegment.allNextSegments.push(segment); + prevSegment.nextSegments.push(segment); + } + } else { + /* + * If the segment is not reachable, then it's not officially part of the + * code path. This loops through all previous segments to update + * their list of next segments. Because the segment is not reachable, + * it's added only to `allNextSegments`. + */ + for (i = 0; i < segment.allPrevSegments.length; ++i) { + segment.allPrevSegments[i].allNextSegments.push(segment); + } + } + } + + /** + * Marks a previous segment as looped. + * @param {CodePathSegment} segment A segment. + * @param {CodePathSegment} prevSegment A previous segment to mark. + * @returns {void} + */ + static markPrevSegmentAsLooped(segment, prevSegment) { + segment.internal.loopedPrevSegments.push(prevSegment); + } + + /** + * Creates a new array based on an array of segments. If any segment in the + * array is unused, then it is replaced by all of its previous segments. + * All used segments are returned as-is without replacement. + * @param {CodePathSegment[]} segments The array of segments to flatten. + * @returns {CodePathSegment[]} The flattened array. + */ + static flattenUnusedSegments(segments) { + const done = new Set(); + + for (let i = 0; i < segments.length; ++i) { + const segment = segments[i]; + + // Ignores duplicated. + if (done.has(segment)) { + continue; + } + + // Use previous segments if unused. + if (!segment.internal.used) { + for (let j = 0; j < segment.allPrevSegments.length; ++j) { + const prevSegment = segment.allPrevSegments[j]; + + if (!done.has(prevSegment)) { + done.add(prevSegment); + } + } + } else { + done.add(segment); + } + } + + return [...done]; + } +} + +module.exports = CodePathSegment; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-state.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-state.js new file mode 100644 index 00000000..7621671b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path-state.js @@ -0,0 +1,2390 @@ +/** + * @fileoverview A class to manage state of generating a code path. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const CodePathSegment = require("./code-path-segment"), + ForkContext = require("./fork-context"); + +//----------------------------------------------------------------------------- +// Contexts +//----------------------------------------------------------------------------- + +/** + * Represents the context in which a `break` statement can be used. + * + * A `break` statement without a label is only valid in a few places in + * JavaScript: any type of loop or a `switch` statement. Otherwise, `break` + * without a label causes a syntax error. For these contexts, `breakable` is + * set to `true` to indicate that a `break` without a label is valid. + * + * However, a `break` statement with a label is also valid inside of a labeled + * statement. For example, this is valid: + * + * a : { + * break a; + * } + * + * The `breakable` property is set false for labeled statements to indicate + * that `break` without a label is invalid. + */ +class BreakContext { + /** + * Creates a new instance. + * @param {BreakContext} upperContext The previous `BreakContext`. + * @param {boolean} breakable Indicates if we are inside a statement where + * `break` without a label will exit the statement. + * @param {string|null} label The label for the statement. + * @param {ForkContext} forkContext The current fork context. + */ + constructor(upperContext, breakable, label, forkContext) { + /** + * The previous `BreakContext` + * @type {BreakContext} + */ + this.upper = upperContext; + + /** + * Indicates if we are inside a statement where `break` without a label + * will exit the statement. + * @type {boolean} + */ + this.breakable = breakable; + + /** + * The label associated with the statement. + * @type {string|null} + */ + this.label = label; + + /** + * The fork context for the `break`. + * @type {ForkContext} + */ + this.brokenForkContext = ForkContext.newEmpty(forkContext); + } +} + +/** + * Represents the context for `ChainExpression` nodes. + */ +class ChainContext { + /** + * Creates a new instance. + * @param {ChainContext} upperContext The previous `ChainContext`. + */ + constructor(upperContext) { + /** + * The previous `ChainContext` + * @type {ChainContext} + */ + this.upper = upperContext; + + /** + * The number of choice contexts inside of the `ChainContext`. + * @type {number} + */ + this.choiceContextCount = 0; + } +} + +/** + * Represents a choice in the code path. + * + * Choices are created by logical operators such as `&&`, loops, conditionals, + * and `if` statements. This is the point at which the code path has a choice of + * which direction to go. + * + * The result of a choice might be in the left (test) expression of another choice, + * and in that case, may create a new fork. For example, `a || b` is a choice + * but does not create a new fork because the result of the expression is + * not used as the test expression in another expression. In this case, + * `isForkingAsResult` is false. In the expression `a || b || c`, the `a || b` + * expression appears as the test expression for `|| c`, so the + * result of `a || b` creates a fork because execution may or may not + * continue to `|| c`. `isForkingAsResult` for `a || b` in this case is true + * while `isForkingAsResult` for `|| c` is false. (`isForkingAsResult` is always + * false for `if` statements, conditional expressions, and loops.) + * + * All of the choices except one (`??`) operate on a true/false fork, meaning if + * true go one way and if false go the other (tracked by `trueForkContext` and + * `falseForkContext`). The `??` operator doesn't operate on true/false because + * the left expression is evaluated to be nullish or not, so only if nullish do + * we fork to the right expression (tracked by `nullishForkContext`). + */ +class ChoiceContext { + /** + * Creates a new instance. + * @param {ChoiceContext} upperContext The previous `ChoiceContext`. + * @param {string} kind The kind of choice. If it's a logical or assignment expression, this + * is `"&&"` or `"||"` or `"??"`; if it's an `if` statement or + * conditional expression, this is `"test"`; otherwise, this is `"loop"`. + * @param {boolean} isForkingAsResult Indicates if the result of the choice + * creates a fork. + * @param {ForkContext} forkContext The containing `ForkContext`. + */ + constructor(upperContext, kind, isForkingAsResult, forkContext) { + /** + * The previous `ChoiceContext` + * @type {ChoiceContext} + */ + this.upper = upperContext; + + /** + * The kind of choice. If it's a logical or assignment expression, this + * is `"&&"` or `"||"` or `"??"`; if it's an `if` statement or + * conditional expression, this is `"test"`; otherwise, this is `"loop"`. + * @type {string} + */ + this.kind = kind; + + /** + * Indicates if the result of the choice forks the code path. + * @type {boolean} + */ + this.isForkingAsResult = isForkingAsResult; + + /** + * The fork context for the `true` path of the choice. + * @type {ForkContext} + */ + this.trueForkContext = ForkContext.newEmpty(forkContext); + + /** + * The fork context for the `false` path of the choice. + * @type {ForkContext} + */ + this.falseForkContext = ForkContext.newEmpty(forkContext); + + /** + * The fork context for when the choice result is `null` or `undefined`. + * @type {ForkContext} + */ + this.nullishForkContext = ForkContext.newEmpty(forkContext); + + /** + * Indicates if any of `trueForkContext`, `falseForkContext`, or + * `nullishForkContext` have been updated with segments from a child context. + * @type {boolean} + */ + this.processed = false; + } +} + +/** + * Base class for all loop contexts. + */ +class LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string} type The AST node's `type` for the loop. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + */ + constructor(upperContext, type, label, breakContext) { + /** + * The previous `LoopContext`. + * @type {LoopContext} + */ + this.upper = upperContext; + + /** + * The AST node's `type` for the loop. + * @type {string} + */ + this.type = type; + + /** + * The label for the loop from an enclosing `LabeledStatement`. + * @type {string|null} + */ + this.label = label; + + /** + * The fork context for when `break` is encountered. + * @type {ForkContext} + */ + this.brokenForkContext = breakContext.brokenForkContext; + } +} + +/** + * Represents the context for a `while` loop. + */ +class WhileLoopContext extends LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + */ + constructor(upperContext, label, breakContext) { + super(upperContext, "WhileStatement", label, breakContext); + + /** + * The hardcoded literal boolean test condition for + * the loop. Used to catch infinite or skipped loops. + * @type {boolean|undefined} + */ + this.test = void 0; + + /** + * The segments representing the test condition where `continue` will + * jump to. The test condition will typically have just one segment but + * it's possible for there to be more than one. + * @type {Array|null} + */ + this.continueDestSegments = null; + } +} + +/** + * Represents the context for a `do-while` loop. + */ +class DoWhileLoopContext extends LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + * @param {ForkContext} forkContext The enclosing fork context. + */ + constructor(upperContext, label, breakContext, forkContext) { + super(upperContext, "DoWhileStatement", label, breakContext); + + /** + * The hardcoded literal boolean test condition for + * the loop. Used to catch infinite or skipped loops. + * @type {boolean|undefined} + */ + this.test = void 0; + + /** + * The segments at the start of the loop body. This is the only loop + * where the test comes at the end, so the first iteration always + * happens and we need a reference to the first statements. + * @type {Array|null} + */ + this.entrySegments = null; + + /** + * The fork context to follow when a `continue` is found. + * @type {ForkContext} + */ + this.continueForkContext = ForkContext.newEmpty(forkContext); + } +} + +/** + * Represents the context for a `for` loop. + */ +class ForLoopContext extends LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + */ + constructor(upperContext, label, breakContext) { + super(upperContext, "ForStatement", label, breakContext); + + /** + * The hardcoded literal boolean test condition for + * the loop. Used to catch infinite or skipped loops. + * @type {boolean|undefined} + */ + this.test = void 0; + + /** + * The end of the init expression. This may change during the lifetime + * of the instance as we traverse the loop because some loops don't have + * an init expression. + * @type {Array|null} + */ + this.endOfInitSegments = null; + + /** + * The start of the test expression. This may change during the lifetime + * of the instance as we traverse the loop because some loops don't have + * a test expression. + * @type {Array|null} + */ + this.testSegments = null; + + /** + * The end of the test expression. This may change during the lifetime + * of the instance as we traverse the loop because some loops don't have + * a test expression. + * @type {Array|null} + */ + this.endOfTestSegments = null; + + /** + * The start of the update expression. This may change during the lifetime + * of the instance as we traverse the loop because some loops don't have + * an update expression. + * @type {Array|null} + */ + this.updateSegments = null; + + /** + * The end of the update expression. This may change during the lifetime + * of the instance as we traverse the loop because some loops don't have + * an update expression. + * @type {Array|null} + */ + this.endOfUpdateSegments = null; + + /** + * The segments representing the test condition where `continue` will + * jump to. The test condition will typically have just one segment but + * it's possible for there to be more than one. This may change during the + * lifetime of the instance as we traverse the loop because some loops + * don't have an update expression. When there is an update expression, this + * will end up pointing to that expression; otherwise it will end up pointing + * to the test expression. + * @type {Array|null} + */ + this.continueDestSegments = null; + } +} + +/** + * Represents the context for a `for-in` loop. + * + * Terminology: + * - "left" means the part of the loop to the left of the `in` keyword. For + * example, in `for (var x in y)`, the left is `var x`. + * - "right" means the part of the loop to the right of the `in` keyword. For + * example, in `for (var x in y)`, the right is `y`. + */ +class ForInLoopContext extends LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + */ + constructor(upperContext, label, breakContext) { + super(upperContext, "ForInStatement", label, breakContext); + + /** + * The segments that came immediately before the start of the loop. + * This allows you to traverse backwards out of the loop into the + * surrounding code. This is necessary to evaluate the right expression + * correctly, as it must be evaluated in the same way as the left + * expression, but the pointer to these segments would otherwise be + * lost if not stored on the instance. Once the right expression has + * been evaluated, this property is no longer used. + * @type {Array|null} + */ + this.prevSegments = null; + + /** + * Segments representing the start of everything to the left of the + * `in` keyword. This can be used to move forward towards + * `endOfLeftSegments`. `leftSegments` and `endOfLeftSegments` are + * effectively the head and tail of a doubly-linked list. + * @type {Array|null} + */ + this.leftSegments = null; + + /** + * Segments representing the end of everything to the left of the + * `in` keyword. This can be used to move backward towards `leftSegments`. + * `leftSegments` and `endOfLeftSegments` are effectively the head + * and tail of a doubly-linked list. + * @type {Array|null} + */ + this.endOfLeftSegments = null; + + /** + * The segments representing the left expression where `continue` will + * jump to. In `for-in` loops, `continue` must always re-execute the + * left expression each time through the loop. This contains the same + * segments as `leftSegments`, but is duplicated here so each loop + * context has the same property pointing to where `continue` should + * end up. + * @type {Array|null} + */ + this.continueDestSegments = null; + } +} + +/** + * Represents the context for a `for-of` loop. + */ +class ForOfLoopContext extends LoopContextBase { + /** + * Creates a new instance. + * @param {LoopContext|null} upperContext The previous `LoopContext`. + * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. + * @param {BreakContext} breakContext The context for breaking the loop. + */ + constructor(upperContext, label, breakContext) { + super(upperContext, "ForOfStatement", label, breakContext); + + /** + * The segments that came immediately before the start of the loop. + * This allows you to traverse backwards out of the loop into the + * surrounding code. This is necessary to evaluate the right expression + * correctly, as it must be evaluated in the same way as the left + * expression, but the pointer to these segments would otherwise be + * lost if not stored on the instance. Once the right expression has + * been evaluated, this property is no longer used. + * @type {Array|null} + */ + this.prevSegments = null; + + /** + * Segments representing the start of everything to the left of the + * `of` keyword. This can be used to move forward towards + * `endOfLeftSegments`. `leftSegments` and `endOfLeftSegments` are + * effectively the head and tail of a doubly-linked list. + * @type {Array|null} + */ + this.leftSegments = null; + + /** + * Segments representing the end of everything to the left of the + * `of` keyword. This can be used to move backward towards `leftSegments`. + * `leftSegments` and `endOfLeftSegments` are effectively the head + * and tail of a doubly-linked list. + * @type {Array|null} + */ + this.endOfLeftSegments = null; + + /** + * The segments representing the left expression where `continue` will + * jump to. In `for-in` loops, `continue` must always re-execute the + * left expression each time through the loop. This contains the same + * segments as `leftSegments`, but is duplicated here so each loop + * context has the same property pointing to where `continue` should + * end up. + * @type {Array|null} + */ + this.continueDestSegments = null; + } +} + +/** + * Represents the context for any loop. + * @typedef {WhileLoopContext|DoWhileLoopContext|ForLoopContext|ForInLoopContext|ForOfLoopContext} LoopContext + */ + +/** + * Represents the context for a `switch` statement. + */ +class SwitchContext { + /** + * Creates a new instance. + * @param {SwitchContext} upperContext The previous context. + * @param {boolean} hasCase Indicates if there is at least one `case` statement. + * `default` doesn't count. + */ + constructor(upperContext, hasCase) { + /** + * The previous context. + * @type {SwitchContext} + */ + this.upper = upperContext; + + /** + * Indicates if there is at least one `case` statement. `default` doesn't count. + * @type {boolean} + */ + this.hasCase = hasCase; + + /** + * The `default` keyword. + * @type {Array|null} + */ + this.defaultSegments = null; + + /** + * The default case body starting segments. + * @type {Array|null} + */ + this.defaultBodySegments = null; + + /** + * Indicates if a `default` case and is empty exists. + * @type {boolean} + */ + this.foundEmptyDefault = false; + + /** + * Indicates that a `default` exists and is the last case. + * @type {boolean} + */ + this.lastIsDefault = false; + + /** + * The number of fork contexts created. This is equivalent to the + * number of `case` statements plus a `default` statement (if present). + * @type {number} + */ + this.forkCount = 0; + } +} + +/** + * Represents the context for a `try` statement. + */ +class TryContext { + /** + * Creates a new instance. + * @param {TryContext} upperContext The previous context. + * @param {boolean} hasFinalizer Indicates if the `try` statement has a + * `finally` block. + * @param {ForkContext} forkContext The enclosing fork context. + */ + constructor(upperContext, hasFinalizer, forkContext) { + /** + * The previous context. + * @type {TryContext} + */ + this.upper = upperContext; + + /** + * Indicates if the `try` statement has a `finally` block. + * @type {boolean} + */ + this.hasFinalizer = hasFinalizer; + + /** + * Tracks the traversal position inside of the `try` statement. This is + * used to help determine the context necessary to create paths because + * a `try` statement may or may not have `catch` or `finally` blocks, + * and code paths behave differently in those blocks. + * @type {"try"|"catch"|"finally"} + */ + this.position = "try"; + + /** + * If the `try` statement has a `finally` block, this affects how return-like + * leaving paths behave in the `try` block. Without `finally`, they behave as + * usual and don't require a fork; with `finally`, they fork into the + * `finally` block, so we need a fork context to track them. + * @type {ForkContext|null} + */ + this.returnedForkContext = hasFinalizer + ? ForkContext.newEmpty(forkContext) + : null; + + /** + * When a `throw` occurs inside of a `try` block, the code path forks + * into the `catch` or `finally` blocks, and this fork context tracks + * that path. + * @type {ForkContext} + */ + this.thrownForkContext = ForkContext.newEmpty(forkContext); + + /** + * Indicates if the last segment in the `try` block is reachable. + * @type {boolean} + */ + this.lastOfTryIsReachable = false; + + /** + * Indicates if the last segment in the `catch` block is reachable. + * @type {boolean} + */ + this.lastOfCatchIsReachable = false; + } +} + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Adds given segments into the `dest` array. + * If the `others` array does not include the given segments, adds to the `all` + * array as well. + * + * This adds only reachable and used segments. + * @param {CodePathSegment[]} dest A destination array (`returnedSegments` or `thrownSegments`). + * @param {CodePathSegment[]} others Another destination array (`returnedSegments` or `thrownSegments`). + * @param {CodePathSegment[]} all The unified destination array (`finalSegments`). + * @param {CodePathSegment[]} segments Segments to add. + * @returns {void} + */ +function addToReturnedOrThrown(dest, others, all, segments) { + for (let i = 0; i < segments.length; ++i) { + const segment = segments[i]; + + dest.push(segment); + if (!others.includes(segment)) { + all.push(segment); + } + } +} + +/** + * Gets a loop context for a `continue` statement based on a given label. + * @param {CodePathState} state The state to search within. + * @param {string|null} label The label of a `continue` statement. + * @returns {LoopContext} A loop-context for a `continue` statement. + */ +function getContinueContext(state, label) { + if (!label) { + return state.loopContext; + } + + let context = state.loopContext; + + while (context) { + if (context.label === label) { + return context; + } + context = context.upper; + } + + /* c8 ignore next */ + return null; +} + +/** + * Gets a context for a `break` statement. + * @param {CodePathState} state The state to search within. + * @param {string|null} label The label of a `break` statement. + * @returns {BreakContext} A context for a `break` statement. + */ +function getBreakContext(state, label) { + let context = state.breakContext; + + while (context) { + if (label ? context.label === label : context.breakable) { + return context; + } + context = context.upper; + } + + /* c8 ignore next */ + return null; +} + +/** + * Gets a context for a `return` statement. There is just one special case: + * if there is a `try` statement with a `finally` block, because that alters + * how `return` behaves; otherwise, this just passes through the given state. + * @param {CodePathState} state The state to search within + * @returns {TryContext|CodePathState} A context for a `return` statement. + */ +function getReturnContext(state) { + let context = state.tryContext; + + while (context) { + if (context.hasFinalizer && context.position !== "finally") { + return context; + } + context = context.upper; + } + + return state; +} + +/** + * Gets a context for a `throw` statement. There is just one special case: + * if there is a `try` statement with a `finally` block and we are inside of + * a `catch` because that changes how `throw` behaves; otherwise, this just + * passes through the given state. + * @param {CodePathState} state The state to search within. + * @returns {TryContext|CodePathState} A context for a `throw` statement. + */ +function getThrowContext(state) { + let context = state.tryContext; + + while (context) { + if ( + context.position === "try" || + (context.hasFinalizer && context.position === "catch") + ) { + return context; + } + context = context.upper; + } + + return state; +} + +/** + * Removes a given value from a given array. + * @param {any[]} elements An array to remove the specific element. + * @param {any} value The value to be removed. + * @returns {void} + */ +function removeFromArray(elements, value) { + elements.splice(elements.indexOf(value), 1); +} + +/** + * Disconnect given segments. + * + * This is used in a process for switch statements. + * If there is the "default" chunk before other cases, the order is different + * between node's and running's. + * @param {CodePathSegment[]} prevSegments Forward segments to disconnect. + * @param {CodePathSegment[]} nextSegments Backward segments to disconnect. + * @returns {void} + */ +function disconnectSegments(prevSegments, nextSegments) { + for (let i = 0; i < prevSegments.length; ++i) { + const prevSegment = prevSegments[i]; + const nextSegment = nextSegments[i]; + + removeFromArray(prevSegment.nextSegments, nextSegment); + removeFromArray(prevSegment.allNextSegments, nextSegment); + removeFromArray(nextSegment.prevSegments, prevSegment); + removeFromArray(nextSegment.allPrevSegments, prevSegment); + } +} + +/** + * Creates looping path between two arrays of segments, ensuring that there are + * paths going between matching segments in the arrays. + * @param {CodePathState} state The state to operate on. + * @param {CodePathSegment[]} unflattenedFromSegments Segments which are source. + * @param {CodePathSegment[]} unflattenedToSegments Segments which are destination. + * @returns {void} + */ +function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) { + const fromSegments = CodePathSegment.flattenUnusedSegments( + unflattenedFromSegments, + ); + const toSegments = CodePathSegment.flattenUnusedSegments( + unflattenedToSegments, + ); + const end = Math.min(fromSegments.length, toSegments.length); + + /* + * This loop effectively updates a doubly-linked list between two collections + * of segments making sure that segments in the same array indices are + * combined to create a path. + */ + for (let i = 0; i < end; ++i) { + // get the segments in matching array indices + const fromSegment = fromSegments[i]; + const toSegment = toSegments[i]; + + /* + * If the destination segment is reachable, then create a path from the + * source segment to the destination segment. + */ + if (toSegment.reachable) { + fromSegment.nextSegments.push(toSegment); + } + + /* + * If the source segment is reachable, then create a path from the + * destination segment back to the source segment. + */ + if (fromSegment.reachable) { + toSegment.prevSegments.push(fromSegment); + } + + /* + * Also update the arrays that don't care if the segments are reachable + * or not. This should always happen regardless of anything else. + */ + fromSegment.allNextSegments.push(toSegment); + toSegment.allPrevSegments.push(fromSegment); + + /* + * If the destination segment has at least two previous segments in its + * path then that means there was one previous segment before this iteration + * of the loop was executed. So, we need to mark the source segment as + * looped. + */ + if (toSegment.allPrevSegments.length >= 2) { + CodePathSegment.markPrevSegmentAsLooped(toSegment, fromSegment); + } + + // let the code path analyzer know that there's been a loop created + state.notifyLooped(fromSegment, toSegment); + } +} + +/** + * Finalizes segments of `test` chunk of a ForStatement. + * + * - Adds `false` paths to paths which are leaving from the loop. + * - Sets `true` paths to paths which go to the body. + * @param {LoopContext} context A loop context to modify. + * @param {ChoiceContext} choiceContext A choice context of this loop. + * @param {CodePathSegment[]} head The current head paths. + * @returns {void} + */ +function finalizeTestSegmentsOfFor(context, choiceContext, head) { + /* + * If this choice context doesn't already contain paths from a + * child context, then add the current head to each potential path. + */ + if (!choiceContext.processed) { + choiceContext.trueForkContext.add(head); + choiceContext.falseForkContext.add(head); + choiceContext.nullishForkContext.add(head); + } + + /* + * If the test condition isn't a hardcoded truthy value, then `break` + * must follow the same path as if the test condition is false. To represent + * that, we append the path for when the loop test is false (represented by + * `falseForkContext`) to the `brokenForkContext`. + */ + if (context.test !== true) { + context.brokenForkContext.addAll(choiceContext.falseForkContext); + } + + context.endOfTestSegments = choiceContext.trueForkContext.makeNext(0, -1); +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * A class which manages state to analyze code paths. + */ +class CodePathState { + /** + * Creates a new instance. + * @param {IdGenerator} idGenerator An id generator to generate id for code + * path segments. + * @param {Function} onLooped A callback function to notify looping. + */ + constructor(idGenerator, onLooped) { + /** + * The ID generator to use when creating new segments. + * @type {IdGenerator} + */ + this.idGenerator = idGenerator; + + /** + * A callback function to call when there is a loop. + * @type {Function} + */ + this.notifyLooped = onLooped; + + /** + * The root fork context for this state. + * @type {ForkContext} + */ + this.forkContext = ForkContext.newRoot(idGenerator); + + /** + * Context for logical expressions, conditional expressions, `if` statements, + * and loops. + * @type {ChoiceContext} + */ + this.choiceContext = null; + + /** + * Context for `switch` statements. + * @type {SwitchContext} + */ + this.switchContext = null; + + /** + * Context for `try` statements. + * @type {TryContext} + */ + this.tryContext = null; + + /** + * Context for loop statements. + * @type {LoopContext} + */ + this.loopContext = null; + + /** + * Context for `break` statements. + * @type {BreakContext} + */ + this.breakContext = null; + + /** + * Context for `ChainExpression` nodes. + * @type {ChainContext} + */ + this.chainContext = null; + + /** + * An array that tracks the current segments in the state. The array + * starts empty and segments are added with each `onCodePathSegmentStart` + * event and removed with each `onCodePathSegmentEnd` event. Effectively, + * this is tracking the code path segment traversal as the state is + * modified. + * @type {Array} + */ + this.currentSegments = []; + + /** + * Tracks the starting segment for this path. This value never changes. + * @type {CodePathSegment} + */ + this.initialSegment = this.forkContext.head[0]; + + /** + * The final segments of the code path which are either `return` or `throw`. + * This is a union of the segments in `returnedForkContext` and `thrownForkContext`. + * @type {Array} + */ + this.finalSegments = []; + + /** + * The final segments of the code path which are `return`. These + * segments are also contained in `finalSegments`. + * @type {Array} + */ + this.returnedForkContext = []; + + /** + * The final segments of the code path which are `throw`. These + * segments are also contained in `finalSegments`. + * @type {Array} + */ + this.thrownForkContext = []; + + /* + * We add an `add` method so that these look more like fork contexts and + * can be used interchangeably when a fork context is needed to add more + * segments to a path. + * + * Ultimately, we want anything added to `returned` or `thrown` to also + * be added to `final`. We only add reachable and used segments to these + * arrays. + */ + const final = this.finalSegments; + const returned = this.returnedForkContext; + const thrown = this.thrownForkContext; + + returned.add = addToReturnedOrThrown.bind( + null, + returned, + thrown, + final, + ); + thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final); + } + + /** + * A passthrough property exposing the current pointer as part of the API. + * @type {CodePathSegment[]} + */ + get headSegments() { + return this.forkContext.head; + } + + /** + * The parent forking context. + * This is used for the root of new forks. + * @type {ForkContext} + */ + get parentForkContext() { + const current = this.forkContext; + + return current && current.upper; + } + + /** + * Creates and stacks new forking context. + * @param {boolean} forkLeavingPath A flag which shows being in a + * "finally" block. + * @returns {ForkContext} The created context. + */ + pushForkContext(forkLeavingPath) { + this.forkContext = ForkContext.newEmpty( + this.forkContext, + forkLeavingPath, + ); + + return this.forkContext; + } + + /** + * Pops and merges the last forking context. + * @returns {ForkContext} The last context. + */ + popForkContext() { + const lastContext = this.forkContext; + + this.forkContext = lastContext.upper; + this.forkContext.replaceHead(lastContext.makeNext(0, -1)); + + return lastContext; + } + + /** + * Creates a new path. + * @returns {void} + */ + forkPath() { + this.forkContext.add(this.parentForkContext.makeNext(-1, -1)); + } + + /** + * Creates a bypass path. + * This is used for such as IfStatement which does not have "else" chunk. + * @returns {void} + */ + forkBypassPath() { + this.forkContext.add(this.parentForkContext.head); + } + + //-------------------------------------------------------------------------- + // ConditionalExpression, LogicalExpression, IfStatement + //-------------------------------------------------------------------------- + + /** + * Creates a context for ConditionalExpression, LogicalExpression, AssignmentExpression (logical assignments only), + * IfStatement, WhileStatement, DoWhileStatement, or ForStatement. + * + * LogicalExpressions have cases that it goes different paths between the + * `true` case and the `false` case. + * + * For Example: + * + * if (a || b) { + * foo(); + * } else { + * bar(); + * } + * + * In this case, `b` is evaluated always in the code path of the `else` + * block, but it's not so in the code path of the `if` block. + * So there are 3 paths. + * + * a -> foo(); + * a -> b -> foo(); + * a -> b -> bar(); + * @param {string} kind A kind string. + * If the new context is LogicalExpression's or AssignmentExpression's, this is `"&&"` or `"||"` or `"??"`. + * If it's IfStatement's or ConditionalExpression's, this is `"test"`. + * Otherwise, this is `"loop"`. + * @param {boolean} isForkingAsResult Indicates if the result of the choice + * creates a fork. + * @returns {void} + */ + pushChoiceContext(kind, isForkingAsResult) { + this.choiceContext = new ChoiceContext( + this.choiceContext, + kind, + isForkingAsResult, + this.forkContext, + ); + } + + /** + * Pops the last choice context and finalizes it. + * This is called upon leaving a node that represents a choice. + * @throws {Error} (Unreachable.) + * @returns {ChoiceContext} The popped context. + */ + popChoiceContext() { + const poppedChoiceContext = this.choiceContext; + const forkContext = this.forkContext; + const head = forkContext.head; + + this.choiceContext = poppedChoiceContext.upper; + + switch (poppedChoiceContext.kind) { + case "&&": + case "||": + case "??": + /* + * The `head` are the path of the right-hand operand. + * If we haven't previously added segments from child contexts, + * then we add these segments to all possible forks. + */ + if (!poppedChoiceContext.processed) { + poppedChoiceContext.trueForkContext.add(head); + poppedChoiceContext.falseForkContext.add(head); + poppedChoiceContext.nullishForkContext.add(head); + } + + /* + * If this context is the left (test) expression for another choice + * context, such as `a || b` in the expression `a || b || c`, + * then we take the segments for this context and move them up + * to the parent context. + */ + if (poppedChoiceContext.isForkingAsResult) { + const parentContext = this.choiceContext; + + parentContext.trueForkContext.addAll( + poppedChoiceContext.trueForkContext, + ); + parentContext.falseForkContext.addAll( + poppedChoiceContext.falseForkContext, + ); + parentContext.nullishForkContext.addAll( + poppedChoiceContext.nullishForkContext, + ); + parentContext.processed = true; + + // Exit early so we don't collapse all paths into one. + return poppedChoiceContext; + } + + break; + + case "test": + if (!poppedChoiceContext.processed) { + /* + * The head segments are the path of the `if` block here. + * Updates the `true` path with the end of the `if` block. + */ + poppedChoiceContext.trueForkContext.clear(); + poppedChoiceContext.trueForkContext.add(head); + } else { + /* + * The head segments are the path of the `else` block here. + * Updates the `false` path with the end of the `else` + * block. + */ + poppedChoiceContext.falseForkContext.clear(); + poppedChoiceContext.falseForkContext.add(head); + } + + break; + + case "loop": + /* + * Loops are addressed in `popLoopContext()` so just return + * the context without modification. + */ + return poppedChoiceContext; + + /* c8 ignore next */ + default: + throw new Error("unreachable"); + } + + /* + * Merge the true path with the false path to create a single path. + */ + const combinedForkContext = poppedChoiceContext.trueForkContext; + + combinedForkContext.addAll(poppedChoiceContext.falseForkContext); + forkContext.replaceHead(combinedForkContext.makeNext(0, -1)); + + return poppedChoiceContext; + } + + /** + * Creates a code path segment to represent right-hand operand of a logical + * expression. + * This is called in the preprocessing phase when entering a node. + * @throws {Error} (Unreachable.) + * @returns {void} + */ + makeLogicalRight() { + const currentChoiceContext = this.choiceContext; + const forkContext = this.forkContext; + + if (currentChoiceContext.processed) { + /* + * This context was already assigned segments from a child + * choice context. In this case, we are concerned only about + * the path that does not short-circuit and so ends up on the + * right-hand operand of the logical expression. + */ + let prevForkContext; + + switch (currentChoiceContext.kind) { + case "&&": // if true then go to the right-hand side. + prevForkContext = currentChoiceContext.trueForkContext; + break; + case "||": // if false then go to the right-hand side. + prevForkContext = currentChoiceContext.falseForkContext; + break; + case "??": // Both true/false can short-circuit, so needs the third path to go to the right-hand side. That's nullishForkContext. + prevForkContext = currentChoiceContext.nullishForkContext; + break; + default: + throw new Error("unreachable"); + } + + /* + * Create the segment for the right-hand operand of the logical expression + * and adjust the fork context pointer to point there. The right-hand segment + * is added at the end of all segments in `prevForkContext`. + */ + forkContext.replaceHead(prevForkContext.makeNext(0, -1)); + + /* + * We no longer need this list of segments. + * + * Reset `processed` because we've removed the segments from the child + * choice context. This allows `popChoiceContext()` to continue adding + * segments later. + */ + prevForkContext.clear(); + currentChoiceContext.processed = false; + } else { + /* + * This choice context was not assigned segments from a child + * choice context, which means that it's a terminal logical + * expression. + * + * `head` is the segments for the left-hand operand of the + * logical expression. + * + * Each of the fork contexts below are empty at this point. We choose + * the path(s) that will short-circuit and add the segment for the + * left-hand operand to it. Ultimately, this will be the only segment + * in that path due to the short-circuting, so we are just seeding + * these paths to start. + */ + switch (currentChoiceContext.kind) { + case "&&": + /* + * In most contexts, when a && expression evaluates to false, + * it short circuits, so we need to account for that by setting + * the `falseForkContext` to the left operand. + * + * When a && expression is the left-hand operand for a ?? + * expression, such as `(a && b) ?? c`, a nullish value will + * also short-circuit in a different way than a false value, + * so we also set the `nullishForkContext` to the left operand. + * This path is only used with a ?? expression and is thrown + * away for any other type of logical expression, so it's safe + * to always add. + */ + currentChoiceContext.falseForkContext.add(forkContext.head); + currentChoiceContext.nullishForkContext.add( + forkContext.head, + ); + break; + case "||": // the true path can short-circuit. + currentChoiceContext.trueForkContext.add(forkContext.head); + break; + case "??": // both can short-circuit. + currentChoiceContext.trueForkContext.add(forkContext.head); + currentChoiceContext.falseForkContext.add(forkContext.head); + break; + default: + throw new Error("unreachable"); + } + + /* + * Create the segment for the right-hand operand of the logical expression + * and adjust the fork context pointer to point there. + */ + forkContext.replaceHead(forkContext.makeNext(-1, -1)); + } + } + + /** + * Makes a code path segment of the `if` block. + * @returns {void} + */ + makeIfConsequent() { + const context = this.choiceContext; + const forkContext = this.forkContext; + + /* + * If any result were not transferred from child contexts, + * this sets the head segments to both cases. + * The head segments are the path of the test expression. + */ + if (!context.processed) { + context.trueForkContext.add(forkContext.head); + context.falseForkContext.add(forkContext.head); + context.nullishForkContext.add(forkContext.head); + } + + context.processed = false; + + // Creates new path from the `true` case. + forkContext.replaceHead(context.trueForkContext.makeNext(0, -1)); + } + + /** + * Makes a code path segment of the `else` block. + * @returns {void} + */ + makeIfAlternate() { + const context = this.choiceContext; + const forkContext = this.forkContext; + + /* + * The head segments are the path of the `if` block. + * Updates the `true` path with the end of the `if` block. + */ + context.trueForkContext.clear(); + context.trueForkContext.add(forkContext.head); + context.processed = true; + + // Creates new path from the `false` case. + forkContext.replaceHead(context.falseForkContext.makeNext(0, -1)); + } + + //-------------------------------------------------------------------------- + // ChainExpression + //-------------------------------------------------------------------------- + + /** + * Pushes a new `ChainExpression` context to the stack. This method is + * called when entering a `ChainExpression` node. A chain context is used to + * count forking in the optional chain then merge them on the exiting from the + * `ChainExpression` node. + * @returns {void} + */ + pushChainContext() { + this.chainContext = new ChainContext(this.chainContext); + } + + /** + * Pop a `ChainExpression` context from the stack. This method is called on + * exiting from each `ChainExpression` node. This merges all forks of the + * last optional chaining. + * @returns {void} + */ + popChainContext() { + const context = this.chainContext; + + this.chainContext = context.upper; + + // pop all choice contexts of this. + for (let i = context.choiceContextCount; i > 0; --i) { + this.popChoiceContext(); + } + } + + /** + * Create a choice context for optional access. + * This method is called on entering to each `(Call|Member)Expression[optional=true]` node. + * This creates a choice context as similar to `LogicalExpression[operator="??"]` node. + * @returns {void} + */ + makeOptionalNode() { + if (this.chainContext) { + this.chainContext.choiceContextCount += 1; + this.pushChoiceContext("??", false); + } + } + + /** + * Create a fork. + * This method is called on entering to the `arguments|property` property of each `(Call|Member)Expression` node. + * @returns {void} + */ + makeOptionalRight() { + if (this.chainContext) { + this.makeLogicalRight(); + } + } + + //-------------------------------------------------------------------------- + // SwitchStatement + //-------------------------------------------------------------------------- + + /** + * Creates a context object of SwitchStatement and stacks it. + * @param {boolean} hasCase `true` if the switch statement has one or more + * case parts. + * @param {string|null} label The label text. + * @returns {void} + */ + pushSwitchContext(hasCase, label) { + this.switchContext = new SwitchContext(this.switchContext, hasCase); + this.pushBreakContext(true, label); + } + + /** + * Pops the last context of SwitchStatement and finalizes it. + * + * - Disposes all forking stack for `case` and `default`. + * - Creates the next code path segment from `context.brokenForkContext`. + * - If the last `SwitchCase` node is not a `default` part, creates a path + * to the `default` body. + * @returns {void} + */ + popSwitchContext() { + const context = this.switchContext; + + this.switchContext = context.upper; + + const forkContext = this.forkContext; + const brokenForkContext = this.popBreakContext().brokenForkContext; + + if (context.forkCount === 0) { + /* + * When there is only one `default` chunk and there is one or more + * `break` statements, even if forks are nothing, it needs to merge + * those. + */ + if (!brokenForkContext.empty) { + brokenForkContext.add(forkContext.makeNext(-1, -1)); + forkContext.replaceHead(brokenForkContext.makeNext(0, -1)); + } + + return; + } + + const lastSegments = forkContext.head; + + this.forkBypassPath(); + const lastCaseSegments = forkContext.head; + + /* + * `brokenForkContext` is used to make the next segment. + * It must add the last segment into `brokenForkContext`. + */ + brokenForkContext.add(lastSegments); + + /* + * Any value that doesn't match a `case` test should flow to the default + * case. That happens normally when the default case is last in the `switch`, + * but if it's not, we need to rewire some of the paths to be correct. + */ + if (!context.lastIsDefault) { + if (context.defaultBodySegments) { + /* + * There is a non-empty default case, so remove the path from the `default` + * label to its body for an accurate representation. + */ + disconnectSegments( + context.defaultSegments, + context.defaultBodySegments, + ); + + /* + * Connect the path from the last non-default case to the body of the + * default case. + */ + makeLooped(this, lastCaseSegments, context.defaultBodySegments); + } else { + /* + * There is no default case, so we treat this as if the last case + * had a `break` in it. + */ + brokenForkContext.add(lastCaseSegments); + } + } + + // Traverse up to the original fork context for the `switch` statement + for (let i = 0; i < context.forkCount; ++i) { + this.forkContext = this.forkContext.upper; + } + + /* + * Creates a path from all `brokenForkContext` paths. + * This is a path after `switch` statement. + */ + this.forkContext.replaceHead(brokenForkContext.makeNext(0, -1)); + } + + /** + * Makes a code path segment for a `SwitchCase` node. + * @param {boolean} isCaseBodyEmpty `true` if the body is empty. + * @param {boolean} isDefaultCase `true` if the body is the default case. + * @returns {void} + */ + makeSwitchCaseBody(isCaseBodyEmpty, isDefaultCase) { + const context = this.switchContext; + + if (!context.hasCase) { + return; + } + + /* + * Merge forks. + * The parent fork context has two segments. + * Those are from the current `case` and the body of the previous case. + */ + const parentForkContext = this.forkContext; + const forkContext = this.pushForkContext(); + + forkContext.add(parentForkContext.makeNext(0, -1)); + + /* + * Add information about the default case. + * + * The purpose of this is to identify the starting segments for the + * default case to make sure there is a path there. + */ + if (isDefaultCase) { + /* + * This is the default case in the `switch`. + * + * We first save the current pointer as `defaultSegments` to point + * to the `default` keyword. + */ + context.defaultSegments = parentForkContext.head; + + /* + * If the body of the case is empty then we just set + * `foundEmptyDefault` to true; otherwise, we save a reference + * to the current pointer as `defaultBodySegments`. + */ + if (isCaseBodyEmpty) { + context.foundEmptyDefault = true; + } else { + context.defaultBodySegments = forkContext.head; + } + } else { + /* + * This is not the default case in the `switch`. + * + * If it's not empty and there is already an empty default case found, + * that means the default case actually comes before this case, + * and that it will fall through to this case. So, we can now + * ignore the previous default case (reset `foundEmptyDefault` to false) + * and set `defaultBodySegments` to the current segments because this is + * effectively the new default case. + */ + if (!isCaseBodyEmpty && context.foundEmptyDefault) { + context.foundEmptyDefault = false; + context.defaultBodySegments = forkContext.head; + } + } + + // keep track if the default case ends up last + context.lastIsDefault = isDefaultCase; + context.forkCount += 1; + } + + //-------------------------------------------------------------------------- + // TryStatement + //-------------------------------------------------------------------------- + + /** + * Creates a context object of TryStatement and stacks it. + * @param {boolean} hasFinalizer `true` if the try statement has a + * `finally` block. + * @returns {void} + */ + pushTryContext(hasFinalizer) { + this.tryContext = new TryContext( + this.tryContext, + hasFinalizer, + this.forkContext, + ); + } + + /** + * Pops the last context of TryStatement and finalizes it. + * @returns {void} + */ + popTryContext() { + const context = this.tryContext; + + this.tryContext = context.upper; + + /* + * If we're inside the `catch` block, that means there is no `finally`, + * so we can process the `try` and `catch` blocks the simple way and + * merge their two paths. + */ + if (context.position === "catch") { + this.popForkContext(); + return; + } + + /* + * The following process is executed only when there is a `finally` + * block. + */ + + const originalReturnedForkContext = context.returnedForkContext; + const originalThrownForkContext = context.thrownForkContext; + + // no `return` or `throw` in `try` or `catch` so there's nothing left to do + if ( + originalReturnedForkContext.empty && + originalThrownForkContext.empty + ) { + return; + } + + /* + * The following process is executed only when there is a `finally` + * block and there was a `return` or `throw` in the `try` or `catch` + * blocks. + */ + + // Separate head to normal paths and leaving paths. + const headSegments = this.forkContext.head; + + this.forkContext = this.forkContext.upper; + const normalSegments = headSegments.slice( + 0, + (headSegments.length / 2) | 0, + ); + const leavingSegments = headSegments.slice( + (headSegments.length / 2) | 0, + ); + + // Forwards the leaving path to upper contexts. + if (!originalReturnedForkContext.empty) { + getReturnContext(this).returnedForkContext.add(leavingSegments); + } + if (!originalThrownForkContext.empty) { + getThrowContext(this).thrownForkContext.add(leavingSegments); + } + + // Sets the normal path as the next. + this.forkContext.replaceHead(normalSegments); + + /* + * If both paths of the `try` block and the `catch` block are + * unreachable, the next path becomes unreachable as well. + */ + if (!context.lastOfTryIsReachable && !context.lastOfCatchIsReachable) { + this.forkContext.makeUnreachable(); + } + } + + /** + * Makes a code path segment for a `catch` block. + * @returns {void} + */ + makeCatchBlock() { + const context = this.tryContext; + const forkContext = this.forkContext; + const originalThrownForkContext = context.thrownForkContext; + + /* + * We are now in a catch block so we need to update the context + * with that information. This includes creating a new fork + * context in case we encounter any `throw` statements here. + */ + context.position = "catch"; + context.thrownForkContext = ForkContext.newEmpty(forkContext); + context.lastOfTryIsReachable = forkContext.reachable; + + // Merge the thrown paths from the `try` and `catch` blocks + originalThrownForkContext.add(forkContext.head); + const thrownSegments = originalThrownForkContext.makeNext(0, -1); + + // Fork to a bypass and the merged thrown path. + this.pushForkContext(); + this.forkBypassPath(); + this.forkContext.add(thrownSegments); + } + + /** + * Makes a code path segment for a `finally` block. + * + * In the `finally` block, parallel paths are created. The parallel paths + * are used as leaving-paths. The leaving-paths are paths from `return` + * statements and `throw` statements in a `try` block or a `catch` block. + * @returns {void} + */ + makeFinallyBlock() { + const context = this.tryContext; + let forkContext = this.forkContext; + const originalReturnedForkContext = context.returnedForkContext; + const originalThrownForContext = context.thrownForkContext; + const headOfLeavingSegments = forkContext.head; + + // Update state. + if (context.position === "catch") { + // Merges two paths from the `try` block and `catch` block. + this.popForkContext(); + forkContext = this.forkContext; + + context.lastOfCatchIsReachable = forkContext.reachable; + } else { + context.lastOfTryIsReachable = forkContext.reachable; + } + + context.position = "finally"; + + /* + * If there was no `return` or `throw` in either the `try` or `catch` + * blocks, then there's no further code paths to create for `finally`. + */ + if ( + originalReturnedForkContext.empty && + originalThrownForContext.empty + ) { + // This path does not leave. + return; + } + + /* + * Create a parallel segment from merging returned and thrown. + * This segment will leave at the end of this `finally` block. + */ + const segments = forkContext.makeNext(-1, -1); + + for (let i = 0; i < forkContext.count; ++i) { + const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]]; + + for ( + let j = 0; + j < originalReturnedForkContext.segmentsList.length; + ++j + ) { + prevSegsOfLeavingSegment.push( + originalReturnedForkContext.segmentsList[j][i], + ); + } + for ( + let j = 0; + j < originalThrownForContext.segmentsList.length; + ++j + ) { + prevSegsOfLeavingSegment.push( + originalThrownForContext.segmentsList[j][i], + ); + } + + segments.push( + CodePathSegment.newNext( + this.idGenerator.next(), + prevSegsOfLeavingSegment, + ), + ); + } + + this.pushForkContext(true); + this.forkContext.add(segments); + } + + /** + * Records abrupt resumption paths from a suspended `yield` expression, + * then splits normal post-`yield` continuation into a fresh segment. + * @returns {void} + */ + makeYield() { + const forkContext = this.forkContext; + const leavingSegments = forkContext.head; + + if (forkContext.reachable) { + getReturnContext(this).returnedForkContext.add(leavingSegments); + getThrowContext(this).thrownForkContext.add(leavingSegments); + + forkContext.replaceHead(forkContext.makeNext(-1, -1)); + } + } + + /** + * Makes a code path segment from the first throwable node in a `try` block to the `catch` + * block or the `finally` block or from the first throwable node in a `catch` block + * to the `finally` block. + * @returns {void} + */ + makeFirstThrowablePathInTryOrCatchBlock() { + const forkContext = this.forkContext; + + if (!forkContext.reachable) { + return; + } + + const context = getThrowContext(this); + + if (context === this || !context.thrownForkContext.empty) { + return; + } + + if ( + context.position !== "try" && + (context.position !== "catch" || !context.hasFinalizer) + ) { + return; + } + + context.thrownForkContext.add(forkContext.head); + forkContext.replaceHead(forkContext.makeNext(-1, -1)); + } + + //-------------------------------------------------------------------------- + // Loop Statements + //-------------------------------------------------------------------------- + + /** + * Creates a context object of a loop statement and stacks it. + * @param {string} type The type of the node which was triggered. One of + * `WhileStatement`, `DoWhileStatement`, `ForStatement`, `ForInStatement`, + * and `ForStatement`. + * @param {string|null} label A label of the node which was triggered. + * @throws {Error} (Unreachable - unknown type.) + * @returns {void} + */ + pushLoopContext(type, label) { + const forkContext = this.forkContext; + + // All loops need a path to account for `break` statements + const breakContext = this.pushBreakContext(true, label); + + switch (type) { + case "WhileStatement": + this.pushChoiceContext("loop", false); + this.loopContext = new WhileLoopContext( + this.loopContext, + label, + breakContext, + ); + break; + + case "DoWhileStatement": + this.pushChoiceContext("loop", false); + this.loopContext = new DoWhileLoopContext( + this.loopContext, + label, + breakContext, + forkContext, + ); + break; + + case "ForStatement": + this.pushChoiceContext("loop", false); + this.loopContext = new ForLoopContext( + this.loopContext, + label, + breakContext, + ); + break; + + case "ForInStatement": + this.loopContext = new ForInLoopContext( + this.loopContext, + label, + breakContext, + ); + break; + + case "ForOfStatement": + this.loopContext = new ForOfLoopContext( + this.loopContext, + label, + breakContext, + ); + break; + + /* c8 ignore next */ + default: + throw new Error(`unknown type: "${type}"`); + } + } + + /** + * Pops the last context of a loop statement and finalizes it. + * @throws {Error} (Unreachable - unknown type.) + * @returns {void} + */ + popLoopContext() { + const context = this.loopContext; + + this.loopContext = context.upper; + + const forkContext = this.forkContext; + const brokenForkContext = this.popBreakContext().brokenForkContext; + + // Creates a looped path. + switch (context.type) { + case "WhileStatement": + case "ForStatement": + this.popChoiceContext(); + + /* + * Creates the path from the end of the loop body up to the + * location where `continue` would jump to. + */ + makeLooped( + this, + forkContext.head, + context.continueDestSegments, + ); + break; + + case "DoWhileStatement": { + const choiceContext = this.popChoiceContext(); + + if (!choiceContext.processed) { + choiceContext.trueForkContext.add(forkContext.head); + choiceContext.falseForkContext.add(forkContext.head); + } + + /* + * If this isn't a hardcoded `true` condition, then `break` + * should continue down the path as if the condition evaluated + * to false. + */ + if (context.test !== true) { + brokenForkContext.addAll(choiceContext.falseForkContext); + } + + /* + * When the condition is true, the loop continues back to the top, + * so create a path from each possible true condition back to the + * top of the loop. + */ + const segmentsList = choiceContext.trueForkContext.segmentsList; + + for (let i = 0; i < segmentsList.length; ++i) { + makeLooped(this, segmentsList[i], context.entrySegments); + } + break; + } + + case "ForInStatement": + case "ForOfStatement": + brokenForkContext.add(forkContext.head); + + /* + * Creates the path from the end of the loop body up to the + * left expression (left of `in` or `of`) of the loop. + */ + makeLooped(this, forkContext.head, context.leftSegments); + break; + + /* c8 ignore next */ + default: + throw new Error("unreachable"); + } + + /* + * If there wasn't a `break` statement in the loop, then we're at + * the end of the loop's path, so we make an unreachable segment + * to mark that. + * + * If there was a `break` statement, then we continue on into the + * `brokenForkContext`. + */ + if (brokenForkContext.empty) { + forkContext.replaceHead(forkContext.makeUnreachable(-1, -1)); + } else { + forkContext.replaceHead(brokenForkContext.makeNext(0, -1)); + } + } + + /** + * Makes a code path segment for the test part of a WhileStatement. + * @param {boolean|undefined} test The test value (only when constant). + * @returns {void} + */ + makeWhileTest(test) { + const context = this.loopContext; + const forkContext = this.forkContext; + const testSegments = forkContext.makeNext(0, -1); + + // Update state. + context.test = test; + context.continueDestSegments = testSegments; + forkContext.replaceHead(testSegments); + } + + /** + * Makes a code path segment for the body part of a WhileStatement. + * @returns {void} + */ + makeWhileBody() { + const context = this.loopContext; + const choiceContext = this.choiceContext; + const forkContext = this.forkContext; + + if (!choiceContext.processed) { + choiceContext.trueForkContext.add(forkContext.head); + choiceContext.falseForkContext.add(forkContext.head); + } + + /* + * If this isn't a hardcoded `true` condition, then `break` + * should continue down the path as if the condition evaluated + * to false. + */ + if (context.test !== true) { + context.brokenForkContext.addAll(choiceContext.falseForkContext); + } + forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1)); + } + + /** + * Makes a code path segment for the body part of a DoWhileStatement. + * @returns {void} + */ + makeDoWhileBody() { + const context = this.loopContext; + const forkContext = this.forkContext; + const bodySegments = forkContext.makeNext(-1, -1); + + // Update state. + context.entrySegments = bodySegments; + forkContext.replaceHead(bodySegments); + } + + /** + * Makes a code path segment for the test part of a DoWhileStatement. + * @param {boolean|undefined} test The test value (only when constant). + * @returns {void} + */ + makeDoWhileTest(test) { + const context = this.loopContext; + const forkContext = this.forkContext; + + context.test = test; + + /* + * If there is a `continue` statement in the loop then `continueForkContext` + * won't be empty. We wire up the path from `continue` to the loop + * test condition and then continue the traversal in the root fork context. + */ + if (!context.continueForkContext.empty) { + context.continueForkContext.add(forkContext.head); + const testSegments = context.continueForkContext.makeNext(0, -1); + + forkContext.replaceHead(testSegments); + } + } + + /** + * Makes a code path segment for the test part of a ForStatement. + * @param {boolean|undefined} test The test value (only when constant). + * @returns {void} + */ + makeForTest(test) { + const context = this.loopContext; + const forkContext = this.forkContext; + const endOfInitSegments = forkContext.head; + const testSegments = forkContext.makeNext(-1, -1); + + /* + * Update the state. + * + * The `continueDestSegments` are set to `testSegments` because we + * don't yet know if there is an update expression in this loop. So, + * from what we already know at this point, a `continue` statement + * will jump back to the test expression. + */ + context.test = test; + context.endOfInitSegments = endOfInitSegments; + context.continueDestSegments = context.testSegments = testSegments; + forkContext.replaceHead(testSegments); + } + + /** + * Makes a code path segment for the update part of a ForStatement. + * @returns {void} + */ + makeForUpdate() { + const context = this.loopContext; + const choiceContext = this.choiceContext; + const forkContext = this.forkContext; + + // Make the next paths of the test. + if (context.testSegments) { + finalizeTestSegmentsOfFor(context, choiceContext, forkContext.head); + } else { + context.endOfInitSegments = forkContext.head; + } + + /* + * Update the state. + * + * The `continueDestSegments` are now set to `updateSegments` because we + * know there is an update expression in this loop. So, a `continue` statement + * in the loop will jump to the update expression first, and then to any + * test expression the loop might have. + */ + const updateSegments = forkContext.makeDisconnected(-1, -1); + + context.continueDestSegments = context.updateSegments = updateSegments; + forkContext.replaceHead(updateSegments); + } + + /** + * Makes a code path segment for the body part of a ForStatement. + * @returns {void} + */ + makeForBody() { + const context = this.loopContext; + const choiceContext = this.choiceContext; + const forkContext = this.forkContext; + + /* + * Determine what to do based on which part of the `for` loop are present. + * 1. If there is an update expression, then `updateSegments` is not null and + * we need to assign `endOfUpdateSegments`, and if there is a test + * expression, we then need to create the looped path to get back to + * the test condition. + * 2. If there is no update expression but there is a test expression, + * then we only need to update the test segment information. + * 3. If there is no update expression and no test expression, then we + * just save `endOfInitSegments`. + */ + if (context.updateSegments) { + context.endOfUpdateSegments = forkContext.head; + + /* + * In a `for` loop that has both an update expression and a test + * condition, execution flows from the test expression into the + * loop body, to the update expression, and then back to the test + * expression to determine if the loop should continue. + * + * To account for that, we need to make a path from the end of the + * update expression to the start of the test expression. This is + * effectively what creates the loop in the code path. + */ + if (context.testSegments) { + makeLooped( + this, + context.endOfUpdateSegments, + context.testSegments, + ); + } + } else if (context.testSegments) { + finalizeTestSegmentsOfFor(context, choiceContext, forkContext.head); + } else { + context.endOfInitSegments = forkContext.head; + } + + let bodySegments = context.endOfTestSegments; + + /* + * If there is a test condition, then there `endOfTestSegments` is also + * the start of the loop body. If there isn't a test condition then + * `bodySegments` will be null and we need to look elsewhere to find + * the start of the body. + * + * The body starts at the end of the init expression and ends at the end + * of the update expression, so we use those locations to determine the + * body segments. + */ + if (!bodySegments) { + const prevForkContext = ForkContext.newEmpty(forkContext); + + prevForkContext.add(context.endOfInitSegments); + if (context.endOfUpdateSegments) { + prevForkContext.add(context.endOfUpdateSegments); + } + + bodySegments = prevForkContext.makeNext(0, -1); + } + + /* + * If there was no test condition and no update expression, then + * `continueDestSegments` will be null. In that case, a + * `continue` should skip directly to the body of the loop. + * Otherwise, we want to keep the current `continueDestSegments`. + */ + context.continueDestSegments = + context.continueDestSegments || bodySegments; + + // move pointer to the body + forkContext.replaceHead(bodySegments); + } + + /** + * Makes a code path segment for the left part of a ForInStatement and a + * ForOfStatement. + * @returns {void} + */ + makeForInOfLeft() { + const context = this.loopContext; + const forkContext = this.forkContext; + const leftSegments = forkContext.makeDisconnected(-1, -1); + + // Update state. + context.prevSegments = forkContext.head; + context.leftSegments = context.continueDestSegments = leftSegments; + forkContext.replaceHead(leftSegments); + } + + /** + * Makes a code path segment for the right part of a ForInStatement and a + * ForOfStatement. + * @returns {void} + */ + makeForInOfRight() { + const context = this.loopContext; + const forkContext = this.forkContext; + const temp = ForkContext.newEmpty(forkContext); + + temp.add(context.prevSegments); + const rightSegments = temp.makeNext(-1, -1); + + // Update state. + context.endOfLeftSegments = forkContext.head; + forkContext.replaceHead(rightSegments); + } + + /** + * Makes a code path segment for the body part of a ForInStatement and a + * ForOfStatement. + * @returns {void} + */ + makeForInOfBody() { + const context = this.loopContext; + const forkContext = this.forkContext; + const temp = ForkContext.newEmpty(forkContext); + + temp.add(context.endOfLeftSegments); + const bodySegments = temp.makeNext(-1, -1); + + // Make a path: `right` -> `left`. + makeLooped(this, forkContext.head, context.leftSegments); + + // Update state. + context.brokenForkContext.add(forkContext.head); + forkContext.replaceHead(bodySegments); + } + + //-------------------------------------------------------------------------- + // Control Statements + //-------------------------------------------------------------------------- + + /** + * Creates new context in which a `break` statement can be used. This occurs inside of a loop, + * labeled statement, or switch statement. + * @param {boolean} breakable Indicates if we are inside a statement where + * `break` without a label will exit the statement. + * @param {string|null} label The label associated with the statement. + * @returns {BreakContext} The new context. + */ + pushBreakContext(breakable, label) { + this.breakContext = new BreakContext( + this.breakContext, + breakable, + label, + this.forkContext, + ); + return this.breakContext; + } + + /** + * Removes the top item of the break context stack. + * @returns {Object} The removed context. + */ + popBreakContext() { + const context = this.breakContext; + const forkContext = this.forkContext; + + this.breakContext = context.upper; + + // Process this context here for other than switches and loops. + if (!context.breakable) { + const brokenForkContext = context.brokenForkContext; + + if (!brokenForkContext.empty) { + brokenForkContext.add(forkContext.head); + forkContext.replaceHead(brokenForkContext.makeNext(0, -1)); + } + } + + return context; + } + + /** + * Makes a path for a `break` statement. + * + * It registers the head segment to a context of `break`. + * It makes new unreachable segment, then it set the head with the segment. + * @param {string|null} label A label of the break statement. + * @returns {void} + */ + makeBreak(label) { + const forkContext = this.forkContext; + + if (!forkContext.reachable) { + return; + } + + const context = getBreakContext(this, label); + + if (context) { + context.brokenForkContext.add(forkContext.head); + } + + /* c8 ignore next */ + forkContext.replaceHead(forkContext.makeUnreachable(-1, -1)); + } + + /** + * Makes a path for a `continue` statement. + * + * It makes a looping path. + * It makes new unreachable segment, then it set the head with the segment. + * @param {string|null} label A label of the continue statement. + * @returns {void} + */ + makeContinue(label) { + const forkContext = this.forkContext; + + if (!forkContext.reachable) { + return; + } + + const context = getContinueContext(this, label); + + if (context) { + if (context.continueDestSegments) { + makeLooped( + this, + forkContext.head, + context.continueDestSegments, + ); + + // If the context is a for-in/of loop, this affects a break also. + if ( + context.type === "ForInStatement" || + context.type === "ForOfStatement" + ) { + context.brokenForkContext.add(forkContext.head); + } + } else { + context.continueForkContext.add(forkContext.head); + } + } + forkContext.replaceHead(forkContext.makeUnreachable(-1, -1)); + } + + /** + * Makes a path for a `return` statement. + * + * It registers the head segment to a context of `return`. + * It makes new unreachable segment, then it set the head with the segment. + * @returns {void} + */ + makeReturn() { + const forkContext = this.forkContext; + + if (forkContext.reachable) { + getReturnContext(this).returnedForkContext.add(forkContext.head); + forkContext.replaceHead(forkContext.makeUnreachable(-1, -1)); + } + } + + /** + * Makes a path for a `throw` statement. + * + * It registers the head segment to a context of `throw`. + * It makes new unreachable segment, then it set the head with the segment. + * @returns {void} + */ + makeThrow() { + const forkContext = this.forkContext; + + if (forkContext.reachable) { + getThrowContext(this).thrownForkContext.add(forkContext.head); + forkContext.replaceHead(forkContext.makeUnreachable(-1, -1)); + } + } + + /** + * Makes the final path. + * @returns {void} + */ + makeFinal() { + const segments = this.currentSegments; + + if (segments.length > 0 && segments[0].reachable) { + this.returnedForkContext.add(segments); + } + } +} + +module.exports = CodePathState; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path.js new file mode 100644 index 00000000..3c71b55a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/code-path.js @@ -0,0 +1,334 @@ +/** + * @fileoverview A class of the code path. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const CodePathState = require("./code-path-state"); +const IdGenerator = require("./id-generator"); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * A code path. + */ +class CodePath { + /** + * Creates a new instance. + * @param {Object} options Options for the function (see below). + * @param {string} options.id An identifier. + * @param {string} options.origin The type of code path origin. + * @param {CodePath|null} options.upper The code path of the upper function scope. + * @param {Function} options.onLooped A callback function to notify looping. + */ + constructor({ id, origin, upper, onLooped }) { + /** + * The identifier of this code path. + * Rules use it to store additional information of each rule. + * @type {string} + */ + this.id = id; + + /** + * The reason that this code path was started. May be "program", + * "function", "class-field-initializer", or "class-static-block". + * @type {string} + */ + this.origin = origin; + + /** + * The code path of the upper function scope. + * @type {CodePath|null} + */ + this.upper = upper; + + /** + * The code paths of nested function scopes. + * @type {CodePath[]} + */ + this.childCodePaths = []; + + // Initializes internal state. + Object.defineProperty(this, "internal", { + value: new CodePathState(new IdGenerator(`${id}_`), onLooped), + }); + + // Adds this into `childCodePaths` of `upper`. + if (upper) { + upper.childCodePaths.push(this); + } + } + + /** + * Gets the state of a given code path. + * @param {CodePath} codePath A code path to get. + * @returns {CodePathState} The state of the code path. + */ + static getState(codePath) { + return codePath.internal; + } + + /** + * The initial code path segment. This is the segment that is at the head + * of the code path. + * This is a passthrough to the underlying `CodePathState`. + * @type {CodePathSegment} + */ + get initialSegment() { + return this.internal.initialSegment; + } + + /** + * Final code path segments. These are the terminal (tail) segments in the + * code path, which is the combination of `returnedSegments` and `thrownSegments`. + * All segments in this array are reachable. + * This is a passthrough to the underlying `CodePathState`. + * @type {CodePathSegment[]} + */ + get finalSegments() { + return this.internal.finalSegments; + } + + /** + * Final code path segments that represent normal completion of the code path. + * For functions, this means both explicit `return` statements and implicit returns, + * such as the last reachable segment in a function that does not have an + * explicit `return` as this implicitly returns `undefined`, as well as + * return-like exits from suspended `yield` expressions. For scripts, modules, + * class field initializers, and class static blocks, this means all lines of + * code have been executed. + * These segments are also present in `finalSegments`. + * This is a passthrough to the underlying `CodePathState`. + * @type {CodePathSegment[]} + */ + get returnedSegments() { + return this.internal.returnedForkContext; + } + + /** + * Final code path segments that represent `throw` statements and throw-like + * exits from suspended `yield` expressions. + * This is a passthrough to the underlying `CodePathState`. + * These segments are also present in `finalSegments`. + * @type {CodePathSegment[]} + */ + get thrownSegments() { + return this.internal.thrownForkContext; + } + + /** + * Traverses all segments in this code path. + * + * codePath.traverseSegments((segment, controller) => { + * // do something. + * }); + * + * This method enumerates segments in order from the head. + * + * The `controller` argument has two methods: + * + * - `skip()` - skips the following segments in this branch + * - `break()` - skips all following segments in the traversal + * + * A note on the parameters: the `options` argument is optional. This means + * the first argument might be an options object or the callback function. + * @param {Object} [optionsOrCallback] Optional first and last segments to traverse. + * @param {CodePathSegment} [optionsOrCallback.first] The first segment to traverse. + * @param {CodePathSegment} [optionsOrCallback.last] The last segment to traverse. + * @param {Function} callback A callback function. + * @returns {void} + */ + traverseSegments(optionsOrCallback, callback) { + // normalize the arguments into a callback and options + let resolvedOptions; + let resolvedCallback; + + if (typeof optionsOrCallback === "function") { + resolvedCallback = optionsOrCallback; + resolvedOptions = {}; + } else { + resolvedOptions = optionsOrCallback || {}; + resolvedCallback = callback; + } + + // determine where to start traversing from based on the options + const startSegment = + resolvedOptions.first || this.internal.initialSegment; + const lastSegment = resolvedOptions.last; + + // set up initial location information + let record; + let index; + let end; + let segment = null; + + // segments that have already been visited during traversal + const visited = new Set(); + + // tracks the traversal steps + const stack = [[startSegment, 0]]; + + // segments that have been skipped during traversal + const skipped = new Set(); + + // indicates if we exited early from the traversal + let broken = false; + + /** + * Maintains traversal state. + */ + const controller = { + /** + * Skip the following segments in this branch. + * @returns {void} + */ + skip() { + skipped.add(segment); + }, + + /** + * Stop traversal completely - do not traverse to any + * other segments. + * @returns {void} + */ + break() { + broken = true; + }, + }; + + /** + * Checks if a given previous segment has been visited. + * @param {CodePathSegment} prevSegment A previous segment to check. + * @returns {boolean} `true` if the segment has been visited. + */ + function isVisited(prevSegment) { + return ( + visited.has(prevSegment) || + segment.isLoopedPrevSegment(prevSegment) + ); + } + + /** + * Checks if a given previous segment has been skipped. + * @param {CodePathSegment} prevSegment A previous segment to check. + * @returns {boolean} `true` if the segment has been skipped. + */ + function isSkipped(prevSegment) { + return ( + skipped.has(prevSegment) || + segment.isLoopedPrevSegment(prevSegment) + ); + } + + // the traversal + while (stack.length > 0) { + /* + * This isn't a pure stack. We use the top record all the time + * but don't always pop it off. The record is popped only if + * one of the following is true: + * + * 1) We have already visited the segment. + * 2) We have not visited *all* of the previous segments. + * 3) We have traversed past the available next segments. + * + * Otherwise, we just read the value and sometimes modify the + * record as we traverse. + */ + record = stack.at(-1); + segment = record[0]; + index = record[1]; + + if (index === 0) { + // Skip if this segment has been visited already. + if (visited.has(segment)) { + stack.pop(); + continue; + } + + // Skip if all previous segments have not been visited. + if ( + segment !== startSegment && + segment.prevSegments.length > 0 && + !segment.prevSegments.every(isVisited) + ) { + stack.pop(); + continue; + } + + visited.add(segment); + + // Skips the segment if all previous segments have been skipped. + const shouldSkip = + skipped.size > 0 && + segment.prevSegments.length > 0 && + segment.prevSegments.every(isSkipped); + + /* + * If the most recent segment hasn't been skipped, then we call + * the callback, passing in the segment and the controller. + */ + if (!shouldSkip) { + resolvedCallback.call(this, segment, controller); + + // exit if we're at the last segment + if (segment === lastSegment) { + controller.skip(); + } + + /* + * If the previous statement was executed, or if the callback + * called a method on the controller, we might need to exit the + * loop, so check for that and break accordingly. + */ + if (broken) { + break; + } + } else { + // If the most recent segment has been skipped, then mark it as skipped. + skipped.add(segment); + } + } + + // Update the stack. + end = segment.nextSegments.length - 1; + if (index < end) { + /* + * If we haven't yet visited all of the next segments, update + * the current top record on the stack to the next index to visit + * and then push a record for the current segment on top. + * + * Setting the current top record's index lets us know how many + * times we've been here and ensures that the segment won't be + * reprocessed (because we only process segments with an index + * of 0). + */ + record[1] += 1; + stack.push([segment.nextSegments[index], 0]); + } else if (index === end) { + /* + * If we are at the last next segment, then reset the top record + * in the stack to next segment and set its index to 0 so it will + * be processed next. + */ + record[0] = segment.nextSegments[index]; + record[1] = 0; + } else { + /* + * If index > end, that means we have no more segments that need + * processing. So, we pop that record off of the stack in order to + * continue traversing at the next level up. + */ + stack.pop(); + } + } + } +} + +module.exports = CodePath; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/debug-helpers.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/debug-helpers.js new file mode 100644 index 00000000..82f20c7d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/debug-helpers.js @@ -0,0 +1,234 @@ +/** + * @fileoverview Helpers to debug for code path analysis. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const debug = require("debug")("eslint:code-path"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Gets id of a given segment. + * @param {CodePathSegment} segment A segment to get. + * @returns {string} Id of the segment. + */ +/* c8 ignore next */ +// eslint-disable-next-line jsdoc/require-jsdoc -- Ignoring +function getId(segment) { + return segment.id + (segment.reachable ? "" : "!"); +} + +/** + * Get string for the given node and operation. + * @param {ASTNode} node The node to convert. + * @param {"enter" | "exit" | undefined} label The operation label. + * @returns {string} The string representation. + */ +function nodeToString(node, label) { + const suffix = label ? `:${label}` : ""; + + switch (node.type) { + case "Identifier": + return `${node.type}${suffix} (${node.name})`; + case "Literal": + return `${node.type}${suffix} (${node.value})`; + default: + return `${node.type}${suffix}`; + } +} + +/** + * Escape text for use in a DOT label. + * @param {string} value The value to escape. + * @returns {string} The escaped value. + */ +function escapeDotLabelText(value) { + return value.replace(/\\/gu, String.raw`\\`).replace(/"/gu, String.raw`\"`); +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + /** + * A flag that debug dumping is enabled or not. + * @type {boolean} + */ + enabled: debug.enabled, + + /** + * Dumps given objects. + * @param {...any} args objects to dump. + * @returns {void} + */ + dump: debug, + + /** + * Dumps the current analyzing state. + * @param {ASTNode} node A node to dump. + * @param {CodePathState} state A state to dump. + * @param {boolean} leaving A flag whether or not it's leaving + * @returns {void} + */ + dumpState: !debug.enabled + ? debug + : /* c8 ignore next */ function (node, state, leaving) { + for (let i = 0; i < state.currentSegments.length; ++i) { + const segInternal = state.currentSegments[i].internal; + + if (leaving) { + const last = segInternal.nodes.length - 1; + + if ( + last >= 0 && + segInternal.nodes[last] === + nodeToString(node, "enter") + ) { + segInternal.nodes[last] = nodeToString( + node, + void 0, + ); + } else { + segInternal.nodes.push(nodeToString(node, "exit")); + } + } else { + segInternal.nodes.push(nodeToString(node, "enter")); + } + } + + debug( + "%s) %s%s", + state.currentSegments.map(getId).join(","), + node.type, + leaving ? ":exit" : "", + ); + }, + + /** + * Dumps a DOT code of a given code path. + * The DOT code can be visualized with Graphvis. + * @param {CodePath} codePath A code path to dump. + * @returns {void} + * @see https://www.graphviz.org + * @see http://www.webgraphviz.com + */ + dumpDot: !debug.enabled + ? debug + : /* c8 ignore next */ function (codePath) { + let text = + "\n" + + "digraph {\n" + + 'node[shape=box,style="rounded,filled",fillcolor=white];\n' + + 'initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];\n'; + + if (codePath.returnedSegments.length > 0) { + text += + 'final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];\n'; + } + if (codePath.thrownSegments.length > 0) { + text += + 'thrown[label="✘",shape=circle,width=0.3,height=0.3,fixedsize=true];\n'; + } + + const traceMap = Object.create(null); + const arrows = this.makeDotArrows(codePath, traceMap); + + // eslint-disable-next-line guard-for-in -- Want ability to traverse prototype + for (const id in traceMap) { + const segment = traceMap[id]; + + text += `${id}[`; + + if (segment.reachable) { + text += 'label="'; + } else { + text += + 'style="rounded,dashed,filled",fillcolor="#FF9800",label="<>\\n'; + } + + if (segment.internal.nodes.length > 0) { + text += segment.internal.nodes + .map(escapeDotLabelText) + .join("\\n"); + } else { + text += "????"; + } + + text += '"];\n'; + } + + text += `${arrows}\n`; + text += "}"; + debug("DOT", text); + }, + + /** + * Makes a DOT code of a given code path. + * The DOT code can be visualized with Graphvis. + * @param {CodePath} codePath A code path to make DOT. + * @param {Object} traceMap Optional. A map to check whether or not segments had been done. + * @returns {string} A DOT code of the code path. + */ + makeDotArrows(codePath, traceMap) { + const stack = [[codePath.initialSegment, 0]]; + const done = traceMap || Object.create(null); + let lastId = codePath.initialSegment.id; + let text = `initial->${codePath.initialSegment.id}`; + + while (stack.length > 0) { + const item = stack.pop(); + const segment = item[0]; + const index = item[1]; + + if (done[segment.id] && index === 0) { + continue; + } + done[segment.id] = segment; + + const nextSegment = segment.allNextSegments[index]; + + if (!nextSegment) { + continue; + } + + if (lastId === segment.id) { + text += `->${nextSegment.id}`; + } else { + text += `;\n${segment.id}->${nextSegment.id}`; + } + lastId = nextSegment.id; + + stack.unshift([segment, 1 + index]); + stack.push([nextSegment, 0]); + } + + codePath.returnedSegments.forEach(finalSegment => { + if (lastId === finalSegment.id) { + text += "->final"; + } else { + text += `;\n${finalSegment.id}->final`; + } + lastId = null; + }); + + codePath.thrownSegments.forEach(finalSegment => { + if (lastId === finalSegment.id) { + text += "->thrown"; + } else { + text += `;\n${finalSegment.id}->thrown`; + } + lastId = null; + }); + + return `${text};`; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/fork-context.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/fork-context.js new file mode 100644 index 00000000..93d33162 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/fork-context.js @@ -0,0 +1,374 @@ +/** + * @fileoverview A class to operate forking. + * + * This is state of forking. + * This has a fork list and manages it. + * + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const assert = require("../../shared/assert"), + CodePathSegment = require("./code-path-segment"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether or not a given segment is reachable. + * @param {CodePathSegment} segment The segment to check. + * @returns {boolean} `true` if the segment is reachable. + */ +function isReachable(segment) { + return segment.reachable; +} + +/** + * Creates a new segment for each fork in the given context and appends it + * to the end of the specified range of segments. Ultimately, this ends up calling + * `new CodePathSegment()` for each of the forks using the `create` argument + * as a wrapper around special behavior. + * + * The `startIndex` and `endIndex` arguments specify a range of segments in + * `context` that should become `allPrevSegments` for the newly created + * `CodePathSegment` objects. + * + * When `context.segmentsList` is `[[a, b], [c, d], [e, f]]`, `begin` is `0`, and + * `end` is `-1`, this creates two new segments, `[g, h]`. This `g` is appended to + * the end of the path from `a`, `c`, and `e`. This `h` is appended to the end of + * `b`, `d`, and `f`. + * @param {ForkContext} context An instance from which the previous segments + * will be obtained. + * @param {number} startIndex The index of the first segment in the context + * that should be specified as previous segments for the newly created segments. + * @param {number} endIndex The index of the last segment in the context + * that should be specified as previous segments for the newly created segments. + * @param {Function} create A function that creates new `CodePathSegment` + * instances in a particular way. See the `CodePathSegment.new*` methods. + * @returns {Array} An array of the newly-created segments. + */ +function createSegments(context, startIndex, endIndex, create) { + /** @type {Array>} */ + const list = context.segmentsList; + + /* + * Both `startIndex` and `endIndex` work the same way: if the number is zero + * or more, then the number is used as-is. If the number is negative, + * then that number is added to the length of the segments list to + * determine the index to use. That means -1 for either argument + * is the last element, -2 is the second to last, and so on. + * + * So if `startIndex` is 0, `endIndex` is -1, and `list.length` is 3, the + * effective `startIndex` is 0 and the effective `endIndex` is 2, so this function + * will include items at indices 0, 1, and 2. + * + * Therefore, if `startIndex` is -1 and `endIndex` is -1, that means we'll only + * be using the last segment in `list`. + */ + const normalizedBegin = + startIndex >= 0 ? startIndex : list.length + startIndex; + const normalizedEnd = endIndex >= 0 ? endIndex : list.length + endIndex; + + /** @type {Array} */ + const segments = []; + + for (let i = 0; i < context.count; ++i) { + // this is passed into `new CodePathSegment` to add to code path. + const allPrevSegments = []; + + for (let j = normalizedBegin; j <= normalizedEnd; ++j) { + allPrevSegments.push(list[j][i]); + } + + // note: `create` is just a wrapper that augments `new CodePathSegment`. + segments.push(create(context.idGenerator.next(), allPrevSegments)); + } + + return segments; +} + +/** + * Inside of a `finally` block we end up with two parallel paths. If the code path + * exits by a control statement (such as `break` or `continue`) from the `finally` + * block, then we need to merge the remaining parallel paths back into one. + * @param {ForkContext} context The fork context to work on. + * @param {Array} segments Segments to merge. + * @returns {Array} The merged segments. + */ +function mergeExtraSegments(context, segments) { + let currentSegments = segments; + + /* + * We need to ensure that the array returned from this function contains no more + * than the number of segments that the context allows. `context.count` indicates + * how many items should be in the returned array to ensure that the new segment + * entries will line up with the already existing segment entries. + */ + while (currentSegments.length > context.count) { + const merged = []; + + /* + * Because `context.count` is a factor of 2 inside of a `finally` block, + * we can divide the segment count by 2 to merge the paths together. + * This loops through each segment in the list and creates a new `CodePathSegment` + * that has the segment and the segment two slots away as previous segments. + * + * If `currentSegments` is [a,b,c,d], this will create new segments e and f, such + * that: + * + * When `i` is 0: + * a->e + * c->e + * + * When `i` is 1: + * b->f + * d->f + */ + for ( + let i = 0, length = Math.floor(currentSegments.length / 2); + i < length; + ++i + ) { + merged.push( + CodePathSegment.newNext(context.idGenerator.next(), [ + currentSegments[i], + currentSegments[i + length], + ]), + ); + } + + /* + * Go through the loop condition one more time to see if we have the + * number of segments for the context. If not, we'll keep merging paths + * of the merged segments until we get there. + */ + currentSegments = merged; + } + + return currentSegments; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Manages the forking of code paths. + */ +class ForkContext { + /** + * Creates a new instance. + * @param {IdGenerator} idGenerator An identifier generator for segments. + * @param {ForkContext|null} upper The preceding fork context. + * @param {number} count The number of parallel segments in each element + * of `segmentsList`. + */ + constructor(idGenerator, upper, count) { + /** + * The ID generator that will generate segment IDs for any new + * segments that are created. + * @type {IdGenerator} + */ + this.idGenerator = idGenerator; + + /** + * The preceding fork context. + * @type {ForkContext|null} + */ + this.upper = upper; + + /** + * The number of elements in each element of `segmentsList`. In most + * cases, this is 1 but can be 2 when there is a `finally` present, + * which forks the code path outside of normal flow. In the case of nested + * `finally` blocks, this can be a multiple of 2. + * @type {number} + */ + this.count = count; + + /** + * The segments within this context. Each element in this array has + * `count` elements that represent one step in each fork. For example, + * when `segmentsList` is `[[a, b], [c, d], [e, f]]`, there is one path + * a->c->e and one path b->d->f, and `count` is 2 because each element + * is an array with two elements. + * @type {Array>} + */ + this.segmentsList = []; + } + + /** + * The segments that begin this fork context. + * @type {Array} + */ + get head() { + const list = this.segmentsList; + + return list.length === 0 ? [] : list.at(-1); + } + + /** + * Indicates if the context contains no segments. + * @type {boolean} + */ + get empty() { + return this.segmentsList.length === 0; + } + + /** + * Indicates if there are any segments that are reachable. + * @type {boolean} + */ + get reachable() { + const segments = this.head; + + return segments.length > 0 && segments.some(isReachable); + } + + /** + * Creates new segments in this context and appends them to the end of the + * already existing `CodePathSegment`s specified by `startIndex` and + * `endIndex`. + * @param {number} startIndex The index of the first segment in the context + * that should be specified as previous segments for the newly created segments. + * @param {number} endIndex The index of the last segment in the context + * that should be specified as previous segments for the newly created segments. + * @returns {Array} An array of the newly created segments. + */ + makeNext(startIndex, endIndex) { + return createSegments( + this, + startIndex, + endIndex, + CodePathSegment.newNext, + ); + } + + /** + * Creates new unreachable segments in this context and appends them to the end of the + * already existing `CodePathSegment`s specified by `startIndex` and + * `endIndex`. + * @param {number} startIndex The index of the first segment in the context + * that should be specified as previous segments for the newly created segments. + * @param {number} endIndex The index of the last segment in the context + * that should be specified as previous segments for the newly created segments. + * @returns {Array} An array of the newly created segments. + */ + makeUnreachable(startIndex, endIndex) { + return createSegments( + this, + startIndex, + endIndex, + CodePathSegment.newUnreachable, + ); + } + + /** + * Creates new segments in this context and does not append them to the end + * of the already existing `CodePathSegment`s specified by `startIndex` and + * `endIndex`. The `startIndex` and `endIndex` are only used to determine if + * the new segments should be reachable. If any of the segments in this range + * are reachable then the new segments are also reachable; otherwise, the new + * segments are unreachable. + * @param {number} startIndex The index of the first segment in the context + * that should be considered for reachability. + * @param {number} endIndex The index of the last segment in the context + * that should be considered for reachability. + * @returns {Array} An array of the newly created segments. + */ + makeDisconnected(startIndex, endIndex) { + return createSegments( + this, + startIndex, + endIndex, + CodePathSegment.newDisconnected, + ); + } + + /** + * Adds segments to the head of this context. + * @param {Array} segments The segments to add. + * @returns {void} + */ + add(segments) { + assert( + segments.length >= this.count, + `${segments.length} >= ${this.count}`, + ); + this.segmentsList.push(mergeExtraSegments(this, segments)); + } + + /** + * Replaces the head segments with the given segments. + * The current head segments are removed. + * @param {Array} replacementHeadSegments The new head segments. + * @returns {void} + */ + replaceHead(replacementHeadSegments) { + assert( + replacementHeadSegments.length >= this.count, + `${replacementHeadSegments.length} >= ${this.count}`, + ); + this.segmentsList.splice( + -1, + 1, + mergeExtraSegments(this, replacementHeadSegments), + ); + } + + /** + * Adds all segments of a given fork context into this context. + * @param {ForkContext} otherForkContext The fork context to add from. + * @returns {void} + */ + addAll(otherForkContext) { + assert(otherForkContext.count === this.count); + this.segmentsList.push(...otherForkContext.segmentsList); + } + + /** + * Clears all segments in this context. + * @returns {void} + */ + clear() { + this.segmentsList = []; + } + + /** + * Creates a new root context, meaning that there are no parent + * fork contexts. + * @param {IdGenerator} idGenerator An identifier generator for segments. + * @returns {ForkContext} New fork context. + */ + static newRoot(idGenerator) { + const context = new ForkContext(idGenerator, null, 1); + + context.add([CodePathSegment.newRoot(idGenerator.next())]); + + return context; + } + + /** + * Creates an empty fork context preceded by a given context. + * @param {ForkContext} parentContext The parent fork context. + * @param {boolean} shouldForkLeavingPath Indicates that we are inside of + * a `finally` block and should therefore fork the path that leaves + * `finally`. + * @returns {ForkContext} New fork context. + */ + static newEmpty(parentContext, shouldForkLeavingPath) { + return new ForkContext( + parentContext.idGenerator, + parentContext, + (shouldForkLeavingPath ? 2 : 1) * parentContext.count, + ); + } +} + +module.exports = ForkContext; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/id-generator.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/id-generator.js new file mode 100644 index 00000000..8d06946b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/code-path-analysis/id-generator.js @@ -0,0 +1,43 @@ +/** + * @fileoverview A class of identifiers generator for code path segments. + * + * Each rule uses the identifier of code path segments to store additional + * information of the code path. + * + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * A generator for unique ids. + */ +class IdGenerator { + /** + * @param {string} prefix Optional. A prefix of generated ids. + */ + constructor(prefix) { + this.prefix = String(prefix); + this.n = 0; + } + + /** + * Generates id. + * @returns {string} A generated id. + */ + next() { + this.n = (1 + this.n) | 0; + + if (this.n < 0) { + this.n = 1; + } + + return this.prefix + this.n; + } +} + +module.exports = IdGenerator; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/esquery.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/esquery.js new file mode 100644 index 00000000..e3cb1da2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/esquery.js @@ -0,0 +1,455 @@ +/** + * @fileoverview ESQuery wrapper for ESLint. + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const esquery = require("esquery"); + +//----------------------------------------------------------------------------- +// Typedefs +//----------------------------------------------------------------------------- + +/** + * @typedef {import("esquery").Selector} ESQuerySelector + * @typedef {import("esquery").ESQueryOptions} ESQueryOptions + */ + +//------------------------------------------------------------------------------ +// Classes +//------------------------------------------------------------------------------ + +/** + * The result of parsing and analyzing an ESQuery selector. + */ +class ESQueryParsedSelector { + /** + * The raw selector string that was parsed + * @type {string} + */ + source; + + /** + * Whether this selector is an exit selector + * @type {boolean} + */ + isExit; + + /** + * An object (from esquery) describing the matching behavior of the selector + * @type {ESQuerySelector} + */ + root; + + /** + * The node types that could possibly trigger this selector, or `null` if all node types could trigger it + * @type {string[]|null} + */ + nodeTypes; + + /** + * The number of class, pseudo-class, and attribute queries in this selector + * @type {number} + */ + attributeCount; + + /** + * The number of identifier queries in this selector + * @type {number} + */ + identifierCount; + + /** + * Whether this selector is guaranteed to match any node it is tested + * against after node-type-based filtering, making an `esquery.matches()` + * call unnecessary. This is `true` only for selectors that consist solely + * of node type identifiers, wildcards, or unions thereof. + * @type {boolean} + */ + alwaysMatches; + + /** + * A specialized matcher function that is equivalent to calling + * `esquery.matches()` for this selector but faster, or `null` if no + * specialized matcher is available for this selector. + * @type {((node: Object, ancestry: Object[], options: ESQueryOptions) => boolean)|null} + */ + fastMatch; + + /** + * Creates a new parsed selector. + * @param {string} source The raw selector string that was parsed + * @param {boolean} isExit Whether this selector is an exit selector + * @param {ESQuerySelector} root An object (from esquery) describing the matching behavior of the selector + * @param {string[]|null} nodeTypes The node types that could possibly trigger this selector, or `null` if all node types could trigger it + * @param {number} attributeCount The number of class, pseudo-class, and attribute queries in this selector + * @param {number} identifierCount The number of identifier queries in this selector + * @param {boolean} alwaysMatches Whether this selector always matches nodes it is tested against after node-type-based filtering + * @param {Function|null} fastMatch A specialized matcher function for this selector, or `null` if not available + */ + constructor( + source, + isExit, + root, + nodeTypes, + attributeCount, + identifierCount, + alwaysMatches, + fastMatch, + ) { + this.source = source; + this.isExit = isExit; + this.root = root; + this.nodeTypes = nodeTypes; + this.attributeCount = attributeCount; + this.identifierCount = identifierCount; + this.alwaysMatches = alwaysMatches; + this.fastMatch = fastMatch; + } + + /** + * Compares this selector's specificity to another selector for sorting purposes. + * @param {ESQueryParsedSelector} otherSelector The selector to compare against + * @returns {number} + * a value less than 0 if this selector is less specific than otherSelector + * a value greater than 0 if this selector is more specific than otherSelector + * a value less than 0 if this selector and otherSelector have the same specificity, and this selector <= otherSelector alphabetically + * a value greater than 0 if this selector and otherSelector have the same specificity, and this selector > otherSelector alphabetically + */ + compare(otherSelector) { + return ( + this.attributeCount - otherSelector.attributeCount || + this.identifierCount - otherSelector.identifierCount || + (this.source <= otherSelector.source ? -1 : 1) + ); + } +} + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const selectorCache = new Map(); + +/** + * Computes the union of one or more arrays + * @param {...any[]} arrays One or more arrays to union + * @returns {any[]} The union of the input arrays + */ +function union(...arrays) { + return [...new Set(arrays.flat())]; +} + +/** + * Computes the intersection of one or more arrays + * @param {...any[]} arrays One or more arrays to intersect + * @returns {any[]} The intersection of the input arrays + */ +function intersection(...arrays) { + if (arrays.length === 0) { + return []; + } + + let result = [...new Set(arrays[0])]; + + for (const array of arrays.slice(1)) { + result = result.filter(x => array.includes(x)); + } + return result; +} + +/** + * Analyzes a parsed selector and returns combined data about it + * @param {ESQuerySelector} parsedSelector An object (from esquery) describing the matching behavior of the selector + * @returns {{nodeTypes:string[]|null, attributeCount:number, identifierCount:number}} Object containing selector data. + */ +function analyzeParsedSelector(parsedSelector) { + let attributeCount = 0; + let identifierCount = 0; + + /** + * Analyzes a selector and returns the node types that could possibly trigger it. + * @param {ESQuerySelector} selector The selector to analyze. + * @returns {string[]|null} The node types that could possibly trigger this selector, or `null` if all node types could trigger it + */ + function analyzeSelector(selector) { + switch (selector.type) { + case "identifier": + identifierCount++; + return [selector.value]; + + case "not": + selector.selectors.map(analyzeSelector); + return null; + + case "matches": { + const typesForComponents = + selector.selectors.map(analyzeSelector); + + if (typesForComponents.every(Boolean)) { + return union(...typesForComponents); + } + return null; + } + + case "compound": { + const typesForComponents = selector.selectors + .map(analyzeSelector) + .filter(typesForComponent => typesForComponent); + + // If all of the components could match any type, then the compound could also match any type. + if (!typesForComponents.length) { + return null; + } + + /* + * If at least one of the components could only match a particular type, the compound could only match + * the intersection of those types. + */ + return intersection(...typesForComponents); + } + + case "attribute": + case "field": + case "nth-child": + case "nth-last-child": + attributeCount++; + return null; + + case "child": + case "descendant": + case "sibling": + case "adjacent": + analyzeSelector(selector.left); + return analyzeSelector(selector.right); + + case "class": + // TODO: abstract into JSLanguage somehow + if (selector.name === "function") { + return [ + "FunctionDeclaration", + "FunctionExpression", + "ArrowFunctionExpression", + ]; + } + return null; + + default: + return null; + } + } + + const nodeTypes = analyzeSelector(parsedSelector); + + return { + nodeTypes, + attributeCount, + identifierCount, + }; +} + +/** + * Determines whether a parsed selector consists solely of node type + * identifiers, wildcards, or unions thereof. Such selectors are guaranteed to + * match any node they are tested against after node-type-based filtering, so + * calling `esquery.matches()` for them is unnecessary. + * @param {ESQuerySelector} selector The parsed selector to check. + * @returns {boolean} `true` if the selector always matches nodes it is tested against after node-type-based filtering. + */ +function isAlwaysMatchingSelector(selector) { + switch (selector.type) { + case "identifier": + case "wildcard": + return true; + + case "matches": + return selector.selectors.every(isAlwaysMatchingSelector); + + default: + return false; + } +} + +/** + * Creates a specialized matcher function for selectors of the shape + * `ParentType > .field` or `ParentType > *.field`, which are common in core + * rules but can't be bucketed by node type. The matcher replicates `esquery`'s + * matching behavior for these selectors: the parent (`ancestry[0]`) must have + * the given node type (case-insensitively, as `esquery` matches identifiers + * case-insensitively), and the node must be the value of the parent's given + * field (or an element of it, if the field value is an array). + * @param {ESQuerySelector} root The parsed selector to create a matcher for. + * @returns {Function|null} A matcher function, or `null` if the selector doesn't have the expected shape. + */ +function createFastMatcher(root) { + if (root.type !== "child") { + return null; + } + + const { left, right } = root; + + /* + * Subject indicators (`!`) are intentionally not checked here. `esquery` + * only consults `subject` in its `sibling` and `adjacent` matchers (and in + * `esquery.query()`, which ESLint doesn't use), so for the `child` + * selectors handled here a subject indicator has no effect on + * `esquery.matches()`. + */ + if (left.type !== "identifier") { + return null; + } + + let field = null; + + if (right.type === "field") { + field = right; + } else if (right.type === "compound" && right.selectors.length === 2) { + const [first, second] = right.selectors; + + if (first.type === "wildcard" && second.type === "field") { + field = second; + } + } + + /* + * Fields with a dotted name match against `ancestry[path.length - 1]` + * rather than the immediate parent, so they aren't handled here. + */ + if (!field || field.name.includes(".")) { + return null; + } + + const parentType = left.value; + const parentTypeLowercase = parentType.toLowerCase(); + const fieldName = field.name; + + return (node, ancestry, options) => { + const parent = ancestry[0]; + + if (!parent) { + return false; + } + + const parentTypeActual = parent[options?.nodeTypeKey || "type"]; + + if ( + parentTypeActual !== parentType && + (typeof parentTypeActual !== "string" || + parentTypeActual.toLowerCase() !== parentTypeLowercase) + ) { + return false; + } + + const value = parent[fieldName]; + + return value === node || (Array.isArray(value) && value.includes(node)); + }; +} + +/** + * Tries to parse a simple selector string, such as a single identifier or wildcard. + * This saves time by avoiding the overhead of esquery parsing for simple cases. + * @param {string} selector The selector string to parse. + * @returns {Object|null} An object describing the selector if it is simple, or `null` if it is not. + */ +function trySimpleParseSelector(selector) { + if (selector === "*") { + return { + type: "wildcard", + value: "*", + }; + } + + if (/^[a-z]+$/iu.test(selector)) { + return { + type: "identifier", + value: selector, + }; + } + + return null; +} + +/** + * Parses a raw selector string, and throws a useful error if parsing fails. + * @param {string} selector The selector string to parse. + * @returns {Object} An object (from esquery) describing the matching behavior of this selector + * @throws {Error} An error if the selector is invalid + */ +function tryParseSelector(selector) { + try { + return esquery.parse(selector); + } catch (err) { + if ( + err.location && + err.location.start && + typeof err.location.start.offset === "number" + ) { + throw new SyntaxError( + `Syntax error in selector "${selector}" at position ${err.location.start.offset}: ${err.message}`, + { + cause: err, + }, + ); + } + throw err; + } +} + +/** + * Parses a raw selector string, and returns the parsed selector along with specificity and type information. + * @param {string} source A raw AST selector + * @returns {ESQueryParsedSelector} A selector descriptor + */ +function parse(source) { + if (selectorCache.has(source)) { + return selectorCache.get(source); + } + + const cleanSource = source.replace(/:exit$/u, ""); + const parsedSelector = + trySimpleParseSelector(cleanSource) ?? tryParseSelector(cleanSource); + const { nodeTypes, attributeCount, identifierCount } = + analyzeParsedSelector(parsedSelector); + + const result = new ESQueryParsedSelector( + source, + source.endsWith(":exit"), + parsedSelector, + nodeTypes, + attributeCount, + identifierCount, + isAlwaysMatchingSelector(parsedSelector), + createFastMatcher(parsedSelector), + ); + + selectorCache.set(source, result); + return result; +} + +/** + * Checks if a node matches a given selector. + * @param {Object} node The node to check against the selector. + * @param {ESQuerySelector} root The root of the selector to match against. + * @param {Object[]} ancestry The ancestry of the node being checked, which is an array of nodes from the current node to the root. + * @param {ESQueryOptions} options The options to use for matching. + * @returns {boolean} `true` if the node matches the selector, `false` otherwise. + */ +function matches(node, root, ancestry, options) { + return esquery.matches(node, root, ancestry, options); +} + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { + parse, + matches, + ESQueryParsedSelector, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-context.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-context.js new file mode 100644 index 00000000..ff3ac9ee --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-context.js @@ -0,0 +1,88 @@ +/** + * @fileoverview The FileContext class. + * @author Nicholas C. Zakas + */ + +"use strict"; + +/** + * Represents a file context that the linter can use to lint a file. + */ +class FileContext { + /** + * The current working directory. + * @type {string} + */ + cwd; + + /** + * The filename of the file being linted. + * @type {string} + */ + filename; + + /** + * The physical filename of the file being linted. + * @type {string} + */ + physicalFilename; + + /** + * The source code of the file being linted. + * @type {SourceCode} + */ + sourceCode; + + /** + * The language options used when parsing this file. + * @type {Record} + */ + languageOptions; + + /** + * The settings for the file being linted. + * @type {Record} + */ + settings; + + /** + * Creates a new instance. + * @param {Object} config The configuration object for the file context. + * @param {string} config.cwd The current working directory. + * @param {string} config.filename The filename of the file being linted. + * @param {string} config.physicalFilename The physical filename of the file being linted. + * @param {SourceCode} config.sourceCode The source code of the file being linted. + * @param {Record} config.languageOptions The language options used when parsing this file. + * @param {Record} config.settings The settings for the file being linted. + */ + constructor({ + cwd, + filename, + physicalFilename, + sourceCode, + languageOptions, + settings, + }) { + this.cwd = cwd; + this.filename = filename; + this.physicalFilename = physicalFilename; + this.sourceCode = sourceCode; + this.languageOptions = languageOptions; + this.settings = settings; + + Object.freeze(this); + } + + /** + * Creates a new object with the current object as the prototype and + * the specified properties as its own properties. + * @param {Object} extension The properties to add to the new object. + * @returns {FileContext} A new object with the current object as the prototype + * and the specified properties as its own properties. + */ + extend(extension) { + return Object.freeze(Object.assign(Object.create(this), extension)); + } +} + +exports.FileContext = FileContext; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-report.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-report.js new file mode 100644 index 00000000..94fe2fa8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/file-report.js @@ -0,0 +1,633 @@ +/** + * @fileoverview A class to track messages reported by the linter for a file. + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const assert = require("../shared/assert"); +const { RuleFixer } = require("./rule-fixer"); +const { interpolate } = require("./interpolate"); +const ruleReplacements = require("../../conf/replacements.json"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../types").Linter.LintSuggestion} SuggestionResult */ +/** @typedef {import("@eslint/core").Language} Language */ +/** @typedef {import("@eslint/core").SourceLocation} SourceLocation */ + +/** + * An error message description + * @typedef {Object} MessageDescriptor + * @property {ASTNode} [node] The reported node + * @property {Location} loc The location of the problem. + * @property {string} message The problem message. + * @property {Object} [data] Optional data to use to fill in placeholders in the + * message. + * @property {Function} [fix] The function to call that creates a fix command. + * @property {Array<{desc?: string, messageId?: string, fix: Function}>} suggest Suggestion descriptions and functions to create a the associated fixes. + */ + +/** + * @typedef {Object} LintProblem + * @property {string} ruleId The rule ID that reported the problem. + * @property {string} message The problem message. + * @property {SourceLocation} loc The location of the problem. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const DEFAULT_ERROR_LOC = { + start: { line: 1, column: 0 }, + end: { line: 1, column: 1 }, +}; + +/** + * Updates a given location based on the language offsets. This allows us to + * change 0-based locations to 1-based locations. We always want ESLint + * reporting lines and columns starting from 1. + * @todo Potentially this should be moved into a shared utility file. + * @param {Object} location The location to update. + * @param {number} location.line The starting line number. + * @param {number} location.column The starting column number. + * @param {number} [location.endLine] The ending line number. + * @param {number} [location.endColumn] The ending column number. + * @param {Language} language The language to use to adjust the location information. + * @returns {Object} The updated location. + */ +function updateLocationInformation( + { line, column, endLine, endColumn }, + language, +) { + const columnOffset = language.columnStart === 1 ? 0 : 1; + const lineOffset = language.lineStart === 1 ? 0 : 1; + + // calculate separately to account for undefined + const finalEndLine = endLine === void 0 ? endLine : endLine + lineOffset; + const finalEndColumn = + endColumn === void 0 ? endColumn : endColumn + columnOffset; + + return { + line: line + lineOffset, + column: column + columnOffset, + endLine: finalEndLine, + endColumn: finalEndColumn, + }; +} + +/** + * creates a missing-rule message. + * @param {string} ruleId the ruleId to create + * @returns {string} created error message + * @private + */ +function createMissingRuleMessage(ruleId) { + return Object.hasOwn(ruleReplacements.rules, ruleId) + ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}` + : `Definition for rule '${ruleId}' was not found.`; +} + +/** + * creates a linting problem + * @param {LintProblem} options to create linting error + * @param {RuleSeverity} severity the error message to report + * @param {Language} language the language to use to adjust the location information. + * @returns {LintMessage} created problem, returns a missing-rule problem if only provided ruleId. + * @private + */ +function createLintingProblem(options, severity, language) { + const { + ruleId = null, + loc = DEFAULT_ERROR_LOC, + message = createMissingRuleMessage(options.ruleId), + } = options; + + return { + ruleId, + message, + ...updateLocationInformation( + { + line: loc.start.line, + column: loc.start.column, + endLine: loc.end.line, + endColumn: loc.end.column, + }, + language, + ), + severity, + }; +} + +/** + * Translates a multi-argument context.report() call into a single object argument call + * @param {...*} args A list of arguments passed to `context.report` + * @returns {MessageDescriptor} A normalized object containing report information + */ +function normalizeMultiArgReportCall(...args) { + /* + * If there is one argument, it is considered to be a new-style call + * already. The descriptor is fully consumed synchronously before + * `addRuleMessage()` returns and is never mutated or retained, so it's + * safe to use without cloning even if the rule reuses the object. + */ + if (args.length === 1) { + return args[0]; + } + + // If the second argument is a string, the arguments are interpreted as [node, message, data, fix]. + if (typeof args[1] === "string") { + return { + node: args[0], + message: args[1], + data: args[2], + fix: args[3], + }; + } + + // Otherwise, the arguments are interpreted as [node, loc, message, data, fix]. + return { + node: args[0], + loc: args[1], + message: args[2], + data: args[3], + fix: args[4], + }; +} + +/** + * Asserts that either a loc or a node was provided, and the node is valid if it was provided. + * @param {MessageDescriptor} descriptor A descriptor to validate + * @returns {void} + * @throws AssertionError if neither a node nor a loc was provided, or if the node is not an object + */ +function assertValidNodeInfo(descriptor) { + if (descriptor.node) { + assert(typeof descriptor.node === "object", "Node must be an object"); + } else { + assert( + descriptor.loc, + "Node must be provided when reporting error if location is not provided", + ); + } +} + +/** + * Normalizes a MessageDescriptor to always have a `loc` with `start` and `end` properties + * @param {MessageDescriptor} descriptor A descriptor for the report from a rule. + * @returns {{start: Location, end: (Location|null)}} An updated location that infers the `start` and `end` properties + * from the `node` of the original descriptor, or infers the `start` from the `loc` of the original descriptor. + */ +function normalizeReportLoc(descriptor) { + if (descriptor.loc.start) { + return descriptor.loc; + } + return { start: descriptor.loc, end: null }; +} + +/** + * Clones the given fix object. + * @param {Fix|null} fix The fix to clone. + * @returns {Fix|null} Deep cloned fix object or `null` if `null` or `undefined` was passed in. + */ +function cloneFix(fix) { + if (!fix) { + return null; + } + + return { + range: [fix.range[0], fix.range[1]], + text: fix.text, + }; +} + +/** + * Check that a fix has a valid range. + * @param {Fix|null} fix The fix to validate. + * @returns {void} + */ +function assertValidFix(fix) { + if (fix) { + /* + * The error message is built only when the assertion fails so that + * the common case doesn't pay for the `JSON.stringify()` call. + */ + if (!( + fix.range && + typeof fix.range[0] === "number" && + typeof fix.range[1] === "number" + )) { + assert( + false, + `Fix has invalid range: ${JSON.stringify(fix, null, 2)}`, + ); + } + } +} + +/** + * Compares items in a fixes array by range. + * @param {Fix} a The first message. + * @param {Fix} b The second message. + * @returns {number} -1 if a comes before b, 1 if a comes after b, 0 if equal. + * @private + */ +function compareFixesByRange(a, b) { + return a.range[0] - b.range[0] || a.range[1] - b.range[1]; +} + +/** + * Merges the given fixes array into one. + * @param {Fix[]} fixes The fixes to merge. + * @param {SourceCode} sourceCode The source code object to get the text between fixes. + * @returns {{text: string, range: number[]}} The merged fixes + */ +function mergeFixes(fixes, sourceCode) { + for (const fix of fixes) { + assertValidFix(fix); + } + + if (fixes.length === 0) { + return null; + } + if (fixes.length === 1) { + return cloneFix(fixes[0]); + } + + fixes.sort(compareFixesByRange); + + const originalText = sourceCode.text; + const start = fixes[0].range[0]; + const end = fixes.at(-1).range[1]; + let text = ""; + let lastPos = Number.MIN_SAFE_INTEGER; + + for (const fix of fixes) { + assert( + fix.range[0] >= lastPos, + "Fix objects must not be overlapped in a report.", + ); + + if (fix.range[0] >= 0) { + text += originalText.slice( + Math.max(0, start, lastPos), + fix.range[0], + ); + } + text += fix.text; + lastPos = fix.range[1]; + } + text += originalText.slice(Math.max(0, start, lastPos), end); + + return { range: [start, end], text }; +} + +/** + * Gets one fix object from the given descriptor. + * If the descriptor retrieves multiple fixes, this merges those to one. + * @param {MessageDescriptor} descriptor The report descriptor. + * @param {SourceCode} sourceCode The source code object to get text between fixes. + * @param {RuleFixer} ruleFixer The rule fixer to pass to the descriptor's `fix` function. + * @returns {({text: string, range: number[]}|null)} The fix for the descriptor + */ +function normalizeFixes(descriptor, sourceCode, ruleFixer) { + if (typeof descriptor.fix !== "function") { + return null; + } + + // @type {null | Fix | Fix[] | IterableIterator} + const fix = descriptor.fix(ruleFixer); + + // Merge to one. + if (fix && Symbol.iterator in fix) { + return mergeFixes(Array.from(fix), sourceCode); + } + + assertValidFix(fix); + return cloneFix(fix); +} + +/** + * Gets an array of suggestion objects from the given descriptor. + * @param {MessageDescriptor} descriptor The report descriptor. + * @param {SourceCode} sourceCode The source code object to get text between fixes. + * @param {Object} messages Object of meta messages for the rule. + * @param {RuleFixer} ruleFixer The rule fixer to pass to suggestions' `fix` functions. + * @returns {Array} The suggestions for the descriptor + */ +function mapSuggestions(descriptor, sourceCode, messages, ruleFixer) { + if (!descriptor.suggest || !Array.isArray(descriptor.suggest)) { + return []; + } + + return ( + descriptor.suggest + .map(suggestInfo => { + const computedDesc = + suggestInfo.desc || messages[suggestInfo.messageId]; + + return { + ...suggestInfo, + desc: interpolate(computedDesc, suggestInfo.data), + fix: normalizeFixes(suggestInfo, sourceCode, ruleFixer), + }; + }) + + // Remove suggestions that didn't provide a fix + .filter(({ fix }) => fix) + ); +} + +/** + * Creates information about the report from a descriptor + * @param {Object} options Information about the problem + * @param {string} options.ruleId Rule ID + * @param {(0|1|2)} options.severity Rule severity + * @param {string} options.message Error message + * @param {string} [options.messageId] The error message ID. + * @param {{start: SourceLocation, end: (SourceLocation|null)}} options.loc Start and end location + * @param {{text: string, range: (number[]|null)}} options.fix The fix object + * @param {Array<{text: string, range: (number[]|null)}>} options.suggestions The array of suggestions objects + * @param {Language} [options.language] The language to use to adjust line and column offsets. + * @returns {LintMessage} Information about the report + */ +function createProblem(options) { + const { language } = options; + + // calculate offsets based on the language in use + const columnOffset = language.columnStart === 1 ? 0 : 1; + const lineOffset = language.lineStart === 1 ? 0 : 1; + + const problem = { + ruleId: options.ruleId, + severity: options.severity, + message: options.message, + line: options.loc.start.line + lineOffset, + column: options.loc.start.column + columnOffset, + }; + + /* + * If this isn’t in the conditional, some of the tests fail + * because `messageId` is present in the problem object + */ + if (options.messageId) { + problem.messageId = options.messageId; + } + + if (options.loc.end) { + problem.endLine = options.loc.end.line + lineOffset; + problem.endColumn = options.loc.end.column + columnOffset; + } + + if (options.fix) { + problem.fix = options.fix; + } + + if (options.suggestions && options.suggestions.length > 0) { + problem.suggestions = options.suggestions; + } + + return problem; +} + +/** + * Validates that suggestions are properly defined. Throws if an error is detected. + * @param {Array<{ desc?: string, messageId?: string }>} suggest The incoming suggest data. + * @param {Object} messages Object of meta messages for the rule. + * @returns {void} + */ +function validateSuggestions(suggest, messages) { + if (suggest && Array.isArray(suggest)) { + suggest.forEach(suggestion => { + if (suggestion.messageId) { + const { messageId } = suggestion; + + if (!messages) { + throw new TypeError( + `context.report() called with a suggest option with a messageId '${messageId}', but no messages were present in the rule metadata.`, + ); + } + + if (!messages[messageId]) { + throw new TypeError( + `context.report() called with a suggest option with a messageId '${messageId}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`, + ); + } + + if (suggestion.desc) { + throw new TypeError( + "context.report() called with a suggest option that defines both a 'messageId' and an 'desc'. Please only pass one.", + ); + } + } else if (!suggestion.desc) { + throw new TypeError( + "context.report() called with a suggest option that doesn't have either a `desc` or `messageId`", + ); + } + + if (typeof suggestion.fix !== "function") { + throw new TypeError( + `context.report() called with a suggest option without a fix function. See: ${JSON.stringify(suggestion, null, 2)}`, + ); + } + }); + } +} + +/** + * Computes the message from a report descriptor. + * @param {MessageDescriptor} descriptor The report descriptor. + * @param {Object} messages Object of meta messages for the rule. + * @returns {string} The computed message. + * @throws {TypeError} If messageId is not found or both message and messageId are provided. + */ +function computeMessageFromDescriptor(descriptor, messages) { + if (descriptor.messageId) { + if (!messages) { + throw new TypeError( + "context.report() called with a messageId, but no messages were present in the rule metadata.", + ); + } + const id = descriptor.messageId; + + if (descriptor.message) { + throw new TypeError( + "context.report() called with a message and a messageId. Please only pass one.", + ); + } + if (!messages || !Object.hasOwn(messages, id)) { + throw new TypeError( + `context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`, + ); + } + return messages[id]; + } + + if (descriptor.message) { + return descriptor.message; + } + + throw new TypeError( + "Missing `message` property in report() call; add a message that describes the linting problem.", + ); +} + +/** + * A report object that contains the messages reported the linter + * for a file. + */ +class FileReport { + /** + * The messages reported by the linter for this file. + * @type {LintMessage[]} + */ + messages = []; + + /** + * A rule mapper that maps rule IDs to their metadata. + * @type {(string) => RuleDefinition} + */ + #ruleMapper; + + /** + * The source code object for the file. + * @type {SourceCode} + */ + #sourceCode; + + /** + * The language to use to adjust line and column offsets. + * @type {Language} + */ + #language; + + /** + * Whether to disable fixes for this report. + * @type {boolean} + */ + #disableFixes; + + /** + * The rule fixer to pass to rules' `fix` functions. `RuleFixer` is + * stateless, so a single instance is shared by all messages in this + * report to avoid allocating one per fix. + * @type {RuleFixer|undefined} + */ + #ruleFixer; + + /** + * Creates a new FileReport instance. + * @param {Object} options The options for the file report + * @param {(string) => RuleDefinition} options.ruleMapper A rule mapper that maps rule IDs to their metadata. + * @param {SourceCode} options.sourceCode The source code object for the file. + * @param {Language} options.language The language to use to adjust line and column offsets. + * @param {boolean} [options.disableFixes=false] Whether to disable fixes for this report. + */ + constructor({ ruleMapper, sourceCode, language, disableFixes = false }) { + this.#ruleMapper = ruleMapper; + this.#sourceCode = sourceCode; + this.#language = language; + this.#disableFixes = disableFixes; + } + + /** + * Adds a rule-generated message to the report. + * @param {string} ruleId The rule ID that reported the problem. + * @param {0|1|2} severity The severity of the problem (0 = off, 1 = warning, 2 = error). + * @param {...*} args The arguments passed to `context.report()`. + * @returns {LintMessage} The created message object. + * @throws {TypeError} If the messageId is not found or both message and messageId are provided. + * @throws {AssertionError} If the node is not an object or neither a node nor a loc is provided. + */ + addRuleMessage(ruleId, severity, ...args) { + const descriptor = normalizeMultiArgReportCall(...args); + const ruleDefinition = this.#ruleMapper(ruleId); + const messages = ruleDefinition?.meta?.messages; + + assertValidNodeInfo(descriptor); + + const computedMessage = computeMessageFromDescriptor( + descriptor, + messages, + ); + + validateSuggestions(descriptor.suggest, messages); + + if (!this.#disableFixes && this.#ruleFixer === void 0) { + this.#ruleFixer = new RuleFixer({ sourceCode: this.#sourceCode }); + } + + const problem = createProblem({ + ruleId, + severity, + message: interpolate(computedMessage, descriptor.data), + messageId: descriptor.messageId, + loc: descriptor.loc + ? normalizeReportLoc(descriptor) + : this.#sourceCode.getLoc(descriptor.node), + fix: this.#disableFixes + ? null + : normalizeFixes(descriptor, this.#sourceCode, this.#ruleFixer), + suggestions: this.#disableFixes + ? [] + : mapSuggestions( + descriptor, + this.#sourceCode, + messages, + this.#ruleFixer, + ), + language: this.#language, + }); + + this.messages.push(problem); + + return problem; + } + + /** + * Adds an error message to the report. Meant to be called outside of rules. + * @param {LintProblem} descriptor The descriptor for the error message. + * @returns {LintMessage} The created message object. + */ + addError(descriptor) { + const message = createLintingProblem(descriptor, 2, this.#language); + this.messages.push(message); + return message; + } + + /** + * Adds a fatal error message to the report. Meant to be called outside of rules. + * @param {LintProblem} descriptor The descriptor for the fatal error message. + * @returns {LintMessage} The created message object. + */ + addFatal(descriptor) { + const message = createLintingProblem(descriptor, 2, this.#language); + message.fatal = true; + this.messages.push(message); + return message; + } + + /** + * Adds a warning message to the report. Meant to be called outside of rules. + * @param {LintProblem} descriptor The descriptor for the warning message. + * @returns {LintMessage} The created message object. + */ + addWarning(descriptor) { + const message = createLintingProblem(descriptor, 1, this.#language); + this.messages.push(message); + return message; + } +} + +module.exports = { + FileReport, + updateLocationInformation, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/index.js new file mode 100644 index 00000000..5a86f71c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/index.js @@ -0,0 +1,11 @@ +"use strict"; + +const { Linter } = require("./linter"); +const SourceCodeFixer = require("./source-code-fixer"); + +module.exports = { + Linter, + + // For testers. + SourceCodeFixer, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/interpolate.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/interpolate.js new file mode 100644 index 00000000..1de9133b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/interpolate.js @@ -0,0 +1,67 @@ +/** + * @fileoverview Interpolate keys from an object into a string with {{ }} markers. + * @author Jed Fox + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Returns a global expression matching placeholders in messages. + * @returns {RegExp} Global regular expression matching placeholders + */ +function getPlaceholderMatcher() { + return /\{\{([^{}]+)\}\}/gu; +} + +/** + * A shared placeholder matcher used by `interpolate()`. + * @type {RegExp} + */ +const PLACEHOLDER_MATCHER = getPlaceholderMatcher(); + +/** + * Replaces {{ placeholders }} in the message with the provided data. + * Does not replace placeholders not available in the data. + * @param {string} text Original message with potential placeholders + * @param {Record} data Map of placeholder name to its value + * @returns {string} Message with replaced placeholders + */ +function interpolate(text, data) { + if (!data) { + return text; + } + + // Fast path: avoid the regex when there are no placeholders. + if (!text.includes("{{")) { + return text; + } + + /* + * Note: `String#replace()` doesn't depend on or retain `lastIndex` state, + * so a shared regex is safe here and avoids creating a new regex for + * every message. + */ + // Substitution content for any {{ }} markers. + return text.replace( + PLACEHOLDER_MATCHER, + (fullMatch, termWithWhitespace) => { + const term = termWithWhitespace.trim(); + + if (term in data) { + return data[term]; + } + + // Preserve old behavior: If parameter name not provided, don't replace it. + return fullMatch; + }, + ); +} + +module.exports = { + getPlaceholderMatcher, + interpolate, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/linter.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/linter.js new file mode 100644 index 00000000..7acf824d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/linter.js @@ -0,0 +1,1668 @@ +/** + * @fileoverview Main Linter Class + * @author Gyandeep Singh + * @author aladdin-add + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const path = require("node:path"), + eslintScope = require("eslint-scope"), + evk = require("eslint-visitor-keys"), + pkg = require("../../package.json"), + Traverser = require("../shared/traverser"), + { SourceCode } = require("../languages/js/source-code"), + applyDisableDirectives = require("./apply-disable-directives"), + { ConfigCommentParser } = require("@eslint/plugin-kit"), + SourceCodeFixer = require("./source-code-fixer"), + { + SourceCodeVisitor, + getListenerRuleId, + setListenerRuleId, + attachRuleId, + } = require("./source-code-visitor"), + timing = require("./timing"); +const { FlatConfigArray } = require("../config/flat-config-array"); +const { startTime, endTime } = require("../shared/stats"); +const { assertIsRuleSeverity } = require("../config/flat-config-schema"); +const { + normalizeSeverityToString, + normalizeSeverityToNumber, +} = require("../shared/severity"); +const { deepMergeArrays } = require("../shared/deep-merge-arrays"); +const { + activeFlags, + inactiveFlags, + getInactivityReasonMessage, +} = require("../shared/flags"); +const debug = require("debug")("eslint:linter"); +const MAX_AUTOFIX_PASSES = 10; +const DEFAULT_ECMA_VERSION = 5; +const commentParser = new ConfigCommentParser(); +const { VFile } = require("./vfile"); +const { ParserService } = require("../services/parser-service"); +const { FileContext } = require("./file-context"); +const { ProcessorService } = require("../services/processor-service"); +const { containsDifferentProperty } = require("../shared/option-utils"); +const { Config } = require("../config/config"); +const { WarningService } = require("../services/warning-service"); +const { SourceCodeTraverser } = require("./source-code-traverser"); +const { FileReport, updateLocationInformation } = require("./file-report"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @import { Language, LanguageOptions, RuleConfig, RuleDefinition } from "@eslint/core" */ + +/** @typedef {import("../types").Linter.Config} ConfigObject */ +/** @typedef {import("../types").Linter.LanguageOptions} JSLanguageOptions */ +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../types").Linter.Parser} Parser */ +/** @typedef {import("../types").Linter.ParserOptions} ParserOptions */ +/** @typedef {import("../types").Linter.Processor} Processor */ +/** @typedef {import("../types").Rule.RuleModule} Rule */ +/** @typedef {import("../types").Linter.StringSeverity} StringSeverity */ +/** @typedef {import("../types").Linter.SuppressedLintMessage} SuppressedLintMessage */ +/** @typedef {import("../types").Linter.TimePass} TimePass */ + +/* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */ +/** + * @template T + * @typedef {{ [P in keyof T]-?: T[P] }} Required + */ +/* eslint-enable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */ + +/** + * @typedef {Object} DisableDirective + * @property {("disable"|"enable"|"disable-line"|"disable-next-line")} type Type of directive + * @property {number} line The line number + * @property {number} column The column number + * @property {(string|null)} ruleId The rule ID + * @property {string} justification The justification of directive + */ + +/** + * The private data for `Linter` instance. + * @typedef {Object} LinterInternalSlots + * @property {FlatConfigArray|null} lastConfigArray The `ConfigArray` instance that the last `verify()` call used. + * @property {SourceCode|null} lastSourceCode The `SourceCode` instance that the last `verify()` call used. + * @property {SuppressedLintMessage[]} lastSuppressedMessages The `SuppressedLintMessage[]` instance that the last `verify()` call produced. + * @property {{ passes: TimePass[]; }} times The times spent on applying a rule to a file (see `stats` option). + * @property {WarningService} warningService The warning service. + */ + +/** + * @typedef {Object} VerifyOptions + * @property {boolean} [allowInlineConfig] Allow/disallow inline comments' ability + * to change config once it is set. Defaults to true if not supplied. + * Useful if you want to validate JS without comments overriding rules. + * @property {boolean} [disableFixes] if `true` then the linter doesn't make `fix` + * properties into the lint result. + * @property {string} [filename] the filename of the source code. + * @property {boolean | "off" | "warn" | "error"} [reportUnusedDisableDirectives] Adds reported errors for + * unused `eslint-disable` directives. + * @property {Function} [ruleFilter] A predicate function that determines whether a given rule should run. + */ + +/** + * @typedef {Object} ProcessorOptions + * @property {(filename:string, text:string) => boolean} [filterCodeBlock] the + * predicate function that selects adopt code blocks. + * @property {Processor.postprocess} [postprocess] postprocessor for report + * messages. If provided, this should accept an array of the message lists + * for each code block returned from the preprocessor, apply a mapping to + * the messages as appropriate, and return a one-dimensional array of + * messages. + * @property {Processor.preprocess} [preprocess] preprocessor for source text. + * If provided, this should accept a string of source text, and return an + * array of code blocks to lint. + */ + +/** + * @typedef {Object} FixOptions + * @property {boolean | ((message: LintMessage) => boolean)} [fix] Determines + * whether fixes should be applied. + */ + +/** + * @typedef {Object} InternalOptions + * @property {string | null} warnInlineConfig The config name what `noInlineConfig` setting came from. If `noInlineConfig` setting didn't exist, this is null. If this is a config name, then the linter warns directive comments. + * @property {StringSeverity} reportUnusedDisableDirectives Severity to report unused disable directives, if not "off" (boolean values were normalized). + * @property {StringSeverity} reportUnusedInlineConfigs Severity to report unused inline configs, if not "off". + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Wraps the value in an Array if it isn't already one. + * @template T + * @param {T|T[]} value Value to be wrapped. + * @returns {Array} The value as an array. + */ +function asArray(value) { + return Array.isArray(value) ? value : [value]; +} + +/** + * Pushes a problem to inlineConfigProblems if ruleOptions are redundant. + * @param {Config} config Provided config. + * @param {Object} loc A line/column location + * @param {FileReport} report Report that may be added to. + * @param {string} ruleId The rule ID. + * @param {Array} ruleOptions The rule options, merged with the config's. + * @param {Array} ruleOptionsInline The rule options from the comment. + * @param {"error"|"warn"} severity The severity to report. + * @returns {void} + */ +function addProblemIfSameSeverityAndOptions( + config, + loc, + report, + ruleId, + ruleOptions, + ruleOptionsInline, + severity, +) { + const existingConfigRaw = config.rules?.[ruleId]; + const existingConfig = existingConfigRaw + ? asArray(existingConfigRaw) + : ["off"]; + const existingSeverity = normalizeSeverityToString(existingConfig[0]); + const inlineSeverity = normalizeSeverityToString(ruleOptions[0]); + const sameSeverity = existingSeverity === inlineSeverity; + + if (!sameSeverity) { + return; + } + + const alreadyConfigured = existingConfigRaw + ? `is already configured to '${existingSeverity}'` + : "is not enabled so can't be turned off"; + let message; + + if ( + (existingConfig.length === 1 && ruleOptions.length === 1) || + existingSeverity === "off" + ) { + message = `Unused inline config ('${ruleId}' ${alreadyConfigured}).`; + } else if ( + !containsDifferentProperty( + ruleOptions.slice(1), + existingConfig.slice(1), + ) + ) { + message = + ruleOptionsInline.length === 1 + ? `Unused inline config ('${ruleId}' ${alreadyConfigured}).` + : `Unused inline config ('${ruleId}' ${alreadyConfigured} with the same options).`; + } + + if (message) { + const numericSeverity = normalizeSeverityToNumber(severity); + const descriptor = { + message, + loc, + }; + + if (numericSeverity === 1) { + report.addWarning(descriptor); + } else if (numericSeverity === 2) { + report.addError(descriptor); + } + } +} + +/** + * Creates a collection of disable directives from a comment + * @param {Object} options to create disable directives + * @param {("disable"|"enable"|"disable-line"|"disable-next-line")} options.type The type of directive comment + * @param {string} options.value The value after the directive in the comment + * comment specified no specific rules, so it applies to all rules (e.g. `eslint-disable`) + * @param {string} options.justification The justification of the directive + * @param {ASTNode|token} options.node The Comment node/token. + * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules + * @param {Language} language The language to use to adjust the location information. + * @param {SourceCode} sourceCode The SourceCode object to get comments from. + * @param {FileReport} report The report to add problems to. + * @returns {Object[]} Directives from the comment + */ +function createDisableDirectives( + { type, value, justification, node }, + ruleMapper, + language, + sourceCode, + report, +) { + const ruleIds = Object.keys(commentParser.parseListConfig(value)); + const directiveRules = ruleIds.length ? ruleIds : [null]; + const directives = []; // valid disable directives + const parentDirective = { node, value, ruleIds }; + + for (const ruleId of directiveRules) { + const loc = sourceCode.getLoc(node); + + // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/) + if (ruleId === null || !!ruleMapper(ruleId)) { + if (type === "disable-next-line") { + const { line, column } = updateLocationInformation( + loc.end, + language, + ); + + directives.push({ + parentDirective, + type, + line, + column, + ruleId, + justification, + }); + } else { + const { line, column } = updateLocationInformation( + loc.start, + language, + ); + + directives.push({ + parentDirective, + type, + line, + column, + ruleId, + justification, + }); + } + } else { + report.addError({ ruleId, loc }); + } + } + + return directives; +} + +/** + * Parses comments in file to extract disable directives. + * @param {SourceCode} sourceCode The SourceCode object to get comments from. + * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules + * @param {Language} language The language to use to adjust the location information + * @param {FileReport} report The report to add problems to. + * @returns {DisableDirective[]} + * A collection of the directive comments that were found, along with any problems that occurred when parsing + */ +function getDirectiveCommentsForFlatConfig( + sourceCode, + ruleMapper, + language, + report, +) { + const disableDirectives = []; + + if (sourceCode.getDisableDirectives) { + const { directives: directivesSources, problems: directivesProblems } = + sourceCode.getDisableDirectives(); + + if (Array.isArray(directivesProblems)) { + directivesProblems.forEach(problem => report.addError(problem)); + } + + directivesSources.forEach(directive => { + const directives = createDisableDirectives( + directive, + ruleMapper, + language, + sourceCode, + report, + ); + + disableDirectives.push(...directives); + }); + } + + return disableDirectives; +} + +/** + * Convert "/path/to/" to "". + * `CLIEngine#executeOnText()` method gives "/path/to/" if the filename + * was omitted because `configArray.extractConfig()` requires an absolute path. + * But the linter should pass `` to `RuleContext#filename` in that + * case. + * Also, code blocks can have their virtual filename. If the parent filename was + * ``, the virtual filename is `/0_foo.js` or something like (i.e., + * it's not an absolute path). + * @param {string} filename The filename to normalize. + * @returns {string} The normalized filename. + */ +function normalizeFilename(filename) { + const parts = filename.split(path.sep); + const index = parts.lastIndexOf(""); + + return index === -1 ? filename : parts.slice(index).join(path.sep); +} + +/** + * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a + * consistent shape. + * @param {VerifyOptions} providedOptions Options + * @param {Config} config Config. + * @returns {Required & InternalOptions} Normalized options + */ +function normalizeVerifyOptions(providedOptions, config) { + const linterOptions = config.linterOptions || config; + const disableInlineConfig = linterOptions.noInlineConfig === true; + const ignoreInlineConfig = providedOptions.allowInlineConfig === false; + const configNameOfNoInlineConfig = config.configNameOfNoInlineConfig + ? ` (${config.configNameOfNoInlineConfig})` + : ""; + + let reportUnusedDisableDirectives = + providedOptions.reportUnusedDisableDirectives; + + if (typeof reportUnusedDisableDirectives === "boolean") { + reportUnusedDisableDirectives = reportUnusedDisableDirectives + ? "error" + : "off"; + } + if (typeof reportUnusedDisableDirectives !== "string") { + if (typeof linterOptions.reportUnusedDisableDirectives === "boolean") { + reportUnusedDisableDirectives = + linterOptions.reportUnusedDisableDirectives ? "warn" : "off"; + } else { + reportUnusedDisableDirectives = + linterOptions.reportUnusedDisableDirectives === void 0 + ? "off" + : normalizeSeverityToString( + linterOptions.reportUnusedDisableDirectives, + ); + } + } + + const reportUnusedInlineConfigs = + linterOptions.reportUnusedInlineConfigs === void 0 + ? "off" + : normalizeSeverityToString( + linterOptions.reportUnusedInlineConfigs, + ); + + let ruleFilter = providedOptions.ruleFilter; + + if (typeof ruleFilter !== "function") { + ruleFilter = () => true; + } + + return { + filename: normalizeFilename(providedOptions.filename || ""), + allowInlineConfig: !ignoreInlineConfig, + warnInlineConfig: + disableInlineConfig && !ignoreInlineConfig + ? `your config${configNameOfNoInlineConfig}` + : null, + reportUnusedDisableDirectives, + reportUnusedInlineConfigs, + disableFixes: Boolean(providedOptions.disableFixes), + stats: providedOptions.stats, + ruleFilter, + }; +} + +/** + * Store time measurements in map + * @param {number} time Time measurement + * @param {Object} timeOpts Options relating which time was measured + * @param {WeakMap} slots Linter internal slots map + * @returns {void} + */ +function storeTime(time, timeOpts, slots) { + const { type, key } = timeOpts; + + if (!slots.times) { + slots.times = { passes: [{}] }; + } + + const passIndex = slots.fixPasses; + + if (passIndex > slots.times.passes.length - 1) { + slots.times.passes.push({}); + } + + if (key) { + slots.times.passes[passIndex][type] ??= {}; + slots.times.passes[passIndex][type][key] ??= { total: 0 }; + slots.times.passes[passIndex][type][key].total += time; + } else { + slots.times.passes[passIndex][type] ??= { total: 0 }; + slots.times.passes[passIndex][type].total += time; + } +} + +/** + * Get the options for a rule (not including severity), if any + * @param {RuleConfig} ruleConfig rule configuration + * @param {Object|undefined} defaultOptions rule.meta.defaultOptions + * @returns {Array} of rule options, empty Array if none + */ +function getRuleOptions(ruleConfig, defaultOptions) { + if (Array.isArray(ruleConfig)) { + return deepMergeArrays(defaultOptions, ruleConfig.slice(1)); + } + return defaultOptions ?? []; +} + +/** + * Analyze scope of the given AST. + * @param {ASTNode} ast The `Program` node to analyze. + * @param {JSLanguageOptions} languageOptions The language options. + * @param {Record} visitorKeys The visitor keys. + * @returns {ScopeManager} The analysis result. + */ +function analyzeScope(ast, languageOptions, visitorKeys) { + const parserOptions = languageOptions.parserOptions; + const ecmaFeatures = parserOptions.ecmaFeatures || {}; + const ecmaVersion = languageOptions.ecmaVersion || DEFAULT_ECMA_VERSION; + + return eslintScope.analyze(ast, { + ignoreEval: true, + nodejsScope: ecmaFeatures.globalReturn, + impliedStrict: ecmaFeatures.impliedStrict, + ecmaVersion: typeof ecmaVersion === "number" ? ecmaVersion : 6, + sourceType: languageOptions.sourceType || "script", + childVisitorKeys: visitorKeys || evk.KEYS, + fallback: Traverser.getKeys, + jsx: ecmaFeatures.jsx, + }); +} + +/** + * Runs a rule, and gets its listeners + * @param {RuleDefinition} rule A rule object + * @param {Context} ruleContext The context that should be passed to the rule + * @throws {TypeError} If `rule` is not an object with a `create` method + * @throws {any} Any error during the rule's `create` + * @returns {Object} A map of selector listeners provided by the rule + */ +function createRuleListeners(rule, ruleContext) { + if ( + !rule || + typeof rule !== "object" || + typeof rule.create !== "function" + ) { + throw new TypeError( + `Error while loading rule '${ruleContext.id}': Rule must be an object with a \`create\` method`, + ); + } + + try { + return rule.create(ruleContext); + } catch (ex) { + ex.message = `Error while loading rule '${ruleContext.id}': ${ex.message}`; + throw ex; + } +} + +/** + * Runs the given rules on the given SourceCode object + * @param {SourceCode} sourceCode A SourceCode object for the given text + * @param {Object} configuredRules The rules configuration + * @param {function(string): RuleDefinition} ruleMapper A mapper function from rule names to rules + * @param {Language} language The language object used for parsing. + * @param {LanguageOptions} languageOptions The options for parsing the code. + * @param {Object} settings The settings that were enabled in the config + * @param {string} filename The reported filename of the code + * @param {boolean} applyDefaultOptions If true, apply rules' meta.defaultOptions in computing their config options. + * @param {string | undefined} cwd cwd of the cli + * @param {string} physicalFilename The full path of the file on disk without any code block information + * @param {Function} ruleFilter A predicate function to filter which rules should be executed. + * @param {boolean} stats If true, stats are collected appended to the result + * @param {WeakMap} slots InternalSlotsMap of linter + * @param {FileReport} report The report to add problems to + * @returns {FileReport} report The report with added problems + * @throws {Error} If traversal into a node fails. + */ +function runRules( + sourceCode, + configuredRules, + ruleMapper, + language, + languageOptions, + settings, + filename, + applyDefaultOptions, + cwd, + physicalFilename, + ruleFilter, + stats, + slots, + report, +) { + const visitor = new SourceCodeVisitor(); + + /* + * Create a frozen object with the ruleContext properties and methods that are shared by all rules. + * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the + * properties once for each rule. + */ + const fileContext = new FileContext({ + cwd, + filename, + physicalFilename: physicalFilename || filename, + sourceCode, + languageOptions, + settings, + }); + + const steps = sourceCode.traverse(); + + Object.keys(configuredRules).forEach(ruleId => { + const severity = Config.getRuleNumericSeverity(configuredRules[ruleId]); + + // not load disabled rules + if (severity === 0) { + return; + } + + if (ruleFilter && !ruleFilter({ ruleId, severity })) { + return; + } + + const rule = ruleMapper(ruleId); + + if (!rule) { + report.addError({ ruleId }); + return; + } + + const ruleContext = fileContext.extend({ + id: ruleId, + options: getRuleOptions( + configuredRules[ruleId], + applyDefaultOptions ? rule.meta?.defaultOptions : void 0, + ), + report(...args) { + const problem = report.addRuleMessage( + ruleId, + severity, + ...args, + ); + + if (problem.fix && !(rule.meta && rule.meta.fixable)) { + throw new Error( + 'Fixable rules must set the `meta.fixable` property to "code" or "whitespace".', + ); + } + + if ( + problem.suggestions && + !(rule.meta && rule.meta.hasSuggestions === true) + ) { + if ( + rule.meta && + rule.meta.docs && + typeof rule.meta.docs.suggestion !== "undefined" + ) { + // Encourage migration from the former property name. + throw new Error( + "Rules with suggestions must set the `meta.hasSuggestions` property to `true`. `meta.docs.suggestion` is ignored by ESLint.", + ); + } + throw new Error( + "Rules with suggestions must set the `meta.hasSuggestions` property to `true`.", + ); + } + }, + }); + + const ruleListenersReturn = + timing.enabled || stats + ? timing.time( + ruleId, + createRuleListeners, + stats, + )(rule, ruleContext) + : createRuleListeners(rule, ruleContext); + + const ruleListeners = stats + ? ruleListenersReturn.result + : ruleListenersReturn; + + if (stats) { + storeTime( + ruleListenersReturn.tdiff, + { type: "rules", key: ruleId }, + slots, + ); + } + + /** + * Include `ruleId` in error logs + * @param {Function} ruleListener A rule method that listens for a node. + * @returns {Function} ruleListener wrapped in error handler + */ + function addRuleErrorHandler(ruleListener) { + return function ruleErrorHandler(...listenerArgs) { + try { + const ruleListenerReturn = ruleListener(...listenerArgs); + + const ruleListenerResult = stats + ? ruleListenerReturn.result + : ruleListenerReturn; + + if (stats) { + storeTime( + ruleListenerReturn.tdiff, + { type: "rules", key: ruleId }, + slots, + ); + } + + return ruleListenerResult; + } catch (e) { + attachRuleId(e, ruleId); + throw e; + } + }; + } + + if (typeof ruleListeners === "undefined" || ruleListeners === null) { + throw new Error( + `The create() function for rule '${ruleId}' did not return an object.`, + ); + } + + // add all the selectors from the rule as listeners + Object.keys(ruleListeners).forEach(selector => { + const rawListener = ruleListeners[selector]; + + /* + * When neither timing nor stats collection is enabled, register the + * listener directly and tag it with the rule ID so that errors + * thrown from it can still be attributed to the rule. This avoids + * allocating a wrapper closure and rest arguments for every + * listener invocation, which is a hot path. + * + * A listener is keyed by its function object, so this can only be + * used when that object isn't already associated with a different + * rule. Rules that return the same function object (for example, a + * shared visitor from a helper) fall back to the wrapper below so + * that each registration keeps its own rule ID. + */ + const listenerRuleId = getListenerRuleId(rawListener); + + if ( + !timing.enabled && + !stats && + typeof rawListener === "function" && + (listenerRuleId === void 0 || listenerRuleId === ruleId) + ) { + setListenerRuleId(rawListener, ruleId); + visitor.add(selector, rawListener); + return; + } + + const ruleListener = + timing.enabled || stats + ? timing.time(ruleId, rawListener, stats) + : rawListener; + + visitor.add(selector, addRuleErrorHandler(ruleListener)); + }); + }); + + const traverser = SourceCodeTraverser.getInstance(language); + + traverser.traverseSync(sourceCode, visitor, { steps }); + + return report; +} + +/** + * Ensure the source code to be a string. + * @param {string|SourceCode} textOrSourceCode The text or source code object. + * @returns {string} The source code text. + */ +function ensureText(textOrSourceCode) { + if (typeof textOrSourceCode === "object") { + const { hasBOM, text } = textOrSourceCode; + const bom = hasBOM ? "\uFEFF" : ""; + + return bom + text; + } + + return String(textOrSourceCode); +} + +/** + * Normalize the value of the cwd + * @param {string | undefined} cwd raw value of the cwd, path to a directory that should be considered as the current working directory, can be undefined. + * @returns {string | undefined} normalized cwd + */ +function normalizeCwd(cwd) { + if (cwd) { + return cwd; + } + if (typeof process === "object") { + return process.cwd(); + } + + // It's more explicit to assign the undefined + // eslint-disable-next-line no-undefined -- Consistently returning a value + return undefined; +} + +/** + * The map to store private data. + * @type {WeakMap} + */ +const internalSlotsMap = new WeakMap(); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Object that is responsible for verifying JavaScript text + * @name Linter + */ +class Linter { + /** + * Initialize the Linter. + * @param {Object} [config] the config object + * @param {string} [config.cwd] path to a directory that should be considered as the current working directory, can be undefined. + * @param {Array} [config.flags] the feature flags to enable. + * @param {"flat"} [config.configType="flat"] the type of config used. Retrained for backwards compatibility, will be removed in future. + * @param {WarningService} [config.warningService] The warning service to use. + */ + constructor({ + cwd, + configType = "flat", + flags = [], + warningService = new WarningService(), + } = {}) { + const processedFlags = []; + + if (configType !== "flat") { + throw new TypeError( + `The 'configType' option value must be 'flat'. The value '${configType}' is not supported.`, + ); + } + + flags.forEach(flag => { + if (inactiveFlags.has(flag)) { + const inactiveFlagData = inactiveFlags.get(flag); + const inactivityReason = + getInactivityReasonMessage(inactiveFlagData); + const message = `The flag '${flag}' is inactive: ${inactivityReason}`; + + if (typeof inactiveFlagData.replacedBy === "undefined") { + throw new Error(message); + } + + // if there's a replacement, enable it instead of original + if (typeof inactiveFlagData.replacedBy === "string") { + processedFlags.push(inactiveFlagData.replacedBy); + } + + warningService.emitInactiveFlagWarning(flag, message); + + return; + } + + if (!activeFlags.has(flag)) { + throw new Error(`Unknown flag '${flag}'.`); + } + + processedFlags.push(flag); + }); + + internalSlotsMap.set(this, { + cwd: normalizeCwd(cwd), + flags: processedFlags, + lastConfigArray: null, + lastSourceCode: null, + lastSuppressedMessages: [], + warningService, + }); + + this.version = pkg.version; + } + + /** + * Getter for package version. + * @static + * @returns {string} The version from package.json. + */ + static get version() { + return pkg.version; + } + + /** + * Indicates if the given feature flag is enabled for this instance. + * @param {string} flag The feature flag to check. + * @returns {boolean} `true` if the feature flag is enabled, `false` if not. + */ + hasFlag(flag) { + return internalSlotsMap.get(this).flags.includes(flag); + } + + /** + * Verifies the text against the rules specified by the second argument. + * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object. + * @param {ConfigObject|ConfigObject[]} config The ESLint config object or array to use. + * @param {(string|(VerifyOptions&ProcessorOptions))} [filenameOrOptions] The optional filename of the file being checked. + * If this is not set, the filename will default to '' in the rule context. If + * an object, then it has "filename", "allowInlineConfig", and some properties. + * @returns {LintMessage[]} The results as an array of messages or an empty array if no messages. + */ + verify(textOrSourceCode, config, filenameOrOptions) { + debug("Verify"); + + const { cwd } = internalSlotsMap.get(this); + + const options = + typeof filenameOrOptions === "string" + ? { filename: filenameOrOptions } + : filenameOrOptions || {}; + + const configToUse = config ?? {}; + + /* + * Because of how Webpack packages up the files, we can't + * compare directly to `FlatConfigArray` using `instanceof` + * because it's not the same `FlatConfigArray` as in the tests. + * So, we work around it by assuming an array is, in fact, a + * `FlatConfigArray` if it has a `getConfig()` method. + */ + let configArray = configToUse; + + if ( + !Array.isArray(configToUse) || + typeof configToUse.getConfig !== "function" + ) { + configArray = new FlatConfigArray(configToUse, { + basePath: cwd, + }); + configArray.normalizeSync(); + } + + return this._distinguishSuppressedMessages( + this._verifyWithFlatConfigArray( + textOrSourceCode, + configArray, + options, + true, + ), + ); + } + + /** + * Verify with a processor. + * @param {string|SourceCode} textOrSourceCode The source code. + * @param {Config} config The config array. + * @param {VerifyOptions&ProcessorOptions} options The options. + * @param {FlatConfigArray} [configForRecursive] The `ConfigArray` object to apply multiple processors recursively. + * @returns {(LintMessage|SuppressedLintMessage)[]} The found problems. + */ + _verifyWithFlatConfigArrayAndProcessor( + textOrSourceCode, + config, + options, + configForRecursive, + ) { + const slots = internalSlotsMap.get(this); + const filename = options.filename || ""; + const filenameToExpose = normalizeFilename(filename); + const physicalFilename = options.physicalFilename || filenameToExpose; + const text = ensureText(textOrSourceCode); + const file = new VFile(filenameToExpose, text, { + physicalPath: physicalFilename, + }); + + const preprocess = options.preprocess || (rawText => [rawText]); + const postprocess = + options.postprocess || (messagesList => messagesList.flat()); + + const processorService = new ProcessorService(); + const preprocessResult = processorService.preprocessSync(file, { + processor: { + preprocess, + postprocess, + }, + }); + + if (!preprocessResult.ok) { + return preprocessResult.errors; + } + + const filterCodeBlock = + options.filterCodeBlock || + (blockFilename => blockFilename.endsWith(".js")); + const originalExtname = path.extname(filename); + const { files } = preprocessResult; + + const messageLists = files.map(block => { + debug("A code block was found: %o", block.path || "(unnamed)"); + + // Keep the legacy behavior. + if (typeof block === "string") { + return this._verifyWithFlatConfigArrayAndWithoutProcessors( + block, + config, + options, + ); + } + + // Skip this block if filtered. + if (!filterCodeBlock(block.path, block.body)) { + debug("This code block was skipped."); + return []; + } + + // Resolve configuration again if the file content or extension was changed. + if ( + configForRecursive && + (text !== block.rawBody || + path.extname(block.path) !== originalExtname) + ) { + debug( + "Resolving configuration again because the file content or extension was changed.", + ); + return this._verifyWithFlatConfigArray( + block.rawBody, + configForRecursive, + { + ...options, + filename: block.path, + physicalFilename: block.physicalPath, + }, + ); + } + + slots.lastSourceCode = null; + + // Does lint. + return this.#flatVerifyWithoutProcessors(block, config, { + ...options, + filename: block.path, + physicalFilename: block.physicalPath, + }); + }); + + return processorService.postprocessSync(file, messageLists, { + processor: { + preprocess, + postprocess, + }, + }); + } + + /** + * Verify using flat config and without any processors. + * @param {VFile} file The file to lint. + * @param {Config} providedConfig An ESLintConfig instance to configure everything. + * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked. + * @throws {Error} If during rule execution. + * @returns {(LintMessage|SuppressedLintMessage)[]} The results as an array of messages or an empty array if no messages. + */ + #flatVerifyWithoutProcessors(file, providedConfig, providedOptions) { + const slots = internalSlotsMap.get(this); + const config = providedConfig || {}; + const { settings = {}, languageOptions } = config; + const options = normalizeVerifyOptions(providedOptions, config); + + if (!slots.lastSourceCode) { + let t; + + if (options.stats) { + t = startTime(); + } + + const parserService = new ParserService(); + const parseResult = parserService.parseSync(file, config); + + if (options.stats) { + const time = endTime(t); + + storeTime(time, { type: "parse" }, slots); + } + + if (!parseResult.ok) { + return parseResult.errors; + } + + slots.lastSourceCode = parseResult.sourceCode; + } else { + /* + * If the given source code object as the first argument does not have scopeManager, analyze the scope. + * This is for backward compatibility (SourceCode is frozen so it cannot rebind). + * + * We check explicitly for `null` to ensure that this is a JS-flavored language. + * For non-JS languages we don't want to do this. + * + * TODO: Remove this check when we stop exporting the `SourceCode` object. + */ + if (slots.lastSourceCode.scopeManager === null) { + slots.lastSourceCode = new SourceCode({ + text: slots.lastSourceCode.text, + ast: slots.lastSourceCode.ast, + hasBOM: slots.lastSourceCode.hasBOM, + parserServices: slots.lastSourceCode.parserServices, + visitorKeys: slots.lastSourceCode.visitorKeys, + scopeManager: analyzeScope( + slots.lastSourceCode.ast, + languageOptions, + ), + }); + } + } + + const sourceCode = slots.lastSourceCode; + const report = new FileReport({ + ruleMapper: ruleId => config.getRuleDefinition(ruleId), + language: config.language, + sourceCode, + disableFixes: options.disableFixes, + }); + + /* + * Make adjustments based on the language options. For JavaScript, + * this is primarily about adding variables into the global scope + * to account for ecmaVersion and configured globals. + */ + sourceCode.applyLanguageOptions?.(languageOptions); + + const mergedInlineConfig = { + rules: {}, + }; + + /* + * Inline config can be either enabled or disabled. If disabled, it's possible + * to detect the inline config and emit a warning (though this is not required). + * So we first check to see if inline config is allowed at all, and if so, we + * need to check if it's a warning or not. + */ + if (options.allowInlineConfig) { + // if inline config should warn then add the warnings + if (options.warnInlineConfig) { + if (sourceCode.getInlineConfigNodes) { + sourceCode.getInlineConfigNodes().forEach(node => { + const loc = sourceCode.getLoc(node); + const range = sourceCode.getRange(node); + + report.addWarning({ + message: `'${sourceCode.text.slice(range[0], range[1])}' has no effect because you have 'noInlineConfig' setting in ${options.warnInlineConfig}.`, + loc, + }); + }); + } + } else { + const inlineConfigResult = sourceCode.applyInlineConfig?.(); + + if (inlineConfigResult) { + inlineConfigResult.problems.forEach(problem => { + report.addFatal(problem); + }); + + for (const { + config: inlineConfig, + loc, + } of inlineConfigResult.configs) { + Object.keys(inlineConfig.rules).forEach(ruleId => { + const rule = config.getRuleDefinition(ruleId); + const ruleValue = inlineConfig.rules[ruleId]; + + if (!rule) { + report.addError({ + ruleId, + loc, + }); + return; + } + + if ( + Object.hasOwn(mergedInlineConfig.rules, ruleId) + ) { + report.addError({ + message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`, + loc, + }); + return; + } + + try { + const ruleOptionsInline = asArray(ruleValue); + let ruleOptions = ruleOptionsInline; + + assertIsRuleSeverity(ruleId, ruleOptions[0]); + + /* + * If the rule was already configured, inline rule configuration that + * only has severity should retain options from the config and just override the severity. + * + * Example: + * + * { + * rules: { + * curly: ["error", "multi"] + * } + * } + * + * /* eslint curly: ["warn"] * / + * + * Results in: + * + * curly: ["warn", "multi"] + */ + + let shouldValidateOptions = true; + + if ( + /* + * If inline config for the rule has only severity + */ + ruleOptions.length === 1 && + /* + * And the rule was already configured + */ + config.rules && + Object.hasOwn(config.rules, ruleId) + ) { + /* + * Then use severity from the inline config and options from the provided config + */ + ruleOptions = [ + ruleOptions[0], // severity from the inline config + ...config.rules[ruleId].slice(1), // options from the provided config + ]; + + // if the rule was enabled, the options have already been validated + if (config.rules[ruleId][0] > 0) { + shouldValidateOptions = false; + } + } else { + /** + * Since we know the user provided options, apply defaults on top of them + */ + const slicedOptions = ruleOptions.slice(1); + const mergedOptions = deepMergeArrays( + rule.meta?.defaultOptions, + slicedOptions, + ); + + if (mergedOptions.length) { + ruleOptions = [ + ruleOptions[0], + ...mergedOptions, + ]; + } + } + + if ( + options.reportUnusedInlineConfigs !== "off" + ) { + addProblemIfSameSeverityAndOptions( + config, + loc, + report, + ruleId, + ruleOptions, + ruleOptionsInline, + options.reportUnusedInlineConfigs, + ); + } + + if (shouldValidateOptions) { + config.validateRulesConfig({ + [ruleId]: ruleOptions, + }); + } + + mergedInlineConfig.rules[ruleId] = ruleOptions; + } catch (err) { + /* + * If the rule has invalid `meta.schema`, throw the error because + * this is not an invalid inline configuration but an invalid rule. + */ + if ( + err.code === + "ESLINT_INVALID_RULE_OPTIONS_SCHEMA" + ) { + throw err; + } + + /* + * If the rule does not support the current language, report a + * specific, actionable error message. + */ + if ( + err.messageTemplate === + "rule-unsupported-language" + ) { + report.addError({ + ruleId, + message: `Inline configuration for rule "${ruleId}" is invalid:\n\tRule does not support the language "${err.messageData.language}". Use a config block with "files" to apply the rule only to supported files, or disable it.\n`, + loc, + }); + return; + } + + let baseMessage = err.message + .slice( + err.message.startsWith('Key "rules":') + ? err.message.indexOf(":", 12) + 1 + : err.message.indexOf(":") + 1, + ) + .trim(); + + if (err.messageTemplate) { + baseMessage += ` You passed "${ruleValue}".`; + } + + report.addError({ + ruleId, + message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`, + loc, + }); + } + }); + } + } + } + } + + const commentDirectives = + options.allowInlineConfig && !options.warnInlineConfig + ? getDirectiveCommentsForFlatConfig( + sourceCode, + ruleId => config.getRuleDefinition(ruleId), + config.language, + report, + ) + : []; + + const configuredRules = Object.assign( + {}, + config.rules, + mergedInlineConfig.rules, + ); + + sourceCode.finalize?.(); + + try { + runRules( + sourceCode, + configuredRules, + ruleId => config.getRuleDefinition(ruleId), + config.language, + languageOptions, + settings, + options.filename, + false, + slots.cwd, + providedOptions.physicalFilename, + options.ruleFilter, + options.stats, + slots, + report, + ); + } catch (err) { + err.message += `\nOccurred while linting ${options.filename}`; + debug("An error occurred while traversing"); + debug("Filename:", options.filename); + if (err.currentNode) { + const { line } = sourceCode.getLoc(err.currentNode).start; + + debug("Line:", line); + err.message += `:${line}`; + } + debug("Parser Options:", languageOptions.parserOptions); + debug("Settings:", settings); + + if (err.ruleId) { + err.message += `\nRule: "${err.ruleId}"`; + } + + throw err; + } + + return applyDisableDirectives({ + language: config.language, + sourceCode, + directives: commentDirectives, + disableFixes: options.disableFixes, + problems: report.messages.sort( + (problemA, problemB) => + problemA.line - problemB.line || + problemA.column - problemB.column, + ), + reportUnusedDisableDirectives: + options.reportUnusedDisableDirectives, + ruleFilter: options.ruleFilter, + configuredRules, + }); + } + + /** + * Same as linter.verify, except without support for processors. + * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object. + * @param {Config} providedConfig An ESLintConfig instance to configure everything. + * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked. + * @throws {Error} If during rule execution. + * @returns {(LintMessage|SuppressedLintMessage)[]} The results as an array of messages or an empty array if no messages. + */ + _verifyWithFlatConfigArrayAndWithoutProcessors( + textOrSourceCode, + providedConfig, + providedOptions, + ) { + const slots = internalSlotsMap.get(this); + const filename = normalizeFilename( + providedOptions.filename || "", + ); + let text; + + // evaluate arguments + if (typeof textOrSourceCode === "string") { + slots.lastSourceCode = null; + text = textOrSourceCode; + } else { + slots.lastSourceCode = textOrSourceCode; + text = textOrSourceCode.text; + } + + const file = new VFile(filename, text, { + physicalPath: providedOptions.physicalFilename, + }); + + return this.#flatVerifyWithoutProcessors( + file, + providedConfig, + providedOptions, + ); + } + + /** + * Verify a given code with a flat config. + * @param {string|SourceCode} textOrSourceCode The source code. + * @param {FlatConfigArray} configArray The config array. + * @param {VerifyOptions&ProcessorOptions} options The options. + * @param {boolean} firstCall Indicates if this is the first call in `verify()` + * to determine processor behavior. + * @returns {(LintMessage|SuppressedLintMessage)[]} The found problems. + */ + _verifyWithFlatConfigArray( + textOrSourceCode, + configArray, + options, + firstCall = false, + ) { + debug("With flat config: %s", options.filename); + + // we need a filename to match configs against + const filename = options.filename || "__placeholder__.js"; + + // Store the config array in order to get plugin envs and rules later. + internalSlotsMap.get(this).lastConfigArray = configArray; + const config = configArray.getConfig(filename); + + if (!config) { + return [ + { + ruleId: null, + severity: 1, + message: `No matching configuration found for ${filename}.`, + line: 0, + column: 0, + }, + ]; + } + + // Verify. + if (config.processor) { + debug("Apply the processor: %o", config.processor); + const { preprocess, postprocess, supportsAutofix } = + config.processor; + const disableFixes = options.disableFixes || !supportsAutofix; + + return this._verifyWithFlatConfigArrayAndProcessor( + textOrSourceCode, + config, + { ...options, filename, disableFixes, postprocess, preprocess }, + configArray, + ); + } + + // check for options-based processing + if (firstCall && (options.preprocess || options.postprocess)) { + return this._verifyWithFlatConfigArrayAndProcessor( + textOrSourceCode, + config, + options, + ); + } + + return this._verifyWithFlatConfigArrayAndWithoutProcessors( + textOrSourceCode, + config, + options, + ); + } + + /** + * Given a list of reported problems, distinguish problems between normal messages and suppressed messages. + * The normal messages will be returned and the suppressed messages will be stored as lastSuppressedMessages. + * @param {Array} problems A list of reported problems. + * @returns {LintMessage[]} A list of LintMessage. + */ + _distinguishSuppressedMessages(problems) { + const messages = []; + const suppressedMessages = []; + const slots = internalSlotsMap.get(this); + + for (const problem of problems) { + if (problem.suppressions) { + suppressedMessages.push(problem); + } else { + messages.push(problem); + } + } + + slots.lastSuppressedMessages = suppressedMessages; + + return messages; + } + + /** + * Gets the SourceCode object representing the parsed source. + * @returns {SourceCode} The SourceCode object. + */ + getSourceCode() { + return internalSlotsMap.get(this).lastSourceCode; + } + + /** + * Gets the times spent on (parsing, fixing, linting) a file. + * @returns {{ passes: TimePass[]; }} The times. + */ + getTimes() { + return internalSlotsMap.get(this).times ?? { passes: [] }; + } + + /** + * Gets the number of autofix passes that were made in the last run. + * @returns {number} The number of autofix passes. + */ + getFixPassCount() { + return internalSlotsMap.get(this).fixPasses ?? 0; + } + + /** + * Gets the list of SuppressedLintMessage produced in the last running. + * @returns {SuppressedLintMessage[]} The list of SuppressedLintMessage + */ + getSuppressedMessages() { + return internalSlotsMap.get(this).lastSuppressedMessages; + } + + /** + * Performs multiple autofix passes over the text until as many fixes as possible + * have been applied. + * @param {string} text The source text to apply fixes to. + * @param {ConfigObject|ConfigObject[]} config The ESLint config object or array to use. + * @param {string|(VerifyOptions&ProcessorOptions&FixOptions)} [filenameOrOptions] The filename or ESLint options object to use. + * @returns {{fixed:boolean,messages:LintMessage[],output:string}} The result of the fix operation as returned from the + * SourceCodeFixer. + */ + verifyAndFix(text, config, filenameOrOptions) { + let messages, + fixedResult, + fixed = false, + passNumber = 0, + currentText = text, + secondPreviousText, + previousText; + const options = + typeof filenameOrOptions === "string" + ? { filename: filenameOrOptions } + : filenameOrOptions || {}; + const debugTextDescription = + options.filename || `${text.slice(0, 10)}...`; + const shouldFix = + typeof options.fix !== "undefined" ? options.fix : true; + const stats = options?.stats; + + const slots = internalSlotsMap.get(this); + + // Remove lint times from the last run. + if (stats) { + delete slots.times; + slots.fixPasses = 0; + } + + /** + * This loop continues until one of the following is true: + * + * 1. No more fixes have been applied. + * 2. Ten passes have been made. + * + * That means anytime a fix is successfully applied, there will be another pass. + * Essentially, guaranteeing a minimum of two passes. + */ + do { + passNumber++; + let tTotal; + + if (stats) { + tTotal = startTime(); + } + + debug( + "Linting code for %s (pass %d)", + debugTextDescription, + passNumber, + ); + messages = this.verify(currentText, config, options); + + debug( + "Generating fixed text for %s (pass %d)", + debugTextDescription, + passNumber, + ); + let t; + + if (stats) { + t = startTime(); + } + + fixedResult = SourceCodeFixer.applyFixes( + currentText, + messages, + shouldFix, + ); + + if (stats) { + if (fixedResult.fixed) { + const time = endTime(t); + + storeTime(time, { type: "fix" }, slots); + slots.fixPasses++; + } else { + storeTime(0, { type: "fix" }, slots); + } + } + + /* + * stop if there are any syntax errors. + * 'fixedResult.output' is a empty string. + */ + if (messages.length === 1 && messages[0].fatal) { + break; + } + + // keep track if any fixes were ever applied - important for return value + fixed = fixed || fixedResult.fixed; + + // update to use the fixed output instead of the original text + secondPreviousText = previousText; + previousText = currentText; + currentText = fixedResult.output; + + if (stats) { + tTotal = endTime(tTotal); + const passIndex = slots.times.passes.length - 1; + + slots.times.passes[passIndex].total = tTotal; + } + + // Stop if we've made a circular fix + if ( + passNumber > 1 && + currentText.length === secondPreviousText.length && + currentText === secondPreviousText + ) { + debug( + "Circular fixes detected after pass %d. Exiting fix loop.", + passNumber, + ); + slots.warningService.emitCircularFixesWarning( + options.filename ?? "text", + ); + break; + } + } while (fixedResult.fixed && passNumber < MAX_AUTOFIX_PASSES); + + /* + * If the last result had fixes, we need to lint again to be sure we have + * the most up-to-date information. + */ + if (fixedResult.fixed) { + let tTotal; + + if (stats) { + tTotal = startTime(); + } + + fixedResult.messages = this.verify(currentText, config, options); + + if (stats) { + storeTime(0, { type: "fix" }, slots); + slots.times.passes.at(-1).total = endTime(tTotal); + } + } + + // ensure the last result properly reflects if fixes were done + fixedResult.fixed = fixed; + fixedResult.output = currentText; + + return fixedResult; + } +} + +module.exports = { + Linter, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/rule-fixer.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/rule-fixer.js new file mode 100644 index 00000000..94a2a0c6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/rule-fixer.js @@ -0,0 +1,199 @@ +/** + * @fileoverview An object that creates fix commands for rules. + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @import { SourceRange } from "@eslint/core"; + */ + +/* eslint class-methods-use-this: off -- Methods desired on instance */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +// none! + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Creates a fix command that inserts text at the specified index in the source text. + * @param {number} index The 0-based index at which to insert the new text. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @private + */ +function insertTextAt(index, text) { + return { + range: [index, index], + text, + }; +} + +/** + * Asserts that the provided text is a string. + * @param {unknown} text The text to validate. + * @returns {void} + * @throws {TypeError} If `text` is not a string. + */ +function assertIsString(text) { + if (typeof text !== "string") { + throw new TypeError("'text' must be a string"); + } +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Creates code fixing commands for rules. + */ +class RuleFixer { + /** + * The source code object representing the text to be fixed. + * @type {SourceCode} + */ + #sourceCode; + + /** + * Creates a new instance. + * @param {Object} options The options for the fixer. + * @param {SourceCode} options.sourceCode The source code object representing the text to be fixed. + */ + constructor({ sourceCode }) { + this.#sourceCode = sourceCode; + } + + /** + * Creates a fix command that inserts text after the given node or token. + * The fix is not applied until applyFixes() is called. + * @param {ASTNode|Token} nodeOrToken The node or token to insert after. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + insertTextAfter(nodeOrToken, text) { + assertIsString(text); + + const range = this.#sourceCode.getRange(nodeOrToken); + + return this.insertTextAfterRange(range, text); + } + + /** + * Creates a fix command that inserts text after the specified range in the source text. + * The fix is not applied until applyFixes() is called. + * @param {SourceRange} range The range to replace, first item is start of range, second + * is end of range. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + insertTextAfterRange(range, text) { + assertIsString(text); + + return insertTextAt(range[1], text); + } + + /** + * Creates a fix command that inserts text before the given node or token. + * The fix is not applied until applyFixes() is called. + * @param {ASTNode|Token} nodeOrToken The node or token to insert before. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + insertTextBefore(nodeOrToken, text) { + assertIsString(text); + + const range = this.#sourceCode.getRange(nodeOrToken); + + return this.insertTextBeforeRange(range, text); + } + + /** + * Creates a fix command that inserts text before the specified range in the source text. + * The fix is not applied until applyFixes() is called. + * @param {SourceRange} range The range to replace, first item is start of range, second + * is end of range. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + insertTextBeforeRange(range, text) { + assertIsString(text); + + return insertTextAt(range[0], text); + } + + /** + * Creates a fix command that replaces text at the node or token. + * The fix is not applied until applyFixes() is called. + * @param {ASTNode|Token} nodeOrToken The node or token to remove. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + replaceText(nodeOrToken, text) { + assertIsString(text); + + const range = this.#sourceCode.getRange(nodeOrToken); + + return this.replaceTextRange(range, text); + } + + /** + * Creates a fix command that replaces text at the specified range in the source text. + * The fix is not applied until applyFixes() is called. + * @param {SourceRange} range The range to replace, first item is start of range, second + * is end of range. + * @param {string} text The text to insert. + * @returns {Object} The fix command. + * @throws {TypeError} If `text` is not a string. + */ + replaceTextRange(range, text) { + assertIsString(text); + + return { + range, + text, + }; + } + + /** + * Creates a fix command that removes the node or token from the source. + * The fix is not applied until applyFixes() is called. + * @param {ASTNode|Token} nodeOrToken The node or token to remove. + * @returns {Object} The fix command. + */ + remove(nodeOrToken) { + const range = this.#sourceCode.getRange(nodeOrToken); + + return this.removeRange(range); + } + + /** + * Creates a fix command that removes the specified range of text from the source. + * The fix is not applied until applyFixes() is called. + * @param {SourceRange} range The range to remove, first item is start of range, second + * is end of range. + * @returns {Object} The fix command. + */ + removeRange(range) { + return { + range, + text: "", + }; + } +} + +module.exports = { RuleFixer }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-fixer.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-fixer.js new file mode 100644 index 00000000..2cea2c60 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-fixer.js @@ -0,0 +1,154 @@ +/** + * @fileoverview An object that caches and applies source code fixes. + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const debug = require("debug")("eslint:source-code-fixer"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const BOM = "\uFEFF"; + +/** + * Compares items in a messages array by range. + * @param {Message} a The first message. + * @param {Message} b The second message. + * @returns {number} -1 if a comes before b, 1 if a comes after b, 0 if equal. + * @private + */ +function compareMessagesByFixRange(a, b) { + return a.fix.range[0] - b.fix.range[0] || a.fix.range[1] - b.fix.range[1]; +} + +/** + * Compares items in a messages array by line and column. + * @param {Message} a The first message. + * @param {Message} b The second message. + * @returns {number} -1 if a comes before b, 1 if a comes after b, 0 if equal. + * @private + */ +function compareMessagesByLocation(a, b) { + return a.line - b.line || a.column - b.column; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Utility for apply fixes to source code. + * @constructor + */ +function SourceCodeFixer() { + Object.freeze(this); +} + +/** + * Applies the fixes specified by the messages to the given text. Tries to be + * smart about the fixes and won't apply fixes over the same area in the text. + * @param {string} sourceText The text to apply the changes to. + * @param {Message[]} messages The array of messages reported by ESLint. + * @param {boolean|Function} [shouldFix=true] Determines whether each message should be fixed + * @returns {Object} An object containing the fixed text and any unfixed messages. + */ +SourceCodeFixer.applyFixes = function (sourceText, messages, shouldFix) { + debug("Applying fixes"); + + if (shouldFix === false) { + debug("shouldFix parameter was false, not attempting fixes"); + return { + fixed: false, + messages, + output: sourceText, + }; + } + + // clone the array + const remainingMessages = [], + fixes = [], + bom = sourceText.startsWith(BOM) ? BOM : "", + text = bom ? sourceText.slice(1) : sourceText; + let lastPos = Number.NEGATIVE_INFINITY, + output = bom; + + /** + * Try to use the 'fix' from a problem. + * @param {Message} problem The message object to apply fixes from + * @returns {boolean} Whether fix was successfully applied + */ + function attemptFix(problem) { + const fix = problem.fix; + const start = fix.range[0]; + const end = fix.range[1]; + + // Remain it as a problem if it's overlapped or it's a negative range + if (lastPos >= start || start > end) { + remainingMessages.push(problem); + return false; + } + + // Remove BOM. + if ( + (start < 0 && end >= 0) || + (start === 0 && fix.text.startsWith(BOM)) + ) { + output = ""; + } + + // Make output to this fix. + output += text.slice(Math.max(0, lastPos), Math.max(0, start)); + output += fix.text; + lastPos = end; + return true; + } + + messages.forEach(problem => { + if (Object.hasOwn(problem, "fix") && problem.fix) { + fixes.push(problem); + } else { + remainingMessages.push(problem); + } + }); + + if (fixes.length) { + debug("Found fixes to apply"); + let fixesWereApplied = false; + + for (const problem of fixes.sort(compareMessagesByFixRange)) { + if (typeof shouldFix !== "function" || shouldFix(problem)) { + attemptFix(problem); + + /* + * The only time attemptFix will fail is if a previous fix was + * applied which conflicts with it. So we can mark this as true. + */ + fixesWereApplied = true; + } else { + remainingMessages.push(problem); + } + } + output += text.slice(Math.max(0, lastPos)); + + return { + fixed: fixesWereApplied, + messages: remainingMessages.sort(compareMessagesByLocation), + output, + }; + } + + debug("No fixes to apply"); + return { + fixed: false, + messages, + output: bom + text, + }; +}; + +module.exports = SourceCodeFixer; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-traverser.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-traverser.js new file mode 100644 index 00000000..bf1fed8d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-traverser.js @@ -0,0 +1,378 @@ +/** + * @fileoverview Traverser for SourceCode objects. + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { parse, matches } = require("./esquery"); +const vk = require("eslint-visitor-keys"); + +//----------------------------------------------------------------------------- +// Typedefs +//----------------------------------------------------------------------------- + +/** + * @import { Language, SourceCode } from "@eslint/core"; + * @import { ESQueryOptions } from "esquery"; + * @import { ESQueryParsedSelector } from "./esquery.js"; + * @import { SourceCodeVisitor } from "./source-code-visitor.js"; + */ + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const STEP_KIND_VISIT = 1; +const STEP_KIND_CALL = 2; + +const emptyArray = Object.freeze([]); + +/** + * Compares two ESQuery selectors by specificity. + * @param {ESQueryParsedSelector} a The first selector to compare. + * @param {ESQueryParsedSelector} b The second selector to compare. + * @returns {number} A negative number if `a` is less specific than `b` or they are equally specific and `a` <= `b` alphabetically, a positive number if `a` is more specific than `b`. + */ +function compareSpecificity(a, b) { + return a.compare(b); +} + +/** + * Helper to wrap ESQuery operations. + */ +class ESQueryHelper { + /** + * Creates a new instance. + * @param {SourceCodeVisitor} visitor The visitor containing the functions to call. + * @param {ESQueryOptions} esqueryOptions `esquery` options for traversing custom nodes. + */ + constructor(visitor, esqueryOptions) { + /** + * The visitor to use during traversal. + * @type {SourceCodeVisitor} + */ + this.visitor = visitor; + + /** + * The options for `esquery` to use during matching. + * @type {ESQueryOptions} + */ + this.esqueryOptions = esqueryOptions; + + /** + * The property name to use to read a node's type. + * @type {string} + */ + this.nodeTypeKey = esqueryOptions?.nodeTypeKey || "type"; + + /** + * A map of node type to selectors targeting that node type on the + * enter phase of traversal. + * @type {Map} + */ + this.enterSelectorsByNodeType = new Map(); + + /** + * A map of node type to selectors targeting that node type on the + * exit phase of traversal. + * @type {Map} + */ + this.exitSelectorsByNodeType = new Map(); + + /** + * An array of selectors that match any node type on the + * enter phase of traversal. + * @type {ESQueryParsedSelector[]} + */ + this.anyTypeEnterSelectors = []; + + /** + * An array of selectors that match any node type on the + * exit phase of traversal. + * @type {ESQueryParsedSelector[]} + */ + this.anyTypeExitSelectors = []; + + visitor.forEachName(rawSelector => { + const selector = parse(rawSelector); + + /* + * If this selector has identified specific node types, + * add it to the map for these node types for faster lookup. + */ + if (selector.nodeTypes) { + const typeMap = selector.isExit + ? this.exitSelectorsByNodeType + : this.enterSelectorsByNodeType; + + selector.nodeTypes.forEach(nodeType => { + if (!typeMap.has(nodeType)) { + typeMap.set(nodeType, []); + } + typeMap.get(nodeType).push(selector); + }); + return; + } + + /* + * Remaining selectors are added to the "any type" selectors + * list for the appropriate phase of traversal. This ensures + * that all selectors will still be applied even if no + * specific node type is matched. + */ + const selectors = selector.isExit + ? this.anyTypeExitSelectors + : this.anyTypeEnterSelectors; + + selectors.push(selector); + }); + + // sort all selectors by specificity for prioritizing call order + this.anyTypeEnterSelectors.sort(compareSpecificity); + this.anyTypeExitSelectors.sort(compareSpecificity); + this.enterSelectorsByNodeType.forEach(selectorList => + selectorList.sort(compareSpecificity), + ); + this.exitSelectorsByNodeType.forEach(selectorList => + selectorList.sort(compareSpecificity), + ); + } + + /** + * Checks if a node matches a given selector. + * @param {ASTNode} node The node to check + * @param {ASTNode[]} ancestry The ancestry of the node being checked. + * @param {ESQueryParsedSelector} selector An AST selector descriptor + * @returns {boolean} `true` if the selector matches the node, `false` otherwise + */ + matches(node, ancestry, selector) { + if (selector.fastMatch) { + return selector.fastMatch(node, ancestry, this.esqueryOptions); + } + + return matches(node, selector.root, ancestry, this.esqueryOptions); + } + + /** + * Calculates all appropriate selectors for a node, in specificity order + * @param {ASTNode} node The node to check + * @param {ASTNode[]} ancestry The ancestry of the node being checked. + * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited + * @param {ESQueryParsedSelector[]} out An array to which matching selectors are appended. + * @returns {void} + */ + calculateSelectors(node, ancestry, isExit, out) { + /* + * Get the selectors that may match this node. First, check + * to see if the node type has specific selectors, + * then gather the "any type" selectors. + */ + const selectorsByNodeType = + (isExit + ? this.exitSelectorsByNodeType + : this.enterSelectorsByNodeType + ).get(node[this.nodeTypeKey]) || emptyArray; + const anyTypeSelectors = isExit + ? this.anyTypeExitSelectors + : this.anyTypeEnterSelectors; + + /* + * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor. + * Iterate through each of them, applying selectors in the right order. + */ + let selectorsByNodeTypeIndex = 0; + let anyTypeSelectorsIndex = 0; + + while ( + selectorsByNodeTypeIndex < selectorsByNodeType.length || + anyTypeSelectorsIndex < anyTypeSelectors.length + ) { + /* + * If we've already exhausted the selectors for this node type, + * or if the next any type selector is more specific than the + * next selector for this node type, apply the any type selector. + */ + const hasMoreNodeTypeSelectors = + selectorsByNodeTypeIndex < selectorsByNodeType.length; + const hasMoreAnyTypeSelectors = + anyTypeSelectorsIndex < anyTypeSelectors.length; + const anyTypeSelector = anyTypeSelectors[anyTypeSelectorsIndex]; + const nodeTypeSelector = + selectorsByNodeType[selectorsByNodeTypeIndex]; + + // Only compare specificity if both selectors exist + const isAnyTypeSelectorLessSpecific = + hasMoreAnyTypeSelectors && + hasMoreNodeTypeSelectors && + anyTypeSelector.compare(nodeTypeSelector) < 0; + + if (!hasMoreNodeTypeSelectors || isAnyTypeSelectorLessSpecific) { + anyTypeSelectorsIndex++; + + /* + * Selectors that consist solely of node type identifiers or + * wildcards are guaranteed to match, so the `matches()` call + * can be skipped for them. + */ + if ( + anyTypeSelector.alwaysMatches || + this.matches(node, ancestry, anyTypeSelector) + ) { + out.push(anyTypeSelector); + } + } else { + selectorsByNodeTypeIndex++; + + if ( + nodeTypeSelector.alwaysMatches || + this.matches(node, ancestry, nodeTypeSelector) + ) { + out.push(nodeTypeSelector); + } + } + } + } +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Traverses source code and ensures that visitor methods are called when + * entering and leaving each node. + */ +class SourceCodeTraverser { + /** + * The language of the source code being traversed. + * @type {Language} + */ + #language; + + /** + * Map of languages to instances of this class. + * @type {WeakMap} + */ + static instances = new WeakMap(); + + /** + * Creates a new instance. + * @param {Language} language The language of the source code being traversed. + */ + constructor(language) { + this.#language = language; + } + + static getInstance(language) { + if (!this.instances.has(language)) { + this.instances.set(language, new this(language)); + } + + return this.instances.get(language); + } + + /** + * Traverses the given source code synchronously. + * @param {SourceCode} sourceCode The source code to traverse. + * @param {SourceCodeVisitor} visitor The emitter to use for events. + * @param {Object} options Options for traversal. + * @param {ReturnType} options.steps The steps to take during traversal. + * @returns {void} + * @throws {Error} If an error occurs during traversal. + */ + traverseSync(sourceCode, visitor, { steps } = {}) { + const esquery = new ESQueryHelper(visitor, { + visitorKeys: sourceCode.visitorKeys ?? this.#language.visitorKeys, + fallback: vk.getKeys, + matchClass: this.#language.matchesSelectorClass ?? (() => false), + nodeTypeKey: this.#language.nodeTypeKey, + }); + + const currentAncestry = []; + const matchedSelectors = []; + const allSteps = steps ?? sourceCode.traverse(); + + /** + * Applies a single traversal step. + * @param {Object} step The step to apply. + * @returns {void} + * @throws {Error} If an error occurs while applying the step. + */ + function applyStep(step) { + switch (step.kind) { + case STEP_KIND_VISIT: { + try { + const isExit = step.phase !== 1; + + if (isExit) { + currentAncestry.shift(); + } + + matchedSelectors.length = 0; + esquery.calculateSelectors( + step.target, + currentAncestry, + isExit, + matchedSelectors, + ); + + const args = step.args; + + for (let i = 0; i < matchedSelectors.length; i++) { + const source = matchedSelectors[i].source; + + if (!args) { + visitor.callSync(source, step.target); + } else if (args.length === 1) { + visitor.callSync(source, args[0]); + } else { + visitor.callSync(source, ...args); + } + } + + if (!isExit) { + currentAncestry.unshift(step.target); + } + } catch (err) { + err.currentNode = step.target; + throw err; + } + break; + } + + case STEP_KIND_CALL: { + visitor.callSync(step.target, ...step.args); + break; + } + + default: + throw new Error( + `Invalid traversal step found: "${step.kind}".`, + ); + } + } + + /* + * Iterating an array by index avoids the overhead of the iterator + * protocol. Other iterables are iterated directly instead of being + * converted into an array first, because the conversion is slower than + * iterating them and would fully materialize a lazy iterable. + */ + if (Array.isArray(allSteps)) { + for (let i = 0; i < allSteps.length; i++) { + applyStep(allSteps[i]); + } + } else { + for (const step of allSteps) { + applyStep(step); + } + } + } +} + +module.exports = { SourceCodeTraverser }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-visitor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-visitor.js new file mode 100644 index 00000000..3cef28e4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/source-code-visitor.js @@ -0,0 +1,185 @@ +/** + * @fileoverview SourceCodeVisitor class + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Helpers +//----------------------------------------------------------------------------- + +const emptyArray = Object.freeze([]); + +/** + * Maps listener functions to the ID of the rule that registered them, so that + * errors thrown from a listener can be attributed to the correct rule without + * wrapping every listener in a closure. A `WeakMap` is used rather than a + * property on the function itself because the function is owned by the rule, + * and adding properties to it could surprise the rule's author. + * @type {WeakMap} + */ +const listenerRuleIds = new WeakMap(); + +/** + * Gets the ID of the rule that registered a listener function, if known. + * @param {Function} func The listener function to look up. + * @returns {string|undefined} The rule ID, or `undefined` if the function isn't associated with a rule. + */ +function getListenerRuleId(func) { + return listenerRuleIds.get(func); +} + +/** + * Associates a listener function with the rule that registered it. + * @param {Function} func The listener function. + * @param {string} ruleId The ID of the rule that registered the listener. + * @returns {void} + */ +function setListenerRuleId(func, ruleId) { + listenerRuleIds.set(func, ruleId); +} + +/** + * Attaches a rule ID to a thrown value so that the rule responsible for an + * error can be reported. + * + * The `ruleId` is assigned unconditionally for object values, matching the + * behavior of the wrapper this replaces, which always overwrote any existing + * `ruleId` with the rule whose listener threw. + * @param {any} error The thrown value. + * @param {string} ruleId The ID of the rule that threw. + * @returns {void} + */ +function attachRuleId(error, ruleId) { + /* + * Rules can throw primitives, which can't carry a `ruleId`. Assigning to + * one throws a `TypeError` in strict mode, which would replace the value + * the rule actually threw, so such values are left as-is. + */ + if ( + error !== null && + (typeof error === "object" || typeof error === "function") + ) { + error.ruleId = ruleId; + } +} + +/** + * Attributes an error thrown from a listener function to the rule that + * registered the listener, if known. + * @param {any} error The thrown value. + * @param {Function} func The listener function that threw the error. + * @returns {void} + */ +function attributeError(error, func) { + const ruleId = listenerRuleIds.get(func); + + if (ruleId !== void 0) { + attachRuleId(error, ruleId); + } +} + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * A structure to hold a list of functions to call for a given name. + * This is used to allow multiple rules to register functions for a given name + * without having to know about each other. + */ +class SourceCodeVisitor { + /** + * The functions to call for a given name. + * @type {Map} + */ + #functions = new Map(); + + /** + * Adds a function to the list of functions to call for a given name. + * @param {string} name The name of the function to call. + * @param {Function} func The function to call. + * @returns {void} + */ + add(name, func) { + const funcs = this.#functions.get(name); + + if (funcs) { + funcs.push(func); + } else { + this.#functions.set(name, [func]); + } + } + + /** + * Gets the list of functions to call for a given name. + * @param {string} name The name of the function to call. + * @returns {Function[]} The list of functions to call. + */ + get(name) { + return this.#functions.get(name) ?? emptyArray; + } + + /** + * Iterates over all names and calls the callback with the name. + * @param {(name:string) => void} callback The callback to call for each name. + * @returns {void} + */ + forEachName(callback) { + this.#functions.forEach((funcs, name) => { + callback(name); + }); + } + + /** + * Calls the functions for a given name with the given arguments. + * @param {string} name The name of the function to call. + * @param {any[]} args The arguments to pass to the function. + * @returns {void} + * @throws {any} Any error thrown by a called function, annotated with + * the ID of the rule that registered the function when known. + */ + callSync(name, ...args) { + const funcs = this.#functions.get(name); + + if (!funcs) { + return; + } + + // Fast path for the overwhelmingly common one-argument call. + if (args.length === 1) { + const arg = args[0]; + + for (let i = 0; i < funcs.length; i++) { + const func = funcs[i]; + + try { + func(arg); + } catch (err) { + attributeError(err, func); + throw err; + } + } + return; + } + + for (let i = 0; i < funcs.length; i++) { + const func = funcs[i]; + + try { + func(...args); + } catch (err) { + attributeError(err, func); + throw err; + } + } + } +} + +module.exports = { + SourceCodeVisitor, + getListenerRuleId, + setListenerRuleId, + attachRuleId, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/timing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/timing.js new file mode 100644 index 00000000..1791f8fd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/timing.js @@ -0,0 +1,209 @@ +/** + * @fileoverview Tracks performance of individual rules. + * @author Brandon Mills + */ + +"use strict"; + +const { startTime, endTime } = require("../shared/stats"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/* c8 ignore next */ +/** + * Align the string to left + * @param {string} str string to evaluate + * @param {number} len length of the string + * @param {string} ch delimiter character + * @returns {string} modified string + * @private + */ +function alignLeft(str, len, ch) { + return str + new Array(len - str.length + 1).join(ch || " "); +} + +/* c8 ignore next */ +/** + * Align the string to right + * @param {string} str string to evaluate + * @param {number} len length of the string + * @param {string} ch delimiter character + * @returns {string} modified string + * @private + */ +function alignRight(str, len, ch) { + return new Array(len - str.length + 1).join(ch || " ") + str; +} + +//------------------------------------------------------------------------------ +// Module definition +//------------------------------------------------------------------------------ + +const enabled = !!process.env.TIMING; + +const HEADERS = ["Rule", "Time (ms)", "Relative"]; +const ALIGN = [alignLeft, alignRight, alignRight]; + +/** + * Decide how many rules to show in the output list. + * @returns {number} the number of rules to show + */ +function getListSize() { + const MINIMUM_SIZE = 10; + + if (typeof process.env.TIMING !== "string") { + return MINIMUM_SIZE; + } + + if (process.env.TIMING.toLowerCase() === "all") { + return Number.POSITIVE_INFINITY; + } + + const TIMING_ENV_VAR_AS_INTEGER = Number.parseInt(process.env.TIMING, 10); + + return TIMING_ENV_VAR_AS_INTEGER > 10 + ? TIMING_ENV_VAR_AS_INTEGER + : MINIMUM_SIZE; +} + +/* c8 ignore next */ +/** + * display the data + * @param {Object} data Data object to be displayed + * @returns {void} prints modified string with console.log + * @private + */ +function display(data) { + let total = 0; + const rows = Object.keys(data) + .map(key => { + const time = data[key]; + + total += time; + return [key, time]; + }) + .sort((a, b) => b[1] - a[1]) + .slice(0, getListSize()); + + rows.forEach(row => { + row.push(`${((row[1] * 100) / total).toFixed(1)}%`); + row[1] = row[1].toFixed(3); + }); + + rows.unshift(HEADERS); + + const widths = []; + + rows.forEach(row => { + const len = row.length; + + for (let i = 0; i < len; i++) { + const n = row[i].length; + + if (!widths[i] || n > widths[i]) { + widths[i] = n; + } + } + }); + + const table = rows.map(row => + row.map((cell, index) => ALIGN[index](cell, widths[index])).join(" | "), + ); + + table.splice( + 1, + 0, + widths + .map((width, index) => { + const extraAlignment = + index !== 0 && index !== widths.length - 1 ? 2 : 1; + + return ALIGN[index](":", width + extraAlignment, "-"); + }) + .join("|"), + ); + + console.log(table.join("\n")); // eslint-disable-line no-console -- Debugging function +} + +/* c8 ignore next */ +module.exports = (function () { + const data = Object.create(null); + let displayEnabled = true; + + /** + * Time the run + * @param {any} key key from the data object + * @param {Function} fn function to be called + * @param {boolean} stats if 'stats' is true, return the result and the time difference + * @returns {Function} function to be executed + * @private + */ + function time(key, fn, stats) { + return function (...args) { + const t = startTime(); + const result = fn(...args); + const tdiff = endTime(t); + + if (enabled) { + if (typeof data[key] === "undefined") { + data[key] = 0; + } + + data[key] += tdiff; + } + + return stats ? { result, tdiff } : result; + }; + } + + /** + * Returns a shallow copy of the collected timings data. + * @returns {Record} mapping of ruleId to total time in ms + */ + function getData() { + return { ...data }; + } + + /** + * Merges rule timing totals collected elsewhere into this process' totals. + * @param {Record} dataToMerge mapping of ruleId to total time in ms + * @returns {void} + */ + function mergeData(dataToMerge) { + for (const [key, value] of Object.entries(dataToMerge)) { + if (typeof data[key] === "undefined") { + data[key] = 0; + } + data[key] += value; + } + } + + /** + * Disables printing of timing data on process exit. + * Intended for worker threads or non-main contexts. + * @returns {void} + */ + function disableDisplay() { + displayEnabled = false; + } + + if (enabled) { + process.on("exit", () => { + if (displayEnabled && Object.keys(data).length > 0) { + display(data); + } + }); + } + + return { + time, + enabled, + getListSize, + getData, + mergeData, + disableDisplay, + }; +})(); diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/vfile.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/vfile.js new file mode 100644 index 00000000..2157bd31 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/linter/vfile.js @@ -0,0 +1,115 @@ +/** + * @fileoverview Virtual file + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Type Definitions +//----------------------------------------------------------------------------- + +/** @typedef {import("@eslint/core").File} File */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines if a given value has a byte order mark (BOM). + * @param {string|Uint8Array} value The value to check. + * @returns {boolean} `true` if the value has a BOM, `false` otherwise. + */ +function hasUnicodeBOM(value) { + return typeof value === "string" + ? value.charCodeAt(0) === 0xfeff + : value[0] === 0xef && value[1] === 0xbb && value[2] === 0xbf; +} + +/** + * Strips Unicode BOM from the given value. + * @param {string|Uint8Array} value The value to remove the BOM from. + * @returns {string|Uint8Array} The stripped value. + */ +function stripUnicodeBOM(value) { + if (!hasUnicodeBOM(value)) { + return value; + } + + if (typeof value === "string") { + /* + * Check Unicode BOM. + * In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF. + * https://262.ecma-international.org/6.0/#sec-unicode-format-control-characters + */ + return value.slice(1); + } + + /* + * In a Uint8Array, the BOM is represented by three bytes: 0xEF, 0xBB, and 0xBF, + * so we can just remove the first three bytes. + */ + return value.slice(3); +} + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +/** + * Represents a virtual file inside of ESLint. + * @implements {File} + */ +class VFile { + /** + * The file path including any processor-created virtual path. + * @type {string} + * @readonly + */ + path; + + /** + * The file path on disk. + * @type {string} + * @readonly + */ + physicalPath; + + /** + * The file contents. + * @type {string|Uint8Array} + * @readonly + */ + body; + + /** + * The raw body of the file, including a BOM if present. + * @type {string|Uint8Array} + * @readonly + */ + rawBody; + + /** + * Indicates whether the file has a byte order mark (BOM). + * @type {boolean} + * @readonly + */ + bom; + + /** + * Creates a new instance. + * @param {string} path The file path. + * @param {string|Uint8Array} body The file contents. + * @param {Object} [options] Additional options. + * @param {string} [options.physicalPath] The file path on disk. + */ + constructor(path, body, { physicalPath } = {}) { + this.path = path; + this.physicalPath = physicalPath ?? path; + this.bom = hasUnicodeBOM(body); + this.body = stripUnicodeBOM(body); + this.rawBody = body; + } +} + +module.exports = { VFile }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/options.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/options.js new file mode 100644 index 00000000..a13f671d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/options.js @@ -0,0 +1,416 @@ +/** + * @fileoverview Options configuration for optionator. + * @author George Zahariev + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const optionator = require("optionator"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * The options object parsed by Optionator. + * @typedef {Object} ParsedCLIOptions + * @property {boolean} cache Only check changed files + * @property {string} cacheFile Path to the cache file. Deprecated: use --cache-location + * @property {string} [cacheLocation] Path to the cache file or directory + * @property {"metadata" | "content"} cacheStrategy Strategy to use for detecting changed files in the cache + * @property {boolean} [color] Force enabling/disabling of color + * @property {number | "auto" | "off"} [concurrency] Number of linting threads, "auto" to choose automatically, "off" for no multithreading + * @property {string} [config] Use this configuration, overriding eslint.config.* config options if present + * @property {boolean} debug Output debugging information + * @property {boolean} envInfo Output execution environment information + * @property {boolean} errorOnUnmatchedPattern Prevent errors when pattern is unmatched + * @property {string[]} [ext] Specify JavaScript file extensions + * @property {string[]} [flag] Feature flags + * @property {boolean} fix Automatically fix problems + * @property {boolean} fixDryRun Automatically fix problems without saving the changes to the file system + * @property {("directive" | "problem" | "suggestion" | "layout")[]} [fixType] Specify the types of fixes to apply (directive, problem, suggestion, layout) + * @property {string} format Use a specific output format + * @property {string[]} [global] Define global variables + * @property {boolean} [help] Show help + * @property {boolean} ignore Disable use of ignore files and patterns + * @property {string[]} [ignorePattern] Patterns of files to ignore + * @property {boolean} init Run config initialization wizard + * @property {boolean} inlineConfig Prevent comments from changing config or rules + * @property {number} maxWarnings Number of warnings to trigger nonzero exit code + * @property {string} [outputFile] Specify file to write report to + * @property {string} [parser] Specify the parser to be used + * @property {Object} [parserOptions] Specify parser options + * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause + * the linting operation to short circuit and not report any failures. + * @property {boolean} [passOnUnprunedSuppressions] Ignore unused suppressions + * @property {string[]} [plugin] Specify plugins + * @property {string} [printConfig] Print the configuration for the given file + * @property {boolean} [pruneSuppressions] Prune unused suppressions + * @property {boolean} quiet Report errors only + * @property {boolean | undefined} reportUnusedDisableDirectives Adds reported errors for unused eslint-disable and eslint-enable directives + * @property {string | undefined} reportUnusedDisableDirectivesSeverity A severity string indicating if and how unused disable and enable directives should be tracked and reported. + * @property {Object} [rule] Specify rules + * @property {boolean} [stats] Report additional statistics + * @property {boolean} stdin Lint code provided on + * @property {string} [stdinFilename] Specify filename to process STDIN as + * @property {boolean} [suppressAll] Suppress all error violations + * @property {string} [suppressionsLocation] Path to the suppressions file or directory + * @property {string[]} [suppressRule] Suppress specific rules + * @property {boolean} [version] Output the version number + * @property {boolean} warnIgnored Show warnings when the file list includes ignored files + * @property {string[]} _ Positional filenames or patterns + */ + +//------------------------------------------------------------------------------ +// Initialization and Public Interface +//------------------------------------------------------------------------------ + +// exports "parse(args)", "generateHelp()", and "generateHelpForOption(optionName)" + +/** + * Creates the CLI options for ESLint. + * @returns {Object} The optionator instance. + */ +module.exports = function () { + return optionator({ + prepend: "eslint [options] file.js [file.js] [dir]", + defaults: { + concatRepeatedArrays: true, + mergeRepeatedObjects: true, + }, + options: [ + { + heading: "Basic configuration", + }, + { + option: "config-lookup", + type: "Boolean", + default: "true", + description: "Disable look up for eslint.config.*", + }, + { + option: "config", + alias: "c", + type: "path::String", + description: + "Use this configuration instead of eslint.config.* look up", + }, + { + option: "inspect-config", + type: "Boolean", + description: + "Open the config inspector with the current configuration", + }, + { + option: "ext", + type: "[String]", + description: "Specify additional file extensions to lint", + }, + { + option: "global", + type: "[String]", + description: "Define global variables", + }, + { + option: "parser", + type: "String", + description: "Specify the parser to be used", + }, + { + option: "parser-options", + type: "Object", + description: "Specify parser options", + }, + { + heading: "Specify Rules and Plugins", + }, + { + option: "plugin", + type: "[String]", + description: "Specify plugins", + }, + { + option: "rule", + type: "Object", + description: "Specify rules", + }, + { + heading: "Fix Problems", + }, + { + option: "fix", + type: "Boolean", + default: false, + description: "Automatically fix problems", + }, + { + option: "fix-dry-run", + type: "Boolean", + default: false, + description: + "Automatically fix problems without saving the changes to the file system", + }, + { + option: "fix-type", + type: "Array", + description: + "Specify the types of fixes to apply (directive, problem, suggestion, layout)", + }, + { + heading: "Ignore Files", + }, + { + option: "ignore", + type: "Boolean", + default: "true", + description: "Disable use of ignore files and patterns", + }, + { + option: "ignore-pattern", + type: "[String]", + description: "Patterns of files to ignore", + concatRepeatedArrays: [ + true, + { + oneValuePerFlag: true, + }, + ], + }, + { + heading: "Use stdin", + }, + { + option: "stdin", + type: "Boolean", + default: "false", + description: "Lint code provided on ", + }, + { + option: "stdin-filename", + type: "String", + description: "Specify filename to process STDIN as", + }, + { + heading: "Handle Warnings", + }, + { + option: "quiet", + type: "Boolean", + default: "false", + description: "Report errors only", + }, + { + option: "max-warnings", + type: "Int", + default: "-1", + description: "Number of warnings to trigger nonzero exit code", + }, + { + heading: "Output", + }, + { + option: "output-file", + alias: "o", + type: "path::String", + description: "Specify file to write report to", + }, + { + option: "format", + alias: "f", + type: "String", + default: "stylish", + description: "Use a specific output format", + }, + { + option: "color", + type: "Boolean", + alias: "no-color", + description: "Force enabling/disabling of color", + }, + { + heading: "Inline configuration comments", + }, + { + option: "inline-config", + type: "Boolean", + default: "true", + description: "Prevent comments from changing config or rules", + }, + { + option: "report-unused-disable-directives", + type: "Boolean", + default: void 0, + description: + "Adds reported errors for unused eslint-disable and eslint-enable directives", + }, + { + option: "report-unused-disable-directives-severity", + type: "String", + default: void 0, + description: + "Chooses severity level for reporting unused eslint-disable and eslint-enable directives", + enum: ["off", "warn", "error", "0", "1", "2"], + }, + { + option: "report-unused-inline-configs", + type: "String", + default: void 0, + description: + "Adds reported errors for unused eslint inline config comments", + enum: ["off", "warn", "error", "0", "1", "2"], + }, + { + heading: "Caching", + }, + { + option: "cache", + type: "Boolean", + default: "false", + description: "Only check changed files", + }, + { + option: "cache-file", + type: "path::String", + default: ".eslintcache", + description: + "Path to the cache file. Deprecated: use --cache-location", + }, + { + option: "cache-location", + type: "path::String", + description: "Path to the cache file or directory", + }, + { + option: "cache-strategy", + dependsOn: ["cache"], + type: "String", + default: "metadata", + enum: ["metadata", "content"], + description: + "Strategy to use for detecting changed files in the cache", + }, + { + heading: "Suppressing Violations", + }, + { + option: "suppress-all", + type: "Boolean", + default: "false", + description: "Suppress all violations", + }, + { + option: "suppress-rule", + type: "[String]", + description: "Suppress specific rules", + }, + { + option: "suppressions-location", + type: "path::String", + description: "Specify the location of the suppressions file", + }, + { + option: "prune-suppressions", + type: "Boolean", + default: "false", + description: "Prune unused suppressions", + }, + { + option: "pass-on-unpruned-suppressions", + type: "Boolean", + default: "false", + description: "Ignore unused suppressions", + }, + { + heading: "Miscellaneous", + }, + { + option: "init", + type: "Boolean", + default: "false", + description: "Run config initialization wizard", + }, + { + option: "env-info", + type: "Boolean", + default: "false", + description: "Output execution environment information", + }, + { + option: "error-on-unmatched-pattern", + type: "Boolean", + default: "true", + description: "Prevent errors when pattern is unmatched", + }, + { + option: "exit-on-fatal-error", + type: "Boolean", + default: "false", + description: "Exit with exit code 2 in case of fatal error", + }, + { + option: "warn-ignored", + type: "Boolean", + default: "true", + description: + "Suppress warnings when the file list includes ignored files", + }, + { + option: "pass-on-no-patterns", + type: "Boolean", + default: false, + description: + "Exit with exit code 0 in case no file patterns are passed", + }, + { + option: "debug", + type: "Boolean", + default: false, + description: "Output debugging information", + }, + { + option: "help", + alias: "h", + type: "Boolean", + description: "Show help", + }, + { + option: "version", + alias: "v", + type: "Boolean", + description: "Output the version number", + }, + { + option: "print-config", + type: "path::String", + description: "Print the configuration for the given file", + }, + { + option: "stats", + type: "Boolean", + default: "false", + description: "Add statistics to the lint report", + }, + { + option: "flag", + type: "[String]", + description: "Enable a feature flag", + }, + { + option: "mcp", + type: "Boolean", + description: "Start the ESLint MCP server", + }, + { + option: "concurrency", + type: "Int|String", + default: "off", + description: + "Number of linting threads, auto to choose automatically, off for no multithreading", + }, + ], + }); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/index.js new file mode 100644 index 00000000..4fa651eb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/index.js @@ -0,0 +1,7 @@ +"use strict"; + +const RuleTester = require("./rule-tester"); + +module.exports = { + RuleTester, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/rule-tester.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/rule-tester.js new file mode 100644 index 00000000..60047f06 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rule-tester/rule-tester.js @@ -0,0 +1,2018 @@ +/** + * @fileoverview Mocha/Jest test wrapper + * @author Ilya Volodin + */ +"use strict"; + +/* globals describe, it -- Mocha globals */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const assert = require("node:assert"), + { existsSync, readFileSync } = require("node:fs"), + util = require("node:util"), + path = require("node:path"), + equal = require("fast-deep-equal"), + Traverser = require("../shared/traverser"), + { Config } = require("../config/config"), + { Linter, SourceCodeFixer } = require("../linter"), + { interpolate, getPlaceholderMatcher } = require("../linter/interpolate"), + stringify = require("json-stable-stringify-without-jsonify"), + { isSerializable } = require("../shared/serialization"); + +const { FlatConfigArray } = require("../config/flat-config-array"); +const { + defaultConfig, + defaultRuleTesterConfig, +} = require("../config/default-config"); + +const parserSymbol = Symbol.for("eslint.RuleTester.parser"); +const { ConfigArraySymbol } = require("@eslint/config-array"); + +const jslang = require("../languages/js"); +const { SourceCode } = require("../languages/js/source-code"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @import { LanguageOptions, RuleDefinition } from "@eslint/core" */ + +/** @typedef {import("../types").Linter.Parser} Parser */ + +/** + * A test case that is expected to pass lint. + * @typedef {Object} ValidTestCase + * @property {string} [name] Name for the test case. + * @property {string} code Code for the test case. + * @property {any[]} [options] Options for the test case. + * @property {Function} [before] Function to execute before testing the case. + * @property {Function} [after] Function to execute after testing the case regardless of its result. + * @property {LanguageOptions} [languageOptions] The language options to use in the test case. + * @property {{ [name: string]: any }} [settings] Settings for the test case. + * @property {string} [filename] The fake filename for the test case. Useful for rules that make assertion about filenames. + * @property {boolean} [only] Run only this test case or the subset of test cases with this property. + */ + +/** + * A test case that is expected to fail lint. + * @typedef {Object} InvalidTestCase + * @property {string} [name] Name for the test case. + * @property {string} code Code for the test case. + * @property {number | Array} errors Expected errors. + * @property {string | null} [output] The expected code after autofixes are applied. If set to `null`, the test runner will assert that no autofix is suggested. + * @property {any[]} [options] Options for the test case. + * @property {Function} [before] Function to execute before testing the case. + * @property {Function} [after] Function to execute after testing the case regardless of its result. + * @property {{ [name: string]: any }} [settings] Settings for the test case. + * @property {string} [filename] The fake filename for the test case. Useful for rules that make assertion about filenames. + * @property {LanguageOptions} [languageOptions] The language options to use in the test case. + * @property {boolean} [only] Run only this test case or the subset of test cases with this property. + */ + +/** + * A description of a reported error used in a rule tester test. + * @typedef {Object} TestCaseError + * @property {string | RegExp} [message] Message. + * @property {string} [messageId] Message ID. + * @property {{ [name: string]: string }} [data] The data used to fill the message template. + * @property {number} [line] The 1-based line number of the reported start location. + * @property {number} [column] The 1-based column number of the reported start location. + * @property {number} [endLine] The 1-based line number of the reported end location. + * @property {number} [endColumn] The 1-based column number of the reported end location. + */ + +//------------------------------------------------------------------------------ +// Private Members +//------------------------------------------------------------------------------ + +/* + * testerDefaultConfig must not be modified as it allows to reset the tester to + * the initial default configuration + */ +const testerDefaultConfig = { rules: {} }; + +/* + * The shared ajv instance, constructed on first use. + * + * `ajv` pulls in a large dependency graph (~40 modules) that's only needed + * when a rule's schema is actually validated. Because `lib/api.js` eagerly + * requires this module, constructing it eagerly here would pull `ajv` into the + * dependency graph of every consumer of the `eslint` package, including those + * that never use `RuleTester`. + */ +let ajv; + +/* + * RuleTester uses this config as its default. This can be overwritten via + * setDefaultConfig(). + */ +let sharedDefaultConfig = { rules: {} }; + +/* + * List every parameters possible on a test case that are not related to eslint + * configuration + */ +const RuleTesterParameters = [ + "name", + "code", + "filename", + "options", + "before", + "after", + "errors", + "output", + "only", +]; + +/* + * All allowed property names in error objects. + */ +const errorObjectParameters = new Set([ + "message", + "messageId", + "data", + "line", + "column", + "endLine", + "endColumn", + "suggestions", +]); +const friendlyErrorObjectParameterList = `[${[...errorObjectParameters].map(key => `'${key}'`).join(", ")}]`; + +/* + * All allowed property names in suggestion objects. + */ +const suggestionObjectParameters = new Set([ + "desc", + "messageId", + "data", + "output", +]); +const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`; + +const forbiddenMethods = [ + "applyInlineConfig", + "applyLanguageOptions", + "finalize", +]; + +/** @type {Map} */ +const forbiddenMethodCalls = new Map( + forbiddenMethods.map(methodName => [methodName, new WeakSet()]), +); + +const hasOwnProperty = Function.call.bind(Object.hasOwnProperty); + +/** + * Gets the shared ajv instance, constructing it on first use. + * @returns {import("ajv").Ajv} The ajv instance. + */ +function getAjv() { + if (!ajv) { + ajv = require("../shared/ajv")({ strictDefaults: true }); + } + return ajv; +} + +/** + * Clones a given value deeply. + * Note: This ignores `parent` property. + * @param {any} x A value to clone. + * @returns {any} A cloned value. + */ +function cloneDeeplyExcludesParent(x) { + if (typeof x === "object" && x !== null) { + if (Array.isArray(x)) { + return x.map(cloneDeeplyExcludesParent); + } + + const retv = {}; + + for (const key in x) { + if (key !== "parent" && hasOwnProperty(x, key)) { + retv[key] = cloneDeeplyExcludesParent(x[key]); + } + } + + return retv; + } + + return x; +} + +/** + * Freezes a given value deeply. + * @param {any} x A value to freeze. + * @param {Set} seenObjects Objects already seen during the traversal. + * @returns {void} + */ +function freezeDeeply(x, seenObjects = new Set()) { + if (typeof x === "object" && x !== null) { + if (seenObjects.has(x)) { + return; // skip to avoid infinite recursion + } + seenObjects.add(x); + + if (Array.isArray(x)) { + x.forEach(element => { + freezeDeeply(element, seenObjects); + }); + } else { + for (const key in x) { + if (key !== "parent" && hasOwnProperty(x, key)) { + freezeDeeply(x[key], seenObjects); + } + } + } + Object.freeze(x); + } +} + +/** + * Replace control characters by `\u00xx` form. + * @param {string} text The text to sanitize. + * @returns {string} The sanitized text. + */ +function sanitize(text) { + if (typeof text !== "string") { + return ""; + } + return text.replace( + /[\u0000-\u0009\u000b-\u001a]/gu, // eslint-disable-line no-control-regex -- Escaping controls + c => `\\u${c.codePointAt(0).toString(16).padStart(4, "0")}`, + ); +} + +/** + * Define `start`/`end` properties as throwing error. + * @param {string} objName Object name used for error messages. + * @param {ASTNode} node The node to define. + * @returns {void} + */ +function defineStartEndAsError(objName, node) { + Object.defineProperties(node, { + start: { + get() { + throw new Error( + `Use ${objName}.range[0] instead of ${objName}.start`, + ); + }, + configurable: true, + enumerable: false, + }, + end: { + get() { + throw new Error( + `Use ${objName}.range[1] instead of ${objName}.end`, + ); + }, + configurable: true, + enumerable: false, + }, + }); +} + +/** + * Define `start`/`end` properties of all nodes of the given AST as throwing error. + * @param {ASTNode} ast The root node to errorize `start`/`end` properties. + * @param {Object} [visitorKeys] Visitor keys to be used for traversing the given ast. + * @returns {void} + */ +function defineStartEndAsErrorInTree(ast, visitorKeys) { + Traverser.traverse(ast, { + visitorKeys, + enter: defineStartEndAsError.bind(null, "node"), + }); + ast.tokens.forEach(defineStartEndAsError.bind(null, "token")); + ast.comments.forEach(defineStartEndAsError.bind(null, "token")); +} + +/** + * Wraps the given parser in order to intercept and modify return values from the `parse` and `parseForESLint` methods, for test purposes. + * In particular, to modify ast nodes, tokens and comments to throw on access to their `start` and `end` properties. + * @param {Parser} parser Parser object. + * @returns {Parser} Wrapped parser object. + */ +function wrapParser(parser) { + if (typeof parser.parseForESLint === "function") { + return { + [parserSymbol]: parser, + parseForESLint(...args) { + const ret = parser.parseForESLint(...args); + + defineStartEndAsErrorInTree(ret.ast, ret.visitorKeys); + return ret; + }, + }; + } + + return { + [parserSymbol]: parser, + parse(...args) { + const ast = parser.parse(...args); + + defineStartEndAsErrorInTree(ast); + return ast; + }, + }; +} + +/** + * Function to replace forbidden `SourceCode` methods. Allows just one call per method. + * @param {string} methodName The name of the method to forbid. + * @param {Function} prototype The prototype with the original method to call. + * @returns {Function} The function that throws the error. + */ +function throwForbiddenMethodError(methodName, prototype) { + const original = prototype[methodName]; + + return function (...args) { + const called = forbiddenMethodCalls.get(methodName); + + /* eslint-disable no-invalid-this -- needed to operate as a method. */ + if (!called.has(this)) { + called.add(this); + + return original.apply(this, args); + } + /* eslint-enable no-invalid-this -- not needed past this point */ + + throw new Error( + `\`SourceCode#${methodName}()\` cannot be called inside a rule.`, + ); + }; +} + +/** + * Extracts names of {{ placeholders }} from the reported message. + * @param {string} message Reported message + * @returns {string[]} Array of placeholder names + */ +function getMessagePlaceholders(message) { + const matcher = getPlaceholderMatcher(); + + return Array.from(message.matchAll(matcher), ([, name]) => name.trim()); +} + +/** + * Returns the placeholders in the reported messages but + * only includes the placeholders available in the raw message and not in the provided data. + * @param {string} message The reported message + * @param {string} raw The raw message specified in the rule meta.messages + * @param {undefined|Record} data The passed + * @returns {string[]} Missing placeholder names + */ +function getUnsubstitutedMessagePlaceholders(message, raw, data = {}) { + const unsubstituted = getMessagePlaceholders(message); + + if (unsubstituted.length === 0) { + return []; + } + + // Remove false positives by only counting placeholders in the raw message, which were not provided in the data matcher or added with a data property + const known = getMessagePlaceholders(raw); + const provided = Object.keys(data); + + return unsubstituted.filter( + name => known.includes(name) && !provided.includes(name), + ); +} + +const metaSchemaDescription = ` +\t- If the rule has options, set \`meta.schema\` to an array or non-empty object to enable options validation. +\t- If the rule doesn't have options, omit \`meta.schema\` to enforce that no options can be passed to the rule. +\t- You can also set \`meta.schema\` to \`false\` to opt-out of options validation (not recommended). + +\thttps://eslint.org/docs/latest/extend/custom-rules#options-schemas +`; + +/* + * Ignored test case properties when checking for test case duplicates. + */ +const duplicationIgnoredParameters = new Set(["name", "errors", "output"]); + +/** + * Normalizes a test case item, ensuring it is an object with a 'code' property. + * If the item is not an object, it returns an object with the 'code' property set to the item. + * @param {any} item The test case item to normalize. + * @returns {Object} The normalized test case object. + */ +function normalizeTestCase(item) { + return item && typeof item === "object" ? item : { code: item }; +} + +/** + * Asserts that the `errors` property of an invalid test case is valid. + * @param {number | string[]} errors The `errors` property of the invalid test case. + * @param {string} ruleName The name of the rule being tested. + * @param {Object} [assertionOptions] The assertion options for the test case. + * @returns {void} + */ +function assertErrorsProperty(errors, ruleName, assertionOptions = {}) { + const isNumber = typeof errors === "number"; + const isArray = Array.isArray(errors); + + if (!isNumber && !isArray) { + if (errors === void 0) { + assert.fail( + `Did not specify errors for an invalid test of ${ruleName}`, + ); + } else { + assert.fail( + `Invalid 'errors' property for invalid test of ${ruleName}: expected a number or an array but got ${ + errors === null ? "null" : typeof errors + }`, + ); + } + } + + const { requireMessage = false, requireLocation = false } = + assertionOptions; + + if (isArray) { + assert.ok( + errors.length !== 0, + "Invalid cases must have at least one error", + ); + + for (const [number, error] of errors.entries()) { + if (typeof error === "string" || error instanceof RegExp) { + // Just an error message. + assert.ok( + requireMessage !== "messageId" && !requireLocation, + `errors[${number}] should be an object when 'assertionOptions.requireMessage' is 'messageId' or 'assertionOptions.requireLocation' is true.`, + ); + } else if (typeof error === "object" && error !== null) { + /* + * Error object. + * This may have a message, messageId, data, line, and/or column. + */ + + for (const propertyName of Object.keys(error)) { + assert.ok( + errorObjectParameters.has(propertyName), + `Invalid error property name '${propertyName}'. Expected one of ${friendlyErrorObjectParameterList}.`, + ); + } + + if (requireMessage === "message") { + assert.ok( + !hasOwnProperty(error, "messageId") && + hasOwnProperty(error, "message"), + `errors[${number}] should specify 'message' (and not 'messageId') when 'assertionOptions.requireMessage' is 'message'.`, + ); + } else if (requireMessage === "messageId") { + assert.ok( + !hasOwnProperty(error, "message") && + hasOwnProperty(error, "messageId"), + `errors[${number}] should specify 'messageId' (and not 'message') when 'assertionOptions.requireMessage' is 'messageId'.`, + ); + } + + if (hasOwnProperty(error, "message")) { + assert.ok( + !hasOwnProperty(error, "messageId"), + `errors[${number}] should not specify both 'message' and 'messageId'.`, + ); + assert.ok( + !hasOwnProperty(error, "data"), + `errors[${number}] should not specify both 'data' and 'message'.`, + ); + } else { + assert.ok( + hasOwnProperty(error, "messageId"), + `errors[${number}] must specify either 'messageId' or 'message'.`, + ); + } + } else { + assert.fail( + `errors[${number}] must be a string, RegExp, or an object.`, + ); + } + } + } else { + assert.ok( + !requireMessage && !requireLocation, + "Invalid cases must have 'errors' value as an array", + ); + assert.ok( + errors > 0, + "Invalid cases must have 'error' value greater than 0", + ); + } +} + +/** + * Check if this test case is a duplicate of one we have seen before. + * @param {Object} item test case object + * @param {Set} seenTestCases set of serialized test cases we have seen so far (managed by this function) + * @returns {void} + */ +function checkDuplicateTestCase(item, seenTestCases) { + if (!isSerializable(item)) { + /* + * If we can't serialize a test case (because it contains a function, RegExp, etc), skip the check. + * This might happen with properties like: options, plugins, settings, languageOptions.parser, languageOptions.parserOptions. + */ + return; + } + + const serializedTestCase = stringify(item, { + replacer(key, value) { + // "this" is the currently stringified object --> only ignore top-level properties + return item !== this || !duplicationIgnoredParameters.has(key) + ? value + : void 0; + }, + }); + + assert( + !seenTestCases.has(serializedTestCase), + "detected duplicate test case", + ); + seenTestCases.add(serializedTestCase); +} + +/** + * Asserts that a rule is valid. + * A valid rule must be an object with a `create` method. + * @param {Object} rule The rule to check. + * @param {string} ruleName The name of the rule. + * @returns {void} + * @throws {AssertionError} If the rule is not valid. + */ +function assertRule(rule, ruleName) { + assert.ok( + rule && typeof rule === "object" && typeof rule.create === "function", + `Rule ${ruleName} must be an object with a \`create\` method`, + ); +} + +/** + * Asserts that a test scenario object is valid. + * A valid test scenario object must have `valid` and `invalid` properties, both of + * which must be arrays. + * @param {Object} test The test scenario object to check. + * @param {string} ruleName The name of the rule being tested. + * @returns {void} + * @throws {AssertionError} If the test scenario object is not valid. + */ +function assertTest(test, ruleName) { + assert.ok( + test && typeof test === "object", + `Test Scenarios for rule ${ruleName} : Could not find test scenario object`, + ); + + const hasValid = Array.isArray(test.valid); + const hasInvalid = Array.isArray(test.invalid); + + assert.ok( + hasValid, + `Test Scenarios for rule ${ruleName} is invalid: Could not find any valid test scenarios`, + ); + + assert.ok( + hasInvalid, + `Test Scenarios for rule ${ruleName} is invalid: Could not find any invalid test scenarios`, + ); +} + +/** + * Asserts that the common properties of a valid/invalid test case have the correct types. + * @param {Object} item The test case object to check. + * @returns {void} + */ +function assertTestCommonProperties(item) { + assert.ok( + typeof item.code === "string", + "Test case must specify a string value for 'code'", + ); + + // optional properties + if (item.name) { + assert.ok( + typeof item.name === "string", + "Optional test case property 'name' must be a string", + ); + } + if (hasOwnProperty(item, "only")) { + assert.ok( + typeof item.only === "boolean", + "Optional test case property 'only' must be a boolean", + ); + } + if (hasOwnProperty(item, "filename")) { + assert.ok( + typeof item.filename === "string", + "Optional test case property 'filename' must be a string", + ); + } + if (hasOwnProperty(item, "options")) { + assert.ok( + Array.isArray(item.options), + "Optional test case property 'options' must be an array", + ); + } +} + +/** + * Asserts that a valid test case object is valid. + * A valid test case must specify a string value for 'code'. + * Optional properties are checked for correct types. + * @param {Object} item The valid test case object to check. + * @param {Set} seenTestCases Set of serialized test cases to check for duplicates. + * @returns {void} + * @throws {AssertionError} If the test case is not valid. + */ +function assertValidTestCase(item, seenTestCases) { + // must not have properties of invalid test cases + assert.ok( + item.errors === void 0, + "Valid test case must not have 'errors' property", + ); + assert.ok( + item.output === void 0, + "Valid test case must not have 'output' property", + ); + + assertTestCommonProperties(item); + checkDuplicateTestCase(item, seenTestCases); +} + +/** + * Asserts that the invalid test case object is valid. + * An invalid test case must specify a string value for 'code' and must have 'errors' property. + * Optional properties are checked for correct types. + * @param {Object} item The invalid test case object to check. + * @param {Set} seenTestCases Set of serialized test cases to check for duplicates. + * @param {string} ruleName The name of the rule being tested. + * @param {Object} [assertionOptions] The assertion options for the test case. + * @returns {void} + * @throws {AssertionError} If the test case is not valid. + */ +function assertInvalidTestCase( + item, + seenTestCases, + ruleName, + assertionOptions = {}, +) { + assertTestCommonProperties(item); + + assertErrorsProperty(item.errors, ruleName, assertionOptions); + + // 'output' is optional, but if it exists it must be a string or null + if (hasOwnProperty(item, "output")) { + assert.ok( + item.output === null || typeof item.output === "string", + "Test property 'output', if specified, must be a string or null. If no autofix is expected, then omit the 'output' property or set it to null.", + ); + } + + checkDuplicateTestCase(item, seenTestCases); +} + +/** + * Gets the invocation location from the stack trace for later use. + * @param {Function} relative The function before the invocation point. + * @returns {{ sourceFile: string; sourceLine: number; sourceColumn: number; }} The invocation location. + */ +function getInvocationLocation(relative = getInvocationLocation) { + const dummyObject = {}; + let location; + const { prepareStackTrace } = Error; + Error.prepareStackTrace = (_, [callSite]) => { + location = { + sourceFile: + callSite.getFileName() ?? + `${callSite.getEvalOrigin()}, `, + sourceLine: callSite.getLineNumber() ?? 1, + sourceColumn: callSite.getColumnNumber() ?? 1, + }; + }; + Error.captureStackTrace(dummyObject, relative); // invoke Error.prepareStackTrace in Bun + void dummyObject.stack; // invoke Error.prepareStackTrace in Node.js + Error.prepareStackTrace = prepareStackTrace; + return location; +} + +/** + * Estimates the location of the test case in the source file. + * @param {Function} invoker The method that runs the tests. + * @returns {(key: string) => string} The lazy resolver for the estimated location of the test case. + */ +function buildLazyTestLocationEstimator(invoker) { + const invocationLocation = getInvocationLocation(invoker); + let testLocations = null; + return key => { + if (testLocations === null) { + const { sourceFile, sourceLine, sourceColumn } = invocationLocation; + testLocations = { + root: `${sourceFile}:${sourceLine}:${sourceColumn}`, + }; + + if (existsSync(sourceFile)) { + let content = readFileSync(sourceFile, "utf8") + .split("\n") + .slice(sourceLine - 1); + content[0] = content[0].slice(Math.max(0, sourceColumn - 1)); + content = content.map( + l => + l + .trim() // Remove whitespace + .replace(/\s*\/\/.*$(? + /\bvalid\s*:/u.test(line), + ); + const invalidStartIndex = content.findIndex(line => + /\binvalid\s*:/u.test(line), + ); + + testLocations.valid = `${sourceFile}:${ + sourceLine + validStartIndex + }`; + testLocations.invalid = `${sourceFile}:${ + sourceLine + invalidStartIndex + }`; + + // Scenario basics + const validEndIndex = + validStartIndex < invalidStartIndex + ? invalidStartIndex + : content.length; + const invalidEndIndex = + validStartIndex < invalidStartIndex + ? content.length + : validStartIndex; + + const validLines = content.slice( + validStartIndex, + validEndIndex, + ); + const invalidLines = content.slice( + invalidStartIndex, + invalidEndIndex, + ); + + let objectDepth = 0; + const validLineIndexes = validLines + .map((l, i) => { + // matches `key: {` and `{` + if (/^(?:\w+\s*:\s*)?\{/u.test(l)) { + objectDepth++; + } + + if (objectDepth > 0) { + if (l.endsWith("}") || l.endsWith("},")) { + objectDepth--; + } + + return objectDepth <= 1 && l.includes("code:") + ? i + : null; + } + + return l.endsWith(",") ? i : null; + }) + .filter(Boolean); + const invalidLineIndexes = invalidLines + .map((l, i) => + l.trimStart().startsWith("errors:") ? i : null, + ) + .filter(Boolean); + + Object.assign( + testLocations, + { + [`valid[0]`]: `${sourceFile}:${ + sourceLine + validStartIndex + }`, + }, + Object.fromEntries( + validLineIndexes.map((location, validIndex) => [ + `valid[${validIndex}]`, + `${sourceFile}:${ + sourceLine + validStartIndex + location + }`, + ]), + ), + Object.fromEntries( + invalidLineIndexes.map((location, invalidIndex) => [ + `invalid[${invalidIndex}]`, + `${sourceFile}:${ + sourceLine + invalidStartIndex + location + }`, + ]), + ), + ); + + // Indexes for errors inside each invalid test case + invalidLineIndexes.push(invalidLines.length); + + for (let i = 0; i < invalidLineIndexes.length - 1; i++) { + const start = invalidLineIndexes[i]; + const end = invalidLineIndexes[i + 1]; + const errorLines = invalidLines.slice(start, end); + let errorObjectDepth = 0; + const errorLineIndexes = errorLines + .map((l, j) => { + if (l.startsWith("{") || l.endsWith("{")) { + errorObjectDepth++; + + if (l.endsWith("}") || l.endsWith("},")) { + errorObjectDepth--; + } + + return errorObjectDepth <= 1 ? j : null; + } + + if (errorObjectDepth > 0) { + if (l.endsWith("}") || l.endsWith("},")) { + errorObjectDepth--; + } + + return null; + } + + return l.endsWith(",") ? j : null; + }) + .filter(Boolean); + + Object.assign( + testLocations, + Object.fromEntries( + errorLineIndexes.map((line, errorIndex) => [ + `invalid[${i}].errors[${errorIndex}]`, + `${sourceFile}:${ + sourceLine + + invalidStartIndex + + start + + line + }`, + ]), + ), + ); + } + } + } + + return testLocations[key] || "unknown source"; + }; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +// default separators for testing +const DESCRIBE = Symbol("describe"); +const IT = Symbol("it"); +const IT_ONLY = Symbol("itOnly"); + +/** + * This is `it` default handler if `it` don't exist. + * @this {Mocha} + * @param {string} text The description of the test case. + * @param {Function} method The logic of the test case. + * @throws {Error} Any error upon execution of `method`. + * @returns {any} Returned value of `method`. + */ +function itDefaultHandler(text, method) { + try { + return method.call(this); + } catch (err) { + if (err instanceof assert.AssertionError) { + err.message += ` (${util.inspect(err.actual)} ${err.operator} ${util.inspect(err.expected)})`; + } + throw err; + } +} + +/** + * This is `describe` default handler if `describe` don't exist. + * @this {Mocha} + * @param {string} text The description of the test case. + * @param {Function} method The logic of the test case. + * @returns {any} Returned value of `method`. + */ +function describeDefaultHandler(text, method) { + return method.call(this); +} + +/** + * Mocha test wrapper. + */ +class RuleTester { + /** + * Creates a new instance of RuleTester. + * @param {Object} [testerConfig] Optional, extra configuration for the tester + */ + constructor(testerConfig = {}) { + /** + * The configuration to use for this tester. Combination of the tester + * configuration and the default configuration. + * @type {Object} + */ + this.testerConfig = [ + sharedDefaultConfig, + testerConfig, + { rules: { "rule-tester/validate-ast": "error" } }, + ]; + + this.linter = new Linter({ configType: "flat" }); + } + + /** + * Set the configuration to use for all future tests + * @param {Object} config the configuration to use. + * @throws {TypeError} If non-object config. + * @returns {void} + */ + static setDefaultConfig(config) { + if (typeof config !== "object" || config === null) { + throw new TypeError( + "RuleTester.setDefaultConfig: config must be an object", + ); + } + sharedDefaultConfig = config; + + // Make sure the rules object exists since it is assumed to exist later + sharedDefaultConfig.rules = sharedDefaultConfig.rules || {}; + } + + /** + * Get the current configuration used for all tests + * @returns {Object} the current configuration + */ + static getDefaultConfig() { + return sharedDefaultConfig; + } + + /** + * Reset the configuration to the initial configuration of the tester removing + * any changes made until now. + * @returns {void} + */ + static resetDefaultConfig() { + sharedDefaultConfig = { + rules: { + ...testerDefaultConfig.rules, + }, + }; + } + + /* + * If people use `mocha test.js --watch` command, `describe` and `it` function + * instances are different for each execution. So `describe` and `it` should get fresh instance + * always. + */ + static get describe() { + return ( + this[DESCRIBE] || + (typeof describe === "function" ? describe : describeDefaultHandler) + ); + } + + static set describe(value) { + this[DESCRIBE] = value; + } + + static get it() { + return this[IT] || (typeof it === "function" ? it : itDefaultHandler); + } + + static set it(value) { + this[IT] = value; + } + + /** + * Adds the `only` property to a test to run it in isolation. + * @param {string | ValidTestCase | InvalidTestCase} item A single test to run by itself. + * @returns {ValidTestCase | InvalidTestCase} The test with `only` set. + */ + static only(item) { + if (typeof item === "string") { + return { code: item, only: true }; + } + + return { ...item, only: true }; + } + + static get itOnly() { + if (typeof this[IT_ONLY] === "function") { + return this[IT_ONLY]; + } + if ( + typeof this[IT] === "function" && + typeof this[IT].only === "function" + ) { + return Function.bind.call(this[IT].only, this[IT]); + } + if (typeof it === "function" && typeof it.only === "function") { + return Function.bind.call(it.only, it); + } + + if ( + typeof this[DESCRIBE] === "function" || + typeof this[IT] === "function" + ) { + throw new Error( + "Set `RuleTester.itOnly` to use `only` with a custom test framework.\n" + + "See https://eslint.org/docs/latest/integrate/nodejs-api#customizing-ruletester for more.", + ); + } + if (typeof it === "function") { + throw new Error( + "The current test framework does not support exclusive tests with `only`.", + ); + } + throw new Error( + "To use `only`, use RuleTester with a test framework that provides `it.only()` like Mocha.", + ); + } + + static set itOnly(value) { + this[IT_ONLY] = value; + } + + /** + * Adds a new rule test to execute. + * @param {string} ruleName The name of the rule to run. + * @param {RuleDefinition} rule The rule to test. + * @param {{ + * assertionOptions?: { + * requireMessage?: boolean | "message" | "messageId", + * requireLocation?: boolean + * requireData?: boolean | "error" | "suggestion" + * }, + * valid: (ValidTestCase | string)[], + * invalid: InvalidTestCase[] + * }} test The collection of tests to run. + * @throws {TypeError|Error} If `rule` is not an object with a `create` method, + * or if non-object `test`, or if a required scenario of the given type is missing. + * @returns {void} + */ + run(ruleName, rule, test) { + const testerConfig = this.testerConfig, + linter = this.linter, + ruleId = `rule-to-test/${ruleName}`; + + assertRule(rule, ruleName); + assertTest(test, ruleName); + + const estimateTestLocation = buildLazyTestLocationEstimator(this.run); + + const baseConfig = [ + { + plugins: { + // copy root plugin over + "@": { + /* + * Parsers are wrapped to detect more errors, so this needs + * to be a new object for each call to run(), otherwise the + * parsers will be wrapped multiple times. + */ + parsers: { + ...defaultConfig[0].plugins["@"].parsers, + }, + + /* + * The rules key on the default plugin is a proxy to lazy-load + * just the rules that are needed. So, don't create a new object + * here, just use the default one to keep that performance + * enhancement. + */ + rules: defaultConfig[0].plugins["@"].rules, + languages: defaultConfig[0].plugins["@"].languages, + }, + "rule-to-test": { + rules: { + [ruleName]: Object.assign({}, rule, { + // Create a wrapper rule that freezes the `context` properties. + create(context) { + freezeDeeply(context.options); + freezeDeeply(context.settings); + freezeDeeply(context.parserOptions); + + // freezeDeeply(context.languageOptions); + + return rule.create(context); + }, + }), + }, + }, + }, + language: defaultConfig[0].language, + }, + ...defaultRuleTesterConfig, + ]; + + /** + * Runs a hook on the given item when it's assigned to the given property + * @param {Object} item Item to run the hook on + * @param {string} prop The property having the hook assigned to + * @throws {Error} If the property is not a function or that function throws an error + * @returns {void} + * @private + */ + function runHook(item, prop) { + if (hasOwnProperty(item, prop)) { + assert.strictEqual( + typeof item[prop], + "function", + `Optional test case property '${prop}' must be a function`, + ); + item[prop](); + } + } + /** + * Run the rule for the given item + * @param {Object} item Item to run the rule against + * @throws {Error} If an invalid schema. + * @returns {Object} Eslint run result + * @private + */ + function runRuleForItem(item) { + const code = item.code; + const filename = hasOwnProperty(item, "filename") + ? item.filename + : void 0; + const options = hasOwnProperty(item, "options") ? item.options : []; + const flatConfigArrayOptions = { + baseConfig, + }; + + if (filename) { + flatConfigArrayOptions.basePath = + path.parse(filename).root || void 0; + } + + const configs = new FlatConfigArray( + testerConfig, + flatConfigArrayOptions, + ); + + /* + * Modify the returned config so that the parser is wrapped to catch + * access of the start/end properties. This method is called just + * once per code snippet being tested, so each test case gets a clean + * parser. + */ + configs[ConfigArraySymbol.finalizeConfig] = function (...args) { + // can't do super here :( + const proto = Object.getPrototypeOf(this); + const calculatedConfig = proto[ + ConfigArraySymbol.finalizeConfig + ].apply(this, args); + + // wrap the parser to catch start/end property access + if (calculatedConfig.language === jslang) { + calculatedConfig.languageOptions.parser = wrapParser( + calculatedConfig.languageOptions.parser, + ); + } + + return calculatedConfig; + }; + + let output, beforeAST, afterAST; + + /* + * Assumes everything on the item is a config except for the + * parameters used by this tester + */ + const itemConfig = { ...item }; + + for (const parameter of RuleTesterParameters) { + delete itemConfig[parameter]; + } + + /* + * Create the config object from the tester config and this item + * specific configurations. + */ + configs.push(itemConfig); + + configs.push({ + rules: { + [ruleId]: [1, ...options], + }, + }); + + let schema; + + try { + schema = Config.getRuleOptionsSchema(rule); + } catch (err) { + err.message += metaSchemaDescription; + throw err; + } + + /* + * Check and throw an error if the schema is an empty object (`schema:{}`), because such schema + * doesn't validate or enforce anything and is therefore considered a possible error. If the intent + * was to skip options validation, `schema:false` should be set instead (explicit opt-out). + * + * For this purpose, a schema object is considered empty if it doesn't have any own enumerable string-keyed + * properties. While `ajv.compile()` does use enumerable properties from the prototype chain as well, + * it caches compiled schemas by serializing only own enumerable properties, so it's generally not a good idea + * to use inherited properties in schemas because schemas that differ only in inherited properties would end up + * having the same cache entry that would be correct for only one of them. + * + * At this point, `schema` can only be an object or `null`. + */ + if (schema && Object.keys(schema).length === 0) { + throw new Error( + `\`schema: {}\` is a no-op${metaSchemaDescription}`, + ); + } + + /* + * Setup AST getters. + * The goal is to check whether or not AST was modified when + * running the rule under test. + */ + configs.push({ + plugins: { + "rule-tester": { + rules: { + "validate-ast": { + create() { + return { + Program(node) { + beforeAST = + cloneDeeplyExcludesParent(node); + }, + "Program:exit"(node) { + afterAST = node; + }, + }; + }, + }, + }, + }, + }, + }); + + if (schema) { + const ajvInstance = getAjv(); + + ajvInstance.validateSchema(schema); + + if (ajvInstance.errors) { + const errors = ajvInstance.errors + .map(error => { + const field = + error.dataPath[0] === "." + ? error.dataPath.slice(1) + : error.dataPath; + + return `\t${field}: ${error.message}`; + }) + .join("\n"); + + throw new Error([ + `Schema for rule ${ruleName} is invalid:`, + errors, + ]); + } + + /* + * `ajv.validateSchema` checks for errors in the structure of the schema (by comparing the schema against a "meta-schema"), + * and it reports those errors individually. However, there are other types of schema errors that only occur when compiling + * the schema (e.g. using invalid defaults in a schema), and only one of these errors can be reported at a time. As a result, + * the schema is compiled here separately from checking for `validateSchema` errors. + */ + try { + ajvInstance.compile(schema); + } catch (err) { + throw new Error( + `Schema for rule ${ruleName} is invalid: ${err.message}`, + { + cause: err, + }, + ); + } + } + + // check for validation errors + try { + configs.normalizeSync(); + configs.getConfig("test.js"); + } catch (error) { + error.message = `ESLint configuration in rule-tester is invalid: ${error.message}`; + throw error; + } + + // Verify the code. + const { applyLanguageOptions, applyInlineConfig, finalize } = + SourceCode.prototype; + let messages; + + try { + forbiddenMethods.forEach(methodName => { + SourceCode.prototype[methodName] = + throwForbiddenMethodError( + methodName, + SourceCode.prototype, + ); + }); + + messages = linter.verify(code, configs, filename); + } finally { + SourceCode.prototype.applyInlineConfig = applyInlineConfig; + SourceCode.prototype.applyLanguageOptions = + applyLanguageOptions; + SourceCode.prototype.finalize = finalize; + } + + const fatalErrorMessage = messages.find(m => m.fatal); + + assert( + !fatalErrorMessage, + `A fatal parsing error occurred: ${fatalErrorMessage && fatalErrorMessage.message}`, + ); + + // Verify if autofix makes a syntax error or not. + if (messages.some(m => m.fix)) { + output = SourceCodeFixer.applyFixes(code, messages).output; + const errorMessageInFix = linter + .verify(output, configs, filename) + .find(m => m.fatal); + + assert( + !errorMessageInFix, + [ + "A fatal parsing error occurred in autofix.", + `Error: ${errorMessageInFix && errorMessageInFix.message}`, + "Autofix output:", + output, + ].join("\n"), + ); + } else { + output = code; + } + + return { + messages, + output, + beforeAST, + afterAST: cloneDeeplyExcludesParent(afterAST), + configs, + filename, + }; + } + + /** + * Check if the AST was changed + * @param {ASTNode} beforeAST AST node before running + * @param {ASTNode} afterAST AST node after running + * @returns {void} + * @private + */ + function assertASTDidntChange(beforeAST, afterAST) { + if (!equal(beforeAST, afterAST)) { + assert.fail("Rule should not modify AST."); + } + } + + /** + * Check if the template is valid or not + * all valid cases go through this + * @param {Object} item Item to run the rule against + * @returns {void} + * @private + */ + function testValidTemplate(item) { + const result = runRuleForItem(item); + const messages = result.messages; + + assert.strictEqual( + messages.length, + 0, + util.format( + "Should have no errors but had %d: %s", + messages.length, + util.inspect(messages), + ), + ); + + assertASTDidntChange(result.beforeAST, result.afterAST); + } + + /** + * Asserts that the message matches its expected value. If the expected + * value is a regular expression, it is checked against the actual + * value. + * @param {string} actual Actual value + * @param {string|RegExp} expected Expected value + * @returns {void} + * @private + */ + function assertMessageMatches(actual, expected) { + if (expected instanceof RegExp) { + // assert.js doesn't have a built-in RegExp match function + assert.ok( + expected.test(actual), + `Expected '${actual}' to match ${expected}`, + ); + } else { + assert.strictEqual(actual, expected); + } + } + + /** + * Check if the template is invalid or not + * all invalid cases go through this. + * @param {Object} item Item to run the rule against + * @returns {void} + * @private + * @throws {Error} If the test case is invalid or has an invalid error. + */ + function testInvalidTemplate(item) { + const { + requireMessage = false, + requireLocation = false, + requireData = false, + } = test.assertionOptions ?? {}; + + const ruleHasMetaMessages = + hasOwnProperty(rule, "meta") && + hasOwnProperty(rule.meta, "messages"); + const friendlyIDList = ruleHasMetaMessages + ? `[${Object.keys(rule.meta.messages) + .map(key => `'${key}'`) + .join(", ")}]` + : null; + + assert.ok( + ruleHasMetaMessages || requireMessage !== "messageId", + `Assertion options can not use 'requireMessage: "messageId"' if rule under test doesn't define 'meta.messages'.`, + ); + + const result = runRuleForItem(item); + const messages = result.messages; + + for (const message of messages) { + if (hasOwnProperty(message, "suggestions")) { + /** @type {Map} */ + const seenMessageIndices = new Map(); + + for (let i = 0; i < message.suggestions.length; i += 1) { + const suggestionMessage = message.suggestions[i].desc; + const previous = + seenMessageIndices.get(suggestionMessage); + + assert.ok( + !seenMessageIndices.has(suggestionMessage), + `Suggestion message '${suggestionMessage}' reported from suggestion ${i} was previously reported by suggestion ${previous}. Suggestion messages should be unique within an error.`, + ); + seenMessageIndices.set(suggestionMessage, i); + } + } + } + + if (typeof item.errors === "number") { + assert.strictEqual( + messages.length, + item.errors, + util.format( + "Should have %d error%s but had %d: %s", + item.errors, + item.errors === 1 ? "" : "s", + messages.length, + util.inspect(messages), + ), + ); + } else { + assert.strictEqual( + messages.length, + item.errors.length, + util.format( + "Should have %d error%s but had %d: %s", + item.errors.length, + item.errors.length === 1 ? "" : "s", + messages.length, + util.inspect(messages), + ), + ); + + const hasMessageOfThisRule = messages.some( + m => m.ruleId === ruleId, + ); + + for (let i = 0, l = item.errors.length; i < l; i++) { + try { + const error = item.errors[i]; + const message = messages[i]; + + assert( + hasMessageOfThisRule, + "Error rule name should be the same as the name of the rule being tested", + ); + + if ( + typeof error === "string" || + error instanceof RegExp + ) { + // Just an error message. + assertMessageMatches(message.message, error); + assert.ok( + message.suggestions === void 0, + `Error at index ${i} has suggestions. Please convert the test error into an object and specify 'suggestions' property on it to test suggestions.`, + ); + } else if ( + typeof error === "object" && + error !== null + ) { + /* + * Error object. + * This may have a message, messageId, data, line, and/or column. + */ + + if (hasOwnProperty(error, "message")) { + assertMessageMatches( + message.message, + error.message, + ); + } else if (hasOwnProperty(error, "messageId")) { + assert.ok( + ruleHasMetaMessages, + "Error can not use 'messageId' if rule under test doesn't define 'meta.messages'.", + ); + if ( + !hasOwnProperty( + rule.meta.messages, + error.messageId, + ) + ) { + assert( + false, + `Invalid messageId '${error.messageId}'. Expected one of ${friendlyIDList}.`, + ); + } + assert.strictEqual( + message.messageId, + error.messageId, + `messageId '${message.messageId}' does not match expected messageId '${error.messageId}'.`, + ); + + const unsubstitutedPlaceholders = + getUnsubstitutedMessagePlaceholders( + message.message, + rule.meta.messages[message.messageId], + error.data, + ); + + assert.ok( + unsubstitutedPlaceholders.length === 0, + `The reported message has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property in the context.report() call.`, + ); + + if (hasOwnProperty(error, "data")) { + /* + * if data was provided, then directly compare the returned message to a synthetic + * interpolated message using the same message ID and data provided in the test. + * See https://github.com/eslint/eslint/issues/9890 for context. + */ + const unformattedOriginalMessage = + rule.meta.messages[error.messageId]; + const rehydratedMessage = interpolate( + unformattedOriginalMessage, + error.data, + ); + + assert.strictEqual( + message.message, + rehydratedMessage, + `Hydrated message "${rehydratedMessage}" does not match "${message.message}"`, + ); + } else { + const requiresDataProperty = + requireData === true || + requireData === "error"; + const hasPlaceholders = + getMessagePlaceholders( + rule.meta.messages[error.messageId], + ).length > 0; + assert.ok( + !requiresDataProperty || + !hasPlaceholders, + `Error should specify the 'data' property as the referenced message has placeholders.`, + ); + } + } + + const locationProperties = [ + "line", + "column", + "endLine", + "endColumn", + ]; + const actualLocation = {}; + const expectedLocation = {}; + + for (const key of locationProperties) { + if (hasOwnProperty(error, key)) { + actualLocation[key] = message[key]; + expectedLocation[key] = error[key]; + } + } + + if (requireLocation) { + const missingKeys = locationProperties.filter( + key => + !hasOwnProperty(error, key) && + hasOwnProperty(message, key), + ); + assert.ok( + missingKeys.length === 0, + `Error is missing expected location properties: ${missingKeys.join(", ")}`, + ); + } + + if (Object.keys(expectedLocation).length > 0) { + assert.deepStrictEqual( + actualLocation, + expectedLocation, + "Actual error location does not match expected error location.", + ); + } + + assert.ok( + !message.suggestions || + hasOwnProperty(error, "suggestions"), + `Error at index ${i} has suggestions. Please specify 'suggestions' property on the test error object.`, + ); + if (hasOwnProperty(error, "suggestions")) { + // Support asserting there are no suggestions + const expectsSuggestions = Array.isArray( + error.suggestions, + ) + ? error.suggestions.length > 0 + : Boolean(error.suggestions); + const hasSuggestions = + message.suggestions !== void 0; + + if (!hasSuggestions && expectsSuggestions) { + assert.ok( + !error.suggestions, + `Error should have suggestions on error with message: "${message.message}"`, + ); + } else if (hasSuggestions) { + assert.ok( + expectsSuggestions, + `Error should have no suggestions on error with message: "${message.message}"`, + ); + if (typeof error.suggestions === "number") { + assert.strictEqual( + message.suggestions.length, + error.suggestions, + `Error should have ${error.suggestions} suggestions. Instead found ${message.suggestions.length} suggestions`, + ); + } else if ( + Array.isArray(error.suggestions) + ) { + assert.strictEqual( + message.suggestions.length, + error.suggestions.length, + `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`, + ); + + error.suggestions.forEach( + (expectedSuggestion, index) => { + assert.ok( + typeof expectedSuggestion === + "object" && + expectedSuggestion !== + null, + "Test suggestion in 'suggestions' array must be an object.", + ); + Object.keys( + expectedSuggestion, + ).forEach(propertyName => { + assert.ok( + suggestionObjectParameters.has( + propertyName, + ), + `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`, + ); + }); + + const actualSuggestion = + message.suggestions[index]; + const suggestionPrefix = `Error Suggestion at index ${index}:`; + + if ( + hasOwnProperty( + expectedSuggestion, + "desc", + ) + ) { + assert.ok( + !hasOwnProperty( + expectedSuggestion, + "data", + ), + `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`, + ); + assert.ok( + !hasOwnProperty( + expectedSuggestion, + "messageId", + ), + `${suggestionPrefix} Test should not specify both 'desc' and 'messageId'.`, + ); + assert.strictEqual( + actualSuggestion.desc, + expectedSuggestion.desc, + `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`, + ); + } else if ( + hasOwnProperty( + expectedSuggestion, + "messageId", + ) + ) { + assert.ok( + ruleHasMetaMessages, + `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`, + ); + assert.ok( + hasOwnProperty( + rule.meta.messages, + expectedSuggestion.messageId, + ), + `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`, + ); + assert.strictEqual( + actualSuggestion.messageId, + expectedSuggestion.messageId, + `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`, + ); + + const rawSuggestionMessage = + rule.meta.messages[ + expectedSuggestion + .messageId + ]; + const unsubstitutedPlaceholders = + getUnsubstitutedMessagePlaceholders( + actualSuggestion.desc, + rawSuggestionMessage, + expectedSuggestion.data, + ); + + assert.ok( + unsubstitutedPlaceholders.length === + 0, + `The message of the suggestion has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property for the suggestion in the context.report() call.`, + ); + + if ( + hasOwnProperty( + expectedSuggestion, + "data", + ) + ) { + const unformattedMetaMessage = + rule.meta.messages[ + expectedSuggestion + .messageId + ]; + const rehydratedDesc = + interpolate( + unformattedMetaMessage, + expectedSuggestion.data, + ); + + assert.strictEqual( + actualSuggestion.desc, + rehydratedDesc, + `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`, + ); + } else { + const requiresDataProperty = + requireData === + true || + requireData === + "suggestion"; + const hasPlaceholders = + getMessagePlaceholders( + rawSuggestionMessage, + ).length > 0; + assert.ok( + !requiresDataProperty || + !hasPlaceholders, + `${suggestionPrefix} Suggestion should specify the 'data' property as the referenced message has placeholders.`, + ); + } + } else if ( + hasOwnProperty( + expectedSuggestion, + "data", + ) + ) { + assert.fail( + `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`, + ); + } else { + assert.fail( + `${suggestionPrefix} Test must specify either 'messageId' or 'desc'.`, + ); + } + + assert.ok( + hasOwnProperty( + expectedSuggestion, + "output", + ), + `${suggestionPrefix} The "output" property is required.`, + ); + const codeWithAppliedSuggestion = + SourceCodeFixer.applyFixes( + item.code, + [actualSuggestion], + ).output; + + // Verify if suggestion fix makes a syntax error or not. + const errorMessageInSuggestion = + linter + .verify( + codeWithAppliedSuggestion, + result.configs, + result.filename, + ) + .find(m => m.fatal); + + assert( + !errorMessageInSuggestion, + [ + "A fatal parsing error occurred in suggestion fix.", + `Error: ${errorMessageInSuggestion && errorMessageInSuggestion.message}`, + "Suggestion output:", + codeWithAppliedSuggestion, + ].join("\n"), + ); + + assert.strictEqual( + codeWithAppliedSuggestion, + expectedSuggestion.output, + `Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: "${message.message}"`, + ); + assert.notStrictEqual( + expectedSuggestion.output, + item.code, + `The output of a suggestion should differ from the original source code for suggestion at index: ${index} on error with message: "${message.message}"`, + ); + }, + ); + } else { + assert.fail( + "Test error object property 'suggestions' should be an array or a number", + ); + } + } + } + } + } catch (error) { + if (error instanceof Error) { + error.errorIndex = i; + } + throw error; + } + } + } + + if (hasOwnProperty(item, "output")) { + if (item.output === null) { + assert.strictEqual( + result.output, + item.code, + "Expected no autofixes to be suggested", + ); + } else { + assert.strictEqual( + result.output, + item.output, + "Output is incorrect.", + ); + assert.notStrictEqual( + item.code, + item.output, + "Test property 'output' matches 'code'. If no autofix is expected, then omit the 'output' property or set it to null.", + ); + } + } else { + assert.strictEqual( + result.output, + item.code, + "The rule fixed the code. Please add 'output' property.", + ); + } + + assertASTDidntChange(result.beforeAST, result.afterAST); + } + + /* + * This creates a mocha test suite and pipes all supplied info through + * one of the templates above. + * The test suites for valid/invalid are created conditionally as + * test runners (eg. vitest) fail for empty test suites. + */ + this.constructor.describe(ruleName, () => { + if (test.valid.length > 0) { + this.constructor.describe("valid", () => { + const seenTestCases = new Set(); + test.valid.forEach((valid, index) => { + const item = normalizeTestCase(valid); + this.constructor[valid.only ? "itOnly" : "it"]( + sanitize(item.name || item.code), + () => { + try { + runHook(item, "before"); + assertValidTestCase(item, seenTestCases); + testValidTemplate(item); + } catch (error) { + if (error instanceof Error) { + error.scenarioType = "valid"; + error.scenarioIndex = index; + error.stack = error.stack.replace( + /^ +at /mu, + [ + ` roughly at RuleTester.run.valid[${index}] (${estimateTestLocation(`valid[${index}]`)})`, + ` roughly at RuleTester.run.valid (${estimateTestLocation("valid")})`, + ` at RuleTester.run (${estimateTestLocation("root")})`, + " at ", + ].join("\n"), + ); + } + throw error; + } finally { + runHook(item, "after"); + } + }, + ); + }); + }); + } + + if (test.invalid.length > 0) { + this.constructor.describe("invalid", () => { + const seenTestCases = new Set(); + test.invalid.forEach((invalid, index) => { + const item = normalizeTestCase(invalid); + this.constructor[item.only ? "itOnly" : "it"]( + sanitize(item.name || item.code), + () => { + try { + runHook(item, "before"); + assertInvalidTestCase( + item, + seenTestCases, + ruleName, + test.assertionOptions, + ); + testInvalidTemplate(item); + } catch (error) { + if (error instanceof Error) { + error.scenarioType = "invalid"; + error.scenarioIndex = index; + const errorIndex = error.errorIndex; + error.stack = error.stack.replace( + /^ +at /mu, + [ + ...(typeof errorIndex === + "number" + ? [ + ` roughly at RuleTester.run.invalid[${index}].error[${errorIndex}] (${estimateTestLocation(`invalid[${index}].errors[${errorIndex}]`)})`, + ] + : []), + ` roughly at RuleTester.run.invalid[${index}] (${estimateTestLocation(`invalid[${index}]`)})`, + ` roughly at RuleTester.run.invalid (${estimateTestLocation("invalid")})`, + ` at RuleTester.run (${estimateTestLocation("root")})`, + " at ", + ].join("\n"), + ); + } + throw error; + } finally { + runHook(item, "after"); + } + }, + ); + }); + }); + } + }); + } +} + +RuleTester[DESCRIBE] = RuleTester[IT] = RuleTester[IT_ONLY] = null; + +module.exports = RuleTester; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/accessor-pairs.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/accessor-pairs.js new file mode 100644 index 00000000..5b91b7aa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/accessor-pairs.js @@ -0,0 +1,370 @@ +/** + * @fileoverview Rule to enforce getter and setter pairs in objects and classes. + * @author Gyandeep Singh + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * Property name if it can be computed statically, otherwise the list of the tokens of the key node. + * @typedef {string|Token[]} Key + */ + +/** + * Accessor nodes with the same key. + * @typedef {Object} AccessorData + * @property {Key} key Accessor's key + * @property {ASTNode[]} getters List of getter nodes. + * @property {ASTNode[]} setters List of setter nodes. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not the given lists represent the equal tokens in the same order. + * Tokens are compared by their properties, not by instance. + * @param {Token[]} left First list of tokens. + * @param {Token[]} right Second list of tokens. + * @returns {boolean} `true` if the lists have same tokens. + */ +function areEqualTokenLists(left, right) { + if (left.length !== right.length) { + return false; + } + + for (let i = 0; i < left.length; i++) { + const leftToken = left[i], + rightToken = right[i]; + + if ( + leftToken.type !== rightToken.type || + leftToken.value !== rightToken.value + ) { + return false; + } + } + + return true; +} + +/** + * Checks whether or not the given keys are equal. + * @param {Key} left First key. + * @param {Key} right Second key. + * @returns {boolean} `true` if the keys are equal. + */ +function areEqualKeys(left, right) { + if (typeof left === "string" && typeof right === "string") { + // Statically computed names. + return left === right; + } + if (Array.isArray(left) && Array.isArray(right)) { + // Token lists. + return areEqualTokenLists(left, right); + } + + return false; +} + +/** + * Checks whether or not a given node is of an accessor kind ('get' or 'set'). + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is of an accessor kind. + */ +function isAccessorKind(node) { + return node.kind === "get" || node.kind === "set"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + enforceForTSTypes: false, + enforceForClassMembers: true, + getWithoutSet: false, + setWithoutGet: true, + }, + ], + + docs: { + description: + "Enforce getter and setter pairs in objects and classes", + recommended: false, + url: "https://eslint.org/docs/latest/rules/accessor-pairs", + }, + + schema: [ + { + type: "object", + properties: { + getWithoutSet: { + type: "boolean", + }, + setWithoutGet: { + type: "boolean", + }, + enforceForClassMembers: { + type: "boolean", + }, + enforceForTSTypes: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missingGetterInPropertyDescriptor: + "Getter is not present in property descriptor.", + missingSetterInPropertyDescriptor: + "Setter is not present in property descriptor.", + missingGetterInObjectLiteral: + "Getter is not present for {{ name }}.", + missingSetterInObjectLiteral: + "Setter is not present for {{ name }}.", + missingGetterInClass: "Getter is not present for class {{ name }}.", + missingSetterInClass: "Setter is not present for class {{ name }}.", + missingGetterInType: "Getter is not present for type {{ name }}.", + missingSetterInType: "Setter is not present for type {{ name }}.", + }, + }, + create(context) { + const [ + { + getWithoutSet: checkGetWithoutSet, + setWithoutGet: checkSetWithoutGet, + enforceForClassMembers, + enforceForTSTypes, + }, + ] = context.options; + const sourceCode = context.sourceCode; + + /** + * Reports the given node. + * @param {ASTNode} node The node to report. + * @param {string} messageKind "missingGetter" or "missingSetter". + * @returns {void} + * @private + */ + function report(node, messageKind) { + if (node.type === "Property") { + context.report({ + node, + messageId: `${messageKind}InObjectLiteral`, + loc: astUtils.getFunctionHeadLoc(node.value, sourceCode), + data: { + name: astUtils.getFunctionNameWithKind(node.value), + }, + }); + } else if (node.type === "MethodDefinition") { + context.report({ + node, + messageId: `${messageKind}InClass`, + loc: astUtils.getFunctionHeadLoc(node.value, sourceCode), + data: { + name: astUtils.getFunctionNameWithKind(node.value), + }, + }); + } else if (node.type === "TSMethodSignature") { + context.report({ + node, + messageId: `${messageKind}InType`, + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + data: { + name: astUtils.getFunctionNameWithKind(node), + }, + }); + } else { + context.report({ + node, + messageId: `${messageKind}InPropertyDescriptor`, + }); + } + } + + /** + * Reports each of the nodes in the given list using the same messageId. + * @param {ASTNode[]} nodes Nodes to report. + * @param {string} messageKind "missingGetter" or "missingSetter". + * @returns {void} + * @private + */ + function reportList(nodes, messageKind) { + for (const node of nodes) { + report(node, messageKind); + } + } + + /** + * Checks accessor pairs in the given list of nodes. + * @param {ASTNode[]} nodes The list to check. + * @returns {void} + * @private + */ + function checkList(nodes) { + const accessors = []; + let found = false; + + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + + if (isAccessorKind(node)) { + // Creates a new `AccessorData` object for the given getter or setter node. + const name = astUtils.getStaticPropertyName(node); + const key = + name !== null ? name : sourceCode.getTokens(node.key); + + // Merges the given `AccessorData` object into the given accessors list. + for (let j = 0; j < accessors.length; j++) { + const accessor = accessors[j]; + + if (areEqualKeys(accessor.key, key)) { + accessor.getters.push( + ...(node.kind === "get" ? [node] : []), + ); + accessor.setters.push( + ...(node.kind === "set" ? [node] : []), + ); + found = true; + break; + } + } + if (!found) { + accessors.push({ + key, + getters: node.kind === "get" ? [node] : [], + setters: node.kind === "set" ? [node] : [], + }); + } + found = false; + } + } + + for (const { getters, setters } of accessors) { + if (checkSetWithoutGet && setters.length && !getters.length) { + reportList(setters, "missingGetter"); + } + if (checkGetWithoutSet && getters.length && !setters.length) { + reportList(getters, "missingSetter"); + } + } + } + + /** + * Checks accessor pairs in an object literal. + * @param {ASTNode} node `ObjectExpression` node to check. + * @returns {void} + * @private + */ + function checkObjectLiteral(node) { + checkList(node.properties.filter(p => p.type === "Property")); + } + + /** + * Checks accessor pairs in a property descriptor. + * @param {ASTNode} node Property descriptor `ObjectExpression` node to check. + * @returns {void} + * @private + */ + function checkPropertyDescriptor(node) { + const namesToCheck = new Set( + node.properties + .filter( + p => + p.type === "Property" && + p.kind === "init" && + !p.computed, + ) + .map(({ key }) => key.name), + ); + + const hasGetter = namesToCheck.has("get"); + const hasSetter = namesToCheck.has("set"); + + if (checkSetWithoutGet && hasSetter && !hasGetter) { + report(node, "missingGetter"); + } + if (checkGetWithoutSet && hasGetter && !hasSetter) { + report(node, "missingSetter"); + } + } + + /** + * Checks the given object expression as an object literal and as a possible property descriptor. + * @param {ASTNode} node `ObjectExpression` node to check. + * @returns {void} + * @private + */ + function checkObjectExpression(node) { + checkObjectLiteral(node); + if (astUtils.isPropertyDescriptor(node, sourceCode)) { + checkPropertyDescriptor(node); + } + } + + /** + * Checks the given class body. + * @param {ASTNode} node `ClassBody` node to check. + * @returns {void} + * @private + */ + function checkClassBody(node) { + const methodDefinitions = node.body.filter( + m => m.type === "MethodDefinition", + ); + + checkList(methodDefinitions.filter(m => m.static)); + checkList(methodDefinitions.filter(m => !m.static)); + } + + /** + * Checks the given type. + * @param {ASTNode} node `TSTypeLiteral` or `TSInterfaceBody` node to check. + * @returns {void} + * @private + */ + function checkType(node) { + const members = + node.type === "TSTypeLiteral" ? node.members : node.body; + const methodDefinitions = members.filter( + m => m.type === "TSMethodSignature", + ); + + checkList(methodDefinitions); + } + + const listeners = {}; + + if (checkSetWithoutGet || checkGetWithoutSet) { + listeners.ObjectExpression = checkObjectExpression; + if (enforceForClassMembers) { + listeners.ClassBody = checkClassBody; + } + if (enforceForTSTypes) { + listeners["TSTypeLiteral, TSInterfaceBody"] = checkType; + } + } + + return listeners; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-newline.js new file mode 100644 index 00000000..56887af1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-newline.js @@ -0,0 +1,291 @@ +/** + * @fileoverview Rule to enforce linebreaks after open and before close array brackets + * @author Jan Peer Stöcklmair + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "array-bracket-newline", + url: "https://eslint.style/rules/array-bracket-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce linebreaks after opening and before closing array brackets", + recommended: false, + url: "https://eslint.org/docs/latest/rules/array-bracket-newline", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["always", "never", "consistent"], + }, + { + type: "object", + properties: { + multiline: { + type: "boolean", + }, + minItems: { + type: ["integer", "null"], + minimum: 0, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + unexpectedOpeningLinebreak: + "There should be no linebreak after '['.", + unexpectedClosingLinebreak: + "There should be no linebreak before ']'.", + missingOpeningLinebreak: "A linebreak is required after '['.", + missingClosingLinebreak: "A linebreak is required before ']'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Normalizes a given option value. + * @param {string|Object|undefined} option An option value to parse. + * @returns {{multiline: boolean, minItems: number}} Normalized option object. + */ + function normalizeOptionValue(option) { + let consistent = false; + let multiline = false; + let minItems; + + if (option) { + if (option === "consistent") { + consistent = true; + minItems = Number.POSITIVE_INFINITY; + } else if (option === "always" || option.minItems === 0) { + minItems = 0; + } else if (option === "never") { + minItems = Number.POSITIVE_INFINITY; + } else { + multiline = Boolean(option.multiline); + minItems = option.minItems || Number.POSITIVE_INFINITY; + } + } else { + consistent = false; + multiline = true; + minItems = Number.POSITIVE_INFINITY; + } + + return { consistent, multiline, minItems }; + } + + /** + * Normalizes a given option value. + * @param {string|Object|undefined} options An option value to parse. + * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object. + */ + function normalizeOptions(options) { + const value = normalizeOptionValue(options); + + return { ArrayExpression: value, ArrayPattern: value }; + } + + /** + * Reports that there shouldn't be a linebreak after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoBeginningLinebreak(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "unexpectedOpeningLinebreak", + fix(fixer) { + const nextToken = sourceCode.getTokenAfter(token, { + includeComments: true, + }); + + if (astUtils.isCommentToken(nextToken)) { + return null; + } + + return fixer.removeRange([ + token.range[1], + nextToken.range[0], + ]); + }, + }); + } + + /** + * Reports that there shouldn't be a linebreak before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoEndingLinebreak(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "unexpectedClosingLinebreak", + fix(fixer) { + const previousToken = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + + if (astUtils.isCommentToken(previousToken)) { + return null; + } + + return fixer.removeRange([ + previousToken.range[1], + token.range[0], + ]); + }, + }); + } + + /** + * Reports that there should be a linebreak after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredBeginningLinebreak(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingOpeningLinebreak", + fix(fixer) { + return fixer.insertTextAfter(token, "\n"); + }, + }); + } + + /** + * Reports that there should be a linebreak before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredEndingLinebreak(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingClosingLinebreak", + fix(fixer) { + return fixer.insertTextBefore(token, "\n"); + }, + }); + } + + /** + * Reports a given node if it violated this rule. + * @param {ASTNode} node A node to check. This is an ArrayExpression node or an ArrayPattern node. + * @returns {void} + */ + function check(node) { + const elements = node.elements; + const normalizedOptions = normalizeOptions(context.options[0]); + const options = normalizedOptions[node.type]; + const openBracket = sourceCode.getFirstToken(node); + const closeBracket = sourceCode.getLastToken(node); + const firstIncComment = sourceCode.getTokenAfter(openBracket, { + includeComments: true, + }); + const lastIncComment = sourceCode.getTokenBefore(closeBracket, { + includeComments: true, + }); + const first = sourceCode.getTokenAfter(openBracket); + const last = sourceCode.getTokenBefore(closeBracket); + + const needsLinebreaks = + elements.length >= options.minItems || + (options.multiline && + elements.length > 0 && + firstIncComment.loc.start.line !== + lastIncComment.loc.end.line) || + (elements.length === 0 && + firstIncComment.type === "Block" && + firstIncComment.loc.start.line !== + lastIncComment.loc.end.line && + firstIncComment === lastIncComment) || + (options.consistent && + openBracket.loc.end.line !== first.loc.start.line); + + /* + * Use tokens or comments to check multiline or not. + * But use only tokens to check whether linebreaks are needed. + * This allows: + * var arr = [ // eslint-disable-line foo + * 'a' + * ] + */ + + if (needsLinebreaks) { + if (astUtils.isTokenOnSameLine(openBracket, first)) { + reportRequiredBeginningLinebreak(node, openBracket); + } + if (astUtils.isTokenOnSameLine(last, closeBracket)) { + reportRequiredEndingLinebreak(node, closeBracket); + } + } else { + if (!astUtils.isTokenOnSameLine(openBracket, first)) { + reportNoBeginningLinebreak(node, openBracket); + } + if (!astUtils.isTokenOnSameLine(last, closeBracket)) { + reportNoEndingLinebreak(node, closeBracket); + } + } + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + ArrayPattern: check, + ArrayExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-spacing.js new file mode 100644 index 00000000..98cdbb5f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-bracket-spacing.js @@ -0,0 +1,301 @@ +/** + * @fileoverview Disallows or enforces spaces inside of array brackets. + * @author Jamund Ferguson + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "array-bracket-spacing", + url: "https://eslint.style/rules/array-bracket-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing inside array brackets", + recommended: false, + url: "https://eslint.org/docs/latest/rules/array-bracket-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + singleValue: { + type: "boolean", + }, + objectsInArrays: { + type: "boolean", + }, + arraysInArrays: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedSpaceAfter: + "There should be no space after '{{tokenValue}}'.", + unexpectedSpaceBefore: + "There should be no space before '{{tokenValue}}'.", + missingSpaceAfter: "A space is required after '{{tokenValue}}'.", + missingSpaceBefore: "A space is required before '{{tokenValue}}'.", + }, + }, + create(context) { + const spaced = context.options[0] === "always", + sourceCode = context.sourceCode; + + /** + * Determines whether an option is set, relative to the spacing option. + * If spaced is "always", then check whether option is set to false. + * If spaced is "never", then check whether option is set to true. + * @param {Object} option The option to exclude. + * @returns {boolean} Whether or not the property is excluded. + */ + function isOptionSet(option) { + return context.options[1] + ? context.options[1][option] === !spaced + : false; + } + + const options = { + spaced, + singleElementException: isOptionSet("singleValue"), + objectsInArraysException: isOptionSet("objectsInArrays"), + arraysInArraysException: isOptionSet("arraysInArrays"), + }; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports that there shouldn't be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoBeginningSpace(node, token) { + const nextToken = sourceCode.getTokenAfter(token); + + context.report({ + node, + loc: { start: token.loc.end, end: nextToken.loc.start }, + messageId: "unexpectedSpaceAfter", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + token.range[1], + nextToken.range[0], + ]); + }, + }); + } + + /** + * Reports that there shouldn't be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoEndingSpace(node, token) { + const previousToken = sourceCode.getTokenBefore(token); + + context.report({ + node, + loc: { start: previousToken.loc.end, end: token.loc.start }, + messageId: "unexpectedSpaceBefore", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + previousToken.range[1], + token.range[0], + ]); + }, + }); + } + + /** + * Reports that there should be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredBeginningSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingSpaceAfter", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + + /** + * Reports that there should be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredEndingSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingSpaceBefore", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + + /** + * Determines if a node is an object type + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the node is an object type. + */ + function isObjectType(node) { + return ( + node && + (node.type === "ObjectExpression" || + node.type === "ObjectPattern") + ); + } + + /** + * Determines if a node is an array type + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the node is an array type. + */ + function isArrayType(node) { + return ( + node && + (node.type === "ArrayExpression" || + node.type === "ArrayPattern") + ); + } + + /** + * Validates the spacing around array brackets + * @param {ASTNode} node The node we're checking for spacing + * @returns {void} + */ + function validateArraySpacing(node) { + if (options.spaced && node.elements.length === 0) { + return; + } + + const first = sourceCode.getFirstToken(node), + second = sourceCode.getFirstToken(node, 1), + last = node.typeAnnotation + ? sourceCode.getTokenBefore(node.typeAnnotation) + : sourceCode.getLastToken(node), + penultimate = sourceCode.getTokenBefore(last), + firstElement = node.elements[0], + lastElement = node.elements.at(-1); + + const openingBracketMustBeSpaced = + (options.objectsInArraysException && + isObjectType(firstElement)) || + (options.arraysInArraysException && + isArrayType(firstElement)) || + (options.singleElementException && node.elements.length === 1) + ? !options.spaced + : options.spaced; + + const closingBracketMustBeSpaced = + (options.objectsInArraysException && + isObjectType(lastElement)) || + (options.arraysInArraysException && isArrayType(lastElement)) || + (options.singleElementException && node.elements.length === 1) + ? !options.spaced + : options.spaced; + + if (astUtils.isTokenOnSameLine(first, second)) { + if ( + openingBracketMustBeSpaced && + !sourceCode.isSpaceBetween(first, second) + ) { + reportRequiredBeginningSpace(node, first); + } + if ( + !openingBracketMustBeSpaced && + sourceCode.isSpaceBetween(first, second) + ) { + reportNoBeginningSpace(node, first); + } + } + + if ( + first !== penultimate && + astUtils.isTokenOnSameLine(penultimate, last) + ) { + if ( + closingBracketMustBeSpaced && + !sourceCode.isSpaceBetween(penultimate, last) + ) { + reportRequiredEndingSpace(node, last); + } + if ( + !closingBracketMustBeSpaced && + sourceCode.isSpaceBetween(penultimate, last) + ) { + reportNoEndingSpace(node, last); + } + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ArrayPattern: validateArraySpacing, + ArrayExpression: validateArraySpacing, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-callback-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-callback-return.js new file mode 100644 index 00000000..019a60e8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-callback-return.js @@ -0,0 +1,496 @@ +/** + * @fileoverview Rule to enforce return statements in callbacks of array's methods + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u; +const TARGET_METHODS = + /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort|toSorted)$/u; + +/** + * Checks a given node is a member access which has the specified name's + * property. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is a member access which has + * the specified name's property. The node may be a `(Chain|Member)Expression` node. + */ +function isTargetMethod(node) { + return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS); +} + +/** + * Returns a human-legible description of an array method + * @param {string} arrayMethodName A method name to fully qualify + * @returns {string} the method name prefixed with `Array.` if it is a class method, + * or else `Array.prototype.` if it is an instance method. + */ +function fullMethodName(arrayMethodName) { + if (["from", "fromAsync", "of", "isArray"].includes(arrayMethodName)) { + return "Array.".concat(arrayMethodName); + } + return "Array.prototype.".concat(arrayMethodName); +} + +/** + * Checks whether or not a given node is a function expression which is the + * callback of an array method, returning the method name. + * Generators are excluded. Async functions are allowed only for `Array.fromAsync`. + * @param {ASTNode} node A node to check. This is one of + * FunctionExpression or ArrowFunctionExpression. + * @returns {string} The method name if the node is a callback method, + * null otherwise. + */ +function getArrayMethodName(node) { + // Generators are not checked for any methods. + if (node.generator) { + return null; + } + let currentNode = node; + + while (currentNode) { + const parent = currentNode.parent; + + switch (parent.type) { + /* + * Looks up the destination. e.g., + * foo.every(nativeFoo || function foo() { ... }); + */ + case "LogicalExpression": + case "ConditionalExpression": + case "ChainExpression": + currentNode = parent; + break; + + /* + * If the upper function is IIFE, checks the destination of the return value. + * e.g. + * foo.every((function() { + * // setup... + * return function callback() { ... }; + * })()); + */ + case "ReturnStatement": { + const func = astUtils.getUpperFunction(parent); + + if (func === null || !astUtils.isCallee(func)) { + return null; + } + currentNode = func.parent; + break; + } + + /* + * e.g. + * Array.from([], function() {}); + * list.every(function() {}); + */ + case "CallExpression": + if (!node.async) { + if (astUtils.isArrayFromMethod(parent.callee)) { + if ( + parent.arguments.length >= 2 && + parent.arguments[1] === currentNode + ) { + return "from"; + } + } + if (isTargetMethod(parent.callee)) { + if ( + parent.arguments.length >= 1 && + parent.arguments[0] === currentNode + ) { + return astUtils.getStaticPropertyName( + parent.callee, + ); + } + } + } + if (astUtils.isArrayFromAsyncMethod(parent.callee)) { + if ( + parent.arguments.length >= 2 && + parent.arguments[1] === currentNode + ) { + return "fromAsync"; + } + } + return null; + + // Otherwise this node is not target. + default: + return null; + } + } + + /* c8 ignore next */ + return null; +} + +/** + * Checks if the given node is a void expression. + * @param {ASTNode} node The node to check. + * @returns {boolean} - `true` if the node is a void expression + */ +function isExpressionVoid(node) { + return node.type === "UnaryExpression" && node.operator === "void"; +} + +/** + * Fixes the linting error by prepending "void " to the given node + * @param {Object} sourceCode context given by context.sourceCode + * @param {ASTNode} node The node to fix. + * @param {Object} fixer The fixer object provided by ESLint. + * @returns {Array} - An array of fix objects to apply to the node. + */ +function voidPrependFixer(sourceCode, node, fixer) { + const requiresParens = + // prepending `void ` will fail if the node has a lower precedence than void + astUtils.getPrecedence(node) < + astUtils.getPrecedence({ + type: "UnaryExpression", + operator: "void", + }) && + // check if there are parentheses around the node to avoid redundant parentheses + !astUtils.isParenthesised(sourceCode, node); + + // avoid parentheses issues + const returnOrArrowToken = sourceCode.getTokenBefore( + node, + node.parent.type === "ArrowFunctionExpression" + ? astUtils.isArrowToken + : // isReturnToken + token => token.type === "Keyword" && token.value === "return", + ); + + const firstToken = sourceCode.getTokenAfter(returnOrArrowToken); + + const prependSpace = + // is return token, as => allows void to be adjacent + returnOrArrowToken.value === "return" && + // If two tokens (return and "(") are adjacent + returnOrArrowToken.range[1] === firstToken.range[0]; + + return [ + fixer.insertTextBefore( + firstToken, + `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`, + ), + fixer.insertTextAfter(node, requiresParens ? ")" : ""), + ]; +} + +/** + * Fixes the linting error by `wrapping {}` around the given node's body. + * @param {Object} sourceCode context given by context.sourceCode + * @param {ASTNode} node The node to fix. + * @param {Object} fixer The fixer object provided by ESLint. + * @returns {Array} - An array of fix objects to apply to the node. + */ +function curlyWrapFixer(sourceCode, node, fixer) { + const arrowToken = sourceCode.getTokenBefore( + node.body, + astUtils.isArrowToken, + ); + const firstToken = sourceCode.getTokenAfter(arrowToken); + const lastToken = sourceCode.getLastToken(node); + + return [ + fixer.insertTextBefore(firstToken, "{"), + fixer.insertTextAfter(lastToken, "}"), + ]; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowImplicit: false, + checkForEach: false, + allowVoid: false, + }, + ], + + docs: { + description: + "Enforce `return` statements in callbacks of array methods", + recommended: false, + url: "https://eslint.org/docs/latest/rules/array-callback-return", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + allowImplicit: { + type: "boolean", + }, + checkForEach: { + type: "boolean", + }, + allowVoid: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + expectedAtEnd: + "{{arrayMethodName}}() expects a value to be returned at the end of {{name}}.", + expectedInside: + "{{arrayMethodName}}() expects a return value from {{name}}.", + expectedReturnValue: + "{{arrayMethodName}}() expects a return value from {{name}}.", + expectedNoReturnValue: + "{{arrayMethodName}}() expects no useless return value from {{name}}.", + wrapBraces: "Wrap the expression in `{}`.", + prependVoid: "Prepend `void` to the expression.", + }, + }, + + create(context) { + const [options] = context.options; + const sourceCode = context.sourceCode; + + let funcInfo = { + arrayMethodName: null, + upper: null, + codePath: null, + hasReturn: false, + shouldCheck: false, + node: null, + }; + + /** + * Checks whether or not the last code path segment is reachable. + * Then reports this function if the segment is reachable. + * + * If the last code path segment is reachable, there are paths which are not + * returned or thrown. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function checkLastSegment(node) { + if (!funcInfo.shouldCheck) { + return; + } + + const messageAndSuggestions = { messageId: "", suggest: [] }; + + if (funcInfo.arrayMethodName === "forEach") { + if ( + options.checkForEach && + node.type === "ArrowFunctionExpression" && + node.expression + ) { + if (options.allowVoid) { + if (isExpressionVoid(node.body)) { + return; + } + + messageAndSuggestions.messageId = + "expectedNoReturnValue"; + messageAndSuggestions.suggest = [ + { + messageId: "wrapBraces", + fix(fixer) { + return curlyWrapFixer( + sourceCode, + node, + fixer, + ); + }, + }, + { + messageId: "prependVoid", + fix(fixer) { + return voidPrependFixer( + sourceCode, + node.body, + fixer, + ); + }, + }, + ]; + } else { + messageAndSuggestions.messageId = + "expectedNoReturnValue"; + messageAndSuggestions.suggest = [ + { + messageId: "wrapBraces", + fix(fixer) { + return curlyWrapFixer( + sourceCode, + node, + fixer, + ); + }, + }, + ]; + } + } + } else { + if ( + node.body.type === "BlockStatement" && + isAnySegmentReachable(funcInfo.currentSegments) + ) { + messageAndSuggestions.messageId = funcInfo.hasReturn + ? "expectedAtEnd" + : "expectedInside"; + } + } + + if (messageAndSuggestions.messageId) { + const name = astUtils.getFunctionNameWithKind(node); + + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + messageId: messageAndSuggestions.messageId, + data: { + name, + arrayMethodName: fullMethodName( + funcInfo.arrayMethodName, + ), + }, + suggest: + messageAndSuggestions.suggest.length !== 0 + ? messageAndSuggestions.suggest + : null, + }); + } + } + + return { + // Stacks this function's information. + onCodePathStart(codePath, node) { + let methodName = null; + + if (TARGET_NODE_TYPE.test(node.type)) { + methodName = getArrayMethodName(node); + } + + funcInfo = { + arrayMethodName: methodName, + upper: funcInfo, + codePath, + hasReturn: false, + shouldCheck: !!methodName, + node, + currentSegments: new Set(), + }; + }, + + // Pops this function's information. + onCodePathEnd() { + funcInfo = funcInfo.upper; + }, + + onUnreachableCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + // Checks the return statement is valid. + ReturnStatement(node) { + if (!funcInfo.shouldCheck) { + return; + } + + funcInfo.hasReturn = true; + + const messageAndSuggestions = { messageId: "", suggest: [] }; + + if (funcInfo.arrayMethodName === "forEach") { + // if checkForEach: true, returning a value at any path inside a forEach is not allowed + if (options.checkForEach && node.argument) { + if (options.allowVoid) { + if (isExpressionVoid(node.argument)) { + return; + } + + messageAndSuggestions.messageId = + "expectedNoReturnValue"; + messageAndSuggestions.suggest = [ + { + messageId: "prependVoid", + fix(fixer) { + return voidPrependFixer( + sourceCode, + node.argument, + fixer, + ); + }, + }, + ]; + } else { + messageAndSuggestions.messageId = + "expectedNoReturnValue"; + } + } + } else { + // if allowImplicit: false, should also check node.argument + if (!options.allowImplicit && !node.argument) { + messageAndSuggestions.messageId = "expectedReturnValue"; + } + } + + if (messageAndSuggestions.messageId) { + context.report({ + node, + messageId: messageAndSuggestions.messageId, + data: { + name: astUtils.getFunctionNameWithKind( + funcInfo.node, + ), + arrayMethodName: fullMethodName( + funcInfo.arrayMethodName, + ), + }, + suggest: + messageAndSuggestions.suggest.length !== 0 + ? messageAndSuggestions.suggest + : null, + }); + } + }, + + // Reports a given function if the last path is reachable. + "FunctionExpression:exit": checkLastSegment, + "ArrowFunctionExpression:exit": checkLastSegment, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-element-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-element-newline.js new file mode 100644 index 00000000..d687cba0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/array-element-newline.js @@ -0,0 +1,374 @@ +/** + * @fileoverview Rule to enforce line breaks after each array element + * @author Jan Peer Stöcklmair + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "array-element-newline", + url: "https://eslint.style/rules/array-element-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce line breaks after each array element", + recommended: false, + url: "https://eslint.org/docs/latest/rules/array-element-newline", + }, + + fixable: "whitespace", + + schema: { + definitions: { + basicConfig: { + oneOf: [ + { + enum: ["always", "never", "consistent"], + }, + { + type: "object", + properties: { + multiline: { + type: "boolean", + }, + minItems: { + type: ["integer", "null"], + minimum: 0, + }, + }, + additionalProperties: false, + }, + ], + }, + }, + type: "array", + items: [ + { + oneOf: [ + { + $ref: "#/definitions/basicConfig", + }, + { + type: "object", + properties: { + ArrayExpression: { + $ref: "#/definitions/basicConfig", + }, + ArrayPattern: { + $ref: "#/definitions/basicConfig", + }, + }, + additionalProperties: false, + minProperties: 1, + }, + ], + }, + ], + }, + + messages: { + unexpectedLineBreak: "There should be no linebreak here.", + missingLineBreak: "There should be a linebreak after this element.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Normalizes a given option value. + * @param {string|Object|undefined} providedOption An option value to parse. + * @returns {{multiline: boolean, minItems: number}} Normalized option object. + */ + function normalizeOptionValue(providedOption) { + let consistent = false; + let multiline = false; + let minItems; + + const option = providedOption || "always"; + + if (!option || option === "always" || option.minItems === 0) { + minItems = 0; + } else if (option === "never") { + minItems = Number.POSITIVE_INFINITY; + } else if (option === "consistent") { + consistent = true; + minItems = Number.POSITIVE_INFINITY; + } else { + multiline = Boolean(option.multiline); + minItems = option.minItems || Number.POSITIVE_INFINITY; + } + + return { consistent, multiline, minItems }; + } + + /** + * Normalizes a given option value. + * @param {string|Object|undefined} options An option value to parse. + * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object. + */ + function normalizeOptions(options) { + if (options && (options.ArrayExpression || options.ArrayPattern)) { + let expressionOptions, patternOptions; + + if (options.ArrayExpression) { + expressionOptions = normalizeOptionValue( + options.ArrayExpression, + ); + } + + if (options.ArrayPattern) { + patternOptions = normalizeOptionValue(options.ArrayPattern); + } + + return { + ArrayExpression: expressionOptions, + ArrayPattern: patternOptions, + }; + } + + const value = normalizeOptionValue(options); + + return { ArrayExpression: value, ArrayPattern: value }; + } + + /** + * Reports that there shouldn't be a line break after the first token + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoLineBreak(token) { + const tokenBefore = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + + context.report({ + loc: { + start: tokenBefore.loc.end, + end: token.loc.start, + }, + messageId: "unexpectedLineBreak", + fix(fixer) { + if (astUtils.isCommentToken(tokenBefore)) { + return null; + } + + if (!astUtils.isTokenOnSameLine(tokenBefore, token)) { + return fixer.replaceTextRange( + [tokenBefore.range[1], token.range[0]], + " ", + ); + } + + /* + * This will check if the comma is on the same line as the next element + * Following array: + * [ + * 1 + * , 2 + * , 3 + * ] + * + * will be fixed to: + * [ + * 1, 2, 3 + * ] + */ + const twoTokensBefore = sourceCode.getTokenBefore( + tokenBefore, + { includeComments: true }, + ); + + if (astUtils.isCommentToken(twoTokensBefore)) { + return null; + } + + return fixer.replaceTextRange( + [twoTokensBefore.range[1], tokenBefore.range[0]], + "", + ); + }, + }); + } + + /** + * Reports that there should be a line break after the first token + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredLineBreak(token) { + const tokenBefore = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + + context.report({ + loc: { + start: tokenBefore.loc.end, + end: token.loc.start, + }, + messageId: "missingLineBreak", + fix(fixer) { + return fixer.replaceTextRange( + [tokenBefore.range[1], token.range[0]], + "\n", + ); + }, + }); + } + + /** + * Reports a given node if it violated this rule. + * @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node. + * @returns {void} + */ + function check(node) { + const elements = node.elements; + const normalizedOptions = normalizeOptions(context.options[0]); + const options = normalizedOptions[node.type]; + + if (!options) { + return; + } + + let elementBreak = false; + + /* + * MULTILINE: true + * loop through every element and check + * if at least one element has linebreaks inside + * this ensures that following is not valid (due to elements are on the same line): + * + * [ + * 1, + * 2, + * 3 + * ] + */ + if (options.multiline) { + elementBreak = elements + .filter(element => element !== null) + .some( + element => + element.loc.start.line !== element.loc.end.line, + ); + } + + let linebreaksCount = 0; + + for (let i = 0; i < node.elements.length; i++) { + const element = node.elements[i]; + + const previousElement = elements[i - 1]; + + if (i === 0 || element === null || previousElement === null) { + continue; + } + + const commaToken = sourceCode.getFirstTokenBetween( + previousElement, + element, + astUtils.isCommaToken, + ); + const lastTokenOfPreviousElement = + sourceCode.getTokenBefore(commaToken); + const firstTokenOfCurrentElement = + sourceCode.getTokenAfter(commaToken); + + if ( + !astUtils.isTokenOnSameLine( + lastTokenOfPreviousElement, + firstTokenOfCurrentElement, + ) + ) { + linebreaksCount++; + } + } + + const needsLinebreaks = + elements.length >= options.minItems || + (options.multiline && elementBreak) || + (options.consistent && + linebreaksCount > 0 && + linebreaksCount < node.elements.length); + + elements.forEach((element, i) => { + const previousElement = elements[i - 1]; + + if (i === 0 || element === null || previousElement === null) { + return; + } + + const commaToken = sourceCode.getFirstTokenBetween( + previousElement, + element, + astUtils.isCommaToken, + ); + const lastTokenOfPreviousElement = + sourceCode.getTokenBefore(commaToken); + const firstTokenOfCurrentElement = + sourceCode.getTokenAfter(commaToken); + + if (needsLinebreaks) { + if ( + astUtils.isTokenOnSameLine( + lastTokenOfPreviousElement, + firstTokenOfCurrentElement, + ) + ) { + reportRequiredLineBreak(firstTokenOfCurrentElement); + } + } else { + if ( + !astUtils.isTokenOnSameLine( + lastTokenOfPreviousElement, + firstTokenOfCurrentElement, + ) + ) { + reportNoLineBreak(firstTokenOfCurrentElement); + } + } + }); + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + ArrayPattern: check, + ArrayExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-body-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-body-style.js new file mode 100644 index 00000000..8272317b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-body-style.js @@ -0,0 +1,418 @@ +/** + * @fileoverview Rule to require braces in arrow function body. + * @author Alberto Rodríguez + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: ["as-needed"], + + docs: { + description: "Require braces around arrow function bodies", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/arrow-body-style", + }, + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["always", "never"], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["as-needed"], + }, + { + type: "object", + properties: { + requireReturnForObjectLiteral: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + fixable: "code", + + messages: { + unexpectedOtherBlock: + "Unexpected block statement surrounding arrow body.", + unexpectedEmptyBlock: + "Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.", + unexpectedObjectBlock: + "Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.", + unexpectedSingleBlock: + "Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.", + expectedBlock: "Expected block statement surrounding arrow body.", + }, + }, + + create(context) { + const options = context.options; + const always = options[0] === "always"; + const asNeeded = options[0] === "as-needed"; + const never = options[0] === "never"; + const requireReturnForObjectLiteral = + options[1] && options[1].requireReturnForObjectLiteral; + const sourceCode = context.sourceCode; + let funcInfo = null; + + /** + * Checks whether the given node has ASI problem or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed. + */ + function hasASIProblem(token) { + return ( + token && + token.type === "Punctuator" && + /^[([/`+-]/u.test(token.value) + ); + } + + /** + * Gets the closing parenthesis by the given node. + * @param {ASTNode} node first node after an opening parenthesis. + * @returns {Token} The found closing parenthesis token. + */ + function findClosingParen(node) { + let nodeToCheck = node; + + while (!astUtils.isParenthesised(sourceCode, nodeToCheck)) { + nodeToCheck = nodeToCheck.parent; + } + return sourceCode.getTokenAfter(nodeToCheck); + } + + /** + * Check whether the node is inside of a for loop's init + * @param {ASTNode} node node is inside for loop + * @returns {boolean} `true` if the node is inside of a for loop, else `false` + */ + function isInsideForLoopInitializer(node) { + if (node && node.parent) { + if ( + node.parent.type === "ForStatement" && + node.parent.init === node + ) { + return true; + } + return isInsideForLoopInitializer(node.parent); + } + return false; + } + + /** + * Determines whether a arrow function body needs braces + * @param {ASTNode} node The arrow function node. + * @returns {void} + */ + function validate(node) { + const arrowBody = node.body; + + if (arrowBody.type === "BlockStatement") { + const blockBody = arrowBody.body; + + if (blockBody.length !== 1 && !never) { + return; + } + + if ( + asNeeded && + requireReturnForObjectLiteral && + blockBody[0].type === "ReturnStatement" && + blockBody[0].argument && + blockBody[0].argument.type === "ObjectExpression" + ) { + return; + } + + if ( + never || + (asNeeded && blockBody[0].type === "ReturnStatement") + ) { + let messageId; + + if (blockBody.length === 0) { + messageId = "unexpectedEmptyBlock"; + } else if ( + blockBody.length > 1 || + blockBody[0].type !== "ReturnStatement" + ) { + messageId = "unexpectedOtherBlock"; + } else if (blockBody[0].argument === null) { + messageId = "unexpectedSingleBlock"; + } else if ( + astUtils.isOpeningBraceToken( + sourceCode.getFirstToken(blockBody[0], { skip: 1 }), + ) + ) { + messageId = "unexpectedObjectBlock"; + } else { + messageId = "unexpectedSingleBlock"; + } + + context.report({ + node, + loc: arrowBody.loc, + messageId, + fix(fixer) { + const fixes = []; + + if ( + blockBody.length !== 1 || + blockBody[0].type !== "ReturnStatement" || + !blockBody[0].argument || + hasASIProblem( + sourceCode.getTokenAfter(arrowBody), + ) + ) { + return fixes; + } + + const openingBrace = + sourceCode.getFirstToken(arrowBody); + const closingBrace = + sourceCode.getLastToken(arrowBody); + const firstValueToken = sourceCode.getFirstToken( + blockBody[0], + 1, + ); + const lastValueToken = sourceCode.getLastToken( + blockBody[0], + ); + const commentsExist = + sourceCode.commentsExistBetween( + openingBrace, + firstValueToken, + ) || + sourceCode.commentsExistBetween( + lastValueToken, + closingBrace, + ); + + /* + * Remove tokens around the return value. + * If comments don't exist, remove extra spaces as well. + */ + if (commentsExist) { + fixes.push( + fixer.remove(openingBrace), + fixer.remove(closingBrace), + fixer.remove( + sourceCode.getTokenAfter(openingBrace), + ), // return keyword + ); + } else { + fixes.push( + fixer.removeRange([ + openingBrace.range[0], + firstValueToken.range[0], + ]), + fixer.removeRange([ + lastValueToken.range[1], + closingBrace.range[1], + ]), + ); + } + + /* + * If the first token of the return value is `{` or the return value is a sequence expression, + * enclose the return value by parentheses to avoid syntax error. + */ + if ( + astUtils.isOpeningBraceToken(firstValueToken) || + blockBody[0].argument.type === + "SequenceExpression" || + (funcInfo.hasInOperator && + isInsideForLoopInitializer(node)) + ) { + if ( + !astUtils.isParenthesised( + sourceCode, + blockBody[0].argument, + ) + ) { + fixes.push( + fixer.insertTextBefore( + firstValueToken, + "(", + ), + fixer.insertTextAfter( + lastValueToken, + ")", + ), + ); + } + } + + /* + * If the last token of the return statement is semicolon, remove it. + * Non-block arrow body is an expression, not a statement. + */ + if (astUtils.isSemicolonToken(lastValueToken)) { + fixes.push(fixer.remove(lastValueToken)); + } + + return fixes; + }, + }); + } + } else { + if ( + always || + (asNeeded && + requireReturnForObjectLiteral && + arrowBody.type === "ObjectExpression") + ) { + context.report({ + node, + loc: arrowBody.loc, + messageId: "expectedBlock", + fix(fixer) { + const fixes = []; + const arrowToken = sourceCode.getTokenBefore( + arrowBody, + astUtils.isArrowToken, + ); + const [ + firstTokenAfterArrow, + secondTokenAfterArrow, + ] = sourceCode.getTokensAfter(arrowToken, { + count: 2, + }); + const lastToken = sourceCode.getLastToken(node); + + let parenthesisedObjectLiteral = null; + + if ( + astUtils.isOpeningParenToken( + firstTokenAfterArrow, + ) && + astUtils.isOpeningBraceToken( + secondTokenAfterArrow, + ) + ) { + const braceNode = + sourceCode.getNodeByRangeIndex( + secondTokenAfterArrow.range[0], + ); + + if (braceNode.type === "ObjectExpression") { + parenthesisedObjectLiteral = braceNode; + } + } + + // If the value is object literal, remove parentheses which were forced by syntax. + if (parenthesisedObjectLiteral) { + const openingParenToken = firstTokenAfterArrow; + const openingBraceToken = secondTokenAfterArrow; + + if ( + astUtils.isTokenOnSameLine( + openingParenToken, + openingBraceToken, + ) + ) { + fixes.push( + fixer.replaceText( + openingParenToken, + "{return ", + ), + ); + } else { + // Avoid ASI + fixes.push( + fixer.replaceText( + openingParenToken, + "{", + ), + fixer.insertTextBefore( + openingBraceToken, + "return ", + ), + ); + } + + // Closing paren for the object doesn't have to be lastToken, e.g.: () => ({}).foo() + fixes.push( + fixer.remove( + findClosingParen( + parenthesisedObjectLiteral, + ), + ), + ); + fixes.push( + fixer.insertTextAfter(lastToken, "}"), + ); + } else { + fixes.push( + fixer.insertTextBefore( + firstTokenAfterArrow, + "{return ", + ), + ); + fixes.push( + fixer.insertTextAfter(lastToken, "}"), + ); + } + + return fixes; + }, + }); + } + } + } + + return { + "BinaryExpression[operator='in']"() { + let info = funcInfo; + + while (info) { + info.hasInOperator = true; + info = info.upper; + } + }, + ArrowFunctionExpression() { + funcInfo = { + upper: funcInfo, + hasInOperator: false, + }; + }, + "ArrowFunctionExpression:exit"(node) { + validate(node); + funcInfo = funcInfo.upper; + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-parens.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-parens.js new file mode 100644 index 00000000..bbb3d335 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-parens.js @@ -0,0 +1,237 @@ +/** + * @fileoverview Rule to require parens in arrow function arguments. + * @author Jxck + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines if the given arrow function has block body. + * @param {ASTNode} node `ArrowFunctionExpression` node. + * @returns {boolean} `true` if the function has block body. + */ +function hasBlockBody(node) { + return node.body.type === "BlockStatement"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "arrow-parens", + url: "https://eslint.style/rules/arrow-parens", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require parentheses around arrow function arguments", + recommended: false, + url: "https://eslint.org/docs/latest/rules/arrow-parens", + }, + + fixable: "code", + + schema: [ + { + enum: ["always", "as-needed"], + }, + { + type: "object", + properties: { + requireForBlockBody: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedParens: + "Unexpected parentheses around single function argument.", + expectedParens: + "Expected parentheses around arrow function argument.", + + unexpectedParensInline: + "Unexpected parentheses around single function argument having a body with no curly braces.", + expectedParensBlock: + "Expected parentheses around arrow function argument having a body with curly braces.", + }, + }, + + create(context) { + const asNeeded = context.options[0] === "as-needed"; + const requireForBlockBody = + asNeeded && + context.options[1] && + context.options[1].requireForBlockBody === true; + + const sourceCode = context.sourceCode; + + /** + * Finds opening paren of parameters for the given arrow function, if it exists. + * It is assumed that the given arrow function has exactly one parameter. + * @param {ASTNode} node `ArrowFunctionExpression` node. + * @returns {Token|null} the opening paren, or `null` if the given arrow function doesn't have parens of parameters. + */ + function findOpeningParenOfParams(node) { + const tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]); + + if ( + tokenBeforeParams && + astUtils.isOpeningParenToken(tokenBeforeParams) && + node.range[0] <= tokenBeforeParams.range[0] + ) { + return tokenBeforeParams; + } + + return null; + } + + /** + * Finds closing paren of parameters for the given arrow function. + * It is assumed that the given arrow function has parens of parameters and that it has exactly one parameter. + * @param {ASTNode} node `ArrowFunctionExpression` node. + * @returns {Token} the closing paren of parameters. + */ + function getClosingParenOfParams(node) { + return sourceCode.getTokenAfter( + node.params[0], + astUtils.isClosingParenToken, + ); + } + + /** + * Determines whether the given arrow function has comments inside parens of parameters. + * It is assumed that the given arrow function has parens of parameters. + * @param {ASTNode} node `ArrowFunctionExpression` node. + * @param {Token} openingParen Opening paren of parameters. + * @returns {boolean} `true` if the function has at least one comment inside of parens of parameters. + */ + function hasCommentsInParensOfParams(node, openingParen) { + return sourceCode.commentsExistBetween( + openingParen, + getClosingParenOfParams(node), + ); + } + + /** + * Determines whether the given arrow function has unexpected tokens before opening paren of parameters, + * in which case it will be assumed that the existing parens of parameters are necessary. + * Only tokens within the range of the arrow function (tokens that are part of the arrow function) are taken into account. + * Example: (a) => b + * @param {ASTNode} node `ArrowFunctionExpression` node. + * @param {Token} openingParen Opening paren of parameters. + * @returns {boolean} `true` if the function has at least one unexpected token. + */ + function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) { + const expectedCount = node.async ? 1 : 0; + + return ( + sourceCode.getFirstToken(node, { skip: expectedCount }) !== + openingParen + ); + } + + return { + "ArrowFunctionExpression[params.length=1]"(node) { + const shouldHaveParens = + !asNeeded || (requireForBlockBody && hasBlockBody(node)); + const openingParen = findOpeningParenOfParams(node); + const hasParens = openingParen !== null; + const [param] = node.params; + + if (shouldHaveParens && !hasParens) { + context.report({ + node, + messageId: requireForBlockBody + ? "expectedParensBlock" + : "expectedParens", + loc: param.loc, + *fix(fixer) { + yield fixer.insertTextBefore(param, "("); + yield fixer.insertTextAfter(param, ")"); + }, + }); + } + + if ( + !shouldHaveParens && + hasParens && + param.type === "Identifier" && + !param.typeAnnotation && + !node.returnType && + !hasCommentsInParensOfParams(node, openingParen) && + !hasUnexpectedTokensBeforeOpeningParen(node, openingParen) + ) { + context.report({ + node, + messageId: requireForBlockBody + ? "unexpectedParensInline" + : "unexpectedParens", + loc: param.loc, + *fix(fixer) { + const tokenBeforeOpeningParen = + sourceCode.getTokenBefore(openingParen); + const closingParen = getClosingParenOfParams(node); + + if ( + tokenBeforeOpeningParen && + tokenBeforeOpeningParen.range[1] === + openingParen.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBeforeOpeningParen, + sourceCode.getFirstToken(param), + ) + ) { + yield fixer.insertTextBefore(openingParen, " "); + } + + // remove parens, whitespace inside parens, and possible trailing comma + yield fixer.removeRange([ + openingParen.range[0], + param.range[0], + ]); + yield fixer.removeRange([ + param.range[1], + closingParen.range[1], + ]); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-spacing.js new file mode 100644 index 00000000..21b20531 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/arrow-spacing.js @@ -0,0 +1,188 @@ +/** + * @fileoverview Rule to define spacing before/after arrow function's arrow. + * @author Jxck + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "arrow-spacing", + url: "https://eslint.style/rules/arrow-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing before and after the arrow in arrow functions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/arrow-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + before: { + type: "boolean", + default: true, + }, + after: { + type: "boolean", + default: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + expectedBefore: "Missing space before =>.", + unexpectedBefore: "Unexpected space before =>.", + + expectedAfter: "Missing space after =>.", + unexpectedAfter: "Unexpected space after =>.", + }, + }, + + create(context) { + // merge rules with default + const rule = Object.assign({}, context.options[0]); + + rule.before = rule.before !== false; + rule.after = rule.after !== false; + + const sourceCode = context.sourceCode; + + /** + * Get tokens of arrow(`=>`) and before/after arrow. + * @param {ASTNode} node The arrow function node. + * @returns {Object} Tokens of arrow and before/after arrow. + */ + function getTokens(node) { + const arrow = sourceCode.getTokenBefore( + node.body, + astUtils.isArrowToken, + ); + + return { + before: sourceCode.getTokenBefore(arrow), + arrow, + after: sourceCode.getTokenAfter(arrow), + }; + } + + /** + * Count spaces before/after arrow(`=>`) token. + * @param {Object} tokens Tokens before/after arrow. + * @returns {Object} count of space before/after arrow. + */ + function countSpaces(tokens) { + const before = tokens.arrow.range[0] - tokens.before.range[1]; + const after = tokens.after.range[0] - tokens.arrow.range[1]; + + return { before, after }; + } + + /** + * Determines whether space(s) before after arrow(`=>`) is satisfy rule. + * if before/after value is `true`, there should be space(s). + * if before/after value is `false`, there should be no space. + * @param {ASTNode} node The arrow function node. + * @returns {void} + */ + function spaces(node) { + const tokens = getTokens(node); + const countSpace = countSpaces(tokens); + + if (rule.before) { + // should be space(s) before arrow + if (countSpace.before === 0) { + context.report({ + node: tokens.before, + messageId: "expectedBefore", + fix(fixer) { + return fixer.insertTextBefore(tokens.arrow, " "); + }, + }); + } + } else { + // should be no space before arrow + if (countSpace.before > 0) { + context.report({ + node: tokens.before, + messageId: "unexpectedBefore", + fix(fixer) { + return fixer.removeRange([ + tokens.before.range[1], + tokens.arrow.range[0], + ]); + }, + }); + } + } + + if (rule.after) { + // should be space(s) after arrow + if (countSpace.after === 0) { + context.report({ + node: tokens.after, + messageId: "expectedAfter", + fix(fixer) { + return fixer.insertTextAfter(tokens.arrow, " "); + }, + }); + } + } else { + // should be no space after arrow + if (countSpace.after > 0) { + context.report({ + node: tokens.after, + messageId: "unexpectedAfter", + fix(fixer) { + return fixer.removeRange([ + tokens.arrow.range[1], + tokens.after.range[0], + ]); + }, + }); + } + } + } + + return { + ArrowFunctionExpression: spaces, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-scoped-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-scoped-var.js new file mode 100644 index 00000000..f83806fe --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-scoped-var.js @@ -0,0 +1,144 @@ +/** + * @fileoverview Rule to check for "block scoped" variables by binding context + * @author Matt DuVall + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Definition} Definition */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce the use of variables within the scope they are defined", + recommended: false, + url: "https://eslint.org/docs/latest/rules/block-scoped-var", + }, + + schema: [], + + messages: { + outOfScope: + "'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context.", + }, + }, + + create(context) { + let stack = []; + const sourceCode = context.sourceCode; + + /** + * Makes a block scope. + * @param {ASTNode} node A node of a scope. + * @returns {void} + */ + function enterScope(node) { + stack.push(node.range); + } + + /** + * Pops the last block scope. + * @returns {void} + */ + function exitScope() { + stack.pop(); + } + + /** + * Reports a given reference. + * @param {Reference} reference A reference to report. + * @param {Definition} definition A definition for which to report reference. + * @returns {void} + */ + function report(reference, definition) { + const identifier = reference.identifier; + const definitionPosition = definition.name.loc.start; + + context.report({ + node: identifier, + messageId: "outOfScope", + data: { + name: identifier.name, + definitionLine: definitionPosition.line, + definitionColumn: definitionPosition.column + 1, + }, + }); + } + + /** + * Finds and reports references which are outside of valid scopes. + * @param {ASTNode} node A node to get variables. + * @returns {void} + */ + function checkForVariables(node) { + if (node.kind !== "var") { + return; + } + + // Defines a predicate to check whether or not a given reference is outside of valid scope. + const scopeRange = stack.at(-1); + + /** + * Check if a reference is out of scope + * @param {ASTNode} reference node to examine + * @returns {boolean} True is its outside the scope + * @private + */ + function isOutsideOfScope(reference) { + const idRange = reference.identifier.range; + + return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1]; + } + + // Gets declared variables, and checks its references. + const variables = sourceCode.getDeclaredVariables(node); + + for (let i = 0; i < variables.length; ++i) { + // Reports. + variables[i].references.filter(isOutsideOfScope).forEach(ref => + report( + ref, + variables[i].defs.find(def => def.parent === node), + ), + ); + } + } + + return { + Program(node) { + stack = [node.range]; + }, + + // Manages scopes. + BlockStatement: enterScope, + "BlockStatement:exit": exitScope, + ForStatement: enterScope, + "ForStatement:exit": exitScope, + ForInStatement: enterScope, + "ForInStatement:exit": exitScope, + ForOfStatement: enterScope, + "ForOfStatement:exit": exitScope, + SwitchStatement: enterScope, + "SwitchStatement:exit": exitScope, + CatchClause: enterScope, + "CatchClause:exit": exitScope, + StaticBlock: enterScope, + "StaticBlock:exit": exitScope, + + // Finds and reports references which are outside of valid scope. + VariableDeclaration: checkForVariables, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-spacing.js new file mode 100644 index 00000000..83279cbe --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/block-spacing.js @@ -0,0 +1,202 @@ +/** + * @fileoverview A rule to disallow or enforce spaces inside of single line blocks. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const util = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "block-spacing", + url: "https://eslint.style/rules/block-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Disallow or enforce spaces inside of blocks after opening block and before closing block", + recommended: false, + url: "https://eslint.org/docs/latest/rules/block-spacing", + }, + + fixable: "whitespace", + + schema: [{ enum: ["always", "never"] }], + + messages: { + missing: "Requires a space {{location}} '{{token}}'.", + extra: "Unexpected space(s) {{location}} '{{token}}'.", + }, + }, + + create(context) { + const always = context.options[0] !== "never", + messageId = always ? "missing" : "extra", + sourceCode = context.sourceCode; + + /** + * Gets the open brace token from a given node. + * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get. + * @returns {Token} The token of the open brace. + */ + function getOpenBrace(node) { + if (node.type === "SwitchStatement") { + if (node.cases.length > 0) { + return sourceCode.getTokenBefore(node.cases[0]); + } + return sourceCode.getLastToken(node, 1); + } + + if (node.type === "StaticBlock") { + return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token + } + + // "BlockStatement" + return sourceCode.getFirstToken(node); + } + + /** + * Checks whether or not: + * - given tokens are on same line. + * - there is/isn't a space between given tokens. + * @param {Token} left A token to check. + * @param {Token} right The token which is next to `left`. + * @returns {boolean} + * When the option is `"always"`, `true` if there are one or more spaces between given tokens. + * When the option is `"never"`, `true` if there are not any spaces between given tokens. + * If given tokens are not on same line, it's always `true`. + */ + function isValid(left, right) { + return ( + !util.isTokenOnSameLine(left, right) || + sourceCode.isSpaceBetween(left, right) === always + ); + } + + /** + * Checks and reports invalid spacing style inside braces. + * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check. + * @returns {void} + */ + function checkSpacingInsideBraces(node) { + // Gets braces and the first/last token of content. + const openBrace = getOpenBrace(node); + const closeBrace = sourceCode.getLastToken(node); + const firstToken = sourceCode.getTokenAfter(openBrace, { + includeComments: true, + }); + const lastToken = sourceCode.getTokenBefore(closeBrace, { + includeComments: true, + }); + + // Skip if the node is invalid or empty. + if ( + openBrace.type !== "Punctuator" || + openBrace.value !== "{" || + closeBrace.type !== "Punctuator" || + closeBrace.value !== "}" || + firstToken === closeBrace + ) { + return; + } + + // Skip line comments for option never + if (!always && firstToken.type === "Line") { + return; + } + + // Check. + if (!isValid(openBrace, firstToken)) { + let loc = openBrace.loc; + + if (messageId === "extra") { + loc = { + start: openBrace.loc.end, + end: firstToken.loc.start, + }; + } + + context.report({ + node, + loc, + messageId, + data: { + location: "after", + token: openBrace.value, + }, + fix(fixer) { + if (always) { + return fixer.insertTextBefore(firstToken, " "); + } + + return fixer.removeRange([ + openBrace.range[1], + firstToken.range[0], + ]); + }, + }); + } + if (!isValid(lastToken, closeBrace)) { + let loc = closeBrace.loc; + + if (messageId === "extra") { + loc = { + start: lastToken.loc.end, + end: closeBrace.loc.start, + }; + } + context.report({ + node, + loc, + messageId, + data: { + location: "before", + token: closeBrace.value, + }, + fix(fixer) { + if (always) { + return fixer.insertTextAfter(lastToken, " "); + } + + return fixer.removeRange([ + lastToken.range[1], + closeBrace.range[0], + ]); + }, + }); + } + } + + return { + BlockStatement: checkSpacingInsideBraces, + StaticBlock: checkSpacingInsideBraces, + SwitchStatement: checkSpacingInsideBraces, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/brace-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/brace-style.js new file mode 100644 index 00000000..f4388400 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/brace-style.js @@ -0,0 +1,278 @@ +/** + * @fileoverview Rule to flag block statements that do not use the one true brace style + * @author Ian Christian Myers + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "brace-style", + url: "https://eslint.style/rules/brace-style", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent brace style for blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/brace-style", + }, + + schema: [ + { + enum: ["1tbs", "stroustrup", "allman"], + }, + { + type: "object", + properties: { + allowSingleLine: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + fixable: "whitespace", + + messages: { + nextLineOpen: + "Opening curly brace does not appear on the same line as controlling statement.", + sameLineOpen: + "Opening curly brace appears on the same line as controlling statement.", + blockSameLine: + "Statement inside of curly braces should be on next line.", + nextLineClose: + "Closing curly brace does not appear on the same line as the subsequent block.", + singleLineClose: + "Closing curly brace should be on the same line as opening curly brace or on the line after the previous block.", + sameLineClose: + "Closing curly brace appears on the same line as the subsequent block.", + }, + }, + + create(context) { + const style = context.options[0] || "1tbs", + params = context.options[1] || {}, + sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Fixes a place where a newline unexpectedly appears + * @param {Token} firstToken The token before the unexpected newline + * @param {Token} secondToken The token after the unexpected newline + * @returns {Function} A fixer function to remove the newlines between the tokens + */ + function removeNewlineBetween(firstToken, secondToken) { + const textRange = [firstToken.range[1], secondToken.range[0]]; + const textBetween = sourceCode.text.slice( + textRange[0], + textRange[1], + ); + + // Don't do a fix if there is a comment between the tokens + if (textBetween.trim()) { + return null; + } + return fixer => fixer.replaceTextRange(textRange, " "); + } + + /** + * Validates a pair of curly brackets based on the user's config + * @param {Token} openingCurly The opening curly bracket + * @param {Token} closingCurly The closing curly bracket + * @returns {void} + */ + function validateCurlyPair(openingCurly, closingCurly) { + const tokenBeforeOpeningCurly = + sourceCode.getTokenBefore(openingCurly); + const tokenAfterOpeningCurly = + sourceCode.getTokenAfter(openingCurly); + const tokenBeforeClosingCurly = + sourceCode.getTokenBefore(closingCurly); + const singleLineException = + params.allowSingleLine && + astUtils.isTokenOnSameLine(openingCurly, closingCurly); + + if ( + style !== "allman" && + !astUtils.isTokenOnSameLine( + tokenBeforeOpeningCurly, + openingCurly, + ) + ) { + context.report({ + node: openingCurly, + messageId: "nextLineOpen", + fix: removeNewlineBetween( + tokenBeforeOpeningCurly, + openingCurly, + ), + }); + } + + if ( + style === "allman" && + astUtils.isTokenOnSameLine( + tokenBeforeOpeningCurly, + openingCurly, + ) && + !singleLineException + ) { + context.report({ + node: openingCurly, + messageId: "sameLineOpen", + fix: fixer => fixer.insertTextBefore(openingCurly, "\n"), + }); + } + + if ( + astUtils.isTokenOnSameLine( + openingCurly, + tokenAfterOpeningCurly, + ) && + tokenAfterOpeningCurly !== closingCurly && + !singleLineException + ) { + context.report({ + node: openingCurly, + messageId: "blockSameLine", + fix: fixer => fixer.insertTextAfter(openingCurly, "\n"), + }); + } + + if ( + tokenBeforeClosingCurly !== openingCurly && + !singleLineException && + astUtils.isTokenOnSameLine( + tokenBeforeClosingCurly, + closingCurly, + ) + ) { + context.report({ + node: closingCurly, + messageId: "singleLineClose", + fix: fixer => fixer.insertTextBefore(closingCurly, "\n"), + }); + } + } + + /** + * Validates the location of a token that appears before a keyword (e.g. a newline before `else`) + * @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`). + * @returns {void} + */ + function validateCurlyBeforeKeyword(curlyToken) { + const keywordToken = sourceCode.getTokenAfter(curlyToken); + + if ( + style === "1tbs" && + !astUtils.isTokenOnSameLine(curlyToken, keywordToken) + ) { + context.report({ + node: curlyToken, + messageId: "nextLineClose", + fix: removeNewlineBetween(curlyToken, keywordToken), + }); + } + + if ( + style !== "1tbs" && + astUtils.isTokenOnSameLine(curlyToken, keywordToken) + ) { + context.report({ + node: curlyToken, + messageId: "sameLineClose", + fix: fixer => fixer.insertTextAfter(curlyToken, "\n"), + }); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + BlockStatement(node) { + if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) { + validateCurlyPair( + sourceCode.getFirstToken(node), + sourceCode.getLastToken(node), + ); + } + }, + StaticBlock(node) { + validateCurlyPair( + sourceCode.getFirstToken(node, { skip: 1 }), // skip the `static` token + sourceCode.getLastToken(node), + ); + }, + ClassBody(node) { + validateCurlyPair( + sourceCode.getFirstToken(node), + sourceCode.getLastToken(node), + ); + }, + SwitchStatement(node) { + const closingCurly = sourceCode.getLastToken(node); + const openingCurly = sourceCode.getTokenBefore( + node.cases.length ? node.cases[0] : closingCurly, + ); + + validateCurlyPair(openingCurly, closingCurly); + }, + IfStatement(node) { + if ( + node.consequent.type === "BlockStatement" && + node.alternate + ) { + // Handle the keyword after the `if` block (before `else`) + validateCurlyBeforeKeyword( + sourceCode.getLastToken(node.consequent), + ); + } + }, + TryStatement(node) { + // Handle the keyword after the `try` block (before `catch` or `finally`) + validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block)); + + if (node.handler && node.finalizer) { + // Handle the keyword after the `catch` block (before `finally`) + validateCurlyBeforeKeyword( + sourceCode.getLastToken(node.handler.body), + ); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/callback-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/callback-return.js new file mode 100644 index 00000000..471ecf26 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/callback-return.js @@ -0,0 +1,216 @@ +/** + * @fileoverview Enforce return after a callback. + * @author Jamund Ferguson + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "callback-return", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/callback-return.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Require `return` statements after callbacks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/callback-return", + }, + + schema: [ + { + type: "array", + items: { type: "string" }, + }, + ], + + messages: { + missingReturn: "Expected return with your callback function.", + }, + }, + + create(context) { + const callbacks = context.options[0] || ["callback", "cb", "next"], + sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Find the closest parent matching a list of types. + * @param {ASTNode} node The node whose parents we are searching + * @param {Array} types The node types to match + * @returns {ASTNode} The matched node or undefined. + */ + function findClosestParentOfType(node, types) { + if (!node.parent) { + return null; + } + if (!types.includes(node.parent.type)) { + return findClosestParentOfType(node.parent, types); + } + return node.parent; + } + + /** + * Check to see if a node contains only identifiers + * @param {ASTNode} node The node to check + * @returns {boolean} Whether or not the node contains only identifiers + */ + function containsOnlyIdentifiers(node) { + if (node.type === "Identifier") { + return true; + } + + if (node.type === "MemberExpression") { + if (node.object.type === "Identifier") { + return true; + } + if (node.object.type === "MemberExpression") { + return containsOnlyIdentifiers(node.object); + } + } + + return false; + } + + /** + * Check to see if a CallExpression is in our callback list. + * @param {ASTNode} node The node to check against our callback names list. + * @returns {boolean} Whether or not this function matches our callback name. + */ + function isCallback(node) { + return ( + containsOnlyIdentifiers(node.callee) && + callbacks.includes(sourceCode.getText(node.callee)) + ); + } + + /** + * Determines whether or not the callback is part of a callback expression. + * @param {ASTNode} node The callback node + * @param {ASTNode} parentNode The expression node + * @returns {boolean} Whether or not this is part of a callback expression + */ + function isCallbackExpression(node, parentNode) { + // ensure the parent node exists and is an expression + if (!parentNode || parentNode.type !== "ExpressionStatement") { + return false; + } + + // cb() + if (parentNode.expression === node) { + return true; + } + + // special case for cb && cb() and similar + if ( + parentNode.expression.type === "BinaryExpression" || + parentNode.expression.type === "LogicalExpression" + ) { + if (parentNode.expression.right === node) { + return true; + } + } + + return false; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + CallExpression(node) { + // if we're not a callback we can return + if (!isCallback(node)) { + return; + } + + // find the closest block, return or loop + const closestBlock = + findClosestParentOfType(node, [ + "BlockStatement", + "ReturnStatement", + "ArrowFunctionExpression", + ]) || {}; + + // if our parent is a return we know we're ok + if (closestBlock.type === "ReturnStatement") { + return; + } + + // arrow functions don't always have blocks and implicitly return + if (closestBlock.type === "ArrowFunctionExpression") { + return; + } + + // block statements are part of functions and most if statements + if (closestBlock.type === "BlockStatement") { + // find the last item in the block + const lastItem = closestBlock.body.at(-1); + + // if the callback is the last thing in a block that might be ok + if (isCallbackExpression(node, lastItem)) { + const parentType = closestBlock.parent.type; + + // but only if the block is part of a function + if ( + parentType === "FunctionExpression" || + parentType === "FunctionDeclaration" || + parentType === "ArrowFunctionExpression" + ) { + return; + } + } + + // ending a block with a return is also ok + if (lastItem.type === "ReturnStatement") { + // but only if the callback is immediately before + if ( + isCallbackExpression(node, closestBlock.body.at(-2)) + ) { + return; + } + } + } + + // as long as you're the child of a function at this point you should be asked to return + if ( + findClosestParentOfType(node, [ + "FunctionDeclaration", + "FunctionExpression", + "ArrowFunctionExpression", + ]) + ) { + context.report({ node, messageId: "missingReturn" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/camelcase.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/camelcase.js new file mode 100644 index 00000000..dad6b120 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/camelcase.js @@ -0,0 +1,422 @@ +/** + * @fileoverview Rule to flag non-camelcased identifiers + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allow: [], + ignoreDestructuring: false, + ignoreGlobals: false, + ignoreImports: false, + properties: "always", + }, + ], + + docs: { + description: "Enforce camelcase naming convention", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/camelcase", + }, + + schema: [ + { + type: "object", + properties: { + ignoreDestructuring: { + type: "boolean", + }, + ignoreImports: { + type: "boolean", + }, + ignoreGlobals: { + type: "boolean", + }, + properties: { + enum: ["always", "never"], + }, + allow: { + type: "array", + items: { + type: "string", + }, + minItems: 0, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + notCamelCase: "Identifier '{{name}}' is not in camel case.", + notCamelCasePrivate: "#{{name}} is not in camel case.", + }, + }, + + create(context) { + const [ + { + allow, + ignoreDestructuring, + ignoreGlobals, + ignoreImports, + properties, + }, + ] = context.options; + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + // contains reported nodes to avoid reporting twice on destructuring with shorthand notation + const reported = new Set(); + + /** + * Checks if a string contains an underscore and isn't all upper-case + * @param {string} name The string to check. + * @returns {boolean} if the string is underscored + * @private + */ + function isUnderscored(name) { + const nameBody = name.replace(/^_+|_+$/gu, ""); + + // if there's an underscore, it might be A_CONSTANT, which is okay + return ( + nameBody.includes("_") && nameBody !== nameBody.toUpperCase() + ); + } + + /** + * Checks if a string match the ignore list + * @param {string} name The string to check. + * @returns {boolean} if the string is ignored + * @private + */ + function isAllowed(name) { + return allow.some( + entry => name === entry || name.match(new RegExp(entry, "u")), + ); + } + + /** + * Checks if a given name is good or not. + * @param {string} name The name to check. + * @returns {boolean} `true` if the name is good. + * @private + */ + function isGoodName(name) { + return !isUnderscored(name) || isAllowed(name); + } + + /** + * Checks if a given identifier reference or member expression is an assignment + * target. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is an assignment target. + */ + function isAssignmentTarget(node) { + const parent = node.parent; + + switch (parent.type) { + case "AssignmentExpression": + case "AssignmentPattern": + return parent.left === node; + + case "Property": + return ( + parent.parent.type === "ObjectPattern" && + parent.value === node + ); + case "ArrayPattern": + case "RestElement": + return true; + + default: + return false; + } + } + + /** + * Checks if a given binding identifier uses the original name as-is. + * - If it's in object destructuring or object expression, the original name is its property name. + * - If it's in import declaration, the original name is its exported name. + * @param {ASTNode} node The `Identifier` node to check. + * @returns {boolean} `true` if the identifier uses the original name as-is. + */ + function equalsToOriginalName(node) { + const localName = node.name; + const valueNode = + node.parent.type === "AssignmentPattern" ? node.parent : node; + const parent = valueNode.parent; + + switch (parent.type) { + case "Property": + return ( + (parent.parent.type === "ObjectPattern" || + parent.parent.type === "ObjectExpression") && + parent.value === valueNode && + !parent.computed && + parent.key.type === "Identifier" && + parent.key.name === localName + ); + + case "ImportSpecifier": + return ( + parent.local === node && + astUtils.getModuleExportName(parent.imported) === + localName + ); + + default: + return false; + } + } + + /** + * Reports an AST node as a rule violation. + * @param {ASTNode} node The node to report. + * @returns {void} + * @private + */ + function report(node) { + if (reported.has(node.range[0])) { + return; + } + reported.add(node.range[0]); + + // Report it. + context.report({ + node, + messageId: + node.type === "PrivateIdentifier" + ? "notCamelCasePrivate" + : "notCamelCase", + data: { name: node.name }, + }); + } + + /** + * Reports an identifier reference or a binding identifier. + * @param {ASTNode} node The `Identifier` node to report. + * @returns {void} + */ + function reportReferenceId(node) { + /* + * For backward compatibility, if it's in callings then ignore it. + * Not sure why it is. + */ + if ( + node.parent.type === "CallExpression" || + node.parent.type === "NewExpression" + ) { + return; + } + + /* + * For backward compatibility, if it's a default value of + * destructuring/parameters then ignore it. + * Not sure why it is. + */ + if ( + node.parent.type === "AssignmentPattern" && + node.parent.right === node + ) { + return; + } + + /* + * The `ignoreDestructuring` flag skips the identifiers that uses + * the property name as-is. + */ + if (ignoreDestructuring && equalsToOriginalName(node)) { + return; + } + + /* + * Import attribute keys are always ignored + */ + if (astUtils.isImportAttributeKey(node)) { + return; + } + + report(node); + } + + return { + // Report camelcase of global variable references ------------------ + Program(node) { + const scope = sourceCode.getScope(node); + + if (!ignoreGlobals) { + // Defined globals in config files or directive comments. + for (const variable of scope.variables) { + if ( + variable.identifiers.length > 0 || + isGoodName(variable.name) + ) { + continue; + } + for (const reference of variable.references) { + /* + * For backward compatibility, this rule reports read-only + * references as well. + */ + reportReferenceId(reference.identifier); + } + } + } + + // Undefined globals. + for (const reference of scope.through) { + const id = reference.identifier; + + if ( + isGoodName(id.name) || + astUtils.isImportAttributeKey(id) + ) { + continue; + } + + /* + * For backward compatibility, this rule reports read-only + * references as well. + */ + reportReferenceId(id); + } + }, + + // Report camelcase of declared variables -------------------------- + [[ + "VariableDeclaration", + "FunctionDeclaration", + "FunctionExpression", + "ArrowFunctionExpression", + "ClassDeclaration", + "ClassExpression", + "CatchClause", + ]](node) { + for (const variable of sourceCode.getDeclaredVariables(node)) { + if (isGoodName(variable.name)) { + continue; + } + const id = variable.identifiers[0]; + + // Report declaration. + if (!(ignoreDestructuring && equalsToOriginalName(id))) { + report(id); + } + + /* + * For backward compatibility, report references as well. + * It looks unnecessary because declarations are reported. + */ + for (const reference of variable.references) { + if (reference.init) { + continue; // Skip the write references of initializers. + } + reportReferenceId(reference.identifier); + } + } + }, + + // Report camelcase in properties ---------------------------------- + [[ + "ObjectExpression > Property[computed!=true] > Identifier.key", + "MethodDefinition[computed!=true] > Identifier.key", + "PropertyDefinition[computed!=true] > Identifier.key", + "MethodDefinition > PrivateIdentifier.key", + "PropertyDefinition > PrivateIdentifier.key", + ]](node) { + if ( + properties === "never" || + astUtils.isImportAttributeKey(node) || + isGoodName(node.name) + ) { + return; + } + report(node); + }, + "MemberExpression[computed!=true] > Identifier.property"(node) { + if ( + properties === "never" || + !isAssignmentTarget(node.parent) || // ← ignore read-only references. + isGoodName(node.name) + ) { + return; + } + report(node); + }, + + // Report camelcase in import -------------------------------------- + ImportDeclaration(node) { + for (const variable of sourceCode.getDeclaredVariables(node)) { + if (isGoodName(variable.name)) { + continue; + } + const id = variable.identifiers[0]; + + // Report declaration. + if (!(ignoreImports && equalsToOriginalName(id))) { + report(id); + } + + /* + * For backward compatibility, report references as well. + * It looks unnecessary because declarations are reported. + */ + for (const reference of variable.references) { + reportReferenceId(reference.identifier); + } + } + }, + + // Report camelcase in re-export ----------------------------------- + [[ + "ExportAllDeclaration > Identifier.exported", + "ExportSpecifier > Identifier.exported", + ]](node) { + if (isGoodName(node.name)) { + return; + } + report(node); + }, + + // Report camelcase in labels -------------------------------------- + [[ + "LabeledStatement > Identifier.label", + + /* + * For backward compatibility, report references as well. + * It looks unnecessary because declarations are reported. + */ + "BreakStatement > Identifier.label", + "ContinueStatement > Identifier.label", + ]](node) { + if (isGoodName(node.name)) { + return; + } + report(node); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/capitalized-comments.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/capitalized-comments.js new file mode 100644 index 00000000..03b9e076 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/capitalized-comments.js @@ -0,0 +1,327 @@ +/** + * @fileoverview enforce or disallow capitalization of the first letter of a comment + * @author Kevin Partington + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { LETTER_PATTERN, containsLetter } = require("./utils/string-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const DEFAULT_IGNORE_PATTERN = astUtils.COMMENTS_IGNORE_PATTERN, + WHITESPACE = /\s/gu, + MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u; // TODO: Combine w/ max-len pattern? + +/* + * Base schema body for defining the basic capitalization rule, ignorePattern, + * and ignoreInlineComments values. + * This can be used in a few different ways in the actual schema. + */ +const SCHEMA_BODY = { + type: "object", + properties: { + ignorePattern: { + type: "string", + }, + ignoreInlineComments: { + type: "boolean", + }, + ignoreConsecutiveComments: { + type: "boolean", + }, + }, + additionalProperties: false, +}; +const DEFAULTS = { + ignorePattern: "", + ignoreInlineComments: false, + ignoreConsecutiveComments: false, +}; + +/** + * Get normalized options for either block or line comments from the given + * user-provided options. + * - If the user-provided options is just a string, returns a normalized + * set of options using default values for all other options. + * - If the user-provided options is an object, then a normalized option + * set is returned. Options specified in overrides will take priority + * over options specified in the main options object, which will in + * turn take priority over the rule's defaults. + * @param {Object|string} rawOptions The user-provided options. + * @param {string} which Either "line" or "block". + * @returns {Object} The normalized options. + */ +function getNormalizedOptions(rawOptions, which) { + return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions); +} + +/** + * Get normalized options for block and line comments. + * @param {Object|string} rawOptions The user-provided options. + * @returns {Object} An object with "Line" and "Block" keys and corresponding + * normalized options objects. + */ +function getAllNormalizedOptions(rawOptions = {}) { + return { + Line: getNormalizedOptions(rawOptions, "line"), + Block: getNormalizedOptions(rawOptions, "block"), + }; +} + +/** + * Creates a regular expression for each ignorePattern defined in the rule + * options. + * + * This is done in order to avoid invoking the RegExp constructor repeatedly. + * @param {Object} normalizedOptions The normalized rule options. + * @returns {void} + */ +function createRegExpForIgnorePatterns(normalizedOptions) { + Object.keys(normalizedOptions).forEach(key => { + const ignorePatternStr = normalizedOptions[key].ignorePattern; + + if (ignorePatternStr) { + const regExp = RegExp(`^\\s*(?:${ignorePatternStr})`, "u"); + + normalizedOptions[key].ignorePatternRegExp = regExp; + } + }); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce or disallow capitalization of the first letter of a comment", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/capitalized-comments", + }, + + fixable: "code", + + schema: [ + { enum: ["always", "never"] }, + { + oneOf: [ + SCHEMA_BODY, + { + type: "object", + properties: { + line: SCHEMA_BODY, + block: SCHEMA_BODY, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: ["always"], + + messages: { + unexpectedLowercaseComment: + "Comments should not begin with a lowercase character.", + unexpectedUppercaseComment: + "Comments should not begin with an uppercase character.", + }, + }, + + create(context) { + const capitalize = context.options[0], + normalizedOptions = getAllNormalizedOptions(context.options[1]), + sourceCode = context.sourceCode; + + createRegExpForIgnorePatterns(normalizedOptions); + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Checks whether a comment is an inline comment. + * + * For the purpose of this rule, a comment is inline if: + * 1. The comment is preceded by a token on the same line; and + * 2. The command is followed by a token on the same line. + * + * Note that the comment itself need not be single-line! + * + * Also, it follows from this definition that only block comments can + * be considered as possibly inline. This is because line comments + * would consume any following tokens on the same line as the comment. + * @param {ASTNode} comment The comment node to check. + * @returns {boolean} True if the comment is an inline comment, false + * otherwise. + */ + function isInlineComment(comment) { + const previousToken = sourceCode.getTokenBefore(comment, { + includeComments: true, + }), + nextToken = sourceCode.getTokenAfter(comment, { + includeComments: true, + }); + + return Boolean( + previousToken && + nextToken && + comment.loc.start.line === previousToken.loc.end.line && + comment.loc.end.line === nextToken.loc.start.line, + ); + } + + /** + * Determine if a comment follows another comment. + * @param {ASTNode} comment The comment to check. + * @returns {boolean} True if the comment follows a valid comment. + */ + function isConsecutiveComment(comment) { + const previousTokenOrComment = sourceCode.getTokenBefore(comment, { + includeComments: true, + }); + + return Boolean( + previousTokenOrComment && + ["Block", "Line"].includes(previousTokenOrComment.type), + ); + } + + /** + * Check a comment to determine if it is valid for this rule. + * @param {ASTNode} comment The comment node to process. + * @param {Object} options The options for checking this comment. + * @returns {boolean} True if the comment is valid, false otherwise. + */ + function isCommentValid(comment, options) { + // 1. Check for default ignore pattern. + if (DEFAULT_IGNORE_PATTERN.test(comment.value)) { + return true; + } + + // 2. Check for custom ignore pattern. + const commentWithoutAsterisks = comment.value.replace(/\*/gu, ""); + + if ( + options.ignorePatternRegExp && + options.ignorePatternRegExp.test(commentWithoutAsterisks) + ) { + return true; + } + + // 3. Check for inline comments. + if (options.ignoreInlineComments && isInlineComment(comment)) { + return true; + } + + // 4. Is this a consecutive comment (and are we tolerating those)? + if ( + options.ignoreConsecutiveComments && + isConsecutiveComment(comment) + ) { + return true; + } + + // 5. Does the comment start with a possible URL? + if (MAYBE_URL.test(commentWithoutAsterisks)) { + return true; + } + + // 6. Is the initial word character a letter? + const commentWordCharsOnly = commentWithoutAsterisks.replace( + WHITESPACE, + "", + ); + + if (commentWordCharsOnly.length === 0) { + return true; + } + + // Get the first Unicode character (1 or 2 code units). + const [firstWordChar] = commentWordCharsOnly; + + if (!containsLetter(firstWordChar)) { + return true; + } + + // 7. Check the case of the initial word character. + const isUppercase = + firstWordChar !== firstWordChar.toLocaleLowerCase(), + isLowercase = + firstWordChar !== firstWordChar.toLocaleUpperCase(); + + if (capitalize === "always" && isLowercase) { + return false; + } + if (capitalize === "never" && isUppercase) { + return false; + } + + return true; + } + + /** + * Process a comment to determine if it needs to be reported. + * @param {ASTNode} comment The comment node to process. + * @returns {void} + */ + function processComment(comment) { + const options = normalizedOptions[comment.type], + commentValid = isCommentValid(comment, options); + + if (!commentValid) { + const messageId = + capitalize === "always" + ? "unexpectedLowercaseComment" + : "unexpectedUppercaseComment"; + + context.report({ + node: null, // Intentionally using loc instead + loc: comment.loc, + messageId, + fix(fixer) { + const match = comment.value.match(LETTER_PATTERN); + const char = match[0]; + + // Offset match.index by 2 to account for the first 2 characters that start the comment (// or /*) + const charIndex = comment.range[0] + match.index + 2; + + return fixer.replaceTextRange( + [charIndex, charIndex + char.length], + capitalize === "always" + ? char.toLocaleUpperCase() + : char.toLocaleLowerCase(), + ); + }, + }); + } + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + Program() { + const comments = sourceCode.getAllComments(); + + comments + .filter(token => token.type !== "Shebang") + .forEach(processComment); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/class-methods-use-this.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/class-methods-use-this.js new file mode 100644 index 00000000..2feab65e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/class-methods-use-this.js @@ -0,0 +1,250 @@ +/** + * @fileoverview Rule to enforce that all class methods use 'this'. + * @author Patrick Williams + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + enforceForClassFields: true, + exceptMethods: [], + ignoreOverrideMethods: false, + }, + ], + + docs: { + description: "Enforce that class methods utilize `this`", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/class-methods-use-this", + }, + + schema: [ + { + type: "object", + properties: { + exceptMethods: { + type: "array", + items: { + type: "string", + }, + }, + enforceForClassFields: { + type: "boolean", + }, + ignoreOverrideMethods: { + type: "boolean", + }, + ignoreClassesWithImplements: { + enum: ["all", "public-fields"], + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missingThis: "Expected 'this' to be used by class {{name}}.", + }, + }, + create(context) { + const [options] = context.options; + const { + enforceForClassFields, + ignoreOverrideMethods, + ignoreClassesWithImplements, + } = options; + const exceptMethods = new Set(options.exceptMethods); + + const stack = []; + + /** + * Push `this` used flag initialized with `false` onto the stack. + * @returns {void} + */ + function pushContext() { + stack.push(false); + } + + /** + * Pop `this` used flag from the stack. + * @returns {boolean | undefined} `this` used flag + */ + function popContext() { + return stack.pop(); + } + + /** + * Initializes the current context to false and pushes it onto the stack. + * These booleans represent whether 'this' has been used in the context. + * @returns {void} + * @private + */ + function enterFunction() { + pushContext(); + } + + /** + * Check if the node is an instance method + * @param {ASTNode} node node to check + * @returns {boolean} True if its an instance method + * @private + */ + function isInstanceMethod(node) { + switch (node.type) { + case "MethodDefinition": + return !node.static && node.kind !== "constructor"; + case "AccessorProperty": + case "PropertyDefinition": + return !node.static && enforceForClassFields; + default: + return false; + } + } + + /** + * Check if the node's parent class implements any interfaces + * @param {ASTNode} node node to check + * @returns {boolean} True if parent class implements interfaces + * @private + */ + function hasImplements(node) { + const classNode = node.parent.parent; + return ( + (classNode?.type === "ClassDeclaration" || + classNode?.type === "ClassExpression") && + classNode.implements?.length > 0 + ); + } + + /** + * Check if the node is an instance method not excluded by config + * @param {ASTNode} node node to check + * @returns {boolean} True if it is an instance method, and not excluded by config + * @private + */ + function isIncludedInstanceMethod(node) { + if (isInstanceMethod(node)) { + if (ignoreOverrideMethods && node.override) { + return false; + } + + if (ignoreClassesWithImplements) { + const implementsInterfaces = hasImplements(node); + if (implementsInterfaces) { + if ( + ignoreClassesWithImplements === "all" || + (ignoreClassesWithImplements === "public-fields" && + node.key.type !== "PrivateIdentifier" && + (!node.accessibility || + node.accessibility === "public")) + ) { + return false; + } + } + } + + if (node.computed) { + return true; + } + + const hashIfNeeded = + node.key.type === "PrivateIdentifier" ? "#" : ""; + const name = + node.key.type === "Literal" + ? astUtils.getStaticStringValue(node.key) + : node.key.name || ""; + + return !exceptMethods.has(hashIfNeeded + name); + } + return false; + } + + /** + * Checks if we are leaving a function that is a method, and reports if 'this' has not been used. + * Static methods and the constructor are exempt. + * Then pops the context off the stack. + * @param {ASTNode} node A function node that was entered. + * @returns {void} + * @private + */ + function exitFunction(node) { + const methodUsesThis = popContext(); + + if (isIncludedInstanceMethod(node.parent) && !methodUsesThis) { + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, context.sourceCode), + messageId: "missingThis", + data: { + name: astUtils.getFunctionNameWithKind(node), + }, + }); + } + } + + /** + * Mark the current context as having used 'this'. + * @returns {void} + * @private + */ + function markThisUsed() { + if (stack.length) { + stack[stack.length - 1] = true; + } + } + + return { + FunctionDeclaration: enterFunction, + "FunctionDeclaration:exit": exitFunction, + FunctionExpression: enterFunction, + "FunctionExpression:exit": exitFunction, + + /* + * Class field value are implicit functions. + */ + "AccessorProperty > *.key:exit": pushContext, + "AccessorProperty:exit": popContext, + "PropertyDefinition > *.key:exit": pushContext, + "PropertyDefinition:exit": popContext, + + /* + * Class static blocks are implicit functions. They aren't required to use `this`, + * but we have to push context so that it captures any use of `this` in the static block + * separately from enclosing contexts, because static blocks have their own `this` and it + * shouldn't count as used `this` in enclosing contexts. + */ + StaticBlock: pushContext, + "StaticBlock:exit": popContext, + + ThisExpression: markThisUsed, + Super: markThisUsed, + ...(enforceForClassFields && { + "AccessorProperty > ArrowFunctionExpression.value": + enterFunction, + "AccessorProperty > ArrowFunctionExpression.value:exit": + exitFunction, + "PropertyDefinition > ArrowFunctionExpression.value": + enterFunction, + "PropertyDefinition > ArrowFunctionExpression.value:exit": + exitFunction, + }), + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-dangle.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-dangle.js new file mode 100644 index 00000000..121ada3c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-dangle.js @@ -0,0 +1,424 @@ +/** + * @fileoverview Rule to forbid or enforce dangling commas. + * @author Ian Christian Myers + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const DEFAULT_OPTIONS = Object.freeze({ + arrays: "never", + objects: "never", + imports: "never", + exports: "never", + functions: "never", +}); + +/** + * Checks whether or not a trailing comma is allowed in a given node. + * If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas. + * @param {ASTNode} lastItem The node of the last element in the given node. + * @returns {boolean} `true` if a trailing comma is allowed. + */ +function isTrailingCommaAllowed(lastItem) { + return !( + lastItem.type === "RestElement" || + lastItem.type === "RestProperty" || + lastItem.type === "ExperimentalRestProperty" + ); +} + +/** + * Normalize option value. + * @param {string|Object|undefined} optionValue The 1st option value to normalize. + * @param {number} ecmaVersion The normalized ECMAScript version. + * @returns {Object} The normalized option value. + */ +function normalizeOptions(optionValue, ecmaVersion) { + if (typeof optionValue === "string") { + return { + arrays: optionValue, + objects: optionValue, + imports: optionValue, + exports: optionValue, + functions: ecmaVersion < 2017 ? "ignore" : optionValue, + }; + } + if (typeof optionValue === "object" && optionValue !== null) { + return { + arrays: optionValue.arrays || DEFAULT_OPTIONS.arrays, + objects: optionValue.objects || DEFAULT_OPTIONS.objects, + imports: optionValue.imports || DEFAULT_OPTIONS.imports, + exports: optionValue.exports || DEFAULT_OPTIONS.exports, + functions: optionValue.functions || DEFAULT_OPTIONS.functions, + }; + } + + return DEFAULT_OPTIONS; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "comma-dangle", + url: "https://eslint.style/rules/comma-dangle", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require or disallow trailing commas", + recommended: false, + url: "https://eslint.org/docs/latest/rules/comma-dangle", + }, + + fixable: "code", + + schema: { + definitions: { + value: { + enum: [ + "always-multiline", + "always", + "never", + "only-multiline", + ], + }, + valueWithIgnore: { + enum: [ + "always-multiline", + "always", + "ignore", + "never", + "only-multiline", + ], + }, + }, + type: "array", + items: [ + { + oneOf: [ + { + $ref: "#/definitions/value", + }, + { + type: "object", + properties: { + arrays: { + $ref: "#/definitions/valueWithIgnore", + }, + objects: { + $ref: "#/definitions/valueWithIgnore", + }, + imports: { + $ref: "#/definitions/valueWithIgnore", + }, + exports: { + $ref: "#/definitions/valueWithIgnore", + }, + functions: { + $ref: "#/definitions/valueWithIgnore", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + additionalItems: false, + }, + + messages: { + unexpected: "Unexpected trailing comma.", + missing: "Missing trailing comma.", + }, + }, + + create(context) { + const options = normalizeOptions( + context.options[0], + context.languageOptions.ecmaVersion, + ); + + const sourceCode = context.sourceCode; + + /** + * Gets the last item of the given node. + * @param {ASTNode} node The node to get. + * @returns {ASTNode|null} The last node or null. + */ + function getLastItem(node) { + /** + * Returns the last element of an array + * @param {any[]} array The input array + * @returns {any} The last element + */ + function last(array) { + return array.at(-1); + } + + switch (node.type) { + case "ObjectExpression": + case "ObjectPattern": + return last(node.properties); + case "ArrayExpression": + case "ArrayPattern": + return last(node.elements); + case "ImportDeclaration": + case "ExportNamedDeclaration": + return last(node.specifiers); + case "FunctionDeclaration": + case "FunctionExpression": + case "ArrowFunctionExpression": + return last(node.params); + case "CallExpression": + case "NewExpression": + return last(node.arguments); + default: + return null; + } + } + + /** + * Gets the trailing comma token of the given node. + * If the trailing comma does not exist, this returns the token which is + * the insertion point of the trailing comma token. + * @param {ASTNode} node The node to get. + * @param {ASTNode} lastItem The last item of the node. + * @returns {Token} The trailing comma token or the insertion point. + */ + function getTrailingToken(node, lastItem) { + switch (node.type) { + case "ObjectExpression": + case "ArrayExpression": + case "CallExpression": + case "NewExpression": + return sourceCode.getLastToken(node, 1); + default: { + const nextToken = sourceCode.getTokenAfter(lastItem); + + if (astUtils.isCommaToken(nextToken)) { + return nextToken; + } + return sourceCode.getLastToken(lastItem); + } + } + } + + /** + * Checks whether or not a given node is multiline. + * This rule handles a given node as multiline when the closing parenthesis + * and the last element are not on the same line. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is multiline. + */ + function isMultiline(node) { + const lastItem = getLastItem(node); + + if (!lastItem) { + return false; + } + + const penultimateToken = getTrailingToken(node, lastItem); + const lastToken = sourceCode.getTokenAfter(penultimateToken); + + return lastToken.loc.end.line !== penultimateToken.loc.end.line; + } + + /** + * Reports a trailing comma if it exists. + * @param {ASTNode} node A node to check. Its type is one of + * ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern, + * ImportDeclaration, and ExportNamedDeclaration. + * @returns {void} + */ + function forbidTrailingComma(node) { + const lastItem = getLastItem(node); + + if ( + !lastItem || + (node.type === "ImportDeclaration" && + lastItem.type !== "ImportSpecifier") + ) { + return; + } + + const trailingToken = getTrailingToken(node, lastItem); + + if (astUtils.isCommaToken(trailingToken)) { + context.report({ + node: lastItem, + loc: trailingToken.loc, + messageId: "unexpected", + *fix(fixer) { + yield fixer.remove(trailingToken); + + /* + * Extend the range of the fix to include surrounding tokens to ensure + * that the element after which the comma is removed stays _last_. + * This intentionally makes conflicts in fix ranges with rules that may be + * adding or removing elements in the same autofix pass. + * https://github.com/eslint/eslint/issues/15660 + */ + yield fixer.insertTextBefore( + sourceCode.getTokenBefore(trailingToken), + "", + ); + yield fixer.insertTextAfter( + sourceCode.getTokenAfter(trailingToken), + "", + ); + }, + }); + } + } + + /** + * Reports the last element of a given node if it does not have a trailing + * comma. + * + * If a given node is `ArrayPattern` which has `RestElement`, the trailing + * comma is disallowed, so report if it exists. + * @param {ASTNode} node A node to check. Its type is one of + * ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern, + * ImportDeclaration, and ExportNamedDeclaration. + * @returns {void} + */ + function forceTrailingComma(node) { + const lastItem = getLastItem(node); + + if ( + !lastItem || + (node.type === "ImportDeclaration" && + lastItem.type !== "ImportSpecifier") + ) { + return; + } + if (!isTrailingCommaAllowed(lastItem)) { + forbidTrailingComma(node); + return; + } + + const trailingToken = getTrailingToken(node, lastItem); + + if (trailingToken.value !== ",") { + context.report({ + node: lastItem, + loc: { + start: trailingToken.loc.end, + end: astUtils.getNextLocation( + sourceCode, + trailingToken.loc.end, + ), + }, + messageId: "missing", + *fix(fixer) { + yield fixer.insertTextAfter(trailingToken, ","); + + /* + * Extend the range of the fix to include surrounding tokens to ensure + * that the element after which the comma is inserted stays _last_. + * This intentionally makes conflicts in fix ranges with rules that may be + * adding or removing elements in the same autofix pass. + * https://github.com/eslint/eslint/issues/15660 + */ + yield fixer.insertTextBefore(trailingToken, ""); + yield fixer.insertTextAfter( + sourceCode.getTokenAfter(trailingToken), + "", + ); + }, + }); + } + } + + /** + * If a given node is multiline, reports the last element of a given node + * when it does not have a trailing comma. + * Otherwise, reports a trailing comma if it exists. + * @param {ASTNode} node A node to check. Its type is one of + * ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern, + * ImportDeclaration, and ExportNamedDeclaration. + * @returns {void} + */ + function forceTrailingCommaIfMultiline(node) { + if (isMultiline(node)) { + forceTrailingComma(node); + } else { + forbidTrailingComma(node); + } + } + + /** + * Only if a given node is not multiline, reports the last element of a given node + * when it does not have a trailing comma. + * Otherwise, reports a trailing comma if it exists. + * @param {ASTNode} node A node to check. Its type is one of + * ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern, + * ImportDeclaration, and ExportNamedDeclaration. + * @returns {void} + */ + function allowTrailingCommaIfMultiline(node) { + if (!isMultiline(node)) { + forbidTrailingComma(node); + } + } + + const predicate = { + always: forceTrailingComma, + "always-multiline": forceTrailingCommaIfMultiline, + "only-multiline": allowTrailingCommaIfMultiline, + never: forbidTrailingComma, + ignore() {}, + }; + + return { + ObjectExpression: predicate[options.objects], + ObjectPattern: predicate[options.objects], + + ArrayExpression: predicate[options.arrays], + ArrayPattern: predicate[options.arrays], + + ImportDeclaration: predicate[options.imports], + + ExportNamedDeclaration: predicate[options.exports], + + FunctionDeclaration: predicate[options.functions], + FunctionExpression: predicate[options.functions], + ArrowFunctionExpression: predicate[options.functions], + CallExpression: predicate[options.functions], + NewExpression: predicate[options.functions], + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-spacing.js new file mode 100644 index 00000000..417f736e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-spacing.js @@ -0,0 +1,205 @@ +/** + * @fileoverview Comma spacing - validates spacing before and after comma + * @author Vignesh Anand aka vegetableman. + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "comma-spacing", + url: "https://eslint.style/rules/comma-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing before and after commas", + recommended: false, + url: "https://eslint.org/docs/latest/rules/comma-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + before: { + type: "boolean", + default: false, + }, + after: { + type: "boolean", + default: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missing: "A space is required {{loc}} ','.", + unexpected: "There should be no space {{loc}} ','.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const tokensAndComments = sourceCode.tokensAndComments; + + const options = { + before: context.options[0] ? context.options[0].before : false, + after: context.options[0] ? context.options[0].after : true, + }; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + // list of comma tokens to ignore for the check of leading whitespace + const commaTokensToIgnore = []; + + /** + * Reports a spacing error with an appropriate message. + * @param {ASTNode} node The binary expression node to report. + * @param {string} loc Is the error "before" or "after" the comma? + * @param {ASTNode} otherNode The node at the left or right of `node` + * @returns {void} + * @private + */ + function report(node, loc, otherNode) { + context.report({ + node, + fix(fixer) { + if (options[loc]) { + if (loc === "before") { + return fixer.insertTextBefore(node, " "); + } + return fixer.insertTextAfter(node, " "); + } + let start, end; + const newText = ""; + + if (loc === "before") { + start = otherNode.range[1]; + end = node.range[0]; + } else { + start = node.range[1]; + end = otherNode.range[0]; + } + + return fixer.replaceTextRange([start, end], newText); + }, + messageId: options[loc] ? "missing" : "unexpected", + data: { + loc, + }, + }); + } + + /** + * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list. + * @param {ASTNode} node An ArrayExpression or ArrayPattern node. + * @returns {void} + */ + function addNullElementsToIgnoreList(node) { + let previousToken = sourceCode.getFirstToken(node); + + node.elements.forEach(element => { + let token; + + if (element === null) { + token = sourceCode.getTokenAfter(previousToken); + + if (astUtils.isCommaToken(token)) { + commaTokensToIgnore.push(token); + } + } else { + token = sourceCode.getTokenAfter(element); + } + + previousToken = token; + }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + "Program:exit"() { + tokensAndComments.forEach((token, i) => { + if (!astUtils.isCommaToken(token)) { + return; + } + + const previousToken = tokensAndComments[i - 1]; + const nextToken = tokensAndComments[i + 1]; + + if ( + previousToken && + !astUtils.isCommaToken(previousToken) && // ignore spacing between two commas + /* + * `commaTokensToIgnore` are ending commas of `null` elements (array holes/elisions). + * In addition to spacing between two commas, this can also ignore: + * + * - Spacing after `[` (controlled by array-bracket-spacing) + * Example: [ , ] + * ^ + * - Spacing after a comment (for backwards compatibility, this was possibly unintentional) + * Example: [a, /* * / ,] + * ^ + */ + !commaTokensToIgnore.includes(token) && + astUtils.isTokenOnSameLine(previousToken, token) && + options.before !== + sourceCode.isSpaceBetween(previousToken, token) + ) { + report(token, "before", previousToken); + } + + if ( + nextToken && + !astUtils.isCommaToken(nextToken) && // ignore spacing between two commas + !astUtils.isClosingParenToken(nextToken) && // controlled by space-in-parens + !astUtils.isClosingBracketToken(nextToken) && // controlled by array-bracket-spacing + !astUtils.isClosingBraceToken(nextToken) && // controlled by object-curly-spacing + !(!options.after && nextToken.type === "Line") && // special case, allow space before line comment + astUtils.isTokenOnSameLine(token, nextToken) && + options.after !== + sourceCode.isSpaceBetween(token, nextToken) + ) { + report(token, "after", nextToken); + } + }); + }, + ArrayExpression: addNullElementsToIgnoreList, + ArrayPattern: addNullElementsToIgnoreList, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-style.js new file mode 100644 index 00000000..6c8e7656 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/comma-style.js @@ -0,0 +1,391 @@ +/** + * @fileoverview Comma style - enforces comma styles of two types: last and first + * @author Vignesh Anand aka vegetableman + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "comma-style", + url: "https://eslint.style/rules/comma-style", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent comma style", + recommended: false, + url: "https://eslint.org/docs/latest/rules/comma-style", + }, + + fixable: "code", + + schema: [ + { + enum: ["first", "last"], + }, + { + type: "object", + properties: { + exceptions: { + type: "object", + additionalProperties: { + type: "boolean", + }, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedLineBeforeAndAfterComma: + "Bad line breaking before and after ','.", + expectedCommaFirst: "',' should be placed first.", + expectedCommaLast: "',' should be placed last.", + }, + }, + + create(context) { + const style = context.options[0] || "last", + sourceCode = context.sourceCode; + const exceptions = { + ArrayPattern: true, + ArrowFunctionExpression: true, + CallExpression: true, + FunctionDeclaration: true, + FunctionExpression: true, + ImportDeclaration: true, + ObjectPattern: true, + NewExpression: true, + }; + + if ( + context.options.length === 2 && + Object.hasOwn(context.options[1], "exceptions") + ) { + const keys = Object.keys(context.options[1].exceptions); + + for (let i = 0; i < keys.length; i++) { + exceptions[keys[i]] = context.options[1].exceptions[keys[i]]; + } + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Modified text based on the style + * @param {string} styleType Style type + * @param {string} text Source code text + * @returns {string} modified text + * @private + */ + function getReplacedText(styleType, text) { + switch (styleType) { + case "between": + return `,${text.replace(astUtils.LINEBREAK_MATCHER, "")}`; + + case "first": + return `${text},`; + + case "last": + return `,${text}`; + + default: + return ""; + } + } + + /** + * Determines the fixer function for a given style. + * @param {string} styleType comma style + * @param {ASTNode} previousItemToken The token to check. + * @param {ASTNode} commaToken The token to check. + * @param {ASTNode} currentItemToken The token to check. + * @returns {Function} Fixer function + * @private + */ + function getFixerFunction( + styleType, + previousItemToken, + commaToken, + currentItemToken, + ) { + const text = + sourceCode.text.slice( + previousItemToken.range[1], + commaToken.range[0], + ) + + sourceCode.text.slice( + commaToken.range[1], + currentItemToken.range[0], + ); + const range = [ + previousItemToken.range[1], + currentItemToken.range[0], + ]; + + return function (fixer) { + return fixer.replaceTextRange( + range, + getReplacedText(styleType, text), + ); + }; + } + + /** + * Validates the spacing around single items in lists. + * @param {Token} previousItemToken The last token from the previous item. + * @param {Token} commaToken The token representing the comma. + * @param {Token} currentItemToken The first token of the current item. + * @param {Token} reportItem The item to use when reporting an error. + * @returns {void} + * @private + */ + function validateCommaItemSpacing( + previousItemToken, + commaToken, + currentItemToken, + reportItem, + ) { + // if single line + if ( + astUtils.isTokenOnSameLine(commaToken, currentItemToken) && + astUtils.isTokenOnSameLine(previousItemToken, commaToken) + ) { + // do nothing. + } else if ( + !astUtils.isTokenOnSameLine(commaToken, currentItemToken) && + !astUtils.isTokenOnSameLine(previousItemToken, commaToken) + ) { + const comment = sourceCode.getCommentsAfter(commaToken)[0]; + const styleType = + comment && + comment.type === "Block" && + astUtils.isTokenOnSameLine(commaToken, comment) + ? style + : "between"; + + // lone comma + context.report({ + node: reportItem, + loc: commaToken.loc, + messageId: "unexpectedLineBeforeAndAfterComma", + fix: getFixerFunction( + styleType, + previousItemToken, + commaToken, + currentItemToken, + ), + }); + } else if ( + style === "first" && + !astUtils.isTokenOnSameLine(commaToken, currentItemToken) + ) { + context.report({ + node: reportItem, + loc: commaToken.loc, + messageId: "expectedCommaFirst", + fix: getFixerFunction( + style, + previousItemToken, + commaToken, + currentItemToken, + ), + }); + } else if ( + style === "last" && + astUtils.isTokenOnSameLine(commaToken, currentItemToken) + ) { + context.report({ + node: reportItem, + loc: commaToken.loc, + messageId: "expectedCommaLast", + fix: getFixerFunction( + style, + previousItemToken, + commaToken, + currentItemToken, + ), + }); + } + } + + /** + * Checks the comma placement with regards to a declaration/property/element + * @param {ASTNode} node The binary expression node to check + * @param {string} property The property of the node containing child nodes. + * @private + * @returns {void} + */ + function validateComma(node, property) { + const items = node[property], + arrayLiteral = + node.type === "ArrayExpression" || + node.type === "ArrayPattern"; + + if (items.length > 1 || arrayLiteral) { + // seed as opening [ + let previousItemToken = sourceCode.getFirstToken(node); + + items.forEach(item => { + const commaToken = item + ? sourceCode.getTokenBefore(item) + : previousItemToken, + currentItemToken = item + ? sourceCode.getFirstToken(item) + : sourceCode.getTokenAfter(commaToken), + reportItem = item || currentItemToken; + + /* + * This works by comparing three token locations: + * - previousItemToken is the last token of the previous item + * - commaToken is the location of the comma before the current item + * - currentItemToken is the first token of the current item + * + * These values get switched around if item is undefined. + * previousItemToken will refer to the last token not belonging + * to the current item, which could be a comma or an opening + * square bracket. currentItemToken could be a comma. + * + * All comparisons are done based on these tokens directly, so + * they are always valid regardless of an undefined item. + */ + if (astUtils.isCommaToken(commaToken)) { + validateCommaItemSpacing( + previousItemToken, + commaToken, + currentItemToken, + reportItem, + ); + } + + if (item) { + const tokenAfterItem = sourceCode.getTokenAfter( + item, + astUtils.isNotClosingParenToken, + ); + + previousItemToken = tokenAfterItem + ? sourceCode.getTokenBefore(tokenAfterItem) + : sourceCode.ast.tokens.at(-1); + } else { + previousItemToken = currentItemToken; + } + }); + + /* + * Special case for array literals that have empty last items, such + * as [ 1, 2, ]. These arrays only have two items show up in the + * AST, so we need to look at the token to verify that there's no + * dangling comma. + */ + if (arrayLiteral) { + const lastToken = sourceCode.getLastToken(node), + nextToLastToken = sourceCode.getTokenBefore(lastToken); + + if (astUtils.isCommaToken(nextToLastToken)) { + validateCommaItemSpacing( + sourceCode.getTokenBefore(nextToLastToken), + nextToLastToken, + lastToken, + lastToken, + ); + } + } + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + const nodes = {}; + + if (!exceptions.VariableDeclaration) { + nodes.VariableDeclaration = function (node) { + validateComma(node, "declarations"); + }; + } + if (!exceptions.ObjectExpression) { + nodes.ObjectExpression = function (node) { + validateComma(node, "properties"); + }; + } + if (!exceptions.ObjectPattern) { + nodes.ObjectPattern = function (node) { + validateComma(node, "properties"); + }; + } + if (!exceptions.ArrayExpression) { + nodes.ArrayExpression = function (node) { + validateComma(node, "elements"); + }; + } + if (!exceptions.ArrayPattern) { + nodes.ArrayPattern = function (node) { + validateComma(node, "elements"); + }; + } + if (!exceptions.FunctionDeclaration) { + nodes.FunctionDeclaration = function (node) { + validateComma(node, "params"); + }; + } + if (!exceptions.FunctionExpression) { + nodes.FunctionExpression = function (node) { + validateComma(node, "params"); + }; + } + if (!exceptions.ArrowFunctionExpression) { + nodes.ArrowFunctionExpression = function (node) { + validateComma(node, "params"); + }; + } + if (!exceptions.CallExpression) { + nodes.CallExpression = function (node) { + validateComma(node, "arguments"); + }; + } + if (!exceptions.ImportDeclaration) { + nodes.ImportDeclaration = function (node) { + validateComma(node, "specifiers"); + }; + } + if (!exceptions.NewExpression) { + nodes.NewExpression = function (node) { + validateComma(node, "arguments"); + }; + } + + return nodes; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/complexity.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/complexity.js new file mode 100644 index 00000000..5b985669 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/complexity.js @@ -0,0 +1,201 @@ +/** + * @fileoverview Counts the cyclomatic complexity of each function of the script. See https://en.wikipedia.org/wiki/Cyclomatic_complexity. + * Counts the number of if, conditional, for, while, try, switch/case, + * @author Patrick Brosset + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { upperCaseFirst } = require("../shared/string-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const THRESHOLD_DEFAULT = 20; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [THRESHOLD_DEFAULT], + + docs: { + description: + "Enforce a maximum cyclomatic complexity allowed in a program", + recommended: false, + url: "https://eslint.org/docs/latest/rules/complexity", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + maximum: { + type: "integer", + minimum: 0, + }, + max: { + type: "integer", + minimum: 0, + }, + variant: { + enum: ["classic", "modified"], + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + complex: + "{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0]; + let threshold = THRESHOLD_DEFAULT; + let VARIANT = "classic"; + + if (typeof option === "object") { + if ( + Object.hasOwn(option, "maximum") || + Object.hasOwn(option, "max") + ) { + threshold = option.maximum || option.max; + } + + if (Object.hasOwn(option, "variant")) { + VARIANT = option.variant; + } + } else if (typeof option === "number") { + threshold = option; + } + + const IS_MODIFIED_COMPLEXITY = VARIANT === "modified"; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + // Using a stack to store complexity per code path + const complexities = []; + + /** + * Increase the complexity of the code path in context + * @returns {void} + * @private + */ + function increaseComplexity() { + complexities[complexities.length - 1]++; + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + onCodePathStart() { + // The initial complexity is 1, representing one execution path in the CodePath + complexities.push(1); + }, + + // Each branching in the code adds 1 to the complexity + CatchClause: increaseComplexity, + ConditionalExpression: increaseComplexity, + LogicalExpression: increaseComplexity, + ForStatement: increaseComplexity, + ForInStatement: increaseComplexity, + ForOfStatement: increaseComplexity, + IfStatement: increaseComplexity, + WhileStatement: increaseComplexity, + DoWhileStatement: increaseComplexity, + AssignmentPattern: increaseComplexity, + + // Avoid `default` + "SwitchCase[test]": () => + IS_MODIFIED_COMPLEXITY || increaseComplexity(), + SwitchStatement: () => + IS_MODIFIED_COMPLEXITY && increaseComplexity(), + + // Logical assignment operators have short-circuiting behavior + AssignmentExpression(node) { + if (astUtils.isLogicalAssignmentOperator(node.operator)) { + increaseComplexity(); + } + }, + + MemberExpression(node) { + if (node.optional === true) { + increaseComplexity(); + } + }, + + CallExpression(node) { + if (node.optional === true) { + increaseComplexity(); + } + }, + + onCodePathEnd(codePath, node) { + const complexity = complexities.pop(); + + /* + * This rule only evaluates complexity of functions, so "program" is excluded. + * Class field initializers and class static blocks are implicit functions. Therefore, + * they shouldn't contribute to the enclosing function's complexity, but their + * own complexity should be evaluated. + */ + if ( + codePath.origin !== "function" && + codePath.origin !== "class-field-initializer" && + codePath.origin !== "class-static-block" + ) { + return; + } + + if (complexity > threshold) { + let name; + let loc = node.loc; + + if (codePath.origin === "class-field-initializer") { + name = "class field initializer"; + } else if (codePath.origin === "class-static-block") { + name = "class static block"; + loc = sourceCode.getFirstToken(node).loc; + } else { + name = astUtils.getFunctionNameWithKind(node); + loc = astUtils.getFunctionHeadLoc(node, sourceCode); + } + + context.report({ + node, + loc, + messageId: "complex", + data: { + name: upperCaseFirst(name), + complexity, + max: threshold, + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/computed-property-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/computed-property-spacing.js new file mode 100644 index 00000000..7d47ff9a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/computed-property-spacing.js @@ -0,0 +1,251 @@ +/** + * @fileoverview Disallows or enforces spaces inside computed properties. + * @author Jamund Ferguson + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "computed-property-spacing", + url: "https://eslint.style/rules/computed-property-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing inside computed property brackets", + recommended: false, + url: "https://eslint.org/docs/latest/rules/computed-property-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + enforceForClassMembers: { + type: "boolean", + default: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedSpaceBefore: + "There should be no space before '{{tokenValue}}'.", + unexpectedSpaceAfter: + "There should be no space after '{{tokenValue}}'.", + + missingSpaceBefore: "A space is required before '{{tokenValue}}'.", + missingSpaceAfter: "A space is required after '{{tokenValue}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never" + const enforceForClassMembers = + !context.options[1] || context.options[1].enforceForClassMembers; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports that there shouldn't be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @param {Token} tokenAfter The token after `token`. + * @returns {void} + */ + function reportNoBeginningSpace(node, token, tokenAfter) { + context.report({ + node, + loc: { start: token.loc.end, end: tokenAfter.loc.start }, + messageId: "unexpectedSpaceAfter", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + token.range[1], + tokenAfter.range[0], + ]); + }, + }); + } + + /** + * Reports that there shouldn't be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @param {Token} tokenBefore The token before `token`. + * @returns {void} + */ + function reportNoEndingSpace(node, token, tokenBefore) { + context.report({ + node, + loc: { start: tokenBefore.loc.end, end: token.loc.start }, + messageId: "unexpectedSpaceBefore", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + tokenBefore.range[1], + token.range[0], + ]); + }, + }); + } + + /** + * Reports that there should be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredBeginningSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingSpaceAfter", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + + /** + * Reports that there should be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredEndingSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "missingSpaceBefore", + data: { + tokenValue: token.value, + }, + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + + /** + * Returns a function that checks the spacing of a node on the property name + * that was passed in. + * @param {string} propertyName The property on the node to check for spacing + * @returns {Function} A function that will check spacing on a node + */ + function checkSpacing(propertyName) { + return function (node) { + if (!node.computed) { + return; + } + + const property = node[propertyName]; + + const before = sourceCode.getTokenBefore( + property, + astUtils.isOpeningBracketToken, + ), + first = sourceCode.getTokenAfter(before, { + includeComments: true, + }), + after = sourceCode.getTokenAfter( + property, + astUtils.isClosingBracketToken, + ), + last = sourceCode.getTokenBefore(after, { + includeComments: true, + }); + + if (astUtils.isTokenOnSameLine(before, first)) { + if (propertyNameMustBeSpaced) { + if ( + !sourceCode.isSpaceBetween(before, first) && + astUtils.isTokenOnSameLine(before, first) + ) { + reportRequiredBeginningSpace(node, before); + } + } else { + if (sourceCode.isSpaceBetween(before, first)) { + reportNoBeginningSpace(node, before, first); + } + } + } + + if (astUtils.isTokenOnSameLine(last, after)) { + if (propertyNameMustBeSpaced) { + if ( + !sourceCode.isSpaceBetween(last, after) && + astUtils.isTokenOnSameLine(last, after) + ) { + reportRequiredEndingSpace(node, after); + } + } else { + if (sourceCode.isSpaceBetween(last, after)) { + reportNoEndingSpace(node, after, last); + } + } + } + }; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + const listeners = { + Property: checkSpacing("key"), + MemberExpression: checkSpacing("property"), + }; + + if (enforceForClassMembers) { + listeners.MethodDefinition = listeners.PropertyDefinition = + listeners.Property; + } + + return listeners; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-return.js new file mode 100644 index 00000000..eca8ec3d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-return.js @@ -0,0 +1,207 @@ +/** + * @fileoverview Rule to flag consistent return values + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { upperCaseFirst } = require("../shared/string-utils"); +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether a given node is a `constructor` method in an ES6 class + * @param {ASTNode} node A node to check + * @returns {boolean} `true` if the node is a `constructor` method + */ +function isClassConstructor(node) { + return ( + node.type === "FunctionExpression" && + node.parent && + node.parent.type === "MethodDefinition" && + node.parent.kind === "constructor" + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require `return` statements to either always or never specify values", + recommended: false, + url: "https://eslint.org/docs/latest/rules/consistent-return", + }, + + schema: [ + { + type: "object", + properties: { + treatUndefinedAsUnspecified: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [{ treatUndefinedAsUnspecified: false }], + + messages: { + missingReturn: "Expected to return a value at the end of {{name}}.", + missingReturnValue: "{{name}} expected a return value.", + unexpectedReturnValue: "{{name}} expected no return value.", + }, + }, + + create(context) { + const [{ treatUndefinedAsUnspecified }] = context.options; + let funcInfo = null; + + /** + * Checks whether of not the implicit returning is consistent if the last + * code path segment is reachable. + * @param {ASTNode} node A program/function node to check. + * @returns {void} + */ + function checkLastSegment(node) { + let loc, name; + + /* + * Skip if it expected no return value or unreachable. + * When unreachable, all paths are returned or thrown. + */ + if ( + !funcInfo.hasReturnValue || + !isAnySegmentReachable(funcInfo.currentSegments) || + astUtils.isES5Constructor(node) || + isClassConstructor(node) + ) { + return; + } + + // Adjust a location and a message. + if (node.type === "Program") { + // The head of program. + loc = { line: 1, column: 0 }; + name = "program"; + } else if (node.type === "ArrowFunctionExpression") { + // `=>` token + loc = context.sourceCode.getTokenBefore( + node.body, + astUtils.isArrowToken, + ).loc; + } else if ( + node.parent.type === "MethodDefinition" || + (node.parent.type === "Property" && node.parent.method) + ) { + // Method name. + loc = node.parent.key.loc; + } else { + // Function name or `function` keyword. + loc = (node.id || context.sourceCode.getFirstToken(node)).loc; + } + + if (!name) { + name = astUtils.getFunctionNameWithKind(node); + } + + // Reports. + context.report({ + node, + loc, + messageId: "missingReturn", + data: { name }, + }); + } + + return { + // Initializes/Disposes state of each code path. + onCodePathStart(codePath, node) { + funcInfo = { + upper: funcInfo, + codePath, + hasReturn: false, + hasReturnValue: false, + messageId: "", + node, + currentSegments: new Set(), + }; + }, + onCodePathEnd() { + funcInfo = funcInfo.upper; + }, + + onUnreachableCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + // Reports a given return statement if it's inconsistent. + ReturnStatement(node) { + const argument = node.argument; + let hasReturnValue = Boolean(argument); + + if (treatUndefinedAsUnspecified && hasReturnValue) { + hasReturnValue = + !astUtils.isSpecificId(argument, "undefined") && + argument.operator !== "void"; + } + + if (!funcInfo.hasReturn) { + funcInfo.hasReturn = true; + funcInfo.hasReturnValue = hasReturnValue; + funcInfo.messageId = hasReturnValue + ? "missingReturnValue" + : "unexpectedReturnValue"; + funcInfo.data = { + name: + funcInfo.node.type === "Program" + ? "Program" + : upperCaseFirst( + astUtils.getFunctionNameWithKind( + funcInfo.node, + ), + ), + }; + } else if (funcInfo.hasReturnValue !== hasReturnValue) { + context.report({ + node, + messageId: funcInfo.messageId, + data: funcInfo.data, + }); + } + }, + + // Reports a given program/function if the implicit returning is not consistent. + "Program:exit": checkLastSegment, + "FunctionDeclaration:exit": checkLastSegment, + "FunctionExpression:exit": checkLastSegment, + "ArrowFunctionExpression:exit": checkLastSegment, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-this.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-this.js new file mode 100644 index 00000000..8e9372d2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/consistent-this.js @@ -0,0 +1,179 @@ +/** + * @fileoverview Rule to enforce consistent naming of "this" context variables + * @author Raphael Pigulla + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce consistent naming when capturing the current execution context", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/consistent-this", + }, + + schema: { + type: "array", + items: { + type: "string", + minLength: 1, + }, + uniqueItems: true, + }, + + defaultOptions: ["that"], + + messages: { + aliasNotAssignedToThis: + "Designated alias '{{name}}' is not assigned to 'this'.", + unexpectedAlias: "Unexpected alias '{{name}}' for 'this'.", + }, + }, + + create(context) { + const aliases = context.options; + const sourceCode = context.sourceCode; + + /** + * Reports that a variable declarator or assignment expression is assigning + * a non-'this' value to the specified alias. + * @param {ASTNode} node The assigning node. + * @param {string} name the name of the alias that was incorrectly used. + * @returns {void} + */ + function reportBadAssignment(node, name) { + context.report({ + node, + messageId: "aliasNotAssignedToThis", + data: { name }, + }); + } + + /** + * Checks that an assignment to an identifier only assigns 'this' to the + * appropriate alias, and the alias is only assigned to 'this'. + * @param {ASTNode} node The assigning node. + * @param {Identifier} name The name of the variable assigned to. + * @param {Expression} value The value of the assignment. + * @returns {void} + */ + function checkAssignment(node, name, value) { + const isThis = value.type === "ThisExpression"; + + if (aliases.includes(name)) { + if (!isThis || (node.operator && node.operator !== "=")) { + reportBadAssignment(node, name); + } + } else if (isThis) { + context.report({ + node, + messageId: "unexpectedAlias", + data: { name }, + }); + } + } + + /** + * Ensures that a variable declaration of the alias in a program or function + * is assigned to the correct value. + * @param {string} alias alias the check the assignment of. + * @param {Object} scope scope of the current code we are checking. + * @private + * @returns {void} + */ + function checkWasAssigned(alias, scope) { + const variable = scope.set.get(alias); + + if (!variable) { + return; + } + + if ( + variable.defs.some( + def => + def.node.type === "VariableDeclarator" && + def.node.init !== null, + ) + ) { + return; + } + + /* + * The alias has been declared and not assigned: check it was + * assigned later in the same scope. + */ + if ( + !variable.references.some(reference => { + const write = reference.writeExpr; + + return ( + reference.from === scope && + write && + write.type === "ThisExpression" && + write.parent.operator === "=" + ); + }) + ) { + variable.defs + .map(def => def.node) + .forEach(node => { + reportBadAssignment(node, alias); + }); + } + } + + /** + * Check each alias to ensure that is was assigned to the correct value. + * @param {ASTNode} node The node that represents the scope to check. + * @returns {void} + */ + function ensureWasAssigned(node) { + const scope = sourceCode.getScope(node); + + // if this is program scope we also need to check module scope + const extraScope = + node.type === "Program" && node.sourceType === "module" + ? scope.childScopes[0] + : null; + + aliases.forEach(alias => { + checkWasAssigned(alias, scope); + + if (extraScope) { + checkWasAssigned(alias, extraScope); + } + }); + } + + return { + "Program:exit": ensureWasAssigned, + "FunctionExpression:exit": ensureWasAssigned, + "FunctionDeclaration:exit": ensureWasAssigned, + + VariableDeclarator(node) { + const id = node.id; + const isDestructuring = + id.type === "ArrayPattern" || id.type === "ObjectPattern"; + + if (node.init !== null && !isDestructuring) { + checkAssignment(node, id.name, node.init); + } + }, + + AssignmentExpression(node) { + if (node.left.type === "Identifier") { + checkAssignment(node, node.left.name, node.right); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/constructor-super.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/constructor-super.js new file mode 100644 index 00000000..2262677d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/constructor-super.js @@ -0,0 +1,453 @@ +/** + * @fileoverview A rule to verify `super()` callings in constructor. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given node is a constructor. + * @param {ASTNode} node A node to check. This node type is one of + * `Program`, `FunctionDeclaration`, `FunctionExpression`, and + * `ArrowFunctionExpression`. + * @returns {boolean} `true` if the node is a constructor. + */ +function isConstructorFunction(node) { + return ( + node.type === "FunctionExpression" && + node.parent.type === "MethodDefinition" && + node.parent.kind === "constructor" + ); +} + +/** + * Checks whether a given node can be a constructor or not. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node can be a constructor. + */ +function isPossibleConstructor(node) { + if (!node) { + return false; + } + + switch (node.type) { + case "ClassExpression": + case "FunctionExpression": + case "ThisExpression": + case "MemberExpression": + case "CallExpression": + case "NewExpression": + case "ChainExpression": + case "YieldExpression": + case "TaggedTemplateExpression": + case "MetaProperty": + return true; + + case "Identifier": + return node.name !== "undefined"; + + case "AssignmentExpression": + if (["=", "&&="].includes(node.operator)) { + return isPossibleConstructor(node.right); + } + + if (["||=", "??="].includes(node.operator)) { + return ( + isPossibleConstructor(node.left) || + isPossibleConstructor(node.right) + ); + } + + /** + * All other assignment operators are mathematical assignment operators (arithmetic or bitwise). + * An assignment expression with a mathematical operator can either evaluate to a primitive value, + * or throw, depending on the operands. Thus, it cannot evaluate to a constructor function. + */ + return false; + + case "LogicalExpression": + /* + * If the && operator short-circuits, the left side was falsy and therefore not a constructor, and if + * it doesn't short-circuit, it takes the value from the right side, so the right side must always be a + * possible constructor. A future improvement could verify that the left side could be truthy by + * excluding falsy literals. + */ + if (node.operator === "&&") { + return isPossibleConstructor(node.right); + } + + return ( + isPossibleConstructor(node.left) || + isPossibleConstructor(node.right) + ); + + case "ConditionalExpression": + return ( + isPossibleConstructor(node.alternate) || + isPossibleConstructor(node.consequent) + ); + + case "SequenceExpression": { + const lastExpression = node.expressions.at(-1); + + return isPossibleConstructor(lastExpression); + } + + default: + return false; + } +} + +/** + * A class to store information about a code path segment. + */ +class SegmentInfo { + /** + * Indicates if super() is called in all code paths. + * @type {boolean} + */ + calledInEveryPaths = false; + + /** + * Indicates if super() is called in any code paths. + * @type {boolean} + */ + calledInSomePaths = false; + + /** + * The nodes which have been validated and don't need to be reconsidered. + * @type {ASTNode[]} + */ + validNodes = []; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Require `super()` calls in constructors", + recommended: true, + url: "https://eslint.org/docs/latest/rules/constructor-super", + }, + + schema: [], + + messages: { + missingSome: "Lacked a call of 'super()' in some code paths.", + missingAll: "Expected to call 'super()'.", + + duplicate: "Unexpected duplicate 'super()'.", + badSuper: + "Unexpected 'super()' because 'super' is not a constructor.", + }, + }, + + create(context) { + /* + * {{hasExtends: boolean, scope: Scope, codePath: CodePath}[]} + * Information for each constructor. + * - upper: Information of the upper constructor. + * - hasExtends: A flag which shows whether own class has a valid `extends` + * part. + * - scope: The scope of own class. + * - codePath: The code path object of the constructor. + */ + let funcInfo = null; + + /** + * @type {Record} + */ + const segInfoMap = Object.create(null); + + /** + * Gets the flag which shows `super()` is called in some paths. + * @param {CodePathSegment} segment A code path segment to get. + * @returns {boolean} The flag which shows `super()` is called in some paths + */ + function isCalledInSomePath(segment) { + return ( + segment.reachable && segInfoMap[segment.id].calledInSomePaths + ); + } + + /** + * Determines if a segment has been seen in the traversal. + * @param {CodePathSegment} segment A code path segment to check. + * @returns {boolean} `true` if the segment has been seen. + */ + function hasSegmentBeenSeen(segment) { + return !!segInfoMap[segment.id]; + } + + /** + * Gets the flag which shows `super()` is called in all paths. + * @param {CodePathSegment} segment A code path segment to get. + * @returns {boolean} The flag which shows `super()` is called in all paths. + */ + function isCalledInEveryPath(segment) { + return ( + segment.reachable && segInfoMap[segment.id].calledInEveryPaths + ); + } + + return { + /** + * Stacks a constructor information. + * @param {CodePath} codePath A code path which was started. + * @param {ASTNode} node The current node. + * @returns {void} + */ + onCodePathStart(codePath, node) { + if (isConstructorFunction(node)) { + // Class > ClassBody > MethodDefinition > FunctionExpression + const classNode = node.parent.parent.parent; + const superClass = classNode.superClass; + + funcInfo = { + upper: funcInfo, + isConstructor: true, + hasExtends: Boolean(superClass), + superIsConstructor: isPossibleConstructor(superClass), + codePath, + currentSegments: new Set(), + }; + } else { + funcInfo = { + upper: funcInfo, + isConstructor: false, + hasExtends: false, + superIsConstructor: false, + codePath, + currentSegments: new Set(), + }; + } + }, + + /** + * Pops a constructor information. + * And reports if `super()` lacked. + * @param {CodePath} codePath A code path which was ended. + * @param {ASTNode} node The current node. + * @returns {void} + */ + onCodePathEnd(codePath, node) { + const hasExtends = funcInfo.hasExtends; + + // Pop. + funcInfo = funcInfo.upper; + + if (!hasExtends) { + return; + } + + // Reports if `super()` lacked. + const returnedSegments = codePath.returnedSegments; + const calledInEveryPaths = + returnedSegments.every(isCalledInEveryPath); + const calledInSomePaths = + returnedSegments.some(isCalledInSomePath); + + if (!calledInEveryPaths) { + context.report({ + messageId: calledInSomePaths + ? "missingSome" + : "missingAll", + node: node.parent, + }); + } + }, + + /** + * Initialize information of a given code path segment. + * @param {CodePathSegment} segment A code path segment to initialize. + * @param {CodePathSegment} node Node that starts the segment. + * @returns {void} + */ + onCodePathSegmentStart(segment, node) { + funcInfo.currentSegments.add(segment); + + if (!(funcInfo.isConstructor && funcInfo.hasExtends)) { + return; + } + + // Initialize info. + const info = (segInfoMap[segment.id] = new SegmentInfo()); + + const seenPrevSegments = + segment.prevSegments.filter(hasSegmentBeenSeen); + + // When there are previous segments, aggregates these. + if (seenPrevSegments.length > 0) { + info.calledInSomePaths = + seenPrevSegments.some(isCalledInSomePath); + info.calledInEveryPaths = + seenPrevSegments.every(isCalledInEveryPath); + } + + /* + * ForStatement > *.update segments are a special case as they are created in advance, + * without seen previous segments. Since they logically don't affect `calledInEveryPaths` + * calculations, and they can never be a lone previous segment of another one, we'll set + * their `calledInEveryPaths` to `true` to effectively ignore them in those calculations. + * . + */ + if ( + node.parent && + node.parent.type === "ForStatement" && + node.parent.update === node + ) { + info.calledInEveryPaths = true; + } + }, + + onUnreachableCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + /** + * Update information of the code path segment when a code path was + * looped. + * @param {CodePathSegment} fromSegment The code path segment of the + * end of a loop. + * @param {CodePathSegment} toSegment A code path segment of the head + * of a loop. + * @returns {void} + */ + onCodePathSegmentLoop(fromSegment, toSegment) { + if (!(funcInfo.isConstructor && funcInfo.hasExtends)) { + return; + } + + funcInfo.codePath.traverseSegments( + { first: toSegment, last: fromSegment }, + (segment, controller) => { + const info = segInfoMap[segment.id]; + + // skip segments after the loop + if (!info) { + controller.skip(); + return; + } + + const seenPrevSegments = + segment.prevSegments.filter(hasSegmentBeenSeen); + const calledInSomePreviousPaths = + seenPrevSegments.some(isCalledInSomePath); + const calledInEveryPreviousPaths = + seenPrevSegments.every(isCalledInEveryPath); + + info.calledInSomePaths ||= calledInSomePreviousPaths; + info.calledInEveryPaths ||= calledInEveryPreviousPaths; + + // If flags become true anew, reports the valid nodes. + if (calledInSomePreviousPaths) { + const nodes = info.validNodes; + + info.validNodes = []; + + for (let i = 0; i < nodes.length; ++i) { + const node = nodes[i]; + + context.report({ + messageId: "duplicate", + node, + }); + } + } + }, + ); + }, + + /** + * Checks for a call of `super()`. + * @param {ASTNode} node A CallExpression node to check. + * @returns {void} + */ + "CallExpression:exit"(node) { + if (!(funcInfo.isConstructor && funcInfo.hasExtends)) { + return; + } + + // Skips except `super()`. + if (node.callee.type !== "Super") { + return; + } + + // Reports if needed. + const segments = funcInfo.currentSegments; + let duplicate = false; + let info = null; + + for (const segment of segments) { + if (segment.reachable) { + info = segInfoMap[segment.id]; + + duplicate = duplicate || info.calledInSomePaths; + info.calledInSomePaths = info.calledInEveryPaths = true; + } + } + + if (info) { + if (duplicate) { + context.report({ + messageId: "duplicate", + node, + }); + } else if (!funcInfo.superIsConstructor) { + context.report({ + messageId: "badSuper", + node, + }); + } else { + info.validNodes.push(node); + } + } + }, + + /** + * Set the mark to the returned path as `super()` was called. + * @param {ASTNode} node A ReturnStatement node to check. + * @returns {void} + */ + ReturnStatement(node) { + if (!(funcInfo.isConstructor && funcInfo.hasExtends)) { + return; + } + + // Skips if no argument. + if (!node.argument) { + return; + } + + // Returning argument is a substitute of 'super()'. + const segments = funcInfo.currentSegments; + + for (const segment of segments) { + if (segment.reachable) { + const info = segInfoMap[segment.id]; + + info.calledInSomePaths = info.calledInEveryPaths = true; + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/curly.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/curly.js new file mode 100644 index 00000000..fd4438d3 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/curly.js @@ -0,0 +1,425 @@ +/** + * @fileoverview Rule to flag statements without curly braces + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce consistent brace style for all control statements", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/curly", + }, + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["all"], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["multi", "multi-line", "multi-or-nest"], + }, + { + enum: ["consistent"], + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + defaultOptions: ["all"], + + fixable: "code", + + messages: { + missingCurlyAfter: "Expected { after '{{name}}'.", + missingCurlyAfterCondition: + "Expected { after '{{name}}' condition.", + unexpectedCurlyAfter: "Unnecessary { after '{{name}}'.", + unexpectedCurlyAfterCondition: + "Unnecessary { after '{{name}}' condition.", + }, + }, + + create(context) { + const multiOnly = context.options[0] === "multi"; + const multiLine = context.options[0] === "multi-line"; + const multiOrNest = context.options[0] === "multi-or-nest"; + const consistent = context.options[1] === "consistent"; + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Determines if a given node is a one-liner that's on the same line as it's preceding code. + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code. + * @private + */ + function isCollapsedOneLiner(node) { + const before = sourceCode.getTokenBefore(node); + const last = sourceCode.getLastToken(node); + const lastExcludingSemicolon = astUtils.isSemicolonToken(last) + ? sourceCode.getTokenBefore(last) + : last; + + return ( + before.loc.start.line === lastExcludingSemicolon.loc.end.line + ); + } + + /** + * Determines if a given node is a one-liner. + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node is a one-liner. + * @private + */ + function isOneLiner(node) { + if (node.type === "EmptyStatement") { + return true; + } + + const first = sourceCode.getFirstToken(node); + const last = sourceCode.getLastToken(node); + const lastExcludingSemicolon = astUtils.isSemicolonToken(last) + ? sourceCode.getTokenBefore(last) + : last; + + return first.loc.start.line === lastExcludingSemicolon.loc.end.line; + } + + /** + * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError. + * @param {Token} closingBracket The } token + * @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block. + */ + function needsSemicolon(closingBracket) { + const tokenBefore = sourceCode.getTokenBefore(closingBracket); + const tokenAfter = sourceCode.getTokenAfter(closingBracket); + const lastBlockNode = sourceCode.getNodeByRangeIndex( + tokenBefore.range[0], + ); + + if (astUtils.isSemicolonToken(tokenBefore)) { + // If the last statement already has a semicolon, don't add another one. + return false; + } + + if (!tokenAfter) { + // If there are no statements after this block, there is no need to add a semicolon. + return false; + } + + if ( + lastBlockNode.type === "BlockStatement" && + lastBlockNode.parent.type !== "FunctionExpression" && + lastBlockNode.parent.type !== "ArrowFunctionExpression" + ) { + /* + * If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression), + * don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause + * a SyntaxError if it was followed by `else`. + */ + return false; + } + + if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) { + // If the next token is on the same line, insert a semicolon. + return true; + } + + if (/^[([/`+-]/u.test(tokenAfter.value)) { + // If the next token starts with a character that would disrupt ASI, insert a semicolon. + return true; + } + + if ( + tokenBefore.type === "Punctuator" && + (tokenBefore.value === "++" || tokenBefore.value === "--") + ) { + // If the last token is ++ or --, insert a semicolon to avoid disrupting ASI. + return true; + } + + // Otherwise, do not insert a semicolon. + return false; + } + + /** + * Prepares to check the body of a node to see if it's a block statement. + * @param {ASTNode} node The node to report if there's a problem. + * @param {ASTNode} body The body node to check for blocks. + * @param {string} name The name to report if there's a problem. + * @param {{ condition: boolean }} opts Options to pass to the report functions + * @returns {Object} a prepared check object, with "actual", "expected", "check" properties. + * "actual" will be `true` or `false` whether the body is already a block statement. + * "expected" will be `true` or `false` if the body should be a block statement or not, or + * `null` if it doesn't matter, depending on the rule options. It can be modified to change + * the final behavior of "check". + * "check" will be a function reporting appropriate problems depending on the other + * properties. + */ + function prepareCheck(node, body, name, opts) { + const hasBlock = body.type === "BlockStatement"; + let expected = null; + + if ( + hasBlock && + (body.body.length !== 1 || + astUtils.areBracesNecessary(body, sourceCode)) + ) { + expected = true; + } else if (multiOnly) { + expected = false; + } else if (multiLine) { + if (!isCollapsedOneLiner(body)) { + expected = true; + } + + // otherwise, the body is allowed to have braces or not to have braces + } else if (multiOrNest) { + if (hasBlock) { + const statement = body.body[0]; + const leadingCommentsInBlock = + sourceCode.getCommentsBefore(statement); + + expected = + !isOneLiner(statement) || + leadingCommentsInBlock.length > 0; + } else { + expected = !isOneLiner(body); + } + } else { + // default "all" + expected = true; + } + + return { + actual: hasBlock, + expected, + check() { + if ( + this.expected !== null && + this.expected !== this.actual + ) { + if (this.expected) { + context.report({ + node, + loc: body.loc, + messageId: + opts && opts.condition + ? "missingCurlyAfterCondition" + : "missingCurlyAfter", + data: { + name, + }, + fix: fixer => + fixer.replaceText( + body, + `{${sourceCode.getText(body)}}`, + ), + }); + } else { + context.report({ + node, + loc: body.loc, + messageId: + opts && opts.condition + ? "unexpectedCurlyAfterCondition" + : "unexpectedCurlyAfter", + data: { + name, + }, + fix(fixer) { + /* + * `do while` expressions sometimes need a space to be inserted after `do`. + * e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)` + */ + const needsPrecedingSpace = + node.type === "DoWhileStatement" && + sourceCode.getTokenBefore(body) + .range[1] === body.range[0] && + !astUtils.canTokensBeAdjacent( + "do", + sourceCode.getFirstToken(body, { + skip: 1, + }), + ); + + const openingBracket = + sourceCode.getFirstToken(body); + const closingBracket = + sourceCode.getLastToken(body); + const lastTokenInBlock = + sourceCode.getTokenBefore( + closingBracket, + ); + + if (needsSemicolon(closingBracket)) { + /* + * If removing braces would cause a SyntaxError due to multiple statements on the same line (or + * change the semantics of the code due to ASI), don't perform a fix. + */ + return null; + } + + const resultingBodyText = + sourceCode + .getText() + .slice( + openingBracket.range[1], + lastTokenInBlock.range[0], + ) + + sourceCode.getText(lastTokenInBlock) + + sourceCode + .getText() + .slice( + lastTokenInBlock.range[1], + closingBracket.range[0], + ); + + return fixer.replaceText( + body, + (needsPrecedingSpace ? " " : "") + + resultingBodyText, + ); + }, + }); + } + } + }, + }; + } + + /** + * Prepares to check the bodies of a "if", "else if" and "else" chain. + * @param {ASTNode} node The first IfStatement node of the chain. + * @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more + * information. + */ + function prepareIfChecks(node) { + const preparedChecks = []; + + for ( + let currentNode = node; + currentNode; + currentNode = currentNode.alternate + ) { + preparedChecks.push( + prepareCheck(currentNode, currentNode.consequent, "if", { + condition: true, + }), + ); + if ( + currentNode.alternate && + currentNode.alternate.type !== "IfStatement" + ) { + preparedChecks.push( + prepareCheck( + currentNode, + currentNode.alternate, + "else", + ), + ); + break; + } + } + + if (consistent) { + /* + * If any node should have or already have braces, make sure they + * all have braces. + * If all nodes shouldn't have braces, make sure they don't. + */ + const expected = preparedChecks.some(preparedCheck => { + if (preparedCheck.expected !== null) { + return preparedCheck.expected; + } + return preparedCheck.actual; + }); + + preparedChecks.forEach(preparedCheck => { + preparedCheck.expected = expected; + }); + } + + return preparedChecks; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + IfStatement(node) { + const parent = node.parent; + const isElseIf = + parent.type === "IfStatement" && parent.alternate === node; + + if (!isElseIf) { + // This is a top `if`, check the whole `if-else-if` chain + prepareIfChecks(node).forEach(preparedCheck => { + preparedCheck.check(); + }); + } + + // Skip `else if`, it's already checked (when the top `if` was visited) + }, + + WhileStatement(node) { + prepareCheck(node, node.body, "while", { + condition: true, + }).check(); + }, + + DoWhileStatement(node) { + prepareCheck(node, node.body, "do").check(); + }, + + ForStatement(node) { + prepareCheck(node, node.body, "for", { + condition: true, + }).check(); + }, + + ForInStatement(node) { + prepareCheck(node, node.body, "for-in").check(); + }, + + ForOfStatement(node) { + prepareCheck(node, node.body, "for-of").check(); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case-last.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case-last.js new file mode 100644 index 00000000..1c6170b4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case-last.js @@ -0,0 +1,51 @@ +/** + * @fileoverview Rule to enforce `default` clauses in `switch` statements to be last + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce `default` clauses in `switch` statements to be last", + recommended: false, + url: "https://eslint.org/docs/latest/rules/default-case-last", + }, + + schema: [], + + messages: { + notLast: "Default clause should be the last clause.", + }, + }, + + create(context) { + return { + SwitchStatement(node) { + const cases = node.cases, + indexOfDefault = cases.findIndex(c => c.test === null); + + if ( + indexOfDefault !== -1 && + indexOfDefault !== cases.length - 1 + ) { + const defaultClause = cases[indexOfDefault]; + + context.report({ + node: defaultClause, + messageId: "notLast", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case.js new file mode 100644 index 00000000..23e2f6ef --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-case.js @@ -0,0 +1,103 @@ +/** + * @fileoverview require default case in switch statements + * @author Aliaksei Shytkin + */ +"use strict"; + +const DEFAULT_COMMENT_PATTERN = /^no default$/iu; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{}], + + docs: { + description: "Require `default` cases in `switch` statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/default-case", + }, + + schema: [ + { + type: "object", + properties: { + commentPattern: { + type: "string", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missingDefaultCase: "Expected a default case.", + }, + }, + + create(context) { + const [options] = context.options; + const commentPattern = options.commentPattern + ? new RegExp(options.commentPattern, "u") + : DEFAULT_COMMENT_PATTERN; + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Shortcut to get last element of array + * @param {*[]} collection Array + * @returns {any} Last element + */ + function last(collection) { + return collection.at(-1); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + SwitchStatement(node) { + if (!node.cases.length) { + /* + * skip check of empty switch because there is no easy way + * to extract comments inside it now + */ + return; + } + + const hasDefault = node.cases.some(v => v.test === null); + + if (!hasDefault) { + let comment; + + const lastCase = last(node.cases); + const comments = sourceCode.getCommentsAfter(lastCase); + + if (comments.length) { + comment = last(comments); + } + + if ( + !comment || + !commentPattern.test(comment.value.trim()) + ) { + context.report({ + node, + messageId: "missingDefaultCase", + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-param-last.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-param-last.js new file mode 100644 index 00000000..8ecf51b6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/default-param-last.js @@ -0,0 +1,77 @@ +/** + * @fileoverview enforce default parameters to be last + * @author Chiawen Chen + */ + +"use strict"; + +/** + * Checks if node is required: i.e. does not have a default value or ? optional indicator. + * @param {ASTNode} node the node to be evaluated + * @returns {boolean} true if the node is required, false if not. + */ +function isRequiredParameter(node) { + return !( + node.type === "AssignmentPattern" || + node.type === "RestElement" || + node.optional + ); +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Enforce default parameters to be last", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/default-param-last", + }, + + schema: [], + + messages: { + shouldBeLast: "Default parameters should be last.", + }, + }, + + create(context) { + /** + * Handler for function contexts. + * @param {ASTNode} node function node + * @returns {void} + */ + function handleFunction(node) { + let hasSeenRequiredParameter = false; + + for (let i = node.params.length - 1; i >= 0; i -= 1) { + const current = node.params[i]; + const param = + current.type === "TSParameterProperty" + ? current.parameter + : current; + + if (isRequiredParameter(param)) { + hasSeenRequiredParameter = true; + continue; + } + + if (hasSeenRequiredParameter) { + context.report({ + node: current, + messageId: "shouldBeLast", + }); + } + } + } + + return { + FunctionDeclaration: handleFunction, + FunctionExpression: handleFunction, + ArrowFunctionExpression: handleFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-location.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-location.js new file mode 100644 index 00000000..9025a1fe --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-location.js @@ -0,0 +1,138 @@ +/** + * @fileoverview Validates newlines before and after dots + * @author Greg Cochard + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "dot-location", + url: "https://eslint.style/rules/dot-location", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent newlines before and after dots", + recommended: false, + url: "https://eslint.org/docs/latest/rules/dot-location", + }, + + schema: [ + { + enum: ["object", "property"], + }, + ], + + fixable: "code", + + messages: { + expectedDotAfterObject: + "Expected dot to be on same line as object.", + expectedDotBeforeProperty: + "Expected dot to be on same line as property.", + }, + }, + + create(context) { + const config = context.options[0]; + + // default to onObject if no preference is passed + const onObject = config === "object" || !config; + + const sourceCode = context.sourceCode; + + /** + * Reports if the dot between object and property is on the correct location. + * @param {ASTNode} node The `MemberExpression` node. + * @returns {void} + */ + function checkDotLocation(node) { + const property = node.property; + const dotToken = sourceCode.getTokenBefore(property); + + if (onObject) { + // `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node. + const tokenBeforeDot = sourceCode.getTokenBefore(dotToken); + + if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dotToken)) { + context.report({ + node, + loc: dotToken.loc, + messageId: "expectedDotAfterObject", + *fix(fixer) { + if ( + dotToken.value.startsWith(".") && + astUtils.isDecimalIntegerNumericToken( + tokenBeforeDot, + ) + ) { + yield fixer.insertTextAfter( + tokenBeforeDot, + ` ${dotToken.value}`, + ); + } else { + yield fixer.insertTextAfter( + tokenBeforeDot, + dotToken.value, + ); + } + yield fixer.remove(dotToken); + }, + }); + } + } else if (!astUtils.isTokenOnSameLine(dotToken, property)) { + context.report({ + node, + loc: dotToken.loc, + messageId: "expectedDotBeforeProperty", + *fix(fixer) { + yield fixer.remove(dotToken); + yield fixer.insertTextBefore(property, dotToken.value); + }, + }); + } + } + + /** + * Checks the spacing of the dot within a member expression. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkNode(node) { + if (!node.computed) { + checkDotLocation(node); + } + } + + return { + MemberExpression: checkNode, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-notation.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-notation.js new file mode 100644 index 00000000..a7b27dec --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/dot-notation.js @@ -0,0 +1,216 @@ +/** + * @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible. + * @author Josh Perez + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const keywords = require("./utils/keywords"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const validIdentifier = /^[a-zA-Z_$][\w$]*$/u; + +// `null` literal must be handled separately. +const literalTypesToCheck = new Set(["string", "boolean"]); + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowKeywords: true, + allowPattern: "", + }, + ], + + docs: { + description: "Enforce dot notation whenever possible", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/dot-notation", + }, + + schema: [ + { + type: "object", + properties: { + allowKeywords: { + type: "boolean", + }, + allowPattern: { + type: "string", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + useDot: "[{{key}}] is better written in dot notation.", + useBrackets: ".{{key}} is a syntax error.", + }, + }, + + create(context) { + const [options] = context.options; + const allowKeywords = options.allowKeywords; + const sourceCode = context.sourceCode; + + let allowPattern; + + if (options.allowPattern) { + allowPattern = new RegExp(options.allowPattern, "u"); + } + + /** + * Check if the property is valid dot notation + * @param {ASTNode} node The dot notation node + * @param {string|boolean|null} value Value which is to be checked + * @returns {void} + */ + function checkComputedProperty(node, value) { + if ( + validIdentifier.test(value) && + (allowKeywords || !keywords.includes(String(value))) && + !(allowPattern && allowPattern.test(value)) + ) { + const formattedValue = + node.property.type === "Literal" + ? JSON.stringify(value) + : `\`${value}\``; + + context.report({ + node: node.property, + messageId: "useDot", + data: { + key: formattedValue, + }, + *fix(fixer) { + const leftBracket = sourceCode.getTokenAfter( + node.object, + astUtils.isOpeningBracketToken, + ); + const rightBracket = sourceCode.getLastToken(node); + const nextToken = sourceCode.getTokenAfter(node); + + // Don't perform any fixes if there are comments inside the brackets. + if ( + sourceCode.commentsExistBetween( + leftBracket, + rightBracket, + ) + ) { + return; + } + + // Replace the brackets by an identifier. + if (!node.optional) { + yield fixer.insertTextBefore( + leftBracket, + astUtils.isDecimalInteger(node.object) + ? " ." + : ".", + ); + } + yield fixer.replaceTextRange( + [leftBracket.range[0], rightBracket.range[1]], + String(value), + ); + + // Insert a space after the property if it will be connected to the next token. + if ( + nextToken && + rightBracket.range[1] === nextToken.range[0] && + !astUtils.canTokensBeAdjacent( + String(value), + nextToken, + ) + ) { + yield fixer.insertTextAfter(node, " "); + } + }, + }); + } + } + + return { + MemberExpression(node) { + if ( + node.computed && + node.property.type === "Literal" && + (literalTypesToCheck.has(typeof node.property.value) || + astUtils.isNullLiteral(node.property)) + ) { + checkComputedProperty(node, node.property.value); + } + if ( + node.computed && + astUtils.isStaticTemplateLiteral(node.property) + ) { + checkComputedProperty( + node, + node.property.quasis[0].value.cooked, + ); + } + if ( + !allowKeywords && + !node.computed && + node.property.type === "Identifier" && + keywords.includes(String(node.property.name)) + ) { + context.report({ + node: node.property, + messageId: "useBrackets", + data: { + key: node.property.name, + }, + *fix(fixer) { + const dotToken = sourceCode.getTokenBefore( + node.property, + ); + + // A statement that starts with `let[` is parsed as a destructuring variable declaration, not a MemberExpression. + if ( + node.object.type === "Identifier" && + node.object.name === "let" && + !node.optional + ) { + return; + } + + // Don't perform any fixes if there are comments between the dot and the property name. + if ( + sourceCode.commentsExistBetween( + dotToken, + node.property, + ) + ) { + return; + } + + // Replace the identifier to brackets. + if (!node.optional) { + yield fixer.remove(dotToken); + } + yield fixer.replaceText( + node.property, + `["${node.property.name}"]`, + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eol-last.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eol-last.js new file mode 100644 index 00000000..49437846 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eol-last.js @@ -0,0 +1,135 @@ +/** + * @fileoverview Require or disallow newline at the end of files + * @author Nodeca Team + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "eol-last", + url: "https://eslint.style/rules/eol-last", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require or disallow newline at the end of files", + recommended: false, + url: "https://eslint.org/docs/latest/rules/eol-last", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never", "unix", "windows"], + }, + ], + + messages: { + missing: "Newline required at end of file but not found.", + unexpected: "Newline not allowed at end of file.", + }, + }, + create(context) { + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: function checkBadEOF(node) { + const sourceCode = context.sourceCode, + src = sourceCode.getText(), + lastLine = sourceCode.lines.at(-1), + location = { + column: lastLine.length, + line: sourceCode.lines.length, + }, + LF = "\n", + CRLF = `\r${LF}`, + endsWithNewline = src.endsWith(LF); + + /* + * Empty source is always valid: No content in file so we don't + * need to lint for a newline on the last line of content. + */ + if (!src.length) { + return; + } + + let mode = context.options[0] || "always", + appendCRLF = false; + + if (mode === "unix") { + // `"unix"` should behave exactly as `"always"` + mode = "always"; + } + if (mode === "windows") { + // `"windows"` should behave exactly as `"always"`, but append CRLF in the fixer for backwards compatibility + mode = "always"; + appendCRLF = true; + } + if (mode === "always" && !endsWithNewline) { + // File is not newline-terminated, but should be + context.report({ + node, + loc: location, + messageId: "missing", + fix(fixer) { + return fixer.insertTextAfterRange( + [0, src.length], + appendCRLF ? CRLF : LF, + ); + }, + }); + } else if (mode === "never" && endsWithNewline) { + const secondLastLine = sourceCode.lines.at(-2); + + // File is newline-terminated, but shouldn't be + context.report({ + node, + loc: { + start: { + line: sourceCode.lines.length - 1, + column: secondLastLine.length, + }, + end: { line: sourceCode.lines.length, column: 0 }, + }, + messageId: "unexpected", + fix(fixer) { + const finalEOLs = /(?:\r?\n)+$/u, + match = finalEOLs.exec(sourceCode.text), + start = match.index, + end = sourceCode.text.length; + + return fixer.replaceTextRange([start, end], ""); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eqeqeq.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eqeqeq.js new file mode 100644 index 00000000..6b4d639a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/eqeqeq.js @@ -0,0 +1,232 @@ +/** + * @fileoverview Rule to flag statements that use != and == instead of !== and === + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + hasSuggestions: true, + + docs: { + description: "Require the use of `===` and `!==`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/eqeqeq", + }, + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["always"], + }, + { + type: "object", + properties: { + null: { + enum: ["always", "never", "ignore"], + }, + }, + additionalProperties: false, + }, + ], + additionalItems: false, + }, + { + type: "array", + items: [ + { + enum: ["smart", "allow-null"], + }, + ], + additionalItems: false, + }, + ], + }, + + defaultOptions: ["always"], + + fixable: "code", + + messages: { + unexpected: + "Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.", + replaceOperator: + "Use '{{expectedOperator}}' instead of '{{actualOperator}}'.", + }, + }, + + create(context) { + const config = context.options[0]; + const options = context.options[1] || {}; + const sourceCode = context.sourceCode; + + const nullOption = + config === "always" ? options.null || "always" : "ignore"; + const enforceRuleForNull = nullOption === "always"; + const enforceInverseRuleForNull = nullOption === "never"; + + /** + * Checks if an expression is a typeof expression + * @param {ASTNode} node The node to check + * @returns {boolean} if the node is a typeof expression + */ + function isTypeOf(node) { + return ( + node.type === "UnaryExpression" && node.operator === "typeof" + ); + } + + /** + * Checks if either operand of a binary expression is a typeof operation + * @param {ASTNode} node The node to check + * @returns {boolean} if one of the operands is typeof + * @private + */ + function isTypeOfBinary(node) { + return isTypeOf(node.left) || isTypeOf(node.right); + } + + /** + * Gets the type of a literal node. + * @param {ASTNode} node The node to check + * @returns {string|null} The type of the literal + * @private + */ + function getLiteralType(node) { + if (node.type === "Literal") { + return typeof node.value; + } + + if (astUtils.isStaticTemplateLiteral(node)) { + return "string"; + } + + return null; + } + + /** + * Checks if operands are literals of the same type (via typeof) + * @param {ASTNode} node The node to check + * @returns {boolean} if operands are of same type + * @private + */ + function areLiteralsAndSameType(node) { + const leftType = getLiteralType(node.left); + + return leftType !== null && leftType === getLiteralType(node.right); + } + + /** + * Checks if one of the operands is a literal null + * @param {ASTNode} node The node to check + * @returns {boolean} if operands are null + * @private + */ + function isNullCheck(node) { + return ( + astUtils.isNullLiteral(node.right) || + astUtils.isNullLiteral(node.left) + ); + } + + /** + * Reports a message for this rule. + * @param {ASTNode} node The binary expression node that was checked + * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==') + * @returns {void} + * @private + */ + function report(node, expectedOperator) { + const operatorToken = sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + + const commonReportParams = { + node, + loc: operatorToken.loc, + messageId: "unexpected", + data: { expectedOperator, actualOperator: node.operator }, + }; + + if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) { + context.report({ + ...commonReportParams, + fix(fixer) { + return fixer.replaceText( + operatorToken, + expectedOperator, + ); + }, + }); + } else { + context.report({ + ...commonReportParams, + suggest: [ + { + messageId: "replaceOperator", + data: { + expectedOperator, + actualOperator: node.operator, + }, + fix: fixer => + fixer.replaceText( + operatorToken, + expectedOperator, + ), + }, + ], + }); + } + } + + return { + BinaryExpression(node) { + const isNull = isNullCheck(node); + + if (node.operator !== "==" && node.operator !== "!=") { + if ( + enforceInverseRuleForNull && + isNull && + (node.operator === "===" || node.operator === "!==") + ) { + report(node, node.operator.slice(0, -1)); + } + return; + } + + if ( + config === "smart" && + (isTypeOfBinary(node) || + areLiteralsAndSameType(node) || + isNull) + ) { + return; + } + + if (!enforceRuleForNull && isNull) { + return; + } + + report(node, `${node.operator}=`); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/for-direction.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/for-direction.js new file mode 100644 index 00000000..08e9d432 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/for-direction.js @@ -0,0 +1,212 @@ +/** + * @fileoverview enforce `for` loop update clause moving the counter in the right direction.(for-direction) + * @author Aladdin-ADD + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getStaticValue } = require("@eslint-community/eslint-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Enforce `for` loop update clause moving the counter in the right direction", + recommended: true, + url: "https://eslint.org/docs/latest/rules/for-direction", + }, + + fixable: null, + schema: [], + + messages: { + incorrectDirection: + "The update clause in this loop moves the variable in the wrong direction.", + }, + }, + + create(context) { + const { sourceCode } = context; + + /** + * report an error. + * @param {ASTNode} node the node to report. + * @returns {void} + */ + function report(node) { + context.report({ + loc: { + start: node.loc.start, + end: sourceCode.getTokenBefore(node.body).loc.end, + }, + messageId: "incorrectDirection", + }); + } + + /** + * check the right side of the assignment + * @param {ASTNode} update UpdateExpression to check + * @param {number} dir expected direction that could either be turned around or invalidated + * @returns {number} return dir, the negated dir, or zero if the counter does not change or the direction is not clear + */ + function getRightDirection(update, dir) { + const staticValue = getStaticValue( + update.right, + sourceCode.getScope(update), + ); + + if ( + staticValue && + ["bigint", "boolean", "number"].includes( + typeof staticValue.value, + ) + ) { + const sign = Math.sign(Number(staticValue.value)) || 0; // convert NaN to 0 + + return dir * sign; + } + return 0; + } + + /** + * check UpdateExpression add/sub the counter + * @param {ASTNode} update UpdateExpression to check + * @param {string} counter variable name to check + * @returns {number} if add return 1, if sub return -1, if nochange, return 0 + */ + function getUpdateDirection(update, counter) { + if ( + update.argument.type === "Identifier" && + update.argument.name === counter + ) { + if (update.operator === "++") { + return 1; + } + if (update.operator === "--") { + return -1; + } + } + return 0; + } + + /** + * check AssignmentExpression add/sub the counter + * @param {ASTNode} update AssignmentExpression to check + * @param {string} counter variable name to check + * @returns {number} if add return 1, if sub return -1, if nochange, return 0 + */ + function getAssignmentDirection(update, counter) { + if (update.left.name === counter) { + if (update.operator === "+=") { + return getRightDirection(update, 1); + } + if (update.operator === "-=") { + return getRightDirection(update, -1); + } + } + return 0; + } + /** + * Collects all expressions that modify the counter. + * @param {ASTNode} node The expression node to check. + * @param {string} counter The name of the counter variable. + * @returns {ASTNode[]} An array of modifying expressions. + */ + function getModifyingExpressions(node, counter) { + if (node.type === "SequenceExpression") { + return node.expressions.flatMap(expr => + getModifyingExpressions(expr, counter), + ); + } + if ( + node.type === "UpdateExpression" && + node.argument.type === "Identifier" && + node.argument.name === counter + ) { + return [node]; + } + if ( + node.type === "AssignmentExpression" && + node.left.type === "Identifier" && + node.left.name === counter + ) { + return [node]; + } + return []; + } + + /** + * Determines the direction of a single update expression for the counter. + * @param {ASTNode} expr An expression node to check (UpdateExpression or AssignmentExpression). + * @param {string} counter The variable name of the counter. + * @returns {number} 1 if incrementing, -1 if decrementing, 0 if unknown or not modifying the counter. + */ + function getDirectionFromExpression(expr, counter) { + if (expr.type === "UpdateExpression") { + return getUpdateDirection(expr, counter); + } + if (expr.type === "AssignmentExpression") { + return getAssignmentDirection(expr, counter); + } + return 0; + } + + return { + ForStatement(node) { + if ( + node.test && + node.test.type === "BinaryExpression" && + node.update + ) { + for (const counterPosition of ["left", "right"]) { + if (node.test[counterPosition].type !== "Identifier") { + continue; + } + + const counter = node.test[counterPosition].name; + const operator = node.test.operator; + const update = node.update; + + let wrongDirection; + + if (operator === "<" || operator === "<=") { + wrongDirection = + counterPosition === "left" ? -1 : 1; + } else if (operator === ">" || operator === ">=") { + wrongDirection = + counterPosition === "left" ? 1 : -1; + } else { + return; + } + + const mutatingExpressions = getModifyingExpressions( + update, + counter, + ); + + if ( + mutatingExpressions.length === 1 && + getDirectionFromExpression( + mutatingExpressions[0], + counter, + ) === wrongDirection + ) { + report(node); + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-call-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-call-spacing.js new file mode 100644 index 00000000..1195d3f4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-call-spacing.js @@ -0,0 +1,281 @@ +/** + * @fileoverview Rule to control spacing within function calls + * @author Matt DuVall + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "function-call-spacing", + url: "https://eslint.style/rules/function-call-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require or disallow spacing between function identifiers and their invocations", + recommended: false, + url: "https://eslint.org/docs/latest/rules/func-call-spacing", + }, + + fixable: "whitespace", + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["never"], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["always"], + }, + { + type: "object", + properties: { + allowNewlines: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + messages: { + unexpectedWhitespace: + "Unexpected whitespace between function name and paren.", + unexpectedNewline: + "Unexpected newline between function name and paren.", + missing: "Missing space between function name and paren.", + }, + }, + + create(context) { + const never = context.options[0] !== "always"; + const allowNewlines = + !never && context.options[1] && context.options[1].allowNewlines; + const sourceCode = context.sourceCode; + const text = sourceCode.getText(); + + /** + * Check if open space is present in a function name + * @param {ASTNode} node node to evaluate + * @param {Token} leftToken The last token of the callee. This may be the closing parenthesis that encloses the callee. + * @param {Token} rightToken The first token of the arguments. this is the opening parenthesis that encloses the arguments. + * @returns {void} + * @private + */ + function checkSpacing(node, leftToken, rightToken) { + const textBetweenTokens = text + .slice(leftToken.range[1], rightToken.range[0]) + .replace(/\/\*.*?\*\//gu, ""); + const hasWhitespace = /\s/u.test(textBetweenTokens); + const hasNewline = + hasWhitespace && + astUtils.LINEBREAK_MATCHER.test(textBetweenTokens); + + /* + * never allowNewlines hasWhitespace hasNewline message + * F F F F Missing space between function name and paren. + * F F F T (Invalid `!hasWhitespace && hasNewline`) + * F F T T Unexpected newline between function name and paren. + * F F T F (OK) + * F T T F (OK) + * F T T T (OK) + * F T F T (Invalid `!hasWhitespace && hasNewline`) + * F T F F Missing space between function name and paren. + * T T F F (Invalid `never && allowNewlines`) + * T T F T (Invalid `!hasWhitespace && hasNewline`) + * T T T T (Invalid `never && allowNewlines`) + * T T T F (Invalid `never && allowNewlines`) + * T F T F Unexpected space between function name and paren. + * T F T T Unexpected space between function name and paren. + * T F F T (Invalid `!hasWhitespace && hasNewline`) + * T F F F (OK) + * + * T T Unexpected space between function name and paren. + * F F Missing space between function name and paren. + * F F T Unexpected newline between function name and paren. + */ + + if (never && hasWhitespace) { + context.report({ + node, + loc: { + start: leftToken.loc.end, + end: { + line: rightToken.loc.start.line, + column: rightToken.loc.start.column - 1, + }, + }, + messageId: "unexpectedWhitespace", + fix(fixer) { + // Don't remove comments. + if ( + sourceCode.commentsExistBetween( + leftToken, + rightToken, + ) + ) { + return null; + } + + // If `?.` exists, it doesn't hide no-unexpected-multiline errors + if (node.optional) { + return fixer.replaceTextRange( + [leftToken.range[1], rightToken.range[0]], + "?.", + ); + } + + /* + * Only autofix if there is no newline + * https://github.com/eslint/eslint/issues/7787 + */ + if (hasNewline) { + return null; + } + return fixer.removeRange([ + leftToken.range[1], + rightToken.range[0], + ]); + }, + }); + } else if (!never && !hasWhitespace) { + context.report({ + node, + loc: { + start: { + line: leftToken.loc.end.line, + column: leftToken.loc.end.column - 1, + }, + end: rightToken.loc.start, + }, + messageId: "missing", + fix(fixer) { + if (node.optional) { + return null; // Not sure if inserting a space to either before/after `?.` token. + } + return fixer.insertTextBefore(rightToken, " "); + }, + }); + } else if (!never && !allowNewlines && hasNewline) { + context.report({ + node, + loc: { + start: leftToken.loc.end, + end: rightToken.loc.start, + }, + messageId: "unexpectedNewline", + fix(fixer) { + /* + * Only autofix if there is no newline + * https://github.com/eslint/eslint/issues/7787 + * But if `?.` exists, it doesn't hide no-unexpected-multiline errors + */ + if (!node.optional) { + return null; + } + + // Don't remove comments. + if ( + sourceCode.commentsExistBetween( + leftToken, + rightToken, + ) + ) { + return null; + } + + const range = [leftToken.range[1], rightToken.range[0]]; + const qdToken = sourceCode.getTokenAfter(leftToken); + + if (qdToken.range[0] === leftToken.range[1]) { + return fixer.replaceTextRange(range, "?. "); + } + if (qdToken.range[1] === rightToken.range[0]) { + return fixer.replaceTextRange(range, " ?."); + } + return fixer.replaceTextRange(range, " ?. "); + }, + }); + } + } + + return { + "CallExpression, NewExpression"(node) { + const lastToken = sourceCode.getLastToken(node); + const lastCalleeToken = sourceCode.getLastToken(node.callee); + const parenToken = sourceCode.getFirstTokenBetween( + lastCalleeToken, + lastToken, + astUtils.isOpeningParenToken, + ); + const prevToken = + parenToken && + sourceCode.getTokenBefore( + parenToken, + astUtils.isNotQuestionDotToken, + ); + + // Parens in NewExpression are optional + if (!(parenToken && parenToken.range[1] < node.range[1])) { + return; + } + + checkSpacing(node, prevToken, parenToken); + }, + + ImportExpression(node) { + const leftToken = sourceCode.getFirstToken(node); + const rightToken = sourceCode.getTokenAfter(leftToken); + + checkSpacing(node, leftToken, rightToken); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-name-matching.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-name-matching.js new file mode 100644 index 00000000..a4cd41a5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-name-matching.js @@ -0,0 +1,340 @@ +/** + * @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned. + * @author Annie Zhang, Pavel Strashkin + */ + +"use strict"; + +//-------------------------------------------------------------------------- +// Requirements +//-------------------------------------------------------------------------- + +const astUtils = require("./utils/ast-utils"); +const esutils = require("esutils"); + +//-------------------------------------------------------------------------- +// Helpers +//-------------------------------------------------------------------------- + +/** + * Determines if a pattern is `module.exports` or `module["exports"]` + * @param {ASTNode} pattern The left side of the AssignmentExpression + * @returns {boolean} True if the pattern is `module.exports` or `module["exports"]` + */ +function isModuleExports(pattern) { + if ( + pattern.type === "MemberExpression" && + pattern.object.type === "Identifier" && + pattern.object.name === "module" + ) { + // module.exports + if ( + pattern.property.type === "Identifier" && + pattern.property.name === "exports" + ) { + return true; + } + + // module["exports"] + if ( + pattern.property.type === "Literal" && + pattern.property.value === "exports" + ) { + return true; + } + } + return false; +} + +/** + * Determines if a string name is a valid identifier + * @param {string} name The string to be checked + * @param {number} ecmaVersion The ECMAScript version if specified in the parserOptions config + * @returns {boolean} True if the string is a valid identifier + */ +function isIdentifier(name, ecmaVersion) { + if (ecmaVersion >= 2015) { + return esutils.keyword.isIdentifierES6(name); + } + return esutils.keyword.isIdentifierES5(name); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const alwaysOrNever = { enum: ["always", "never"] }; +const optionsObject = { + type: "object", + properties: { + considerPropertyDescriptor: { + type: "boolean", + }, + includeCommonJSModuleExports: { + type: "boolean", + }, + }, + additionalProperties: false, +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require function names to match the name of the variable or property to which they are assigned", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/func-name-matching", + }, + + schema: { + anyOf: [ + { + type: "array", + additionalItems: false, + items: [alwaysOrNever, optionsObject], + }, + { + type: "array", + additionalItems: false, + items: [optionsObject], + }, + ], + }, + + defaultOptions: ["always"], + + messages: { + matchProperty: + "Function name `{{funcName}}` should match property name `{{name}}`.", + matchVariable: + "Function name `{{funcName}}` should match variable name `{{name}}`.", + notMatchProperty: + "Function name `{{funcName}}` should not match property name `{{name}}`.", + notMatchVariable: + "Function name `{{funcName}}` should not match variable name `{{name}}`.", + }, + }, + + create(context) { + const options = + (typeof context.options[0] === "object" + ? context.options[0] + : context.options[1]) || {}; + const nameMatches = + typeof context.options[0] === "string" + ? context.options[0] + : "always"; + const considerPropertyDescriptor = options.considerPropertyDescriptor; + const includeModuleExports = options.includeCommonJSModuleExports; + const ecmaVersion = context.languageOptions.ecmaVersion; + + /** + * Check whether node is a certain CallExpression. + * @param {string} objName object name + * @param {string} funcName function name + * @param {ASTNode} node The node to check + * @returns {boolean} `true` if node matches CallExpression + */ + function isPropertyCall(objName, funcName, node) { + if (!node) { + return false; + } + return ( + node.type === "CallExpression" && + astUtils.isSpecificMemberAccess(node.callee, objName, funcName) + ); + } + + /** + * Compares identifiers based on the nameMatches option + * @param {string} x the first identifier + * @param {string} y the second identifier + * @returns {boolean} whether the two identifiers should warn. + */ + function shouldWarn(x, y) { + return ( + (nameMatches === "always" && x !== y) || + (nameMatches === "never" && x === y) + ); + } + + /** + * Reports + * @param {ASTNode} node The node to report + * @param {string} name The variable or property name + * @param {string} funcName The function name + * @param {boolean} isProp True if the reported node is a property assignment + * @returns {void} + */ + function report(node, name, funcName, isProp) { + let messageId; + + if (nameMatches === "always" && isProp) { + messageId = "matchProperty"; + } else if (nameMatches === "always") { + messageId = "matchVariable"; + } else if (isProp) { + messageId = "notMatchProperty"; + } else { + messageId = "notMatchVariable"; + } + context.report({ + node, + messageId, + data: { + name, + funcName, + }, + }); + } + + /** + * Determines whether a given node is a string literal + * @param {ASTNode} node The node to check + * @returns {boolean} `true` if the node is a string literal + */ + function isStringLiteral(node) { + return node.type === "Literal" && typeof node.value === "string"; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + VariableDeclarator(node) { + if ( + !node.init || + node.init.type !== "FunctionExpression" || + node.id.type !== "Identifier" + ) { + return; + } + if ( + node.init.id && + shouldWarn(node.id.name, node.init.id.name) + ) { + report(node, node.id.name, node.init.id.name, false); + } + }, + + AssignmentExpression(node) { + if ( + node.right.type !== "FunctionExpression" || + (node.left.computed && + node.left.property.type !== "Literal") || + (!includeModuleExports && isModuleExports(node.left)) || + (node.left.type !== "Identifier" && + node.left.type !== "MemberExpression") + ) { + return; + } + + const isProp = node.left.type === "MemberExpression"; + const name = isProp + ? astUtils.getStaticPropertyName(node.left) + : node.left.name; + + if ( + node.right.id && + name && + isIdentifier(name) && + shouldWarn(name, node.right.id.name) + ) { + report(node, name, node.right.id.name, isProp); + } + }, + + "Property, PropertyDefinition[value]"(node) { + if (!( + node.value.type === "FunctionExpression" && node.value.id + )) { + return; + } + + if (node.key.type === "Identifier" && !node.computed) { + const functionName = node.value.id.name; + let propertyName = node.key.name; + + if ( + considerPropertyDescriptor && + propertyName === "value" && + node.parent.type === "ObjectExpression" + ) { + if ( + isPropertyCall( + "Object", + "defineProperty", + node.parent.parent, + ) || + isPropertyCall( + "Reflect", + "defineProperty", + node.parent.parent, + ) + ) { + const property = node.parent.parent.arguments[1]; + + if ( + isStringLiteral(property) && + shouldWarn(property.value, functionName) + ) { + report( + node, + property.value, + functionName, + true, + ); + } + } else if ( + isPropertyCall( + "Object", + "defineProperties", + node.parent.parent.parent.parent, + ) + ) { + propertyName = node.parent.parent.key.name; + if ( + !node.parent.parent.computed && + shouldWarn(propertyName, functionName) + ) { + report(node, propertyName, functionName, true); + } + } else if ( + isPropertyCall( + "Object", + "create", + node.parent.parent.parent.parent, + ) + ) { + propertyName = node.parent.parent.key.name; + if ( + !node.parent.parent.computed && + shouldWarn(propertyName, functionName) + ) { + report(node, propertyName, functionName, true); + } + } else if (shouldWarn(propertyName, functionName)) { + report(node, propertyName, functionName, true); + } + } else if (shouldWarn(propertyName, functionName)) { + report(node, propertyName, functionName, true); + } + return; + } + + if ( + isStringLiteral(node.key) && + isIdentifier(node.key.value, ecmaVersion) && + shouldWarn(node.key.value, node.value.id.name) + ) { + report(node, node.key.value, node.value.id.name, true); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-names.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-names.js new file mode 100644 index 00000000..3df30a20 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-names.js @@ -0,0 +1,204 @@ +/** + * @fileoverview Rule to warn when a function expression does not have a name. + * @author Kyle T. Nunery + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given variable is a function name. + * @param {Variable} variable A variable to check. + * @returns {boolean} `true` if the variable is a function name. + */ +function isFunctionName(variable) { + return variable && variable.defs[0].type === "FunctionName"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: ["always", {}], + + docs: { + description: "Require or disallow named `function` expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/func-names", + }, + + schema: { + definitions: { + value: { + enum: ["always", "as-needed", "never"], + }, + }, + type: "array", + items: [ + { + $ref: "#/definitions/value", + }, + { + type: "object", + properties: { + generators: { + $ref: "#/definitions/value", + }, + }, + additionalProperties: false, + }, + ], + additionalItems: false, + }, + + messages: { + unnamed: "Unexpected unnamed {{name}}.", + named: "Unexpected named {{name}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Returns the config option for the given node. + * @param {ASTNode} node A node to get the config for. + * @returns {string} The config option. + */ + function getConfigForNode(node) { + if (node.generator && context.options[1].generators) { + return context.options[1].generators; + } + + return context.options[0]; + } + + /** + * Determines whether the current FunctionExpression node is a get, set, or + * shorthand method in an object literal or a class. + * @param {ASTNode} node A node to check. + * @returns {boolean} True if the node is a get, set, or shorthand method. + */ + function isObjectOrClassMethod(node) { + const parent = node.parent; + + return ( + parent.type === "MethodDefinition" || + (parent.type === "Property" && + (parent.method || + parent.kind === "get" || + parent.kind === "set")) + ); + } + + /** + * Determines whether the current FunctionExpression node has a name that would be + * inferred from context in a conforming ES6 environment. + * @param {ASTNode} node A node to check. + * @returns {boolean} True if the node would have a name assigned automatically. + */ + function hasInferredName(node) { + const parent = node.parent; + + return ( + isObjectOrClassMethod(node) || + (parent.type === "VariableDeclarator" && + parent.id.type === "Identifier" && + parent.init === node) || + (parent.type === "Property" && parent.value === node) || + (parent.type === "PropertyDefinition" && + parent.value === node) || + (parent.type === "AssignmentExpression" && + parent.left.type === "Identifier" && + parent.right === node) || + (parent.type === "AssignmentPattern" && + parent.left.type === "Identifier" && + parent.right === node) + ); + } + + /** + * Reports that an unnamed function should be named + * @param {ASTNode} node The node to report in the event of an error. + * @returns {void} + */ + function reportUnexpectedUnnamedFunction(node) { + context.report({ + node, + messageId: "unnamed", + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + data: { name: astUtils.getFunctionNameWithKind(node) }, + }); + } + + /** + * Reports that a named function should be unnamed + * @param {ASTNode} node The node to report in the event of an error. + * @returns {void} + */ + function reportUnexpectedNamedFunction(node) { + context.report({ + node, + messageId: "named", + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + data: { name: astUtils.getFunctionNameWithKind(node) }, + }); + } + + /** + * The listener for function nodes. + * @param {ASTNode} node function node + * @returns {void} + */ + function handleFunction(node) { + // Skip recursive functions. + const nameVar = sourceCode.getDeclaredVariables(node)[0]; + + if (isFunctionName(nameVar) && nameVar.references.length > 0) { + return; + } + + const hasName = Boolean(node.id && node.id.name); + const config = getConfigForNode(node); + + if (config === "never") { + if (hasName && node.type !== "FunctionDeclaration") { + reportUnexpectedNamedFunction(node); + } + } else if (config === "as-needed") { + if (!hasName && !hasInferredName(node)) { + reportUnexpectedUnnamedFunction(node); + } + } else { + if (!hasName && !isObjectOrClassMethod(node)) { + reportUnexpectedUnnamedFunction(node); + } + } + } + + return { + "FunctionExpression:exit": handleFunction, + "ExportDefaultDeclaration > FunctionDeclaration": handleFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-style.js new file mode 100644 index 00000000..0260dc8d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/func-style.js @@ -0,0 +1,220 @@ +/** + * @fileoverview Rule to enforce a particular function style + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + "expression", + { + allowArrowFunctions: false, + allowTypeAnnotation: false, + overrides: {}, + }, + ], + + docs: { + description: + "Enforce the consistent use of either `function` declarations or expressions assigned to variables", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/func-style", + }, + + schema: [ + { + enum: ["declaration", "expression"], + }, + { + type: "object", + properties: { + allowArrowFunctions: { + type: "boolean", + }, + allowTypeAnnotation: { + type: "boolean", + }, + overrides: { + type: "object", + properties: { + namedExports: { + enum: ["declaration", "expression", "ignore"], + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + expression: "Expected a function expression.", + declaration: "Expected a function declaration.", + }, + }, + + create(context) { + const [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] = + context.options; + const enforceDeclarations = style === "declaration"; + const { namedExports: exportFunctionStyle } = overrides; + const stack = []; + + /** + * Checks if a function declaration is part of an overloaded function + * @param {ASTNode} node The function declaration node to check + * @returns {boolean} True if the function is overloaded + */ + function isOverloadedFunction(node) { + const functionName = node.id.name; + + if (node.parent.type === "ExportNamedDeclaration") { + return node.parent.parent.body.some( + member => + member.type === "ExportNamedDeclaration" && + member.declaration?.type === "TSDeclareFunction" && + member.declaration.id.name === functionName, + ); + } + + if (node.parent.type === "SwitchCase") { + return node.parent.parent.cases.some(switchCase => + switchCase.consequent.some( + member => + member.type === "TSDeclareFunction" && + member.id.name === functionName, + ), + ); + } + + return ( + Array.isArray(node.parent.body) && + node.parent.body.some( + member => + member.type === "TSDeclareFunction" && + member.id.name === functionName, + ) + ); + } + + const nodesToCheck = { + FunctionDeclaration(node) { + stack.push(false); + + if ( + !enforceDeclarations && + node.parent.type !== "ExportDefaultDeclaration" && + (typeof exportFunctionStyle === "undefined" || + node.parent.type !== "ExportNamedDeclaration") && + !isOverloadedFunction(node) + ) { + context.report({ node, messageId: "expression" }); + } + + if ( + node.parent.type === "ExportNamedDeclaration" && + exportFunctionStyle === "expression" && + !isOverloadedFunction(node) + ) { + context.report({ node, messageId: "expression" }); + } + }, + "FunctionDeclaration:exit"() { + stack.pop(); + }, + + FunctionExpression(node) { + stack.push(false); + + if ( + enforceDeclarations && + node.parent.type === "VariableDeclarator" && + (typeof exportFunctionStyle === "undefined" || + node.parent.parent.parent.type !== + "ExportNamedDeclaration") && + !(allowTypeAnnotation && node.parent.id.typeAnnotation) + ) { + context.report({ + node: node.parent, + messageId: "declaration", + }); + } + + if ( + node.parent.type === "VariableDeclarator" && + node.parent.parent.parent.type === + "ExportNamedDeclaration" && + exportFunctionStyle === "declaration" && + !(allowTypeAnnotation && node.parent.id.typeAnnotation) + ) { + context.report({ + node: node.parent, + messageId: "declaration", + }); + } + }, + "FunctionExpression:exit"() { + stack.pop(); + }, + + "ThisExpression, Super"() { + if (stack.length > 0) { + stack[stack.length - 1] = true; + } + }, + }; + + if (!allowArrowFunctions) { + nodesToCheck.ArrowFunctionExpression = function () { + stack.push(false); + }; + + nodesToCheck["ArrowFunctionExpression:exit"] = function (node) { + const hasThisOrSuperExpr = stack.pop(); + + if ( + !hasThisOrSuperExpr && + node.parent.type === "VariableDeclarator" + ) { + if ( + enforceDeclarations && + (typeof exportFunctionStyle === "undefined" || + node.parent.parent.parent.type !== + "ExportNamedDeclaration") && + !(allowTypeAnnotation && node.parent.id.typeAnnotation) + ) { + context.report({ + node: node.parent, + messageId: "declaration", + }); + } + + if ( + node.parent.parent.parent.type === + "ExportNamedDeclaration" && + exportFunctionStyle === "declaration" && + !(allowTypeAnnotation && node.parent.id.typeAnnotation) + ) { + context.report({ + node: node.parent, + messageId: "declaration", + }); + } + } + }; + } + + return nodesToCheck; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-call-argument-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-call-argument-newline.js new file mode 100644 index 00000000..0ad1ca1d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-call-argument-newline.js @@ -0,0 +1,166 @@ +/** + * @fileoverview Rule to enforce line breaks between arguments of a function call + * @author Alexey Gonchar + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "function-call-argument-newline", + url: "https://eslint.style/rules/function-call-argument-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce line breaks between arguments of a function call", + recommended: false, + url: "https://eslint.org/docs/latest/rules/function-call-argument-newline", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never", "consistent"], + }, + ], + + messages: { + unexpectedLineBreak: "There should be no line break here.", + missingLineBreak: + "There should be a line break after this argument.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const checkers = { + unexpected: { + messageId: "unexpectedLineBreak", + check: (prevToken, currentToken) => + prevToken.loc.end.line !== currentToken.loc.start.line, + createFix: (token, tokenBefore) => fixer => + fixer.replaceTextRange( + [tokenBefore.range[1], token.range[0]], + " ", + ), + }, + missing: { + messageId: "missingLineBreak", + check: (prevToken, currentToken) => + prevToken.loc.end.line === currentToken.loc.start.line, + createFix: (token, tokenBefore) => fixer => + fixer.replaceTextRange( + [tokenBefore.range[1], token.range[0]], + "\n", + ), + }, + }; + + /** + * Check all arguments for line breaks in the CallExpression + * @param {CallExpression} node node to evaluate + * @param {{ messageId: string, check: Function }} checker selected checker + * @returns {void} + * @private + */ + function checkArguments(node, checker) { + for (let i = 1; i < node.arguments.length; i++) { + const prevArgToken = sourceCode.getLastToken( + node.arguments[i - 1], + ); + const currentArgToken = sourceCode.getFirstToken( + node.arguments[i], + ); + + if (checker.check(prevArgToken, currentArgToken)) { + const tokenBefore = sourceCode.getTokenBefore( + currentArgToken, + { includeComments: true }, + ); + + const hasLineCommentBefore = tokenBefore.type === "Line"; + + context.report({ + node, + loc: { + start: tokenBefore.loc.end, + end: currentArgToken.loc.start, + }, + messageId: checker.messageId, + fix: hasLineCommentBefore + ? null + : checker.createFix(currentArgToken, tokenBefore), + }); + } + } + } + + /** + * Check if open space is present in a function name + * @param {CallExpression} node node to evaluate + * @returns {void} + * @private + */ + function check(node) { + if (node.arguments.length < 2) { + return; + } + + const option = context.options[0] || "always"; + + if (option === "never") { + checkArguments(node, checkers.unexpected); + } else if (option === "always") { + checkArguments(node, checkers.missing); + } else if (option === "consistent") { + const firstArgToken = sourceCode.getLastToken( + node.arguments[0], + ); + const secondArgToken = sourceCode.getFirstToken( + node.arguments[1], + ); + + if ( + firstArgToken.loc.end.line === secondArgToken.loc.start.line + ) { + checkArguments(node, checkers.unexpected); + } else { + checkArguments(node, checkers.missing); + } + } + } + + return { + CallExpression: check, + NewExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-paren-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-paren-newline.js new file mode 100644 index 00000000..17e5e9cf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/function-paren-newline.js @@ -0,0 +1,368 @@ +/** + * @fileoverview enforce consistent line breaks inside function parentheses + * @author Teddy Katz + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "function-paren-newline", + url: "https://eslint.style/rules/function-paren-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent line breaks inside function parentheses", + recommended: false, + url: "https://eslint.org/docs/latest/rules/function-paren-newline", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: [ + "always", + "never", + "consistent", + "multiline", + "multiline-arguments", + ], + }, + { + type: "object", + properties: { + minItems: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + expectedBefore: "Expected newline before ')'.", + expectedAfter: "Expected newline after '('.", + expectedBetween: "Expected newline between arguments/params.", + unexpectedBefore: "Unexpected newline before ')'.", + unexpectedAfter: "Unexpected newline after '('.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const rawOption = context.options[0] || "multiline"; + const multilineOption = rawOption === "multiline"; + const multilineArgumentsOption = rawOption === "multiline-arguments"; + const consistentOption = rawOption === "consistent"; + let minItems; + + if (typeof rawOption === "object") { + minItems = rawOption.minItems; + } else if (rawOption === "always") { + minItems = 0; + } else if (rawOption === "never") { + minItems = Infinity; + } else { + minItems = null; + } + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Determines whether there should be newlines inside function parens + * @param {ASTNode[]} elements The arguments or parameters in the list + * @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code. + * @returns {boolean} `true` if there should be newlines inside the function parens + */ + function shouldHaveNewlines(elements, hasLeftNewline) { + if (multilineArgumentsOption && elements.length === 1) { + return hasLeftNewline; + } + if (multilineOption || multilineArgumentsOption) { + return elements.some( + (element, index) => + index !== elements.length - 1 && + element.loc.end.line !== + elements[index + 1].loc.start.line, + ); + } + if (consistentOption) { + return hasLeftNewline; + } + return elements.length >= minItems; + } + + /** + * Validates parens + * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token + * @param {ASTNode[]} elements The arguments or parameters in the list + * @returns {void} + */ + function validateParens(parens, elements) { + const leftParen = parens.leftParen; + const rightParen = parens.rightParen; + const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen); + const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen); + const hasLeftNewline = !astUtils.isTokenOnSameLine( + leftParen, + tokenAfterLeftParen, + ); + const hasRightNewline = !astUtils.isTokenOnSameLine( + tokenBeforeRightParen, + rightParen, + ); + const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline); + + if (hasLeftNewline && !needsNewlines) { + context.report({ + node: leftParen, + messageId: "unexpectedAfter", + fix(fixer) { + return sourceCode + .getText() + .slice( + leftParen.range[1], + tokenAfterLeftParen.range[0], + ) + .trim() + ? // If there is a comment between the ( and the first element, don't do a fix. + null + : fixer.removeRange([ + leftParen.range[1], + tokenAfterLeftParen.range[0], + ]); + }, + }); + } else if (!hasLeftNewline && needsNewlines) { + context.report({ + node: leftParen, + messageId: "expectedAfter", + fix: fixer => fixer.insertTextAfter(leftParen, "\n"), + }); + } + + if (hasRightNewline && !needsNewlines) { + context.report({ + node: rightParen, + messageId: "unexpectedBefore", + fix(fixer) { + return sourceCode + .getText() + .slice( + tokenBeforeRightParen.range[1], + rightParen.range[0], + ) + .trim() + ? // If there is a comment between the last element and the ), don't do a fix. + null + : fixer.removeRange([ + tokenBeforeRightParen.range[1], + rightParen.range[0], + ]); + }, + }); + } else if (!hasRightNewline && needsNewlines) { + context.report({ + node: rightParen, + messageId: "expectedBefore", + fix: fixer => fixer.insertTextBefore(rightParen, "\n"), + }); + } + } + + /** + * Validates a list of arguments or parameters + * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token + * @param {ASTNode[]} elements The arguments or parameters in the list + * @returns {void} + */ + function validateArguments(parens, elements) { + const leftParen = parens.leftParen; + const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen); + const hasLeftNewline = !astUtils.isTokenOnSameLine( + leftParen, + tokenAfterLeftParen, + ); + const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline); + + for (let i = 0; i <= elements.length - 2; i++) { + const currentElement = elements[i]; + const nextElement = elements[i + 1]; + const hasNewLine = + currentElement.loc.end.line !== nextElement.loc.start.line; + + if (!hasNewLine && needsNewlines) { + context.report({ + node: currentElement, + messageId: "expectedBetween", + fix: fixer => fixer.insertTextBefore(nextElement, "\n"), + }); + } + } + } + + /** + * Gets the left paren and right paren tokens of a node. + * @param {ASTNode} node The node with parens + * @throws {TypeError} Unexpected node type. + * @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token. + * Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression + * with a single parameter) + */ + function getParenTokens(node) { + switch (node.type) { + case "NewExpression": + if ( + !node.arguments.length && + !( + astUtils.isOpeningParenToken( + sourceCode.getLastToken(node, { skip: 1 }), + ) && + astUtils.isClosingParenToken( + sourceCode.getLastToken(node), + ) && + node.callee.range[1] < node.range[1] + ) + ) { + // If the NewExpression does not have parens (e.g. `new Foo`), return null. + return null; + } + + // falls through + + case "CallExpression": + return { + leftParen: sourceCode.getTokenAfter( + node.callee, + astUtils.isOpeningParenToken, + ), + rightParen: sourceCode.getLastToken(node), + }; + + case "FunctionDeclaration": + case "FunctionExpression": { + const leftParen = sourceCode.getFirstToken( + node, + astUtils.isOpeningParenToken, + ); + const rightParen = node.params.length + ? sourceCode.getTokenAfter( + node.params.at(-1), + astUtils.isClosingParenToken, + ) + : sourceCode.getTokenAfter(leftParen); + + return { leftParen, rightParen }; + } + + case "ArrowFunctionExpression": { + const firstToken = sourceCode.getFirstToken(node, { + skip: node.async ? 1 : 0, + }); + + if (!astUtils.isOpeningParenToken(firstToken)) { + // If the ArrowFunctionExpression has a single param without parens, return null. + return null; + } + + const rightParen = node.params.length + ? sourceCode.getTokenAfter( + node.params.at(-1), + astUtils.isClosingParenToken, + ) + : sourceCode.getTokenAfter(firstToken); + + return { + leftParen: firstToken, + rightParen, + }; + } + + case "ImportExpression": { + const leftParen = sourceCode.getFirstToken(node, 1); + const rightParen = sourceCode.getLastToken(node); + + return { leftParen, rightParen }; + } + + default: + throw new TypeError( + `unexpected node with type ${node.type}`, + ); + } + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + [[ + "ArrowFunctionExpression", + "CallExpression", + "FunctionDeclaration", + "FunctionExpression", + "ImportExpression", + "NewExpression", + ]](node) { + const parens = getParenTokens(node); + let params; + + if (node.type === "ImportExpression") { + params = [node.source]; + } else if (astUtils.isFunction(node)) { + params = node.params; + } else { + params = node.arguments; + } + + if (parens) { + validateParens(parens, params); + + if (multilineArgumentsOption) { + validateArguments(parens, params); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/generator-star-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/generator-star-spacing.js new file mode 100644 index 00000000..dd87e2fe --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/generator-star-spacing.js @@ -0,0 +1,244 @@ +/** + * @fileoverview Rule to check the spacing around the * in generator functions. + * @author Jamund Ferguson + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const OVERRIDE_SCHEMA = { + oneOf: [ + { + enum: ["before", "after", "both", "neither"], + }, + { + type: "object", + properties: { + before: { type: "boolean" }, + after: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "generator-star-spacing", + url: "https://eslint.style/rules/generator-star-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing around `*` operators in generator functions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/generator-star-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["before", "after", "both", "neither"], + }, + { + type: "object", + properties: { + before: { type: "boolean" }, + after: { type: "boolean" }, + named: OVERRIDE_SCHEMA, + anonymous: OVERRIDE_SCHEMA, + method: OVERRIDE_SCHEMA, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + missingBefore: "Missing space before *.", + missingAfter: "Missing space after *.", + unexpectedBefore: "Unexpected space before *.", + unexpectedAfter: "Unexpected space after *.", + }, + }, + + create(context) { + const optionDefinitions = { + before: { before: true, after: false }, + after: { before: false, after: true }, + both: { before: true, after: true }, + neither: { before: false, after: false }, + }; + + /** + * Returns resolved option definitions based on an option and defaults + * @param {any} option The option object or string value + * @param {Object} defaults The defaults to use if options are not present + * @returns {Object} the resolved object definition + */ + function optionToDefinition(option, defaults) { + if (!option) { + return defaults; + } + + return typeof option === "string" + ? optionDefinitions[option] + : Object.assign({}, defaults, option); + } + + const modes = (function (option) { + const defaults = optionToDefinition( + option, + optionDefinitions.before, + ); + + return { + named: optionToDefinition(option.named, defaults), + anonymous: optionToDefinition(option.anonymous, defaults), + method: optionToDefinition(option.method, defaults), + }; + })(context.options[0] || {}); + + const sourceCode = context.sourceCode; + + /** + * Checks if the given token is a star token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a star token. + */ + function isStarToken(token) { + return token.value === "*" && token.type === "Punctuator"; + } + + /** + * Gets the generator star token of the given function node. + * @param {ASTNode} node The function node to get. + * @returns {Token} Found star token. + */ + function getStarToken(node) { + return sourceCode.getFirstToken( + node.parent.method || node.parent.type === "MethodDefinition" + ? node.parent + : node, + isStarToken, + ); + } + + /** + * capitalize a given string. + * @param {string} str the given string. + * @returns {string} the capitalized string. + */ + function capitalize(str) { + return str[0].toUpperCase() + str.slice(1); + } + + /** + * Checks the spacing between two tokens before or after the star token. + * @param {string} kind Either "named", "anonymous", or "method" + * @param {string} side Either "before" or "after". + * @param {Token} leftToken `function` keyword token if side is "before", or + * star token if side is "after". + * @param {Token} rightToken Star token if side is "before", or identifier + * token if side is "after". + * @returns {void} + */ + function checkSpacing(kind, side, leftToken, rightToken) { + if ( + !!(rightToken.range[0] - leftToken.range[1]) !== + modes[kind][side] + ) { + const after = leftToken.value === "*"; + const spaceRequired = modes[kind][side]; + const node = after ? leftToken : rightToken; + const messageId = `${spaceRequired ? "missing" : "unexpected"}${capitalize(side)}`; + + context.report({ + node, + messageId, + fix(fixer) { + if (spaceRequired) { + if (after) { + return fixer.insertTextAfter(node, " "); + } + return fixer.insertTextBefore(node, " "); + } + return fixer.removeRange([ + leftToken.range[1], + rightToken.range[0], + ]); + }, + }); + } + } + + /** + * Enforces the spacing around the star if node is a generator function. + * @param {ASTNode} node A function expression or declaration node. + * @returns {void} + */ + function checkFunction(node) { + if (!node.generator) { + return; + } + + const starToken = getStarToken(node); + const prevToken = sourceCode.getTokenBefore(starToken); + const nextToken = sourceCode.getTokenAfter(starToken); + + let kind = "named"; + + if ( + node.parent.type === "MethodDefinition" || + (node.parent.type === "Property" && node.parent.method) + ) { + kind = "method"; + } else if (!node.id) { + kind = "anonymous"; + } + + // Only check before when preceded by `function`|`static` keyword + if (!( + kind === "method" && + starToken === sourceCode.getFirstToken(node.parent) + )) { + checkSpacing(kind, "before", prevToken, starToken); + } + + checkSpacing(kind, "after", starToken, nextToken); + } + + return { + FunctionDeclaration: checkFunction, + FunctionExpression: checkFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/getter-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/getter-return.js new file mode 100644 index 00000000..09874e54 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/getter-return.js @@ -0,0 +1,187 @@ +/** + * @fileoverview Enforces that a return statement is present in property getters. + * @author Aladdin-ADD(hh_2013@foxmail.com) + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowImplicit: false, + }, + ], + + docs: { + description: "Enforce `return` statements in getters", + recommended: true, + url: "https://eslint.org/docs/latest/rules/getter-return", + }, + + fixable: null, + + schema: [ + { + type: "object", + properties: { + allowImplicit: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + expected: "Expected to return a value in {{name}}.", + expectedAlways: "Expected {{name}} to always return a value.", + }, + }, + + create(context) { + const [{ allowImplicit }] = context.options; + const sourceCode = context.sourceCode; + + let funcInfo = { + upper: null, + codePath: null, + hasReturn: false, + shouldCheck: false, + node: null, + currentSegments: [], + }; + + /** + * Checks whether or not the last code path segment is reachable. + * Then reports this function if the segment is reachable. + * + * If the last code path segment is reachable, there are paths which are not + * returned or thrown. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function checkLastSegment(node) { + if ( + funcInfo.shouldCheck && + isAnySegmentReachable(funcInfo.currentSegments) + ) { + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + messageId: funcInfo.hasReturn + ? "expectedAlways" + : "expected", + data: { + name: astUtils.getFunctionNameWithKind(funcInfo.node), + }, + }); + } + } + + /** + * Checks whether a node means a getter function. + * @param {ASTNode} node a node to check. + * @returns {boolean} if node means a getter, return true; else return false. + */ + function isGetter(node) { + const parent = node.parent; + + if ( + TARGET_NODE_TYPE.test(node.type) && + node.body.type === "BlockStatement" + ) { + if (parent.kind === "get") { + return true; + } + if ( + parent.type === "Property" && + astUtils.getStaticPropertyName(parent) === "get" && + parent.parent.type === "ObjectExpression" && + astUtils.isPropertyDescriptor(parent.parent, sourceCode) + ) { + // Getter in a property descriptor + return true; + } + } + return false; + } + return { + // Stacks this function's information. + onCodePathStart(codePath, node) { + funcInfo = { + upper: funcInfo, + codePath, + hasReturn: false, + shouldCheck: isGetter(node), + node, + currentSegments: new Set(), + }; + }, + + // Pops this function's information. + onCodePathEnd() { + funcInfo = funcInfo.upper; + }, + onUnreachableCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + // Checks the return statement is valid. + ReturnStatement(node) { + if (funcInfo.shouldCheck) { + funcInfo.hasReturn = true; + + // if allowImplicit: false, should also check node.argument + if (!allowImplicit && !node.argument) { + context.report({ + node, + messageId: "expected", + data: { + name: astUtils.getFunctionNameWithKind( + funcInfo.node, + ), + }, + }); + } + } + }, + + // Reports a given function if the last path is reachable. + "FunctionExpression:exit": checkLastSegment, + "ArrowFunctionExpression:exit": checkLastSegment, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/global-require.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/global-require.js new file mode 100644 index 00000000..44b31814 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/global-require.js @@ -0,0 +1,117 @@ +/** + * @fileoverview Rule for disallowing require() outside of the top-level module context + * @author Jamund Ferguson + * @deprecated in ESLint v7.0.0 + */ + +"use strict"; + +const ACCEPTABLE_PARENTS = new Set([ + "AssignmentExpression", + "VariableDeclarator", + "MemberExpression", + "ExpressionStatement", + "CallExpression", + "ConditionalExpression", + "Program", + "VariableDeclaration", + "ChainExpression", +]); + +/** + * Finds the eslint-scope reference in the given scope. + * @param {Object} scope The scope to search. + * @param {ASTNode} node The identifier node. + * @returns {Reference|null} Returns the found reference or null if none were found. + */ +function findReference(scope, node) { + const references = scope.references.filter( + reference => + reference.identifier.range[0] === node.range[0] && + reference.identifier.range[1] === node.range[1], + ); + + if (references.length === 1) { + return references[0]; + } + + /* c8 ignore next */ + return null; +} + +/** + * Checks if the given identifier node is shadowed in the given scope. + * @param {Object} scope The current scope. + * @param {ASTNode} node The identifier node to check. + * @returns {boolean} Whether or not the name is shadowed. + */ +function isShadowed(scope, node) { + const reference = findReference(scope, node); + + return ( + reference && reference.resolved && reference.resolved.defs.length > 0 + ); +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "global-require", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/global-require.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: + "Require `require()` calls to be placed at top-level module scope", + recommended: false, + url: "https://eslint.org/docs/latest/rules/global-require", + }, + + schema: [], + messages: { + unexpected: "Unexpected require().", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + CallExpression(node) { + const currentScope = sourceCode.getScope(node); + + if ( + node.callee.name === "require" && + !isShadowed(currentScope, node.callee) + ) { + const isGoodRequire = sourceCode + .getAncestors(node) + .every(parent => ACCEPTABLE_PARENTS.has(parent.type)); + + if (!isGoodRequire) { + context.report({ node, messageId: "unexpected" }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/grouped-accessor-pairs.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/grouped-accessor-pairs.js new file mode 100644 index 00000000..c4ac86dc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/grouped-accessor-pairs.js @@ -0,0 +1,268 @@ +/** + * @fileoverview Rule to require grouped accessor pairs in object literals and classes + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * Property name if it can be computed statically, otherwise the list of the tokens of the key node. + * @typedef {string|Token[]} Key + */ + +/** + * Accessor nodes with the same key. + * @typedef {Object} AccessorData + * @property {Key} key Accessor's key + * @property {ASTNode[]} getters List of getter nodes. + * @property {ASTNode[]} setters List of setter nodes. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not the given lists represent the equal tokens in the same order. + * Tokens are compared by their properties, not by instance. + * @param {Token[]} left First list of tokens. + * @param {Token[]} right Second list of tokens. + * @returns {boolean} `true` if the lists have same tokens. + */ +function areEqualTokenLists(left, right) { + if (left.length !== right.length) { + return false; + } + + for (let i = 0; i < left.length; i++) { + const leftToken = left[i], + rightToken = right[i]; + + if ( + leftToken.type !== rightToken.type || + leftToken.value !== rightToken.value + ) { + return false; + } + } + + return true; +} + +/** + * Checks whether or not the given keys are equal. + * @param {Key} left First key. + * @param {Key} right Second key. + * @returns {boolean} `true` if the keys are equal. + */ +function areEqualKeys(left, right) { + if (typeof left === "string" && typeof right === "string") { + // Statically computed names. + return left === right; + } + if (Array.isArray(left) && Array.isArray(right)) { + // Token lists. + return areEqualTokenLists(left, right); + } + + return false; +} + +/** + * Checks whether or not a given node is of an accessor kind ('get' or 'set'). + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is of an accessor kind. + */ +function isAccessorKind(node) { + return node.kind === "get" || node.kind === "set"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + "anyOrder", + { + enforceForTSTypes: false, + }, + ], + + docs: { + description: + "Require grouped accessor pairs in object literals and classes", + recommended: false, + url: "https://eslint.org/docs/latest/rules/grouped-accessor-pairs", + }, + + schema: [ + { enum: ["anyOrder", "getBeforeSet", "setBeforeGet"] }, + { + type: "object", + properties: { + enforceForTSTypes: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + notGrouped: + "Accessor pair {{ formerName }} and {{ latterName }} should be grouped.", + invalidOrder: + "Expected {{ latterName }} to be before {{ formerName }}.", + }, + }, + + create(context) { + const [order, { enforceForTSTypes }] = context.options; + const { sourceCode } = context; + + /** + * Reports the given accessor pair. + * @param {string} messageId messageId to report. + * @param {ASTNode} formerNode getter/setter node that is defined before `latterNode`. + * @param {ASTNode} latterNode getter/setter node that is defined after `formerNode`. + * @returns {void} + * @private + */ + function report(messageId, formerNode, latterNode) { + context.report({ + node: latterNode, + messageId, + loc: astUtils.getFunctionHeadLoc( + latterNode.type !== "TSMethodSignature" + ? latterNode.value + : latterNode, + sourceCode, + ), + data: { + formerName: astUtils.getFunctionNameWithKind( + formerNode.type !== "TSMethodSignature" + ? formerNode.value + : formerNode, + ), + latterName: astUtils.getFunctionNameWithKind( + latterNode.type !== "TSMethodSignature" + ? latterNode.value + : latterNode, + ), + }, + }); + } + + /** + * Checks accessor pairs in the given list of nodes. + * @param {ASTNode[]} nodes The list to check. + * @param {Function} shouldCheck – Predicate that returns `true` if the node should be checked. + * @returns {void} + * @private + */ + function checkList(nodes, shouldCheck) { + const accessors = []; + let found = false; + + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + + if (shouldCheck(node) && isAccessorKind(node)) { + // Creates a new `AccessorData` object for the given getter or setter node. + const name = astUtils.getStaticPropertyName(node); + const key = + name !== null ? name : sourceCode.getTokens(node.key); + + // Merges the given `AccessorData` object into the given accessors list. + for (let j = 0; j < accessors.length; j++) { + const accessor = accessors[j]; + + if (areEqualKeys(accessor.key, key)) { + accessor.getters.push( + ...(node.kind === "get" ? [node] : []), + ); + accessor.setters.push( + ...(node.kind === "set" ? [node] : []), + ); + found = true; + break; + } + } + if (!found) { + accessors.push({ + key, + getters: node.kind === "get" ? [node] : [], + setters: node.kind === "set" ? [node] : [], + }); + } + found = false; + } + } + + for (const { getters, setters } of accessors) { + // Don't report accessor properties that have duplicate getters or setters. + if (getters.length === 1 && setters.length === 1) { + const [getter] = getters, + [setter] = setters, + getterIndex = nodes.indexOf(getter), + setterIndex = nodes.indexOf(setter), + formerNode = + getterIndex < setterIndex ? getter : setter, + latterNode = + getterIndex < setterIndex ? setter : getter; + + if (Math.abs(getterIndex - setterIndex) > 1) { + report("notGrouped", formerNode, latterNode); + } else if ( + (order === "getBeforeSet" && + getterIndex > setterIndex) || + (order === "setBeforeGet" && getterIndex < setterIndex) + ) { + report("invalidOrder", formerNode, latterNode); + } + } + } + } + + return { + ObjectExpression(node) { + checkList(node.properties, n => n.type === "Property"); + }, + ClassBody(node) { + checkList( + node.body, + n => n.type === "MethodDefinition" && !n.static, + ); + checkList( + node.body, + n => n.type === "MethodDefinition" && n.static, + ); + }, + "TSTypeLiteral, TSInterfaceBody"(node) { + if (enforceForTSTypes) { + checkList( + node.type === "TSTypeLiteral" + ? node.members + : node.body, + n => n.type === "TSMethodSignature", + ); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/guard-for-in.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/guard-for-in.js new file mode 100644 index 00000000..f648aa40 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/guard-for-in.js @@ -0,0 +1,85 @@ +/** + * @fileoverview Rule to flag for-in loops without if statements inside + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require `for-in` loops to include an `if` statement", + recommended: false, + url: "https://eslint.org/docs/latest/rules/guard-for-in", + }, + + schema: [], + messages: { + wrap: "The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.", + }, + }, + + create(context) { + return { + ForInStatement(node) { + const body = node.body; + + // empty statement + if (body.type === "EmptyStatement") { + return; + } + + // if statement + if (body.type === "IfStatement") { + return; + } + + // empty block + if (body.type === "BlockStatement" && body.body.length === 0) { + return; + } + + // block with just if statement + if ( + body.type === "BlockStatement" && + body.body.length === 1 && + body.body[0].type === "IfStatement" + ) { + return; + } + + // block that starts with if statement + if ( + body.type === "BlockStatement" && + body.body.length >= 1 && + body.body[0].type === "IfStatement" + ) { + const i = body.body[0]; + + // ... whose consequent is a continue + if (i.consequent.type === "ContinueStatement") { + return; + } + + // ... whose consequent is a block that contains only a continue + if ( + i.consequent.type === "BlockStatement" && + i.consequent.body.length === 1 && + i.consequent.body[0].type === "ContinueStatement" + ) { + return; + } + } + + context.report({ node, messageId: "wrap" }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/handle-callback-err.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/handle-callback-err.js new file mode 100644 index 00000000..d9b0641a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/handle-callback-err.js @@ -0,0 +1,122 @@ +/** + * @fileoverview Ensure handling of errors when we know they exist. + * @author Jamund Ferguson + * @deprecated in ESLint v7.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "handle-callback-err", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/handle-callback-err.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Require error handling in callbacks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/handle-callback-err", + }, + + schema: [ + { + type: "string", + }, + ], + messages: { + expected: "Expected error to be handled.", + }, + }, + + create(context) { + const errorArgument = context.options[0] || "err"; + const sourceCode = context.sourceCode; + + /** + * Checks if the given argument should be interpreted as a regexp pattern. + * @param {string} stringToCheck The string which should be checked. + * @returns {boolean} Whether or not the string should be interpreted as a pattern. + */ + function isPattern(stringToCheck) { + const firstChar = stringToCheck[0]; + + return firstChar === "^"; + } + + /** + * Checks if the given name matches the configured error argument. + * @param {string} name The name which should be compared. + * @returns {boolean} Whether or not the given name matches the configured error variable name. + */ + function matchesConfiguredErrorName(name) { + if (isPattern(errorArgument)) { + const regexp = new RegExp(errorArgument, "u"); + + return regexp.test(name); + } + return name === errorArgument; + } + + /** + * Get the parameters of a given function scope. + * @param {Object} scope The function scope. + * @returns {Array} All parameters of the given scope. + */ + function getParameters(scope) { + return scope.variables.filter( + variable => + variable.defs[0] && variable.defs[0].type === "Parameter", + ); + } + + /** + * Check to see if we're handling the error object properly. + * @param {ASTNode} node The AST node to check. + * @returns {void} + */ + function checkForError(node) { + const scope = sourceCode.getScope(node), + parameters = getParameters(scope), + firstParameter = parameters[0]; + + if ( + firstParameter && + matchesConfiguredErrorName(firstParameter.name) + ) { + if (firstParameter.references.length === 0) { + context.report({ node, messageId: "expected" }); + } + } + } + + return { + FunctionDeclaration: checkForError, + FunctionExpression: checkForError, + ArrowFunctionExpression: checkForError, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-blacklist.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-blacklist.js new file mode 100644 index 00000000..6a84827c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-blacklist.js @@ -0,0 +1,241 @@ +/** + * @fileoverview Rule that warns when identifier names that are + * specified in the configuration are used. + * @author Keith Cirkel (http://keithcirkel.co.uk) + * @deprecated in ESLint v7.5.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether the given node represents assignment target in a normal assignment or destructuring. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is assignment target. + */ +function isAssignmentTarget(node) { + const parent = node.parent; + + return ( + // normal assignment + (parent.type === "AssignmentExpression" && parent.left === node) || + // destructuring + parent.type === "ArrayPattern" || + parent.type === "RestElement" || + (parent.type === "Property" && + parent.value === node && + parent.parent.type === "ObjectPattern") || + (parent.type === "AssignmentPattern" && parent.left === node) + ); +} + +/** + * Checks whether the given node represents an imported name that is renamed in the same import/export specifier. + * + * Examples: + * import { a as b } from 'mod'; // node `a` is renamed import + * export { a as b } from 'mod'; // node `a` is renamed import + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a renamed import. + */ +function isRenamedImport(node) { + const parent = node.parent; + + return ( + (parent.type === "ImportSpecifier" && + parent.imported !== parent.local && + parent.imported === node) || + (parent.type === "ExportSpecifier" && + parent.parent.source && // re-export + parent.local !== parent.exported && + parent.local === node) + ); +} + +/** + * Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring. + * + * Examples: + * const { a : b } = foo; // node `a` is renamed node. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring. + */ +function isRenamedInDestructuring(node) { + const parent = node.parent; + + return ( + !parent.computed && + parent.type === "Property" && + parent.parent.type === "ObjectPattern" && + parent.value !== node && + parent.key === node + ); +} + +/** + * Checks whether the given node represents shorthand definition of a property in an object literal. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a shorthand property definition. + */ +function isShorthandPropertyDefinition(node) { + const parent = node.parent; + + return ( + parent.type === "Property" && + parent.parent.type === "ObjectExpression" && + parent.shorthand + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "The rule was renamed.", + url: "https://eslint.org/blog/2020/07/eslint-v7.5.0-released/#deprecating-id-blacklist", + deprecatedSince: "7.5.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "id-denylist", + url: "https://eslint.org/docs/rules/id-denylist", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow specified identifiers", + recommended: false, + url: "https://eslint.org/docs/latest/rules/id-blacklist", + }, + + schema: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + messages: { + restricted: "Identifier '{{name}}' is restricted.", + }, + }, + + create(context) { + const denyList = new Set(context.options); + const reportedNodes = new Set(); + const sourceCode = context.sourceCode; + + let globalScope; + + /** + * Checks whether the given name is restricted. + * @param {string} name The name to check. + * @returns {boolean} `true` if the name is restricted. + * @private + */ + function isRestricted(name) { + return denyList.has(name); + } + + /** + * Checks whether the given node represents a reference to a global variable that is not declared in the source code. + * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a reference to a global variable. + */ + function isReferenceToGlobalVariable(node) { + const variable = globalScope.set.get(node.name); + + return ( + variable && + variable.defs.length === 0 && + variable.references.some(ref => ref.identifier === node) + ); + } + + /** + * Determines whether the given node should be checked. + * @param {ASTNode} node `Identifier` node. + * @returns {boolean} `true` if the node should be checked. + */ + function shouldCheck(node) { + const parent = node.parent; + + /* + * Member access has special rules for checking property names. + * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over. + * Write access isn't allowed, because it potentially creates a new property with a restricted name. + */ + if ( + parent.type === "MemberExpression" && + parent.property === node && + !parent.computed + ) { + return isAssignmentTarget(parent); + } + + return ( + parent.type !== "CallExpression" && + parent.type !== "NewExpression" && + !isRenamedImport(node) && + !isRenamedInDestructuring(node) && + !( + isReferenceToGlobalVariable(node) && + !isShorthandPropertyDefinition(node) + ) + ); + } + + /** + * Reports an AST node as a rule violation. + * @param {ASTNode} node The node to report. + * @returns {void} + * @private + */ + function report(node) { + /* + * We used the range instead of the node because it's possible + * for the same identifier to be represented by two different + * nodes, with the most clear example being shorthand properties: + * { foo } + * In this case, "foo" is represented by one node for the name + * and one for the value. The only way to know they are the same + * is to look at the range. + */ + if (!reportedNodes.has(node.range.toString())) { + context.report({ + node, + messageId: "restricted", + data: { + name: node.name, + }, + }); + reportedNodes.add(node.range.toString()); + } + } + + return { + Program(node) { + globalScope = sourceCode.getScope(node); + }, + + Identifier(node) { + if (isRestricted(node.name) && shouldCheck(node)) { + report(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-denylist.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-denylist.js new file mode 100644 index 00000000..d15df039 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-denylist.js @@ -0,0 +1,227 @@ +/** + * @fileoverview Rule that warns when identifier names that are + * specified in the configuration are used. + * @author Keith Cirkel (http://keithcirkel.co.uk) + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether the given node represents assignment target in a normal assignment or destructuring. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is assignment target. + */ +function isAssignmentTarget(node) { + const parent = node.parent; + + return ( + // normal assignment + (parent.type === "AssignmentExpression" && parent.left === node) || + // destructuring + parent.type === "ArrayPattern" || + parent.type === "RestElement" || + (parent.type === "Property" && + parent.value === node && + parent.parent.type === "ObjectPattern") || + (parent.type === "AssignmentPattern" && parent.left === node) + ); +} + +/** + * Checks whether the given node represents an imported name that is renamed in the same import/export specifier. + * + * Examples: + * import { a as b } from 'mod'; // node `a` is renamed import + * export { a as b } from 'mod'; // node `a` is renamed import + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a renamed import. + */ +function isRenamedImport(node) { + const parent = node.parent; + + return ( + (parent.type === "ImportSpecifier" && + parent.imported !== parent.local && + parent.imported === node) || + (parent.type === "ExportSpecifier" && + parent.parent.source && // re-export + parent.local !== parent.exported && + parent.local === node) + ); +} + +/** + * Checks whether the given node is an ObjectPattern destructuring. + * + * Examples: + * const { a : b } = foo; + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is in an ObjectPattern destructuring. + */ +function isPropertyNameInDestructuring(node) { + const parent = node.parent; + + return ( + !parent.computed && + parent.type === "Property" && + parent.parent.type === "ObjectPattern" && + parent.key === node + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [], + + docs: { + description: "Disallow specified identifiers", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/id-denylist", + }, + + schema: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + messages: { + restricted: "Identifier '{{name}}' is restricted.", + restrictedPrivate: "Identifier '#{{name}}' is restricted.", + }, + }, + + create(context) { + const denyList = new Set(context.options); + const reportedNodes = new Set(); + const sourceCode = context.sourceCode; + + let globalScope; + + /** + * Checks whether the given name is restricted. + * @param {string} name The name to check. + * @returns {boolean} `true` if the name is restricted. + * @private + */ + function isRestricted(name) { + return denyList.has(name); + } + + /** + * Checks whether the given node represents a reference to a global variable that is not declared in the source code. + * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a reference to a global variable. + */ + function isReferenceToGlobalVariable(node) { + const variable = globalScope.set.get(node.name); + + return ( + variable && + variable.defs.length === 0 && + variable.references.some(ref => ref.identifier === node) + ); + } + + /** + * Determines whether the given node should be checked. + * @param {ASTNode} node `Identifier` node. + * @returns {boolean} `true` if the node should be checked. + */ + function shouldCheck(node) { + // Import attributes are defined by environments, so naming conventions shouldn't apply to them + if (astUtils.isImportAttributeKey(node)) { + return false; + } + + const parent = node.parent; + + if (parent.type === "MetaProperty") { + return false; + } + + /* + * Member access has special rules for checking property names. + * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over. + * Write access isn't allowed, because it potentially creates a new property with a restricted name. + */ + if ( + parent.type === "MemberExpression" && + parent.property === node && + !parent.computed + ) { + return isAssignmentTarget(parent); + } + + return ( + parent.type !== "CallExpression" && + parent.type !== "NewExpression" && + !isRenamedImport(node) && + !isPropertyNameInDestructuring(node) && + !isReferenceToGlobalVariable(node) + ); + } + + /** + * Reports an AST node as a rule violation. + * @param {ASTNode} node The node to report. + * @returns {void} + * @private + */ + function report(node) { + /* + * We used the range instead of the node because it's possible + * for the same identifier to be represented by two different + * nodes, with the most clear example being shorthand properties: + * { foo } + * In this case, "foo" is represented by one node for the name + * and one for the value. The only way to know they are the same + * is to look at the range. + */ + if (!reportedNodes.has(node.range.toString())) { + const isPrivate = node.type === "PrivateIdentifier"; + + context.report({ + node, + messageId: isPrivate ? "restrictedPrivate" : "restricted", + data: { + name: node.name, + }, + }); + reportedNodes.add(node.range.toString()); + } + } + + return { + Program(node) { + globalScope = sourceCode.getScope(node); + }, + + [["Identifier", "PrivateIdentifier"]](node) { + if (isRestricted(node.name) && shouldCheck(node)) { + report(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-length.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-length.js new file mode 100644 index 00000000..133b8419 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-length.js @@ -0,0 +1,217 @@ +/** + * @fileoverview Rule that warns when identifier names are shorter or longer + * than the values provided in configuration. + * @author Burak Yigit Kaya aka BYK + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getGraphemeCount } = require("../shared/string-utils"); +const { + getModuleExportName, + isImportAttributeKey, +} = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + exceptionPatterns: [], + exceptions: [], + min: 2, + properties: "always", + }, + ], + + docs: { + description: "Enforce minimum and maximum identifier lengths", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/id-length", + }, + + schema: [ + { + type: "object", + properties: { + min: { + type: "integer", + }, + max: { + type: "integer", + }, + exceptions: { + type: "array", + uniqueItems: true, + items: { + type: "string", + }, + }, + exceptionPatterns: { + type: "array", + uniqueItems: true, + items: { + type: "string", + }, + }, + properties: { + enum: ["always", "never"], + }, + }, + additionalProperties: false, + }, + ], + messages: { + tooShort: "Identifier name '{{name}}' is too short (< {{min}}).", + tooShortPrivate: + "Identifier name '#{{name}}' is too short (< {{min}}).", + tooLong: "Identifier name '{{name}}' is too long (> {{max}}).", + tooLongPrivate: + "Identifier name #'{{name}}' is too long (> {{max}}).", + }, + }, + + create(context) { + const [options] = context.options; + const { max: maxLength = Infinity, min: minLength } = options; + const properties = options.properties !== "never"; + const exceptions = new Set(options.exceptions); + const exceptionPatterns = options.exceptionPatterns.map( + pattern => new RegExp(pattern, "u"), + ); + const reportedNodes = new Set(); + + /** + * Checks if a string matches the provided exception patterns + * @param {string} name The string to check. + * @returns {boolean} if the string is a match + * @private + */ + function matchesExceptionPattern(name) { + return exceptionPatterns.some(pattern => pattern.test(name)); + } + + const SUPPORTED_EXPRESSIONS = { + MemberExpression: + properties && + function (parent) { + return ( + !parent.computed && + // regular property assignment + ((parent.parent.left === parent && + parent.parent.type === "AssignmentExpression") || + // or the last identifier in an ObjectPattern destructuring + (parent.parent.type === "Property" && + parent.parent.value === parent && + parent.parent.parent.type === "ObjectPattern" && + parent.parent.parent.parent.left === + parent.parent.parent)) + ); + }, + AssignmentPattern(parent, node) { + return parent.left === node; + }, + VariableDeclarator(parent, node) { + return parent.id === node; + }, + Property(parent, node) { + if (parent.parent.type === "ObjectPattern") { + const isKeyAndValueSame = + parent.value.name === parent.key.name; + + return ( + (!isKeyAndValueSame && parent.value === node) || + (isKeyAndValueSame && parent.key === node && properties) + ); + } + return ( + properties && + !isImportAttributeKey(node) && + !parent.computed && + parent.key.name === node.name + ); + }, + ImportSpecifier(parent, node) { + return ( + parent.local === node && + getModuleExportName(parent.imported) !== + getModuleExportName(parent.local) + ); + }, + ImportDefaultSpecifier: true, + ImportNamespaceSpecifier: true, + RestElement: true, + FunctionExpression: true, + ArrowFunctionExpression: true, + ClassDeclaration: true, + FunctionDeclaration: true, + MethodDefinition: true, + PropertyDefinition: true, + CatchClause: true, + ArrayPattern: true, + }; + + return { + [["Identifier", "PrivateIdentifier"]](node) { + const name = node.name; + const parent = node.parent; + + const nameLength = getGraphemeCount(name); + + const isShort = nameLength < minLength; + const isLong = nameLength > maxLength; + + if ( + !(isShort || isLong) || + exceptions.has(name) || + matchesExceptionPattern(name) + ) { + return; // Nothing to report + } + + const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type]; + + /* + * We used the range instead of the node because it's possible + * for the same identifier to be represented by two different + * nodes, with the most clear example being shorthand properties: + * { foo } + * In this case, "foo" is represented by one node for the name + * and one for the value. The only way to know they are the same + * is to look at the range. + */ + if ( + isValidExpression && + !reportedNodes.has(node.range.toString()) && + (isValidExpression === true || + isValidExpression(parent, node)) + ) { + reportedNodes.add(node.range.toString()); + + let messageId = isShort ? "tooShort" : "tooLong"; + + if (node.type === "PrivateIdentifier") { + messageId += "Private"; + } + + context.report({ + node, + messageId, + data: { name, min: minLength, max: maxLength }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-match.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-match.js new file mode 100644 index 00000000..977c07eb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/id-match.js @@ -0,0 +1,364 @@ +/** + * @fileoverview Rule to flag non-matching identifiers + * @author Matthieu Larcher + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + "^.+$", + { + classFields: false, + ignoreDestructuring: false, + onlyDeclarations: false, + properties: false, + }, + ], + + docs: { + description: + "Require identifiers to match a specified regular expression", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/id-match", + }, + + schema: [ + { + type: "string", + }, + { + type: "object", + properties: { + properties: { + type: "boolean", + }, + classFields: { + type: "boolean", + }, + onlyDeclarations: { + type: "boolean", + }, + ignoreDestructuring: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + messages: { + notMatch: + "Identifier '{{name}}' does not match the pattern '{{pattern}}'.", + notMatchPrivate: + "Identifier '#{{name}}' does not match the pattern '{{pattern}}'.", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Options + //-------------------------------------------------------------------------- + const [ + pattern, + { + classFields: checkClassFields, + ignoreDestructuring, + onlyDeclarations, + properties: checkProperties, + }, + ] = context.options; + const regexp = new RegExp(pattern, "u"); + + const sourceCode = context.sourceCode; + let globalScope; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + // contains reported nodes to avoid reporting twice on destructuring with shorthand notation + const reportedNodes = new Set(); + const ALLOWED_PARENT_TYPES = new Set([ + "CallExpression", + "NewExpression", + ]); + const DECLARATION_TYPES = new Set([ + "FunctionDeclaration", + "VariableDeclarator", + ]); + const IMPORT_TYPES = new Set([ + "ImportSpecifier", + "ImportNamespaceSpecifier", + "ImportDefaultSpecifier", + ]); + + /** + * Checks whether the given node represents a reference to a global variable that is not declared in the source code. + * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a reference to a global variable. + */ + function isReferenceToGlobalVariable(node) { + const variable = globalScope.set.get(node.name); + + return ( + variable && + variable.defs.length === 0 && + variable.references.some(ref => ref.identifier === node) + ); + } + + /** + * Checks if a string matches the provided pattern + * @param {string} name The string to check. + * @returns {boolean} if the string is a match + * @private + */ + function isInvalid(name) { + return !regexp.test(name); + } + + /** + * Checks if a parent of a node is an ObjectPattern. + * @param {ASTNode} node The node to check. + * @returns {boolean} if the node is inside an ObjectPattern + * @private + */ + function isInsideObjectPattern(node) { + let { parent } = node; + + while (parent) { + if (parent.type === "ObjectPattern") { + return true; + } + + parent = parent.parent; + } + + return false; + } + + /** + * Verifies if we should report an error or not based on the effective + * parent node and the identifier name. + * @param {ASTNode} effectiveParent The effective parent node of the node to be reported + * @param {string} name The identifier name of the identifier node + * @returns {boolean} whether an error should be reported or not + */ + function shouldReport(effectiveParent, name) { + return ( + (!onlyDeclarations || + DECLARATION_TYPES.has(effectiveParent.type)) && + !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && + isInvalid(name) + ); + } + + /** + * Reports an AST node as a rule violation. + * @param {ASTNode} node The node to report. + * @returns {void} + * @private + */ + function report(node) { + /* + * We used the range instead of the node because it's possible + * for the same identifier to be represented by two different + * nodes, with the most clear example being shorthand properties: + * { foo } + * In this case, "foo" is represented by one node for the name + * and one for the value. The only way to know they are the same + * is to look at the range. + */ + if (!reportedNodes.has(node.range.toString())) { + const messageId = + node.type === "PrivateIdentifier" + ? "notMatchPrivate" + : "notMatch"; + + context.report({ + node, + messageId, + data: { + name: node.name, + pattern, + }, + }); + reportedNodes.add(node.range.toString()); + } + } + + return { + Program(node) { + globalScope = sourceCode.getScope(node); + }, + + Identifier(node) { + const name = node.name, + parent = node.parent, + effectiveParent = + parent.type === "MemberExpression" + ? parent.parent + : parent; + + if ( + isReferenceToGlobalVariable(node) || + astUtils.isImportAttributeKey(node) || + parent.type === "MetaProperty" + ) { + return; + } + + if (parent.type === "MemberExpression") { + if (!checkProperties) { + return; + } + + // Always check object names + if ( + parent.object.type === "Identifier" && + parent.object.name === name + ) { + if (isInvalid(name)) { + report(node); + } + + // Report AssignmentExpressions left side's assigned variable id + } else if ( + effectiveParent.type === "AssignmentExpression" && + effectiveParent.left.type === "MemberExpression" && + effectiveParent.left.property.name === node.name + ) { + if (isInvalid(name)) { + report(node); + } + + // Report AssignmentExpressions only if they are the left side of the assignment + } else if ( + effectiveParent.type === "AssignmentExpression" && + effectiveParent.right.type !== "MemberExpression" + ) { + if (isInvalid(name)) { + report(node); + } + } + + // For https://github.com/eslint/eslint/issues/15123 + } else if ( + parent.type === "Property" && + parent.parent.type === "ObjectExpression" && + parent.key === node && + !parent.computed + ) { + if (checkProperties && isInvalid(name)) { + report(node); + } + + /* + * Properties have their own rules, and + * AssignmentPattern nodes can be treated like Properties: + * e.g.: const { no_camelcased = false } = bar; + */ + } else if ( + parent.type === "Property" || + parent.type === "AssignmentPattern" + ) { + if ( + parent.parent && + parent.parent.type === "ObjectPattern" + ) { + if ( + !ignoreDestructuring && + parent.shorthand && + parent.value.left && + isInvalid(name) + ) { + report(node); + } + + const assignmentKeyEqualsValue = + parent.key.name === parent.value.name; + + // prevent checking righthand side of destructured object + if (!assignmentKeyEqualsValue && parent.key === node) { + return; + } + + const valueIsInvalid = + parent.value.name && isInvalid(name); + + // ignore destructuring if the option is set, unless a new identifier is created + if ( + valueIsInvalid && + !(assignmentKeyEqualsValue && ignoreDestructuring) + ) { + report(node); + } + } + + // never check properties or always ignore destructuring + if ( + (!checkProperties && !parent.computed) || + (ignoreDestructuring && isInsideObjectPattern(node)) + ) { + return; + } + + // don't check right hand side of AssignmentExpression to prevent duplicate warnings + if ( + parent.right !== node && + shouldReport(effectiveParent, name) + ) { + report(node); + } + + // Check if it's an import specifier + } else if (IMPORT_TYPES.has(parent.type)) { + // Report only if the local imported identifier is invalid + if ( + parent.local && + parent.local.name === node.name && + isInvalid(name) + ) { + report(node); + } + } else if (parent.type === "PropertyDefinition") { + if (checkClassFields && isInvalid(name)) { + report(node); + } + + // Report anything that is invalid that isn't a CallExpression + } else if (shouldReport(effectiveParent, name)) { + report(node); + } + }, + + PrivateIdentifier(node) { + const isClassField = node.parent.type === "PropertyDefinition"; + + if (isClassField && !checkClassFields) { + return; + } + + if (isInvalid(node.name)) { + report(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/implicit-arrow-linebreak.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/implicit-arrow-linebreak.js new file mode 100644 index 00000000..e32d0caf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/implicit-arrow-linebreak.js @@ -0,0 +1,125 @@ +/** + * @fileoverview enforce the location of arrow function bodies + * @author Sharmila Jesupaul + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const { isCommentToken, isNotOpeningParenToken } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "implicit-arrow-linebreak", + url: "https://eslint.style/rules/implicit-arrow-linebreak", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce the location of arrow function bodies", + recommended: false, + url: "https://eslint.org/docs/latest/rules/implicit-arrow-linebreak", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["beside", "below"], + }, + ], + messages: { + expected: "Expected a linebreak before this expression.", + unexpected: "Expected no linebreak before this expression.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0] || "beside"; + + /** + * Validates the location of an arrow function body + * @param {ASTNode} node The arrow function body + * @returns {void} + */ + function validateExpression(node) { + if (node.body.type === "BlockStatement") { + return; + } + + const arrowToken = sourceCode.getTokenBefore( + node.body, + isNotOpeningParenToken, + ); + const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken); + + if ( + arrowToken.loc.end.line === firstTokenOfBody.loc.start.line && + option === "below" + ) { + context.report({ + node: firstTokenOfBody, + messageId: "expected", + fix: fixer => + fixer.insertTextBefore(firstTokenOfBody, "\n"), + }); + } else if ( + arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line && + option === "beside" + ) { + context.report({ + node: firstTokenOfBody, + messageId: "unexpected", + fix(fixer) { + if ( + sourceCode.getFirstTokenBetween( + arrowToken, + firstTokenOfBody, + { + includeComments: true, + filter: isCommentToken, + }, + ) + ) { + return null; + } + + return fixer.replaceTextRange( + [arrowToken.range[1], firstTokenOfBody.range[0]], + " ", + ); + }, + }); + } + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + return { + ArrowFunctionExpression: node => validateExpression(node), + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent-legacy.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent-legacy.js new file mode 100644 index 00000000..3c14ff76 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent-legacy.js @@ -0,0 +1,1369 @@ +/** + * @fileoverview This option sets a specific tab width for your code + * + * This rule has been ported and modified from nodeca. + * @author Vitaly Puzrin + * @author Gyandeep Singh + * @deprecated in ESLint v4.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ +// this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway. +/* c8 ignore next */ +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + docs: { + description: "Enforce consistent indentation", + recommended: false, + url: "https://eslint.org/docs/latest/rules/indent-legacy", + }, + + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "4.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "indent", + url: "https://eslint.style/rules/indent", + }, + }, + ], + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["tab"], + }, + { + type: "integer", + minimum: 0, + }, + ], + }, + { + type: "object", + properties: { + SwitchCase: { + type: "integer", + minimum: 0, + }, + VariableDeclarator: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + var: { + type: "integer", + minimum: 0, + }, + let: { + type: "integer", + minimum: 0, + }, + const: { + type: "integer", + minimum: 0, + }, + }, + }, + ], + }, + outerIIFEBody: { + type: "integer", + minimum: 0, + }, + MemberExpression: { + type: "integer", + minimum: 0, + }, + FunctionDeclaration: { + type: "object", + properties: { + parameters: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first"], + }, + ], + }, + body: { + type: "integer", + minimum: 0, + }, + }, + }, + FunctionExpression: { + type: "object", + properties: { + parameters: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first"], + }, + ], + }, + body: { + type: "integer", + minimum: 0, + }, + }, + }, + CallExpression: { + type: "object", + properties: { + parameters: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first"], + }, + ], + }, + }, + }, + ArrayExpression: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first"], + }, + ], + }, + ObjectExpression: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first"], + }, + ], + }, + }, + additionalProperties: false, + }, + ], + messages: { + expected: + "Expected indentation of {{expected}} but found {{actual}}.", + }, + }, + + create(context) { + const DEFAULT_VARIABLE_INDENT = 1; + const DEFAULT_PARAMETER_INDENT = null; // For backwards compatibility, don't check parameter indentation unless specified in the config + const DEFAULT_FUNCTION_BODY_INDENT = 1; + + let indentType = "space"; + let indentSize = 4; + const options = { + SwitchCase: 0, + VariableDeclarator: { + var: DEFAULT_VARIABLE_INDENT, + let: DEFAULT_VARIABLE_INDENT, + const: DEFAULT_VARIABLE_INDENT, + }, + outerIIFEBody: null, + FunctionDeclaration: { + parameters: DEFAULT_PARAMETER_INDENT, + body: DEFAULT_FUNCTION_BODY_INDENT, + }, + FunctionExpression: { + parameters: DEFAULT_PARAMETER_INDENT, + body: DEFAULT_FUNCTION_BODY_INDENT, + }, + CallExpression: { + arguments: DEFAULT_PARAMETER_INDENT, + }, + ArrayExpression: 1, + ObjectExpression: 1, + }; + + const sourceCode = context.sourceCode; + + if (context.options.length) { + if (context.options[0] === "tab") { + indentSize = 1; + indentType = "tab"; + } /* c8 ignore start */ else if ( + typeof context.options[0] === "number" + ) { + indentSize = context.options[0]; + indentType = "space"; + } /* c8 ignore stop */ + + if (context.options[1]) { + const opts = context.options[1]; + + options.SwitchCase = opts.SwitchCase || 0; + const variableDeclaratorRules = opts.VariableDeclarator; + + if (typeof variableDeclaratorRules === "number") { + options.VariableDeclarator = { + var: variableDeclaratorRules, + let: variableDeclaratorRules, + const: variableDeclaratorRules, + }; + } else if (typeof variableDeclaratorRules === "object") { + Object.assign( + options.VariableDeclarator, + variableDeclaratorRules, + ); + } + + if (typeof opts.outerIIFEBody === "number") { + options.outerIIFEBody = opts.outerIIFEBody; + } + + if (typeof opts.MemberExpression === "number") { + options.MemberExpression = opts.MemberExpression; + } + + if (typeof opts.FunctionDeclaration === "object") { + Object.assign( + options.FunctionDeclaration, + opts.FunctionDeclaration, + ); + } + + if (typeof opts.FunctionExpression === "object") { + Object.assign( + options.FunctionExpression, + opts.FunctionExpression, + ); + } + + if (typeof opts.CallExpression === "object") { + Object.assign(options.CallExpression, opts.CallExpression); + } + + if ( + typeof opts.ArrayExpression === "number" || + typeof opts.ArrayExpression === "string" + ) { + options.ArrayExpression = opts.ArrayExpression; + } + + if ( + typeof opts.ObjectExpression === "number" || + typeof opts.ObjectExpression === "string" + ) { + options.ObjectExpression = opts.ObjectExpression; + } + } + } + + const caseIndentStore = {}; + + /** + * Creates an error message for a line, given the expected/actual indentation. + * @param {number} expectedAmount The expected amount of indentation characters for this line + * @param {number} actualSpaces The actual number of indentation spaces that were found on this line + * @param {number} actualTabs The actual number of indentation tabs that were found on this line + * @returns {string} An error message for this line + */ + function createErrorMessageData( + expectedAmount, + actualSpaces, + actualTabs, + ) { + const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? "" : "s"}`; // e.g. "2 tabs" + const foundSpacesWord = `space${actualSpaces === 1 ? "" : "s"}`; // e.g. "space" + const foundTabsWord = `tab${actualTabs === 1 ? "" : "s"}`; // e.g. "tabs" + let foundStatement; + + if (actualSpaces > 0 && actualTabs > 0) { + foundStatement = `${actualSpaces} ${foundSpacesWord} and ${actualTabs} ${foundTabsWord}`; // e.g. "1 space and 2 tabs" + } else if (actualSpaces > 0) { + /* + * Abbreviate the message if the expected indentation is also spaces. + * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces' + */ + foundStatement = + indentType === "space" + ? actualSpaces + : `${actualSpaces} ${foundSpacesWord}`; + } else if (actualTabs > 0) { + foundStatement = + indentType === "tab" + ? actualTabs + : `${actualTabs} ${foundTabsWord}`; + } else { + foundStatement = "0"; + } + return { + expected: expectedStatement, + actual: foundStatement, + }; + } + + /** + * Reports a given indent violation + * @param {ASTNode} node Node violating the indent rule + * @param {number} needed Expected indentation character count + * @param {number} gottenSpaces Indentation space count in the actual node/code + * @param {number} gottenTabs Indentation tab count in the actual node/code + * @param {Object} [loc] Error line and column location + * @param {boolean} isLastNodeCheck Is the error for last node check + * @returns {void} + */ + function report( + node, + needed, + gottenSpaces, + gottenTabs, + loc, + isLastNodeCheck, + ) { + if (gottenSpaces && gottenTabs) { + // To avoid conflicts with `no-mixed-spaces-and-tabs`, don't report lines that have both spaces and tabs. + return; + } + + const desiredIndent = (indentType === "space" ? " " : "\t").repeat( + needed, + ); + + const textRange = isLastNodeCheck + ? [ + node.range[1] - node.loc.end.column, + node.range[1] - + node.loc.end.column + + gottenSpaces + + gottenTabs, + ] + : [ + node.range[0] - node.loc.start.column, + node.range[0] - + node.loc.start.column + + gottenSpaces + + gottenTabs, + ]; + + context.report({ + node, + loc, + messageId: "expected", + data: createErrorMessageData(needed, gottenSpaces, gottenTabs), + fix: fixer => fixer.replaceTextRange(textRange, desiredIndent), + }); + } + + /** + * Get the actual indent of node + * @param {ASTNode|Token} node Node to examine + * @param {boolean} [byLastLine=false] get indent of node's last line + * @returns {Object} The node's indent. Contains keys `space` and `tab`, representing the indent of each character. Also + * contains keys `goodChar` and `badChar`, where `goodChar` is the amount of the user's desired indentation character, and + * `badChar` is the amount of the other indentation character. + */ + function getNodeIndent(node, byLastLine) { + const token = byLastLine + ? sourceCode.getLastToken(node) + : sourceCode.getFirstToken(node); + const srcCharsBeforeNode = sourceCode + .getText(token, token.loc.start.column) + .split(""); + const indentChars = srcCharsBeforeNode.slice( + 0, + srcCharsBeforeNode.findIndex( + char => char !== " " && char !== "\t", + ), + ); + const spaces = indentChars.filter(char => char === " ").length; + const tabs = indentChars.filter(char => char === "\t").length; + + return { + space: spaces, + tab: tabs, + goodChar: indentType === "space" ? spaces : tabs, + badChar: indentType === "space" ? tabs : spaces, + }; + } + + /** + * Checks node is the first in its own start line. By default it looks by start line. + * @param {ASTNode} node The node to check + * @param {boolean} [byEndLocation=false] Lookup based on start position or end + * @returns {boolean} true if its the first in the its start line + */ + function isNodeFirstInLine(node, byEndLocation) { + const firstToken = + byEndLocation === true + ? sourceCode.getLastToken(node, 1) + : sourceCode.getTokenBefore(node), + startLine = + byEndLocation === true + ? node.loc.end.line + : node.loc.start.line, + endLine = firstToken ? firstToken.loc.end.line : -1; + + return startLine !== endLine; + } + + /** + * Check indent for node + * @param {ASTNode} node Node to check + * @param {number} neededIndent needed indent + * @returns {void} + */ + function checkNodeIndent(node, neededIndent) { + const actualIndent = getNodeIndent(node, false); + + if ( + node.type !== "ArrayExpression" && + node.type !== "ObjectExpression" && + (actualIndent.goodChar !== neededIndent || + actualIndent.badChar !== 0) && + isNodeFirstInLine(node) + ) { + report( + node, + neededIndent, + actualIndent.space, + actualIndent.tab, + ); + } + + if (node.type === "IfStatement" && node.alternate) { + const elseToken = sourceCode.getTokenBefore(node.alternate); + + checkNodeIndent(elseToken, neededIndent); + + if (!isNodeFirstInLine(node.alternate)) { + checkNodeIndent(node.alternate, neededIndent); + } + } + + if (node.type === "TryStatement" && node.handler) { + const catchToken = sourceCode.getFirstToken(node.handler); + + checkNodeIndent(catchToken, neededIndent); + } + + if (node.type === "TryStatement" && node.finalizer) { + const finallyToken = sourceCode.getTokenBefore(node.finalizer); + + checkNodeIndent(finallyToken, neededIndent); + } + + if (node.type === "DoWhileStatement") { + const whileToken = sourceCode.getTokenAfter(node.body); + + checkNodeIndent(whileToken, neededIndent); + } + } + + /** + * Check indent for nodes list + * @param {ASTNode[]} nodes list of node objects + * @param {number} indent needed indent + * @returns {void} + */ + function checkNodesIndent(nodes, indent) { + nodes.forEach(node => checkNodeIndent(node, indent)); + } + + /** + * Check last node line indent this detects, that block closed correctly + * @param {ASTNode} node Node to examine + * @param {number} lastLineIndent needed indent + * @returns {void} + */ + function checkLastNodeLineIndent(node, lastLineIndent) { + const lastToken = sourceCode.getLastToken(node); + const endIndent = getNodeIndent(lastToken, true); + + if ( + (endIndent.goodChar !== lastLineIndent || + endIndent.badChar !== 0) && + isNodeFirstInLine(node, true) + ) { + report( + node, + lastLineIndent, + endIndent.space, + endIndent.tab, + { + line: lastToken.loc.start.line, + column: lastToken.loc.start.column, + }, + true, + ); + } + } + + /** + * Check last node line indent this detects, that block closed correctly + * This function for more complicated return statement case, where closing parenthesis may be followed by ';' + * @param {ASTNode} node Node to examine + * @param {number} firstLineIndent first line needed indent + * @returns {void} + */ + function checkLastReturnStatementLineIndent(node, firstLineIndent) { + /* + * in case if return statement ends with ');' we have traverse back to ')' + * otherwise we'll measure indent for ';' and replace ')' + */ + const lastToken = sourceCode.getLastToken( + node, + astUtils.isClosingParenToken, + ); + const textBeforeClosingParenthesis = sourceCode + .getText(lastToken, lastToken.loc.start.column) + .slice(0, -1); + + if (textBeforeClosingParenthesis.trim()) { + // There are tokens before the closing paren, don't report this case + return; + } + + const endIndent = getNodeIndent(lastToken, true); + + if (endIndent.goodChar !== firstLineIndent) { + report( + node, + firstLineIndent, + endIndent.space, + endIndent.tab, + { + line: lastToken.loc.start.line, + column: lastToken.loc.start.column, + }, + true, + ); + } + } + + /** + * Check first node line indent is correct + * @param {ASTNode} node Node to examine + * @param {number} firstLineIndent needed indent + * @returns {void} + */ + function checkFirstNodeLineIndent(node, firstLineIndent) { + const startIndent = getNodeIndent(node, false); + + if ( + (startIndent.goodChar !== firstLineIndent || + startIndent.badChar !== 0) && + isNodeFirstInLine(node) + ) { + report( + node, + firstLineIndent, + startIndent.space, + startIndent.tab, + { + line: node.loc.start.line, + column: node.loc.start.column, + }, + ); + } + } + + /** + * Returns a parent node of given node based on a specified type + * if not present then return null + * @param {ASTNode} node node to examine + * @param {string} type type that is being looked for + * @param {string} stopAtList end points for the evaluating code + * @returns {ASTNode|void} if found then node otherwise null + */ + function getParentNodeByType(node, type, stopAtList) { + let parent = node.parent; + const stopAtSet = new Set(stopAtList || ["Program"]); + + while ( + parent.type !== type && + !stopAtSet.has(parent.type) && + parent.type !== "Program" + ) { + parent = parent.parent; + } + + return parent.type === type ? parent : null; + } + + /** + * Returns the VariableDeclarator based on the current node + * if not present then return null + * @param {ASTNode} node node to examine + * @returns {ASTNode|void} if found then node otherwise null + */ + function getVariableDeclaratorNode(node) { + return getParentNodeByType(node, "VariableDeclarator"); + } + + /** + * Check to see if the node is part of the multi-line variable declaration. + * Also if its on the same line as the varNode + * @param {ASTNode} node node to check + * @param {ASTNode} varNode variable declaration node to check against + * @returns {boolean} True if all the above condition satisfy + */ + function isNodeInVarOnTop(node, varNode) { + return ( + varNode && + varNode.parent.loc.start.line === node.loc.start.line && + varNode.parent.declarations.length > 1 + ); + } + + /** + * Check to see if the argument before the callee node is multi-line and + * there should only be 1 argument before the callee node + * @param {ASTNode} node node to check + * @returns {boolean} True if arguments are multi-line + */ + function isArgBeforeCalleeNodeMultiline(node) { + const parent = node.parent; + + if (parent.arguments.length >= 2 && parent.arguments[1] === node) { + return ( + parent.arguments[0].loc.end.line > + parent.arguments[0].loc.start.line + ); + } + + return false; + } + + /** + * Check to see if the node is a file level IIFE + * @param {ASTNode} node The function node to check. + * @returns {boolean} True if the node is the outer IIFE + */ + function isOuterIIFE(node) { + const parent = node.parent; + let stmt = parent.parent; + + /* + * Verify that the node is an IIEF + */ + if (parent.type !== "CallExpression" || parent.callee !== node) { + return false; + } + + /* + * Navigate legal ancestors to determine whether this IIEF is outer + */ + while ( + (stmt.type === "UnaryExpression" && + (stmt.operator === "!" || + stmt.operator === "~" || + stmt.operator === "+" || + stmt.operator === "-")) || + stmt.type === "AssignmentExpression" || + stmt.type === "LogicalExpression" || + stmt.type === "SequenceExpression" || + stmt.type === "VariableDeclarator" + ) { + stmt = stmt.parent; + } + + return ( + (stmt.type === "ExpressionStatement" || + stmt.type === "VariableDeclaration") && + stmt.parent && + stmt.parent.type === "Program" + ); + } + + /** + * Check indent for function block content + * @param {ASTNode} node A BlockStatement node that is inside of a function. + * @returns {void} + */ + function checkIndentInFunctionBlock(node) { + /* + * Search first caller in chain. + * Ex.: + * + * Models <- Identifier + * .User + * .find() + * .exec(function() { + * // function body + * }); + * + * Looks for 'Models' + */ + const calleeNode = node.parent; // FunctionExpression + let indent; + + if ( + calleeNode.parent && + (calleeNode.parent.type === "Property" || + calleeNode.parent.type === "ArrayExpression") + ) { + // If function is part of array or object, comma can be put at left + indent = getNodeIndent(calleeNode, false).goodChar; + } else { + // If function is standalone, simple calculate indent + indent = getNodeIndent(calleeNode).goodChar; + } + + if (calleeNode.parent.type === "CallExpression") { + const calleeParent = calleeNode.parent; + + if ( + calleeNode.type !== "FunctionExpression" && + calleeNode.type !== "ArrowFunctionExpression" + ) { + if ( + calleeParent && + calleeParent.loc.start.line < node.loc.start.line + ) { + indent = getNodeIndent(calleeParent).goodChar; + } + } else { + if ( + isArgBeforeCalleeNodeMultiline(calleeNode) && + calleeParent.callee.loc.start.line === + calleeParent.callee.loc.end.line && + !isNodeFirstInLine(calleeNode) + ) { + indent = getNodeIndent(calleeParent).goodChar; + } + } + } + + /* + * function body indent should be indent + indent size, unless this + * is a FunctionDeclaration, FunctionExpression, or outer IIFE and the corresponding options are enabled. + */ + let functionOffset = indentSize; + + if (options.outerIIFEBody !== null && isOuterIIFE(calleeNode)) { + functionOffset = options.outerIIFEBody * indentSize; + } else if (calleeNode.type === "FunctionExpression") { + functionOffset = options.FunctionExpression.body * indentSize; + } else if (calleeNode.type === "FunctionDeclaration") { + functionOffset = options.FunctionDeclaration.body * indentSize; + } + indent += functionOffset; + + // check if the node is inside a variable + const parentVarNode = getVariableDeclaratorNode(node); + + if (parentVarNode && isNodeInVarOnTop(node, parentVarNode)) { + indent += + indentSize * + options.VariableDeclarator[parentVarNode.parent.kind]; + } + + if (node.body.length > 0) { + checkNodesIndent(node.body, indent); + } + + checkLastNodeLineIndent(node, indent - functionOffset); + } + + /** + * Checks if the given node starts and ends on the same line + * @param {ASTNode} node The node to check + * @returns {boolean} Whether or not the block starts and ends on the same line. + */ + function isSingleLineNode(node) { + const lastToken = sourceCode.getLastToken(node), + startLine = node.loc.start.line, + endLine = lastToken.loc.end.line; + + return startLine === endLine; + } + + /** + * Check indent for array block content or object block content + * @param {ASTNode} node node to examine + * @returns {void} + */ + function checkIndentInArrayOrObjectBlock(node) { + // Skip inline + if (isSingleLineNode(node)) { + return; + } + + let elements = + node.type === "ArrayExpression" + ? node.elements + : node.properties; + + // filter out empty elements example would be [ , 2] so remove first element as espree considers it as null + elements = elements.filter(elem => elem !== null); + + let nodeIndent; + let elementsIndent; + const parentVarNode = getVariableDeclaratorNode(node); + + // TODO - come up with a better strategy in future + if (isNodeFirstInLine(node)) { + const parent = node.parent; + + nodeIndent = getNodeIndent(parent).goodChar; + if ( + !parentVarNode || + parentVarNode.loc.start.line !== node.loc.start.line + ) { + if ( + parent.type !== "VariableDeclarator" || + parentVarNode === parentVarNode.parent.declarations[0] + ) { + if ( + parent.type === "VariableDeclarator" && + parentVarNode.loc.start.line === + parent.loc.start.line + ) { + nodeIndent += + indentSize * + options.VariableDeclarator[ + parentVarNode.parent.kind + ]; + } else if ( + parent.type === "ObjectExpression" || + parent.type === "ArrayExpression" + ) { + const parentElements = + node.parent.type === "ObjectExpression" + ? node.parent.properties + : node.parent.elements; + + if ( + parentElements[0] && + parentElements[0].loc.start.line === + parent.loc.start.line && + parentElements[0].loc.end.line !== + parent.loc.start.line + ) { + /* + * If the first element of the array spans multiple lines, don't increase the expected indentation of the rest. + * e.g. [{ + * foo: 1 + * }, + * { + * bar: 1 + * }] + * the second object is not indented. + */ + } else if ( + typeof options[parent.type] === "number" + ) { + nodeIndent += options[parent.type] * indentSize; + } else { + nodeIndent = parentElements[0].loc.start.column; + } + } else if ( + parent.type === "CallExpression" || + parent.type === "NewExpression" + ) { + if ( + typeof options.CallExpression.arguments === + "number" + ) { + nodeIndent += + options.CallExpression.arguments * + indentSize; + } else if ( + options.CallExpression.arguments === "first" + ) { + if (parent.arguments.includes(node)) { + nodeIndent = + parent.arguments[0].loc.start.column; + } + } else { + nodeIndent += indentSize; + } + } else if ( + parent.type === "LogicalExpression" || + parent.type === "ArrowFunctionExpression" + ) { + nodeIndent += indentSize; + } + } + } + + checkFirstNodeLineIndent(node, nodeIndent); + } else { + nodeIndent = getNodeIndent(node).goodChar; + } + + if (options[node.type] === "first") { + elementsIndent = elements.length + ? elements[0].loc.start.column + : 0; // If there are no elements, elementsIndent doesn't matter. + } else { + elementsIndent = nodeIndent + indentSize * options[node.type]; + } + + /* + * Check if the node is a multiple variable declaration; if so, then + * make sure indentation takes that into account. + */ + if (isNodeInVarOnTop(node, parentVarNode)) { + elementsIndent += + indentSize * + options.VariableDeclarator[parentVarNode.parent.kind]; + } + + checkNodesIndent(elements, elementsIndent); + + if (elements.length > 0) { + // Skip last block line check if last item in same line + if (elements.at(-1).loc.end.line === node.loc.end.line) { + return; + } + } + + checkLastNodeLineIndent( + node, + nodeIndent + + (isNodeInVarOnTop(node, parentVarNode) + ? options.VariableDeclarator[ + parentVarNode.parent.kind + ] * indentSize + : 0), + ); + } + + /** + * Check if the node or node body is a BlockStatement or not + * @param {ASTNode} node node to test + * @returns {boolean} True if it or its body is a block statement + */ + function isNodeBodyBlock(node) { + return ( + node.type === "BlockStatement" || + node.type === "ClassBody" || + (node.body && node.body.type === "BlockStatement") || + (node.consequent && node.consequent.type === "BlockStatement") + ); + } + + /** + * Check indentation for blocks + * @param {ASTNode} node node to check + * @returns {void} + */ + function blockIndentationCheck(node) { + // Skip inline blocks + if (isSingleLineNode(node)) { + return; + } + + if ( + node.parent && + (node.parent.type === "FunctionExpression" || + node.parent.type === "FunctionDeclaration" || + node.parent.type === "ArrowFunctionExpression") + ) { + checkIndentInFunctionBlock(node); + return; + } + + let indent; + let nodesToCheck; + + /* + * For this statements we should check indent from statement beginning, + * not from the beginning of the block. + */ + const statementsWithProperties = [ + "IfStatement", + "WhileStatement", + "ForStatement", + "ForInStatement", + "ForOfStatement", + "DoWhileStatement", + "ClassDeclaration", + "TryStatement", + ]; + + if ( + node.parent && + statementsWithProperties.includes(node.parent.type) && + isNodeBodyBlock(node) + ) { + indent = getNodeIndent(node.parent).goodChar; + } else if (node.parent && node.parent.type === "CatchClause") { + indent = getNodeIndent(node.parent.parent).goodChar; + } else { + indent = getNodeIndent(node).goodChar; + } + + if ( + node.type === "IfStatement" && + node.consequent.type !== "BlockStatement" + ) { + nodesToCheck = [node.consequent]; + } else if (Array.isArray(node.body)) { + nodesToCheck = node.body; + } else { + nodesToCheck = [node.body]; + } + + if (nodesToCheck.length > 0) { + checkNodesIndent(nodesToCheck, indent + indentSize); + } + + if (node.type === "BlockStatement") { + checkLastNodeLineIndent(node, indent); + } + } + + /** + * Filter out the elements which are on the same line of each other or the node. + * basically have only 1 elements from each line except the variable declaration line. + * @param {ASTNode} node Variable declaration node + * @returns {ASTNode[]} Filtered elements + */ + function filterOutSameLineVars(node) { + return node.declarations.reduce((finalCollection, elem) => { + const lastElem = finalCollection.at(-1); + + if ( + (elem.loc.start.line !== node.loc.start.line && + !lastElem) || + (lastElem && + lastElem.loc.start.line !== elem.loc.start.line) + ) { + finalCollection.push(elem); + } + + return finalCollection; + }, []); + } + + /** + * Check indentation for variable declarations + * @param {ASTNode} node node to examine + * @returns {void} + */ + function checkIndentInVariableDeclarations(node) { + const elements = filterOutSameLineVars(node); + const nodeIndent = getNodeIndent(node).goodChar; + const lastElement = elements.at(-1); + + const elementsIndent = + nodeIndent + indentSize * options.VariableDeclarator[node.kind]; + + checkNodesIndent(elements, elementsIndent); + + // Only check the last line if there is any token after the last item + if ( + sourceCode.getLastToken(node).loc.end.line <= + lastElement.loc.end.line + ) { + return; + } + + const tokenBeforeLastElement = + sourceCode.getTokenBefore(lastElement); + + if (tokenBeforeLastElement.value === ",") { + // Special case for comma-first syntax where the semicolon is indented + checkLastNodeLineIndent( + node, + getNodeIndent(tokenBeforeLastElement).goodChar, + ); + } else { + checkLastNodeLineIndent(node, elementsIndent - indentSize); + } + } + + /** + * Check and decide whether to check for indentation for blockless nodes + * Scenarios are for or while statements without braces around them + * @param {ASTNode} node node to examine + * @returns {void} + */ + function blockLessNodes(node) { + if (node.body.type !== "BlockStatement") { + blockIndentationCheck(node); + } + } + + /** + * Returns the expected indentation for the case statement + * @param {ASTNode} node node to examine + * @param {number} [providedSwitchIndent] indent for switch statement + * @returns {number} indent size + */ + function expectedCaseIndent(node, providedSwitchIndent) { + const switchNode = + node.type === "SwitchStatement" ? node : node.parent; + const switchIndent = + typeof providedSwitchIndent === "undefined" + ? getNodeIndent(switchNode).goodChar + : providedSwitchIndent; + let caseIndent; + + if (caseIndentStore[switchNode.loc.start.line]) { + return caseIndentStore[switchNode.loc.start.line]; + } + + if (switchNode.cases.length > 0 && options.SwitchCase === 0) { + caseIndent = switchIndent; + } else { + caseIndent = switchIndent + indentSize * options.SwitchCase; + } + + caseIndentStore[switchNode.loc.start.line] = caseIndent; + return caseIndent; + } + + /** + * Checks whether a return statement is wrapped in () + * @param {ASTNode} node node to examine + * @returns {boolean} the result + */ + function isWrappedInParenthesis(node) { + const regex = /^return\s*\(\s*\)/u; + + const statementWithoutArgument = sourceCode + .getText(node) + .replace(sourceCode.getText(node.argument), ""); + + return regex.test(statementWithoutArgument); + } + + return { + Program(node) { + if (node.body.length > 0) { + // Root nodes should have no indent + checkNodesIndent(node.body, getNodeIndent(node).goodChar); + } + }, + + ClassBody: blockIndentationCheck, + + BlockStatement: blockIndentationCheck, + + WhileStatement: blockLessNodes, + + ForStatement: blockLessNodes, + + ForInStatement: blockLessNodes, + + ForOfStatement: blockLessNodes, + + DoWhileStatement: blockLessNodes, + + IfStatement(node) { + if ( + node.consequent.type !== "BlockStatement" && + node.consequent.loc.start.line > node.loc.start.line + ) { + blockIndentationCheck(node); + } + }, + + VariableDeclaration(node) { + if ( + node.declarations.at(-1).loc.start.line > + node.declarations[0].loc.start.line + ) { + checkIndentInVariableDeclarations(node); + } + }, + + ObjectExpression(node) { + checkIndentInArrayOrObjectBlock(node); + }, + + ArrayExpression(node) { + checkIndentInArrayOrObjectBlock(node); + }, + + MemberExpression(node) { + if (typeof options.MemberExpression === "undefined") { + return; + } + + if (isSingleLineNode(node)) { + return; + } + + /* + * The typical layout of variable declarations and assignments + * alter the expectation of correct indentation. Skip them. + * TODO: Add appropriate configuration options for variable + * declarations and assignments. + */ + if ( + getParentNodeByType(node, "VariableDeclarator", [ + "FunctionExpression", + "ArrowFunctionExpression", + ]) + ) { + return; + } + + if ( + getParentNodeByType(node, "AssignmentExpression", [ + "FunctionExpression", + ]) + ) { + return; + } + + const propertyIndent = + getNodeIndent(node).goodChar + + indentSize * options.MemberExpression; + + const checkNodes = [node.property]; + + const dot = sourceCode.getTokenBefore(node.property); + + if (dot.type === "Punctuator" && dot.value === ".") { + checkNodes.push(dot); + } + + checkNodesIndent(checkNodes, propertyIndent); + }, + + SwitchStatement(node) { + // Switch is not a 'BlockStatement' + const switchIndent = getNodeIndent(node).goodChar; + const caseIndent = expectedCaseIndent(node, switchIndent); + + checkNodesIndent(node.cases, caseIndent); + + checkLastNodeLineIndent(node, switchIndent); + }, + + SwitchCase(node) { + // Skip inline cases + if (isSingleLineNode(node)) { + return; + } + const caseIndent = expectedCaseIndent(node); + + checkNodesIndent(node.consequent, caseIndent + indentSize); + }, + + FunctionDeclaration(node) { + if (isSingleLineNode(node)) { + return; + } + if ( + options.FunctionDeclaration.parameters === "first" && + node.params.length + ) { + checkNodesIndent( + node.params.slice(1), + node.params[0].loc.start.column, + ); + } else if (options.FunctionDeclaration.parameters !== null) { + checkNodesIndent( + node.params, + getNodeIndent(node).goodChar + + indentSize * options.FunctionDeclaration.parameters, + ); + } + }, + + FunctionExpression(node) { + if (isSingleLineNode(node)) { + return; + } + if ( + options.FunctionExpression.parameters === "first" && + node.params.length + ) { + checkNodesIndent( + node.params.slice(1), + node.params[0].loc.start.column, + ); + } else if (options.FunctionExpression.parameters !== null) { + checkNodesIndent( + node.params, + getNodeIndent(node).goodChar + + indentSize * options.FunctionExpression.parameters, + ); + } + }, + + ReturnStatement(node) { + if (isSingleLineNode(node)) { + return; + } + + const firstLineIndent = getNodeIndent(node).goodChar; + + // in case if return statement is wrapped in parenthesis + if (isWrappedInParenthesis(node)) { + checkLastReturnStatementLineIndent(node, firstLineIndent); + } else { + checkNodeIndent(node, firstLineIndent); + } + }, + + CallExpression(node) { + if (isSingleLineNode(node)) { + return; + } + if ( + options.CallExpression.arguments === "first" && + node.arguments.length + ) { + checkNodesIndent( + node.arguments.slice(1), + node.arguments[0].loc.start.column, + ); + } else if (options.CallExpression.arguments !== null) { + checkNodesIndent( + node.arguments, + getNodeIndent(node).goodChar + + indentSize * options.CallExpression.arguments, + ); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent.js new file mode 100644 index 00000000..3a58c556 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/indent.js @@ -0,0 +1,2332 @@ +/** + * @fileoverview This rule sets a specific indentation style and width for your code + * + * @author Teddy Katz + * @author Vitaly Puzrin + * @author Gyandeep Singh + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const KNOWN_NODES = new Set([ + "AssignmentExpression", + "AssignmentPattern", + "ArrayExpression", + "ArrayPattern", + "ArrowFunctionExpression", + "AwaitExpression", + "BlockStatement", + "BinaryExpression", + "BreakStatement", + "CallExpression", + "CatchClause", + "ChainExpression", + "ClassBody", + "ClassDeclaration", + "ClassExpression", + "ConditionalExpression", + "ContinueStatement", + "DoWhileStatement", + "DebuggerStatement", + "EmptyStatement", + "ExperimentalRestProperty", + "ExperimentalSpreadProperty", + "ExpressionStatement", + "ForStatement", + "ForInStatement", + "ForOfStatement", + "FunctionDeclaration", + "FunctionExpression", + "Identifier", + "IfStatement", + "Literal", + "LabeledStatement", + "LogicalExpression", + "MemberExpression", + "MetaProperty", + "MethodDefinition", + "NewExpression", + "ObjectExpression", + "ObjectPattern", + "PrivateIdentifier", + "Program", + "Property", + "PropertyDefinition", + "RestElement", + "ReturnStatement", + "SequenceExpression", + "SpreadElement", + "StaticBlock", + "Super", + "SwitchCase", + "SwitchStatement", + "TaggedTemplateExpression", + "TemplateElement", + "TemplateLiteral", + "ThisExpression", + "ThrowStatement", + "TryStatement", + "UnaryExpression", + "UpdateExpression", + "VariableDeclaration", + "VariableDeclarator", + "WhileStatement", + "WithStatement", + "YieldExpression", + "JSXFragment", + "JSXOpeningFragment", + "JSXClosingFragment", + "JSXIdentifier", + "JSXNamespacedName", + "JSXMemberExpression", + "JSXEmptyExpression", + "JSXExpressionContainer", + "JSXElement", + "JSXClosingElement", + "JSXOpeningElement", + "JSXAttribute", + "JSXSpreadAttribute", + "JSXText", + "ExportDefaultDeclaration", + "ExportNamedDeclaration", + "ExportAllDeclaration", + "ExportSpecifier", + "ImportDeclaration", + "ImportSpecifier", + "ImportDefaultSpecifier", + "ImportNamespaceSpecifier", + "ImportExpression", +]); + +/* + * General rule strategy: + * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another + * specified token or to the first column. + * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a + * BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly + * brace of the BlockStatement. + * 3. After traversing the AST, calculate the expected indentation levels of every token according to the + * OffsetStorage container. + * 4. For each line, compare the expected indentation of the first token to the actual indentation in the file, + * and report the token if the two values are not equal. + */ + +/** + * A mutable map that stores (key, value) pairs. The keys are numeric indices, and must be unique. + * This is intended to be a generic wrapper around a map with non-negative integer keys, so that the underlying implementation + * can easily be swapped out. + */ +class IndexMap { + /** + * Creates an empty map + * @param {number} maxKey The maximum key + */ + constructor(maxKey) { + // Initializing the array with the maximum expected size avoids dynamic reallocations that could degrade performance. + this._values = Array(maxKey + 1); + } + + /** + * Inserts an entry into the map. + * @param {number} key The entry's key + * @param {any} value The entry's value + * @returns {void} + */ + insert(key, value) { + this._values[key] = value; + } + + /** + * Finds the value of the entry with the largest key less than or equal to the provided key + * @param {number} key The provided key + * @returns {*|undefined} The value of the found entry, or undefined if no such entry exists. + */ + findLastNotAfter(key) { + const values = this._values; + + for (let index = key; index >= 0; index--) { + const value = values[index]; + + if (value) { + return value; + } + } + return void 0; + } + + /** + * Deletes all of the keys in the interval [start, end) + * @param {number} start The start of the range + * @param {number} end The end of the range + * @returns {void} + */ + deleteRange(start, end) { + this._values.fill(void 0, start, end); + } +} + +/** + * A helper class to get token-based info related to indentation + */ +class TokenInfo { + /** + * @param {SourceCode} sourceCode A SourceCode object + */ + constructor(sourceCode) { + this.sourceCode = sourceCode; + this.firstTokensByLineNumber = new Map(); + const tokens = sourceCode.tokensAndComments; + + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i]; + + if (!this.firstTokensByLineNumber.has(token.loc.start.line)) { + this.firstTokensByLineNumber.set(token.loc.start.line, token); + } + if ( + !this.firstTokensByLineNumber.has(token.loc.end.line) && + sourceCode.text + .slice( + token.range[1] - token.loc.end.column, + token.range[1], + ) + .trim() + ) { + this.firstTokensByLineNumber.set(token.loc.end.line, token); + } + } + } + + /** + * Gets the first token on a given token's line + * @param {Token|ASTNode} token a node or token + * @returns {Token} The first token on the given line + */ + getFirstTokenOfLine(token) { + return this.firstTokensByLineNumber.get(token.loc.start.line); + } + + /** + * Determines whether a token is the first token in its line + * @param {Token} token The token + * @returns {boolean} `true` if the token is the first on its line + */ + isFirstTokenOfLine(token) { + return this.getFirstTokenOfLine(token) === token; + } + + /** + * Get the actual indent of a token + * @param {Token} token Token to examine. This should be the first token on its line. + * @returns {string} The indentation characters that precede the token + */ + getTokenIndent(token) { + return this.sourceCode.text.slice( + token.range[0] - token.loc.start.column, + token.range[0], + ); + } +} + +/** + * A class to store information on desired offsets of tokens from each other + */ +class OffsetStorage { + /** + * @param {TokenInfo} tokenInfo a TokenInfo instance + * @param {number} indentSize The desired size of each indentation level + * @param {string} indentType The indentation character + * @param {number} maxIndex The maximum end index of any token + */ + constructor(tokenInfo, indentSize, indentType, maxIndex) { + this._tokenInfo = tokenInfo; + this._indentSize = indentSize; + this._indentType = indentType; + + this._indexMap = new IndexMap(maxIndex); + this._indexMap.insert(0, { offset: 0, from: null, force: false }); + + this._lockedFirstTokens = new WeakMap(); + this._desiredIndentCache = new WeakMap(); + this._ignoredTokens = new WeakSet(); + } + + _getOffsetDescriptor(token) { + return this._indexMap.findLastNotAfter(token.range[0]); + } + + /** + * Sets the offset column of token B to match the offset column of token A. + * - **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In + * most cases, `setDesiredOffset` should be used instead. + * @param {Token} baseToken The first token + * @param {Token} offsetToken The second token, whose offset should be matched to the first token + * @returns {void} + */ + matchOffsetOf(baseToken, offsetToken) { + /* + * lockedFirstTokens is a map from a token whose indentation is controlled by the "first" option to + * the token that it depends on. For example, with the `ArrayExpression: first` option, the first + * token of each element in the array after the first will be mapped to the first token of the first + * element. The desired indentation of each of these tokens is computed based on the desired indentation + * of the "first" element, rather than through the normal offset mechanism. + */ + this._lockedFirstTokens.set(offsetToken, baseToken); + } + + /** + * Sets the desired offset of a token. + * + * This uses a line-based offset collapsing behavior to handle tokens on the same line. + * For example, consider the following two cases: + * + * ( + * [ + * bar + * ] + * ) + * + * ([ + * bar + * ]) + * + * Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from + * the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is + * the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces) + * from the start of its line. + * + * However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level + * between the `(` and the `[` tokens gets "collapsed" because the two tokens are on the same line. As a result, the + * `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented + * by 1 indent level from the start of the line. + * + * This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node, + * without needing to check which lines those tokens are on. + * + * Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive + * behavior can occur. For example, consider the following cases: + * + * foo( + * ). + * bar( + * baz + * ) + * + * foo( + * ).bar( + * baz + * ) + * + * Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz` + * should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz` + * being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no + * collapsing would occur). + * + * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and + * offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed + * in the second case. + * @param {Token} token The token + * @param {Token} fromToken The token that `token` should be offset from + * @param {number} offset The desired indent level + * @returns {void} + */ + setDesiredOffset(token, fromToken, offset) { + return this.setDesiredOffsets(token.range, fromToken, offset); + } + + /** + * Sets the desired offset of all tokens in a range + * It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens. + * Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains + * it). This means that the offset of each token is updated O(AST depth) times. + * It would not be performant to store and update the offsets for each token independently, because the rule would end + * up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files. + * + * Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following + * list could represent the state of the offset tree at a given point: + * + * - Tokens starting in the interval [0, 15) are aligned with the beginning of the file + * - Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token + * - Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token + * - Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token + * - Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token + * + * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using: + * `setDesiredOffsets([30, 43], fooToken, 1);` + * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied. + * @param {Token} fromToken The token that this is offset from + * @param {number} offset The desired indent level + * @param {boolean} force `true` if this offset should not use the normal collapsing behavior. This should almost always be false. + * @returns {void} + */ + setDesiredOffsets(range, fromToken, offset, force) { + /* + * Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset + * descriptor. The tree for the example above would have the following nodes: + * + * * key: 0, value: { offset: 0, from: null } + * * key: 15, value: { offset: 1, from: barToken } + * * key: 30, value: { offset: 1, from: fooToken } + * * key: 43, value: { offset: 2, from: barToken } + * * key: 820, value: { offset: 1, from: bazToken } + * + * To find the offset descriptor for any given token, one needs to find the node with the largest key + * which is <= token.start. To make this operation fast, the nodes are stored in a map indexed by key. + */ + + const descriptorToInsert = { offset, from: fromToken, force }; + + const descriptorAfterRange = this._indexMap.findLastNotAfter(range[1]); + + const fromTokenIsInRange = + fromToken && + fromToken.range[0] >= range[0] && + fromToken.range[1] <= range[1]; + const fromTokenDescriptor = + fromTokenIsInRange && this._getOffsetDescriptor(fromToken); + + // First, remove any existing nodes in the range from the map. + this._indexMap.deleteRange(range[0] + 1, range[1]); + + // Insert a new node into the map for this range + this._indexMap.insert(range[0], descriptorToInsert); + + /* + * To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously, + * even if it's in the current range. + */ + if (fromTokenIsInRange) { + this._indexMap.insert(fromToken.range[0], fromTokenDescriptor); + this._indexMap.insert(fromToken.range[1], descriptorToInsert); + } + + /* + * To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following + * tokens the same as it was before. + */ + this._indexMap.insert(range[1], descriptorAfterRange); + } + + /** + * Gets the desired indent of a token + * @param {Token} token The token + * @returns {string} The desired indent of the token + */ + getDesiredIndent(token) { + if (!this._desiredIndentCache.has(token)) { + if (this._ignoredTokens.has(token)) { + /* + * If the token is ignored, use the actual indent of the token as the desired indent. + * This ensures that no errors are reported for this token. + */ + this._desiredIndentCache.set( + token, + this._tokenInfo.getTokenIndent(token), + ); + } else if (this._lockedFirstTokens.has(token)) { + const firstToken = this._lockedFirstTokens.get(token); + + this._desiredIndentCache.set( + token, + + // (indentation for the first element's line) + this.getDesiredIndent( + this._tokenInfo.getFirstTokenOfLine(firstToken), + ) + + // (space between the start of the first element's line and the first element) + this._indentType.repeat( + firstToken.loc.start.column - + this._tokenInfo.getFirstTokenOfLine(firstToken) + .loc.start.column, + ), + ); + } else { + const offsetInfo = this._getOffsetDescriptor(token); + const offset = + offsetInfo.from && + offsetInfo.from.loc.start.line === token.loc.start.line && + !/^\s*?\n/u.test(token.value) && + !offsetInfo.force + ? 0 + : offsetInfo.offset * this._indentSize; + + this._desiredIndentCache.set( + token, + (offsetInfo.from + ? this.getDesiredIndent(offsetInfo.from) + : "") + this._indentType.repeat(offset), + ); + } + } + return this._desiredIndentCache.get(token); + } + + /** + * Ignores a token, preventing it from being reported. + * @param {Token} token The token + * @returns {void} + */ + ignoreToken(token) { + if (this._tokenInfo.isFirstTokenOfLine(token)) { + this._ignoredTokens.add(token); + } + } + + /** + * Gets the first token that the given token's indentation is dependent on + * @param {Token} token The token + * @returns {Token} The token that the given token depends on, or `null` if the given token is at the top level + */ + getFirstDependency(token) { + return this._getOffsetDescriptor(token).from; + } +} + +const ELEMENT_LIST_SCHEMA = { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["first", "off"], + }, + ], +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "indent", + url: "https://eslint.style/rules/indent", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent indentation", + recommended: false, + url: "https://eslint.org/docs/latest/rules/indent", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["tab"], + }, + { + type: "integer", + minimum: 0, + }, + ], + }, + { + type: "object", + properties: { + SwitchCase: { + type: "integer", + minimum: 0, + default: 0, + }, + VariableDeclarator: { + oneOf: [ + ELEMENT_LIST_SCHEMA, + { + type: "object", + properties: { + var: ELEMENT_LIST_SCHEMA, + let: ELEMENT_LIST_SCHEMA, + const: ELEMENT_LIST_SCHEMA, + }, + additionalProperties: false, + }, + ], + }, + outerIIFEBody: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["off"], + }, + ], + }, + MemberExpression: { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + enum: ["off"], + }, + ], + }, + FunctionDeclaration: { + type: "object", + properties: { + parameters: ELEMENT_LIST_SCHEMA, + body: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + FunctionExpression: { + type: "object", + properties: { + parameters: ELEMENT_LIST_SCHEMA, + body: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + StaticBlock: { + type: "object", + properties: { + body: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + CallExpression: { + type: "object", + properties: { + arguments: ELEMENT_LIST_SCHEMA, + }, + additionalProperties: false, + }, + ArrayExpression: ELEMENT_LIST_SCHEMA, + ObjectExpression: ELEMENT_LIST_SCHEMA, + ImportDeclaration: ELEMENT_LIST_SCHEMA, + flatTernaryExpressions: { + type: "boolean", + default: false, + }, + offsetTernaryExpressions: { + type: "boolean", + default: false, + }, + ignoredNodes: { + type: "array", + items: { + type: "string", + not: { + pattern: ":exit$", + }, + }, + }, + ignoreComments: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + messages: { + wrongIndentation: + "Expected indentation of {{expected}} but found {{actual}}.", + }, + }, + + create(context) { + const DEFAULT_VARIABLE_INDENT = 1; + const DEFAULT_PARAMETER_INDENT = 1; + const DEFAULT_FUNCTION_BODY_INDENT = 1; + + let indentType = "space"; + let indentSize = 4; + const options = { + SwitchCase: 0, + VariableDeclarator: { + var: DEFAULT_VARIABLE_INDENT, + let: DEFAULT_VARIABLE_INDENT, + const: DEFAULT_VARIABLE_INDENT, + }, + outerIIFEBody: 1, + FunctionDeclaration: { + parameters: DEFAULT_PARAMETER_INDENT, + body: DEFAULT_FUNCTION_BODY_INDENT, + }, + FunctionExpression: { + parameters: DEFAULT_PARAMETER_INDENT, + body: DEFAULT_FUNCTION_BODY_INDENT, + }, + StaticBlock: { + body: DEFAULT_FUNCTION_BODY_INDENT, + }, + CallExpression: { + arguments: DEFAULT_PARAMETER_INDENT, + }, + MemberExpression: 1, + ArrayExpression: 1, + ObjectExpression: 1, + ImportDeclaration: 1, + flatTernaryExpressions: false, + ignoredNodes: [], + ignoreComments: false, + }; + + if (context.options.length) { + if (context.options[0] === "tab") { + indentSize = 1; + indentType = "tab"; + } else { + indentSize = context.options[0]; + indentType = "space"; + } + + if (context.options[1]) { + Object.assign(options, context.options[1]); + + if ( + typeof options.VariableDeclarator === "number" || + options.VariableDeclarator === "first" + ) { + options.VariableDeclarator = { + var: options.VariableDeclarator, + let: options.VariableDeclarator, + const: options.VariableDeclarator, + }; + } + } + } + + const sourceCode = context.sourceCode; + const tokenInfo = new TokenInfo(sourceCode); + const offsets = new OffsetStorage( + tokenInfo, + indentSize, + indentType === "space" ? " " : "\t", + sourceCode.text.length, + ); + const parameterParens = new WeakSet(); + + /** + * Creates an error message for a line, given the expected/actual indentation. + * @param {number} expectedAmount The expected amount of indentation characters for this line + * @param {number} actualSpaces The actual number of indentation spaces that were found on this line + * @param {number} actualTabs The actual number of indentation tabs that were found on this line + * @returns {string} An error message for this line + */ + function createErrorMessageData( + expectedAmount, + actualSpaces, + actualTabs, + ) { + const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? "" : "s"}`; // e.g. "2 tabs" + const foundSpacesWord = `space${actualSpaces === 1 ? "" : "s"}`; // e.g. "space" + const foundTabsWord = `tab${actualTabs === 1 ? "" : "s"}`; // e.g. "tabs" + let foundStatement; + + if (actualSpaces > 0) { + /* + * Abbreviate the message if the expected indentation is also spaces. + * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces' + */ + foundStatement = + indentType === "space" + ? actualSpaces + : `${actualSpaces} ${foundSpacesWord}`; + } else if (actualTabs > 0) { + foundStatement = + indentType === "tab" + ? actualTabs + : `${actualTabs} ${foundTabsWord}`; + } else { + foundStatement = "0"; + } + return { + expected: expectedStatement, + actual: foundStatement, + }; + } + + /** + * Reports a given indent violation + * @param {Token} token Token violating the indent rule + * @param {string} neededIndent Expected indentation string + * @returns {void} + */ + function report(token, neededIndent) { + const actualIndent = Array.from(tokenInfo.getTokenIndent(token)); + const numSpaces = actualIndent.filter(char => char === " ").length; + const numTabs = actualIndent.filter(char => char === "\t").length; + + context.report({ + node: token, + messageId: "wrongIndentation", + data: createErrorMessageData( + neededIndent.length, + numSpaces, + numTabs, + ), + loc: { + start: { line: token.loc.start.line, column: 0 }, + end: { + line: token.loc.start.line, + column: token.loc.start.column, + }, + }, + fix(fixer) { + const range = [ + token.range[0] - token.loc.start.column, + token.range[0], + ]; + const newText = neededIndent; + + return fixer.replaceTextRange(range, newText); + }, + }); + } + + /** + * Checks if a token's indentation is correct + * @param {Token} token Token to examine + * @param {string} desiredIndent Desired indentation of the string + * @returns {boolean} `true` if the token's indentation is correct + */ + function validateTokenIndent(token, desiredIndent) { + const indentation = tokenInfo.getTokenIndent(token); + + return ( + indentation === desiredIndent || + // To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed spaces and tabs. + (indentation.includes(" ") && indentation.includes("\t")) + ); + } + + /** + * Check to see if the node is a file level IIFE + * @param {ASTNode} node The function node to check. + * @returns {boolean} True if the node is the outer IIFE + */ + function isOuterIIFE(node) { + /* + * Verify that the node is an IIFE + */ + if ( + !node.parent || + node.parent.type !== "CallExpression" || + node.parent.callee !== node + ) { + return false; + } + + /* + * Navigate legal ancestors to determine whether this IIFE is outer. + * A "legal ancestor" is an expression or statement that causes the function to get executed immediately. + * For example, `!(function(){})()` is an outer IIFE even though it is preceded by a ! operator. + */ + let statement = node.parent && node.parent.parent; + + while ( + (statement.type === "UnaryExpression" && + ["!", "~", "+", "-"].includes(statement.operator)) || + statement.type === "AssignmentExpression" || + statement.type === "LogicalExpression" || + statement.type === "SequenceExpression" || + statement.type === "VariableDeclarator" + ) { + statement = statement.parent; + } + + return ( + (statement.type === "ExpressionStatement" || + statement.type === "VariableDeclaration") && + statement.parent.type === "Program" + ); + } + + /** + * Counts the number of linebreaks that follow the last non-whitespace character in a string + * @param {string} string The string to check + * @returns {number} The number of JavaScript linebreaks that follow the last non-whitespace character, + * or the total number of linebreaks if the string is all whitespace. + */ + function countTrailingLinebreaks(string) { + const trailingWhitespace = string.match(/\s*$/u)[0]; + const linebreakMatches = trailingWhitespace.match( + astUtils.createGlobalLinebreakMatcher(), + ); + + return linebreakMatches === null ? 0 : linebreakMatches.length; + } + + /** + * Check indentation for lists of elements (arrays, objects, function params) + * @param {ASTNode[]} elements List of elements that should be offset + * @param {Token} startToken The start token of the list that element should be aligned against, e.g. '[' + * @param {Token} endToken The end token of the list, e.g. ']' + * @param {number|string} offset The amount that the elements should be offset + * @returns {void} + */ + function addElementListIndent(elements, startToken, endToken, offset) { + /** + * Gets the first token of a given element, including surrounding parentheses. + * @param {ASTNode} element A node in the `elements` list + * @returns {Token} The first token of this element + */ + function getFirstToken(element) { + let token = sourceCode.getTokenBefore(element); + + while ( + astUtils.isOpeningParenToken(token) && + token !== startToken + ) { + token = sourceCode.getTokenBefore(token); + } + return sourceCode.getTokenAfter(token); + } + + // Run through all the tokens in the list, and offset them by one indent level (mainly for comments, other things will end up overridden) + offsets.setDesiredOffsets( + [startToken.range[1], endToken.range[0]], + startToken, + typeof offset === "number" ? offset : 1, + ); + offsets.setDesiredOffset(endToken, startToken, 0); + + // If the preference is "first" but there is no first element (e.g. sparse arrays w/ empty first slot), fall back to 1 level. + if (offset === "first" && elements.length && !elements[0]) { + return; + } + elements.forEach((element, index) => { + if (!element) { + // Skip holes in arrays + return; + } + if (offset === "off") { + // Ignore the first token of every element if the "off" option is used + offsets.ignoreToken(getFirstToken(element)); + } + + // Offset the following elements correctly relative to the first element + if (index === 0) { + return; + } + if ( + offset === "first" && + tokenInfo.isFirstTokenOfLine(getFirstToken(element)) + ) { + offsets.matchOffsetOf( + getFirstToken(elements[0]), + getFirstToken(element), + ); + } else { + const previousElement = elements[index - 1]; + const firstTokenOfPreviousElement = + previousElement && getFirstToken(previousElement); + const previousElementLastToken = + previousElement && + sourceCode.getLastToken(previousElement); + + if ( + previousElement && + previousElementLastToken.loc.end.line - + countTrailingLinebreaks( + previousElementLastToken.value, + ) > + startToken.loc.end.line + ) { + offsets.setDesiredOffsets( + [previousElement.range[1], element.range[1]], + firstTokenOfPreviousElement, + 0, + ); + } + } + }); + } + + /** + * Check and decide whether to check for indentation for blockless nodes + * Scenarios are for or while statements without braces around them + * @param {ASTNode} node node to examine + * @returns {void} + */ + function addBlocklessNodeIndent(node) { + if (node.type !== "BlockStatement") { + const lastParentToken = sourceCode.getTokenBefore( + node, + astUtils.isNotOpeningParenToken, + ); + + let firstBodyToken = sourceCode.getFirstToken(node); + let lastBodyToken = sourceCode.getLastToken(node); + + while ( + astUtils.isOpeningParenToken( + sourceCode.getTokenBefore(firstBodyToken), + ) && + astUtils.isClosingParenToken( + sourceCode.getTokenAfter(lastBodyToken), + ) + ) { + firstBodyToken = sourceCode.getTokenBefore(firstBodyToken); + lastBodyToken = sourceCode.getTokenAfter(lastBodyToken); + } + + offsets.setDesiredOffsets( + [firstBodyToken.range[0], lastBodyToken.range[1]], + lastParentToken, + 1, + ); + } + } + + /** + * Checks the indentation for nodes that are like function calls (`CallExpression` and `NewExpression`) + * @param {ASTNode} node A CallExpression or NewExpression node + * @returns {void} + */ + function addFunctionCallIndent(node) { + let openingParen; + + if (node.arguments.length) { + openingParen = sourceCode.getFirstTokenBetween( + node.callee, + node.arguments[0], + astUtils.isOpeningParenToken, + ); + } else { + openingParen = sourceCode.getLastToken(node, 1); + } + const closingParen = sourceCode.getLastToken(node); + + parameterParens.add(openingParen); + parameterParens.add(closingParen); + + /* + * If `?.` token exists, set desired offset for that. + * This logic is copied from `MemberExpression`'s. + */ + if (node.optional) { + const dotToken = sourceCode.getTokenAfter( + node.callee, + astUtils.isQuestionDotToken, + ); + const calleeParenCount = sourceCode.getTokensBetween( + node.callee, + dotToken, + { filter: astUtils.isClosingParenToken }, + ).length; + const firstTokenOfCallee = calleeParenCount + ? sourceCode.getTokenBefore(node.callee, { + skip: calleeParenCount - 1, + }) + : sourceCode.getFirstToken(node.callee); + const lastTokenOfCallee = sourceCode.getTokenBefore(dotToken); + const offsetBase = + lastTokenOfCallee.loc.end.line === + openingParen.loc.start.line + ? lastTokenOfCallee + : firstTokenOfCallee; + + offsets.setDesiredOffset(dotToken, offsetBase, 1); + } + + const offsetAfterToken = + node.callee.type === "TaggedTemplateExpression" + ? sourceCode.getFirstToken(node.callee.quasi) + : openingParen; + const offsetToken = sourceCode.getTokenBefore(offsetAfterToken); + + offsets.setDesiredOffset(openingParen, offsetToken, 0); + + addElementListIndent( + node.arguments, + openingParen, + closingParen, + options.CallExpression.arguments, + ); + } + + /** + * Checks the indentation of parenthesized values, given a list of tokens in a program + * @param {Token[]} tokens A list of tokens + * @returns {void} + */ + function addParensIndent(tokens) { + const parenStack = []; + const parenPairs = []; + + for (let i = 0; i < tokens.length; i++) { + const nextToken = tokens[i]; + + if (astUtils.isOpeningParenToken(nextToken)) { + parenStack.push(nextToken); + } else if (astUtils.isClosingParenToken(nextToken)) { + parenPairs.push({ + left: parenStack.pop(), + right: nextToken, + }); + } + } + + for (let i = parenPairs.length - 1; i >= 0; i--) { + const leftParen = parenPairs[i].left; + const rightParen = parenPairs[i].right; + + // We only want to handle parens around expressions, so exclude parentheses that are in function parameters and function call arguments. + if ( + !parameterParens.has(leftParen) && + !parameterParens.has(rightParen) + ) { + const parenthesizedTokens = new Set( + sourceCode.getTokensBetween(leftParen, rightParen), + ); + + parenthesizedTokens.forEach(token => { + if ( + !parenthesizedTokens.has( + offsets.getFirstDependency(token), + ) + ) { + offsets.setDesiredOffset(token, leftParen, 1); + } + }); + } + + offsets.setDesiredOffset(rightParen, leftParen, 0); + } + } + + /** + * Ignore all tokens within an unknown node whose offset do not depend + * on another token's offset within the unknown node + * @param {ASTNode} node Unknown Node + * @returns {void} + */ + function ignoreNode(node) { + const unknownNodeTokens = new Set( + sourceCode.getTokens(node, { includeComments: true }), + ); + + unknownNodeTokens.forEach(token => { + if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) { + const firstTokenOfLine = + tokenInfo.getFirstTokenOfLine(token); + + if (token === firstTokenOfLine) { + offsets.ignoreToken(token); + } else { + offsets.setDesiredOffset(token, firstTokenOfLine, 0); + } + } + }); + } + + /** + * Check whether the given token is on the first line of a statement. + * @param {Token} token The token to check. + * @param {ASTNode} leafNode The expression node that the token belongs directly. + * @returns {boolean} `true` if the token is on the first line of a statement. + */ + function isOnFirstLineOfStatement(token, leafNode) { + let node = leafNode; + + while ( + node.parent && + !node.parent.type.endsWith("Statement") && + !node.parent.type.endsWith("Declaration") + ) { + node = node.parent; + } + node = node.parent; + + return !node || node.loc.start.line === token.loc.start.line; + } + + /** + * Check whether there are any blank (whitespace-only) lines between + * two tokens on separate lines. + * @param {Token} firstToken The first token. + * @param {Token} secondToken The second token. + * @returns {boolean} `true` if the tokens are on separate lines and + * there exists a blank line between them, `false` otherwise. + */ + function hasBlankLinesBetween(firstToken, secondToken) { + const firstTokenLine = firstToken.loc.end.line; + const secondTokenLine = secondToken.loc.start.line; + + if ( + firstTokenLine === secondTokenLine || + firstTokenLine === secondTokenLine - 1 + ) { + return false; + } + + for ( + let line = firstTokenLine + 1; + line < secondTokenLine; + ++line + ) { + if (!tokenInfo.firstTokensByLineNumber.has(line)) { + return true; + } + } + + return false; + } + + const ignoredNodeFirstTokens = new Set(); + + const baseOffsetListeners = { + "ArrayExpression, ArrayPattern"(node) { + const openingBracket = sourceCode.getFirstToken(node); + const closingBracket = sourceCode.getTokenAfter( + [...node.elements].reverse().find(_ => _) || openingBracket, + astUtils.isClosingBracketToken, + ); + + addElementListIndent( + node.elements, + openingBracket, + closingBracket, + options.ArrayExpression, + ); + }, + + "ObjectExpression, ObjectPattern"(node) { + const openingCurly = sourceCode.getFirstToken(node); + const closingCurly = sourceCode.getTokenAfter( + node.properties.length + ? node.properties.at(-1) + : openingCurly, + astUtils.isClosingBraceToken, + ); + + addElementListIndent( + node.properties, + openingCurly, + closingCurly, + options.ObjectExpression, + ); + }, + + ArrowFunctionExpression(node) { + const maybeOpeningParen = sourceCode.getFirstToken(node, { + skip: node.async ? 1 : 0, + }); + + if (astUtils.isOpeningParenToken(maybeOpeningParen)) { + const openingParen = maybeOpeningParen; + const closingParen = sourceCode.getTokenBefore( + node.body, + astUtils.isClosingParenToken, + ); + + parameterParens.add(openingParen); + parameterParens.add(closingParen); + addElementListIndent( + node.params, + openingParen, + closingParen, + options.FunctionExpression.parameters, + ); + } + + addBlocklessNodeIndent(node.body); + }, + + AssignmentExpression(node) { + const operator = sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + + offsets.setDesiredOffsets( + [operator.range[0], node.range[1]], + sourceCode.getLastToken(node.left), + 1, + ); + offsets.ignoreToken(operator); + offsets.ignoreToken(sourceCode.getTokenAfter(operator)); + }, + + "BinaryExpression, LogicalExpression"(node) { + const operator = sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + + /* + * For backwards compatibility, don't check BinaryExpression indents, e.g. + * var foo = bar && + * baz; + */ + + const tokenAfterOperator = sourceCode.getTokenAfter(operator); + + offsets.ignoreToken(operator); + offsets.ignoreToken(tokenAfterOperator); + offsets.setDesiredOffset(tokenAfterOperator, operator, 0); + }, + + "BlockStatement, ClassBody"(node) { + let blockIndentLevel; + + if (node.parent && isOuterIIFE(node.parent)) { + blockIndentLevel = options.outerIIFEBody; + } else if ( + node.parent && + (node.parent.type === "FunctionExpression" || + node.parent.type === "ArrowFunctionExpression") + ) { + blockIndentLevel = options.FunctionExpression.body; + } else if ( + node.parent && + node.parent.type === "FunctionDeclaration" + ) { + blockIndentLevel = options.FunctionDeclaration.body; + } else { + blockIndentLevel = 1; + } + + /* + * For blocks that aren't lone statements, ensure that the opening curly brace + * is aligned with the parent. + */ + if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) { + offsets.setDesiredOffset( + sourceCode.getFirstToken(node), + sourceCode.getFirstToken(node.parent), + 0, + ); + } + + addElementListIndent( + node.body, + sourceCode.getFirstToken(node), + sourceCode.getLastToken(node), + blockIndentLevel, + ); + }, + + CallExpression: addFunctionCallIndent, + + "ClassDeclaration[superClass], ClassExpression[superClass]"(node) { + const classToken = sourceCode.getFirstToken(node); + const extendsToken = sourceCode.getTokenBefore( + node.superClass, + astUtils.isNotOpeningParenToken, + ); + + offsets.setDesiredOffsets( + [extendsToken.range[0], node.body.range[0]], + classToken, + 1, + ); + }, + + ConditionalExpression(node) { + const firstToken = sourceCode.getFirstToken(node); + + // `flatTernaryExpressions` option is for the following style: + // var a = + // foo > 0 ? bar : + // foo < 0 ? baz : + // /*else*/ qiz ; + if ( + !options.flatTernaryExpressions || + !astUtils.isTokenOnSameLine(node.test, node.consequent) || + isOnFirstLineOfStatement(firstToken, node) + ) { + const questionMarkToken = sourceCode.getFirstTokenBetween( + node.test, + node.consequent, + token => + token.type === "Punctuator" && token.value === "?", + ); + const colonToken = sourceCode.getFirstTokenBetween( + node.consequent, + node.alternate, + token => + token.type === "Punctuator" && token.value === ":", + ); + + const firstConsequentToken = + sourceCode.getTokenAfter(questionMarkToken); + const lastConsequentToken = + sourceCode.getTokenBefore(colonToken); + const firstAlternateToken = + sourceCode.getTokenAfter(colonToken); + + offsets.setDesiredOffset(questionMarkToken, firstToken, 1); + offsets.setDesiredOffset(colonToken, firstToken, 1); + + offsets.setDesiredOffset( + firstConsequentToken, + firstToken, + firstConsequentToken.type === "Punctuator" && + options.offsetTernaryExpressions + ? 2 + : 1, + ); + + /* + * The alternate and the consequent should usually have the same indentation. + * If they share part of a line, align the alternate against the first token of the consequent. + * This allows the alternate to be indented correctly in cases like this: + * foo ? ( + * bar + * ) : ( // this '(' is aligned with the '(' above, so it's considered to be aligned with `foo` + * baz // as a result, `baz` is offset by 1 rather than 2 + * ) + */ + if ( + lastConsequentToken.loc.end.line === + firstAlternateToken.loc.start.line + ) { + offsets.setDesiredOffset( + firstAlternateToken, + firstConsequentToken, + 0, + ); + } else { + /** + * If the alternate and consequent do not share part of a line, offset the alternate from the first + * token of the conditional expression. For example: + * foo ? bar + * : baz + * + * If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up + * having no expected indentation. + */ + offsets.setDesiredOffset( + firstAlternateToken, + firstToken, + firstAlternateToken.type === "Punctuator" && + options.offsetTernaryExpressions + ? 2 + : 1, + ); + } + } + }, + + "DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement, WithStatement": + node => addBlocklessNodeIndent(node.body), + + ExportNamedDeclaration(node) { + if (node.declaration === null) { + const closingCurly = sourceCode.getLastToken( + node, + astUtils.isClosingBraceToken, + ); + + // Indent the specifiers in `export {foo, bar, baz}` + addElementListIndent( + node.specifiers, + sourceCode.getFirstToken(node, { skip: 1 }), + closingCurly, + 1, + ); + + if (node.source) { + // Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'` + offsets.setDesiredOffsets( + [closingCurly.range[1], node.range[1]], + sourceCode.getFirstToken(node), + 1, + ); + } + } + }, + + ForStatement(node) { + const forOpeningParen = sourceCode.getFirstToken(node, 1); + + if (node.init) { + offsets.setDesiredOffsets( + node.init.range, + forOpeningParen, + 1, + ); + } + if (node.test) { + offsets.setDesiredOffsets( + node.test.range, + forOpeningParen, + 1, + ); + } + if (node.update) { + offsets.setDesiredOffsets( + node.update.range, + forOpeningParen, + 1, + ); + } + addBlocklessNodeIndent(node.body); + }, + + "FunctionDeclaration, FunctionExpression"(node) { + const closingParen = sourceCode.getTokenBefore(node.body); + const openingParen = sourceCode.getTokenBefore( + node.params.length ? node.params[0] : closingParen, + ); + + parameterParens.add(openingParen); + parameterParens.add(closingParen); + addElementListIndent( + node.params, + openingParen, + closingParen, + options[node.type].parameters, + ); + }, + + IfStatement(node) { + addBlocklessNodeIndent(node.consequent); + if (node.alternate) { + addBlocklessNodeIndent(node.alternate); + } + }, + + /* + * For blockless nodes with semicolon-first style, don't indent the semicolon. + * e.g. + * if (foo) + * bar() + * ; [1, 2, 3].map(foo) + * + * Traversal into the node sets indentation of the semicolon, so we need to override it on exit. + */ + ":matches(DoWhileStatement, ForStatement, ForInStatement, ForOfStatement, IfStatement, WhileStatement, WithStatement):exit"( + node, + ) { + let nodesToCheck; + + if (node.type === "IfStatement") { + nodesToCheck = [node.consequent]; + if (node.alternate) { + nodesToCheck.push(node.alternate); + } + } else { + nodesToCheck = [node.body]; + } + + for (const nodeToCheck of nodesToCheck) { + const lastToken = sourceCode.getLastToken(nodeToCheck); + + if (astUtils.isSemicolonToken(lastToken)) { + const tokenBeforeLast = + sourceCode.getTokenBefore(lastToken); + const tokenAfterLast = + sourceCode.getTokenAfter(lastToken); + + // override indentation of `;` only if its line looks like a semicolon-first style line + if ( + !astUtils.isTokenOnSameLine( + tokenBeforeLast, + lastToken, + ) && + tokenAfterLast && + astUtils.isTokenOnSameLine( + lastToken, + tokenAfterLast, + ) + ) { + offsets.setDesiredOffset( + lastToken, + sourceCode.getFirstToken(node), + 0, + ); + } + } + } + }, + + ImportDeclaration(node) { + if ( + node.specifiers.some( + specifier => specifier.type === "ImportSpecifier", + ) + ) { + const openingCurly = sourceCode.getFirstToken( + node, + astUtils.isOpeningBraceToken, + ); + const closingCurly = sourceCode.getLastToken( + node, + astUtils.isClosingBraceToken, + ); + + addElementListIndent( + node.specifiers.filter( + specifier => specifier.type === "ImportSpecifier", + ), + openingCurly, + closingCurly, + options.ImportDeclaration, + ); + } + + const fromToken = sourceCode.getLastToken( + node, + token => + token.type === "Identifier" && token.value === "from", + ); + const sourceToken = sourceCode.getLastToken( + node, + token => token.type === "String", + ); + const semiToken = sourceCode.getLastToken( + node, + token => token.type === "Punctuator" && token.value === ";", + ); + + if (fromToken) { + const end = + semiToken && semiToken.range[1] === sourceToken.range[1] + ? node.range[1] + : sourceToken.range[1]; + + offsets.setDesiredOffsets( + [fromToken.range[0], end], + sourceCode.getFirstToken(node), + 1, + ); + } + }, + + ImportExpression(node) { + const openingParen = sourceCode.getFirstToken(node, 1); + const closingParen = sourceCode.getLastToken(node); + + parameterParens.add(openingParen); + parameterParens.add(closingParen); + offsets.setDesiredOffset( + openingParen, + sourceCode.getTokenBefore(openingParen), + 0, + ); + + addElementListIndent( + [node.source], + openingParen, + closingParen, + options.CallExpression.arguments, + ); + }, + + "MemberExpression, JSXMemberExpression, MetaProperty"(node) { + const object = + node.type === "MetaProperty" ? node.meta : node.object; + const firstNonObjectToken = sourceCode.getFirstTokenBetween( + object, + node.property, + astUtils.isNotClosingParenToken, + ); + const secondNonObjectToken = + sourceCode.getTokenAfter(firstNonObjectToken); + + const objectParenCount = sourceCode.getTokensBetween( + object, + node.property, + { filter: astUtils.isClosingParenToken }, + ).length; + const firstObjectToken = objectParenCount + ? sourceCode.getTokenBefore(object, { + skip: objectParenCount - 1, + }) + : sourceCode.getFirstToken(object); + const lastObjectToken = + sourceCode.getTokenBefore(firstNonObjectToken); + const firstPropertyToken = node.computed + ? firstNonObjectToken + : secondNonObjectToken; + + if (node.computed) { + // For computed MemberExpressions, match the closing bracket with the opening bracket. + offsets.setDesiredOffset( + sourceCode.getLastToken(node), + firstNonObjectToken, + 0, + ); + offsets.setDesiredOffsets( + node.property.range, + firstNonObjectToken, + 1, + ); + } + + /* + * If the object ends on the same line that the property starts, match against the last token + * of the object, to ensure that the MemberExpression is not indented. + * + * Otherwise, match against the first token of the object, e.g. + * foo + * .bar + * .baz // <-- offset by 1 from `foo` + */ + const offsetBase = + lastObjectToken.loc.end.line === + firstPropertyToken.loc.start.line + ? lastObjectToken + : firstObjectToken; + + if (typeof options.MemberExpression === "number") { + // Match the dot (for non-computed properties) or the opening bracket (for computed properties) against the object. + offsets.setDesiredOffset( + firstNonObjectToken, + offsetBase, + options.MemberExpression, + ); + + /* + * For computed MemberExpressions, match the first token of the property against the opening bracket. + * Otherwise, match the first token of the property against the object. + */ + offsets.setDesiredOffset( + secondNonObjectToken, + node.computed ? firstNonObjectToken : offsetBase, + options.MemberExpression, + ); + } else { + // If the MemberExpression option is off, ignore the dot and the first token of the property. + offsets.ignoreToken(firstNonObjectToken); + offsets.ignoreToken(secondNonObjectToken); + + // To ignore the property indentation, ensure that the property tokens depend on the ignored tokens. + offsets.setDesiredOffset( + firstNonObjectToken, + offsetBase, + 0, + ); + offsets.setDesiredOffset( + secondNonObjectToken, + firstNonObjectToken, + 0, + ); + } + }, + + NewExpression(node) { + // Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo` + if ( + node.arguments.length > 0 || + (astUtils.isClosingParenToken( + sourceCode.getLastToken(node), + ) && + astUtils.isOpeningParenToken( + sourceCode.getLastToken(node, 1), + )) + ) { + addFunctionCallIndent(node); + } + }, + + Property(node) { + if (!node.shorthand && !node.method && node.kind === "init") { + const colon = sourceCode.getFirstTokenBetween( + node.key, + node.value, + astUtils.isColonToken, + ); + + offsets.ignoreToken(sourceCode.getTokenAfter(colon)); + } + }, + + PropertyDefinition(node) { + const firstToken = sourceCode.getFirstToken(node); + const maybeSemicolonToken = sourceCode.getLastToken(node); + let keyLastToken; + + // Indent key. + if (node.computed) { + const bracketTokenL = sourceCode.getTokenBefore( + node.key, + astUtils.isOpeningBracketToken, + ); + const bracketTokenR = (keyLastToken = + sourceCode.getTokenAfter( + node.key, + astUtils.isClosingBracketToken, + )); + const keyRange = [ + bracketTokenL.range[1], + bracketTokenR.range[0], + ]; + + if (bracketTokenL !== firstToken) { + offsets.setDesiredOffset(bracketTokenL, firstToken, 0); + } + offsets.setDesiredOffsets(keyRange, bracketTokenL, 1); + offsets.setDesiredOffset(bracketTokenR, bracketTokenL, 0); + } else { + const idToken = (keyLastToken = sourceCode.getFirstToken( + node.key, + )); + + if (idToken !== firstToken) { + offsets.setDesiredOffset(idToken, firstToken, 1); + } + } + + // Indent initializer. + if (node.value) { + const eqToken = sourceCode.getTokenBefore( + node.value, + astUtils.isEqToken, + ); + const valueToken = sourceCode.getTokenAfter(eqToken); + + offsets.setDesiredOffset(eqToken, keyLastToken, 1); + offsets.setDesiredOffset(valueToken, eqToken, 1); + if (astUtils.isSemicolonToken(maybeSemicolonToken)) { + offsets.setDesiredOffset( + maybeSemicolonToken, + eqToken, + 1, + ); + } + } else if (astUtils.isSemicolonToken(maybeSemicolonToken)) { + offsets.setDesiredOffset( + maybeSemicolonToken, + keyLastToken, + 1, + ); + } + }, + + StaticBlock(node) { + const openingCurly = sourceCode.getFirstToken(node, { + skip: 1, + }); // skip the `static` token + const closingCurly = sourceCode.getLastToken(node); + + addElementListIndent( + node.body, + openingCurly, + closingCurly, + options.StaticBlock.body, + ); + }, + + SwitchStatement(node) { + const openingCurly = sourceCode.getTokenAfter( + node.discriminant, + astUtils.isOpeningBraceToken, + ); + const closingCurly = sourceCode.getLastToken(node); + + offsets.setDesiredOffsets( + [openingCurly.range[1], closingCurly.range[0]], + openingCurly, + options.SwitchCase, + ); + + if (node.cases.length) { + sourceCode + .getTokensBetween(node.cases.at(-1), closingCurly, { + includeComments: true, + filter: astUtils.isCommentToken, + }) + .forEach(token => offsets.ignoreToken(token)); + } + }, + + SwitchCase(node) { + if (!( + node.consequent.length === 1 && + node.consequent[0].type === "BlockStatement" + )) { + const caseKeyword = sourceCode.getFirstToken(node); + const tokenAfterCurrentCase = + sourceCode.getTokenAfter(node); + + offsets.setDesiredOffsets( + [caseKeyword.range[1], tokenAfterCurrentCase.range[0]], + caseKeyword, + 1, + ); + } + }, + + TemplateLiteral(node) { + node.expressions.forEach((expression, index) => { + const previousQuasi = node.quasis[index]; + const nextQuasi = node.quasis[index + 1]; + const tokenToAlignFrom = + previousQuasi.loc.start.line === + previousQuasi.loc.end.line + ? sourceCode.getFirstToken(previousQuasi) + : null; + + offsets.setDesiredOffsets( + [previousQuasi.range[1], nextQuasi.range[0]], + tokenToAlignFrom, + 1, + ); + offsets.setDesiredOffset( + sourceCode.getFirstToken(nextQuasi), + tokenToAlignFrom, + 0, + ); + }); + }, + + VariableDeclaration(node) { + let variableIndent = Object.hasOwn( + options.VariableDeclarator, + node.kind, + ) + ? options.VariableDeclarator[node.kind] + : DEFAULT_VARIABLE_INDENT; + + const firstToken = sourceCode.getFirstToken(node), + lastToken = sourceCode.getLastToken(node); + + if (options.VariableDeclarator[node.kind] === "first") { + if (node.declarations.length > 1) { + addElementListIndent( + node.declarations, + firstToken, + lastToken, + "first", + ); + return; + } + + variableIndent = DEFAULT_VARIABLE_INDENT; + } + + if ( + node.declarations.at(-1).loc.start.line > + node.loc.start.line + ) { + /* + * VariableDeclarator indentation is a bit different from other forms of indentation, in that the + * indentation of an opening bracket sometimes won't match that of a closing bracket. For example, + * the following indentations are correct: + * + * var foo = { + * ok: true + * }; + * + * var foo = { + * ok: true, + * }, + * bar = 1; + * + * Account for when exiting the AST (after indentations have already been set for the nodes in + * the declaration) by manually increasing the indentation level of the tokens in this declarator + * on the same line as the start of the declaration, provided that there are declarators that + * follow this one. + */ + offsets.setDesiredOffsets( + node.range, + firstToken, + variableIndent, + true, + ); + } else { + offsets.setDesiredOffsets( + node.range, + firstToken, + variableIndent, + ); + } + + if (astUtils.isSemicolonToken(lastToken)) { + offsets.ignoreToken(lastToken); + } + }, + + VariableDeclarator(node) { + if (node.init) { + const equalOperator = sourceCode.getTokenBefore( + node.init, + astUtils.isNotOpeningParenToken, + ); + const tokenAfterOperator = + sourceCode.getTokenAfter(equalOperator); + + offsets.ignoreToken(equalOperator); + offsets.ignoreToken(tokenAfterOperator); + offsets.setDesiredOffsets( + [tokenAfterOperator.range[0], node.range[1]], + equalOperator, + 1, + ); + offsets.setDesiredOffset( + equalOperator, + sourceCode.getLastToken(node.id), + 0, + ); + } + }, + + "JSXAttribute[value]"(node) { + const equalsToken = sourceCode.getFirstTokenBetween( + node.name, + node.value, + token => token.type === "Punctuator" && token.value === "=", + ); + + offsets.setDesiredOffsets( + [equalsToken.range[0], node.value.range[1]], + sourceCode.getFirstToken(node.name), + 1, + ); + }, + + JSXElement(node) { + if (node.closingElement) { + addElementListIndent( + node.children, + sourceCode.getFirstToken(node.openingElement), + sourceCode.getFirstToken(node.closingElement), + 1, + ); + } + }, + + JSXOpeningElement(node) { + const firstToken = sourceCode.getFirstToken(node); + let closingToken; + + if (node.selfClosing) { + closingToken = sourceCode.getLastToken(node, { skip: 1 }); + offsets.setDesiredOffset( + sourceCode.getLastToken(node), + closingToken, + 0, + ); + } else { + closingToken = sourceCode.getLastToken(node); + } + offsets.setDesiredOffsets( + node.name.range, + sourceCode.getFirstToken(node), + ); + addElementListIndent( + node.attributes, + firstToken, + closingToken, + 1, + ); + }, + + JSXClosingElement(node) { + const firstToken = sourceCode.getFirstToken(node); + + offsets.setDesiredOffsets(node.name.range, firstToken, 1); + }, + + JSXFragment(node) { + const firstOpeningToken = sourceCode.getFirstToken( + node.openingFragment, + ); + const firstClosingToken = sourceCode.getFirstToken( + node.closingFragment, + ); + + addElementListIndent( + node.children, + firstOpeningToken, + firstClosingToken, + 1, + ); + }, + + JSXOpeningFragment(node) { + const firstToken = sourceCode.getFirstToken(node); + const closingToken = sourceCode.getLastToken(node); + + offsets.setDesiredOffsets(node.range, firstToken, 1); + offsets.matchOffsetOf(firstToken, closingToken); + }, + + JSXClosingFragment(node) { + const firstToken = sourceCode.getFirstToken(node); + const slashToken = sourceCode.getLastToken(node, { skip: 1 }); + const closingToken = sourceCode.getLastToken(node); + const tokenToMatch = astUtils.isTokenOnSameLine( + slashToken, + closingToken, + ) + ? slashToken + : closingToken; + + offsets.setDesiredOffsets(node.range, firstToken, 1); + offsets.matchOffsetOf(firstToken, tokenToMatch); + }, + + JSXExpressionContainer(node) { + const openingCurly = sourceCode.getFirstToken(node); + const closingCurly = sourceCode.getLastToken(node); + + offsets.setDesiredOffsets( + [openingCurly.range[1], closingCurly.range[0]], + openingCurly, + 1, + ); + }, + + JSXSpreadAttribute(node) { + const openingCurly = sourceCode.getFirstToken(node); + const closingCurly = sourceCode.getLastToken(node); + + offsets.setDesiredOffsets( + [openingCurly.range[1], closingCurly.range[0]], + openingCurly, + 1, + ); + }, + + "*"(node) { + const firstToken = sourceCode.getFirstToken(node); + + // Ensure that the children of every node are indented at least as much as the first token. + if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) { + offsets.setDesiredOffsets(node.range, firstToken, 0); + } + }, + }; + + const listenerCallQueue = []; + + /* + * To ignore the indentation of a node: + * 1. Don't call the node's listener when entering it (if it has a listener) + * 2. Don't set any offsets against the first token of the node. + * 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets. + */ + const offsetListeners = {}; + + for (const [selector, listener] of Object.entries( + baseOffsetListeners, + )) { + /* + * Offset listener calls are deferred until traversal is finished, and are called as + * part of the final `Program:exit` listener. This is necessary because a node might + * be matched by multiple selectors. + * + * Example: Suppose there is an offset listener for `Identifier`, and the user has + * specified in configuration that `MemberExpression > Identifier` should be ignored. + * Due to selector specificity rules, the `Identifier` listener will get called first. However, + * if a given Identifier node is supposed to be ignored, then the `Identifier` offset listener + * should not have been called at all. Without doing extra selector matching, we don't know + * whether the Identifier matches the `MemberExpression > Identifier` selector until the + * `MemberExpression > Identifier` listener is called. + * + * To avoid this, the `Identifier` listener isn't called until traversal finishes and all + * ignored nodes are known. + */ + offsetListeners[selector] = node => + listenerCallQueue.push({ listener, node }); + } + + // For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set. + const ignoredNodes = new Set(); + + /** + * Ignores a node + * @param {ASTNode} node The node to ignore + * @returns {void} + */ + function addToIgnoredNodes(node) { + ignoredNodes.add(node); + ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node)); + } + + const ignoredNodeListeners = options.ignoredNodes.reduce( + (listeners, ignoredSelector) => + Object.assign(listeners, { + [ignoredSelector]: addToIgnoredNodes, + }), + {}, + ); + + /* + * Join the listeners, and add a listener to verify that all tokens actually have the correct indentation + * at the end. + * + * Using Object.assign will cause some offset listeners to be overwritten if the same selector also appears + * in `ignoredNodeListeners`. This isn't a problem because all of the matching nodes will be ignored, + * so those listeners wouldn't be called anyway. + */ + return Object.assign(offsetListeners, ignoredNodeListeners, { + "*:exit"(node) { + // If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it. + if (!KNOWN_NODES.has(node.type)) { + addToIgnoredNodes(node); + } + }, + "Program:exit"() { + // If ignoreComments option is enabled, ignore all comment tokens. + if (options.ignoreComments) { + sourceCode + .getAllComments() + .forEach(comment => offsets.ignoreToken(comment)); + } + + // Invoke the queued offset listeners for the nodes that aren't ignored. + for (let i = 0; i < listenerCallQueue.length; i++) { + const nodeInfo = listenerCallQueue[i]; + + if (!ignoredNodes.has(nodeInfo.node)) { + nodeInfo.listener(nodeInfo.node); + } + } + + // Update the offsets for ignored nodes to prevent their child tokens from being reported. + ignoredNodes.forEach(ignoreNode); + + addParensIndent(sourceCode.ast.tokens); + + /* + * Create a Map from (tokenOrComment) => (precedingToken). + * This is necessary because sourceCode.getTokenBefore does not handle a comment as an argument correctly. + */ + const precedingTokens = new WeakMap(); + + for (let i = 0; i < sourceCode.ast.comments.length; i++) { + const comment = sourceCode.ast.comments[i]; + + const tokenOrCommentBefore = sourceCode.getTokenBefore( + comment, + { includeComments: true }, + ); + const hasToken = precedingTokens.has(tokenOrCommentBefore) + ? precedingTokens.get(tokenOrCommentBefore) + : tokenOrCommentBefore; + + precedingTokens.set(comment, hasToken); + } + + for (let i = 1; i < sourceCode.lines.length + 1; i++) { + if (!tokenInfo.firstTokensByLineNumber.has(i)) { + // Don't check indentation on blank lines + continue; + } + + const firstTokenOfLine = + tokenInfo.firstTokensByLineNumber.get(i); + + if (firstTokenOfLine.loc.start.line !== i) { + // Don't check the indentation of multi-line tokens (e.g. template literals or block comments) twice. + continue; + } + + if (astUtils.isCommentToken(firstTokenOfLine)) { + const tokenBefore = + precedingTokens.get(firstTokenOfLine); + const tokenAfter = tokenBefore + ? sourceCode.getTokenAfter(tokenBefore) + : sourceCode.ast.tokens[0]; + const mayAlignWithBefore = + tokenBefore && + !hasBlankLinesBetween( + tokenBefore, + firstTokenOfLine, + ); + const mayAlignWithAfter = + tokenAfter && + !hasBlankLinesBetween(firstTokenOfLine, tokenAfter); + + /* + * If a comment precedes a line that begins with a semicolon token, align to that token, i.e. + * + * let foo + * // comment + * ;(async () => {})() + */ + if ( + tokenAfter && + astUtils.isSemicolonToken(tokenAfter) && + !astUtils.isTokenOnSameLine( + firstTokenOfLine, + tokenAfter, + ) + ) { + offsets.setDesiredOffset( + firstTokenOfLine, + tokenAfter, + 0, + ); + } + + // If a comment matches the expected indentation of the token immediately before or after, don't report it. + if ( + (mayAlignWithBefore && + validateTokenIndent( + firstTokenOfLine, + offsets.getDesiredIndent(tokenBefore), + )) || + (mayAlignWithAfter && + validateTokenIndent( + firstTokenOfLine, + offsets.getDesiredIndent(tokenAfter), + )) + ) { + continue; + } + } + + // If the token matches the expected indentation, don't report it. + if ( + validateTokenIndent( + firstTokenOfLine, + offsets.getDesiredIndent(firstTokenOfLine), + ) + ) { + continue; + } + + // Otherwise, report the token/comment. + report( + firstTokenOfLine, + offsets.getDesiredIndent(firstTokenOfLine), + ); + } + }, + }); + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/index.js new file mode 100644 index 00000000..a750e087 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/index.js @@ -0,0 +1,332 @@ +/** + * @fileoverview Collects the built-in rules into a map structure so that they can be imported all at once and without + * using the file-system directly. + * @author Peter (Somogyvari) Metz + */ + +"use strict"; + +/* eslint sort-keys: ["error", "asc"] -- More readable for long list */ + +const { LazyLoadingRuleMap } = require("./utils/lazy-loading-rule-map"); + +/** @type {Map} */ +module.exports = new LazyLoadingRuleMap( + Object.entries({ + "accessor-pairs": () => require("./accessor-pairs"), + "array-bracket-newline": () => require("./array-bracket-newline"), + "array-bracket-spacing": () => require("./array-bracket-spacing"), + "array-callback-return": () => require("./array-callback-return"), + "array-element-newline": () => require("./array-element-newline"), + "arrow-body-style": () => require("./arrow-body-style"), + "arrow-parens": () => require("./arrow-parens"), + "arrow-spacing": () => require("./arrow-spacing"), + "block-scoped-var": () => require("./block-scoped-var"), + "block-spacing": () => require("./block-spacing"), + "brace-style": () => require("./brace-style"), + "callback-return": () => require("./callback-return"), + camelcase: () => require("./camelcase"), + "capitalized-comments": () => require("./capitalized-comments"), + "class-methods-use-this": () => require("./class-methods-use-this"), + "comma-dangle": () => require("./comma-dangle"), + "comma-spacing": () => require("./comma-spacing"), + "comma-style": () => require("./comma-style"), + complexity: () => require("./complexity"), + "computed-property-spacing": () => + require("./computed-property-spacing"), + "consistent-return": () => require("./consistent-return"), + "consistent-this": () => require("./consistent-this"), + "constructor-super": () => require("./constructor-super"), + curly: () => require("./curly"), + "default-case": () => require("./default-case"), + "default-case-last": () => require("./default-case-last"), + "default-param-last": () => require("./default-param-last"), + "dot-location": () => require("./dot-location"), + "dot-notation": () => require("./dot-notation"), + "eol-last": () => require("./eol-last"), + eqeqeq: () => require("./eqeqeq"), + "for-direction": () => require("./for-direction"), + "func-call-spacing": () => require("./func-call-spacing"), + "func-name-matching": () => require("./func-name-matching"), + "func-names": () => require("./func-names"), + "func-style": () => require("./func-style"), + "function-call-argument-newline": () => + require("./function-call-argument-newline"), + "function-paren-newline": () => require("./function-paren-newline"), + "generator-star-spacing": () => require("./generator-star-spacing"), + "getter-return": () => require("./getter-return"), + "global-require": () => require("./global-require"), + "grouped-accessor-pairs": () => require("./grouped-accessor-pairs"), + "guard-for-in": () => require("./guard-for-in"), + "handle-callback-err": () => require("./handle-callback-err"), + "id-blacklist": () => require("./id-blacklist"), + "id-denylist": () => require("./id-denylist"), + "id-length": () => require("./id-length"), + "id-match": () => require("./id-match"), + "implicit-arrow-linebreak": () => require("./implicit-arrow-linebreak"), + indent: () => require("./indent"), + "indent-legacy": () => require("./indent-legacy"), + "init-declarations": () => require("./init-declarations"), + "jsx-quotes": () => require("./jsx-quotes"), + "key-spacing": () => require("./key-spacing"), + "keyword-spacing": () => require("./keyword-spacing"), + "line-comment-position": () => require("./line-comment-position"), + "linebreak-style": () => require("./linebreak-style"), + "lines-around-comment": () => require("./lines-around-comment"), + "lines-around-directive": () => require("./lines-around-directive"), + "lines-between-class-members": () => + require("./lines-between-class-members"), + "logical-assignment-operators": () => + require("./logical-assignment-operators"), + "max-classes-per-file": () => require("./max-classes-per-file"), + "max-depth": () => require("./max-depth"), + "max-len": () => require("./max-len"), + "max-lines": () => require("./max-lines"), + "max-lines-per-function": () => require("./max-lines-per-function"), + "max-nested-callbacks": () => require("./max-nested-callbacks"), + "max-params": () => require("./max-params"), + "max-statements": () => require("./max-statements"), + "max-statements-per-line": () => require("./max-statements-per-line"), + "multiline-comment-style": () => require("./multiline-comment-style"), + "multiline-ternary": () => require("./multiline-ternary"), + "new-cap": () => require("./new-cap"), + "new-parens": () => require("./new-parens"), + "newline-after-var": () => require("./newline-after-var"), + "newline-before-return": () => require("./newline-before-return"), + "newline-per-chained-call": () => require("./newline-per-chained-call"), + "no-alert": () => require("./no-alert"), + "no-array-constructor": () => require("./no-array-constructor"), + "no-async-promise-executor": () => + require("./no-async-promise-executor"), + "no-await-in-loop": () => require("./no-await-in-loop"), + "no-bitwise": () => require("./no-bitwise"), + "no-buffer-constructor": () => require("./no-buffer-constructor"), + "no-caller": () => require("./no-caller"), + "no-case-declarations": () => require("./no-case-declarations"), + "no-catch-shadow": () => require("./no-catch-shadow"), + "no-class-assign": () => require("./no-class-assign"), + "no-compare-neg-zero": () => require("./no-compare-neg-zero"), + "no-cond-assign": () => require("./no-cond-assign"), + "no-confusing-arrow": () => require("./no-confusing-arrow"), + "no-console": () => require("./no-console"), + "no-const-assign": () => require("./no-const-assign"), + "no-constant-binary-expression": () => + require("./no-constant-binary-expression"), + "no-constant-condition": () => require("./no-constant-condition"), + "no-constructor-return": () => require("./no-constructor-return"), + "no-continue": () => require("./no-continue"), + "no-control-regex": () => require("./no-control-regex"), + "no-debugger": () => require("./no-debugger"), + "no-delete-var": () => require("./no-delete-var"), + "no-div-regex": () => require("./no-div-regex"), + "no-dupe-args": () => require("./no-dupe-args"), + "no-dupe-class-members": () => require("./no-dupe-class-members"), + "no-dupe-else-if": () => require("./no-dupe-else-if"), + "no-dupe-keys": () => require("./no-dupe-keys"), + "no-duplicate-case": () => require("./no-duplicate-case"), + "no-duplicate-imports": () => require("./no-duplicate-imports"), + "no-else-return": () => require("./no-else-return"), + "no-empty": () => require("./no-empty"), + "no-empty-character-class": () => require("./no-empty-character-class"), + "no-empty-function": () => require("./no-empty-function"), + "no-empty-pattern": () => require("./no-empty-pattern"), + "no-empty-static-block": () => require("./no-empty-static-block"), + "no-eq-null": () => require("./no-eq-null"), + "no-eval": () => require("./no-eval"), + "no-ex-assign": () => require("./no-ex-assign"), + "no-extend-native": () => require("./no-extend-native"), + "no-extra-bind": () => require("./no-extra-bind"), + "no-extra-boolean-cast": () => require("./no-extra-boolean-cast"), + "no-extra-label": () => require("./no-extra-label"), + "no-extra-parens": () => require("./no-extra-parens"), + "no-extra-semi": () => require("./no-extra-semi"), + "no-fallthrough": () => require("./no-fallthrough"), + "no-floating-decimal": () => require("./no-floating-decimal"), + "no-func-assign": () => require("./no-func-assign"), + "no-global-assign": () => require("./no-global-assign"), + "no-implicit-coercion": () => require("./no-implicit-coercion"), + "no-implicit-globals": () => require("./no-implicit-globals"), + "no-implied-eval": () => require("./no-implied-eval"), + "no-import-assign": () => require("./no-import-assign"), + "no-inline-comments": () => require("./no-inline-comments"), + "no-inner-declarations": () => require("./no-inner-declarations"), + "no-invalid-regexp": () => require("./no-invalid-regexp"), + "no-invalid-this": () => require("./no-invalid-this"), + "no-irregular-whitespace": () => require("./no-irregular-whitespace"), + "no-iterator": () => require("./no-iterator"), + "no-label-var": () => require("./no-label-var"), + "no-labels": () => require("./no-labels"), + "no-lone-blocks": () => require("./no-lone-blocks"), + "no-lonely-if": () => require("./no-lonely-if"), + "no-loop-func": () => require("./no-loop-func"), + "no-loss-of-precision": () => require("./no-loss-of-precision"), + "no-magic-numbers": () => require("./no-magic-numbers"), + "no-misleading-character-class": () => + require("./no-misleading-character-class"), + "no-mixed-operators": () => require("./no-mixed-operators"), + "no-mixed-requires": () => require("./no-mixed-requires"), + "no-mixed-spaces-and-tabs": () => require("./no-mixed-spaces-and-tabs"), + "no-multi-assign": () => require("./no-multi-assign"), + "no-multi-spaces": () => require("./no-multi-spaces"), + "no-multi-str": () => require("./no-multi-str"), + "no-multiple-empty-lines": () => require("./no-multiple-empty-lines"), + "no-native-reassign": () => require("./no-native-reassign"), + "no-negated-condition": () => require("./no-negated-condition"), + "no-negated-in-lhs": () => require("./no-negated-in-lhs"), + "no-nested-ternary": () => require("./no-nested-ternary"), + "no-new": () => require("./no-new"), + "no-new-func": () => require("./no-new-func"), + "no-new-native-nonconstructor": () => + require("./no-new-native-nonconstructor"), + "no-new-object": () => require("./no-new-object"), + "no-new-require": () => require("./no-new-require"), + "no-new-symbol": () => require("./no-new-symbol"), + "no-new-wrappers": () => require("./no-new-wrappers"), + "no-nonoctal-decimal-escape": () => + require("./no-nonoctal-decimal-escape"), + "no-obj-calls": () => require("./no-obj-calls"), + "no-object-constructor": () => require("./no-object-constructor"), + "no-octal": () => require("./no-octal"), + "no-octal-escape": () => require("./no-octal-escape"), + "no-param-reassign": () => require("./no-param-reassign"), + "no-path-concat": () => require("./no-path-concat"), + "no-plusplus": () => require("./no-plusplus"), + "no-process-env": () => require("./no-process-env"), + "no-process-exit": () => require("./no-process-exit"), + "no-promise-executor-return": () => + require("./no-promise-executor-return"), + "no-proto": () => require("./no-proto"), + "no-prototype-builtins": () => require("./no-prototype-builtins"), + "no-redeclare": () => require("./no-redeclare"), + "no-regex-spaces": () => require("./no-regex-spaces"), + "no-restricted-exports": () => require("./no-restricted-exports"), + "no-restricted-globals": () => require("./no-restricted-globals"), + "no-restricted-imports": () => require("./no-restricted-imports"), + "no-restricted-modules": () => require("./no-restricted-modules"), + "no-restricted-properties": () => require("./no-restricted-properties"), + "no-restricted-syntax": () => require("./no-restricted-syntax"), + "no-return-assign": () => require("./no-return-assign"), + "no-return-await": () => require("./no-return-await"), + "no-script-url": () => require("./no-script-url"), + "no-self-assign": () => require("./no-self-assign"), + "no-self-compare": () => require("./no-self-compare"), + "no-sequences": () => require("./no-sequences"), + "no-setter-return": () => require("./no-setter-return"), + "no-shadow": () => require("./no-shadow"), + "no-shadow-restricted-names": () => + require("./no-shadow-restricted-names"), + "no-spaced-func": () => require("./no-spaced-func"), + "no-sparse-arrays": () => require("./no-sparse-arrays"), + "no-sync": () => require("./no-sync"), + "no-tabs": () => require("./no-tabs"), + "no-template-curly-in-string": () => + require("./no-template-curly-in-string"), + "no-ternary": () => require("./no-ternary"), + "no-this-before-super": () => require("./no-this-before-super"), + "no-throw-literal": () => require("./no-throw-literal"), + "no-trailing-spaces": () => require("./no-trailing-spaces"), + "no-unassigned-vars": () => require("./no-unassigned-vars"), + "no-undef": () => require("./no-undef"), + "no-undef-init": () => require("./no-undef-init"), + "no-undefined": () => require("./no-undefined"), + "no-underscore-dangle": () => require("./no-underscore-dangle"), + "no-unexpected-multiline": () => require("./no-unexpected-multiline"), + "no-unmodified-loop-condition": () => + require("./no-unmodified-loop-condition"), + "no-unneeded-ternary": () => require("./no-unneeded-ternary"), + "no-unreachable": () => require("./no-unreachable"), + "no-unreachable-loop": () => require("./no-unreachable-loop"), + "no-unsafe-finally": () => require("./no-unsafe-finally"), + "no-unsafe-negation": () => require("./no-unsafe-negation"), + "no-unsafe-optional-chaining": () => + require("./no-unsafe-optional-chaining"), + "no-unused-expressions": () => require("./no-unused-expressions"), + "no-unused-labels": () => require("./no-unused-labels"), + "no-unused-private-class-members": () => + require("./no-unused-private-class-members"), + "no-unused-vars": () => require("./no-unused-vars"), + "no-use-before-define": () => require("./no-use-before-define"), + "no-useless-assignment": () => require("./no-useless-assignment"), + "no-useless-backreference": () => require("./no-useless-backreference"), + "no-useless-call": () => require("./no-useless-call"), + "no-useless-catch": () => require("./no-useless-catch"), + "no-useless-computed-key": () => require("./no-useless-computed-key"), + "no-useless-concat": () => require("./no-useless-concat"), + "no-useless-constructor": () => require("./no-useless-constructor"), + "no-useless-escape": () => require("./no-useless-escape"), + "no-useless-rename": () => require("./no-useless-rename"), + "no-useless-return": () => require("./no-useless-return"), + "no-var": () => require("./no-var"), + "no-void": () => require("./no-void"), + "no-warning-comments": () => require("./no-warning-comments"), + "no-whitespace-before-property": () => + require("./no-whitespace-before-property"), + "no-with": () => require("./no-with"), + "nonblock-statement-body-position": () => + require("./nonblock-statement-body-position"), + "object-curly-newline": () => require("./object-curly-newline"), + "object-curly-spacing": () => require("./object-curly-spacing"), + "object-property-newline": () => require("./object-property-newline"), + "object-shorthand": () => require("./object-shorthand"), + "one-var": () => require("./one-var"), + "one-var-declaration-per-line": () => + require("./one-var-declaration-per-line"), + "operator-assignment": () => require("./operator-assignment"), + "operator-linebreak": () => require("./operator-linebreak"), + "padded-blocks": () => require("./padded-blocks"), + "padding-line-between-statements": () => + require("./padding-line-between-statements"), + "prefer-arrow-callback": () => require("./prefer-arrow-callback"), + "prefer-const": () => require("./prefer-const"), + "prefer-destructuring": () => require("./prefer-destructuring"), + "prefer-exponentiation-operator": () => + require("./prefer-exponentiation-operator"), + "prefer-named-capture-group": () => + require("./prefer-named-capture-group"), + "prefer-numeric-literals": () => require("./prefer-numeric-literals"), + "prefer-object-has-own": () => require("./prefer-object-has-own"), + "prefer-object-spread": () => require("./prefer-object-spread"), + "prefer-promise-reject-errors": () => + require("./prefer-promise-reject-errors"), + "prefer-reflect": () => require("./prefer-reflect"), + "prefer-regex-literals": () => require("./prefer-regex-literals"), + "prefer-rest-params": () => require("./prefer-rest-params"), + "prefer-spread": () => require("./prefer-spread"), + "prefer-template": () => require("./prefer-template"), + "preserve-caught-error": () => require("./preserve-caught-error"), + "quote-props": () => require("./quote-props"), + quotes: () => require("./quotes"), + radix: () => require("./radix"), + "require-atomic-updates": () => require("./require-atomic-updates"), + "require-await": () => require("./require-await"), + "require-unicode-regexp": () => require("./require-unicode-regexp"), + "require-yield": () => require("./require-yield"), + "rest-spread-spacing": () => require("./rest-spread-spacing"), + semi: () => require("./semi"), + "semi-spacing": () => require("./semi-spacing"), + "semi-style": () => require("./semi-style"), + "sort-imports": () => require("./sort-imports"), + "sort-keys": () => require("./sort-keys"), + "sort-vars": () => require("./sort-vars"), + "space-before-blocks": () => require("./space-before-blocks"), + "space-before-function-paren": () => + require("./space-before-function-paren"), + "space-in-parens": () => require("./space-in-parens"), + "space-infix-ops": () => require("./space-infix-ops"), + "space-unary-ops": () => require("./space-unary-ops"), + "spaced-comment": () => require("./spaced-comment"), + strict: () => require("./strict"), + "switch-colon-spacing": () => require("./switch-colon-spacing"), + "symbol-description": () => require("./symbol-description"), + "template-curly-spacing": () => require("./template-curly-spacing"), + "template-tag-spacing": () => require("./template-tag-spacing"), + "unicode-bom": () => require("./unicode-bom"), + "use-isnan": () => require("./use-isnan"), + "valid-typeof": () => require("./valid-typeof"), + "vars-on-top": () => require("./vars-on-top"), + "wrap-iife": () => require("./wrap-iife"), + "wrap-regex": () => require("./wrap-regex"), + "yield-star-spacing": () => require("./yield-star-spacing"), + yoda: () => require("./yoda"), + }), +); diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/init-declarations.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/init-declarations.js new file mode 100644 index 00000000..c182f15c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/init-declarations.js @@ -0,0 +1,171 @@ +/** + * @fileoverview A rule to control the style of variable initializations. + * @author Colin Ihrig + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]); + +/** + * Checks whether or not a given node is a for loop. + * @param {ASTNode} block A node to check. + * @returns {boolean} `true` when the node is a for loop. + */ +function isForLoop(block) { + return ( + block.type === "ForInStatement" || + block.type === "ForOfStatement" || + block.type === "ForStatement" + ); +} + +/** + * Checks whether or not a given declarator node has its initializer. + * @param {ASTNode} node A declarator node to check. + * @returns {boolean} `true` when the node has its initializer. + */ +function isInitialized(node) { + const declaration = node.parent; + const block = declaration.parent; + + if (isForLoop(block)) { + if (block.type === "ForStatement") { + return block.init === declaration; + } + return block.left === declaration; + } + return Boolean(node.init); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require or disallow initialization in variable declarations", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/init-declarations", + }, + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["always"], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["never"], + }, + { + type: "object", + properties: { + ignoreForLoopInit: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + defaultOptions: ["always"], + + messages: { + initialized: + "Variable '{{idName}}' should be initialized on declaration.", + notInitialized: + "Variable '{{idName}}' should not be initialized on declaration.", + }, + }, + + create(context) { + const mode = context.options[0]; + const params = context.options[1] || {}; + + // Track whether we're inside a declared namespace + let insideDeclaredNamespace = false; + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + TSModuleDeclaration(node) { + if (node.declare) { + insideDeclaredNamespace = true; + } + }, + + "TSModuleDeclaration:exit"(node) { + if (node.declare) { + insideDeclaredNamespace = false; + } + }, + + "VariableDeclaration:exit"(node) { + const kind = node.kind, + declarations = node.declarations; + + if (node.declare || insideDeclaredNamespace) { + return; + } + + for (let i = 0; i < declarations.length; ++i) { + const declaration = declarations[i], + id = declaration.id, + initialized = isInitialized(declaration), + isIgnoredForLoop = + params.ignoreForLoopInit && isForLoop(node.parent); + let messageId = ""; + + if (mode === "always" && !initialized) { + messageId = "initialized"; + } else if ( + mode === "never" && + !CONSTANT_BINDINGS.has(kind) && + initialized && + !isIgnoredForLoop + ) { + messageId = "notInitialized"; + } + + if (id.type === "Identifier" && messageId) { + context.report({ + node: declaration, + messageId, + data: { + idName: id.name, + }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/jsx-quotes.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/jsx-quotes.js new file mode 100644 index 00000000..f435d9cb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/jsx-quotes.js @@ -0,0 +1,128 @@ +/** + * @fileoverview A rule to ensure consistent quotes used in jsx syntax. + * @author Mathias Schreck + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const QUOTE_SETTINGS = { + "prefer-double": { + quote: '"', + description: "singlequote", + convert(str) { + return str.replace(/'/gu, '"'); + }, + }, + "prefer-single": { + quote: "'", + description: "doublequote", + convert(str) { + return str.replace(/"/gu, "'"); + }, + }, +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "jsx-quotes", + url: "https://eslint.style/rules/jsx-quotes", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce the consistent use of either double or single quotes in JSX attributes", + recommended: false, + url: "https://eslint.org/docs/latest/rules/jsx-quotes", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["prefer-single", "prefer-double"], + }, + ], + messages: { + unexpected: "Unexpected usage of {{description}}.", + }, + }, + + create(context) { + const quoteOption = context.options[0] || "prefer-double", + setting = QUOTE_SETTINGS[quoteOption]; + + /** + * Checks if the given string literal node uses the expected quotes + * @param {ASTNode} node A string literal node. + * @returns {boolean} Whether or not the string literal used the expected quotes. + * @public + */ + function usesExpectedQuotes(node) { + return ( + node.value.includes(setting.quote) || + astUtils.isSurroundedBy(node.raw, setting.quote) + ); + } + + return { + JSXAttribute(node) { + const attributeValue = node.value; + + if ( + attributeValue && + astUtils.isStringLiteral(attributeValue) && + !usesExpectedQuotes(attributeValue) + ) { + context.report({ + node: attributeValue, + messageId: "unexpected", + data: { + description: setting.description, + }, + fix(fixer) { + return fixer.replaceText( + attributeValue, + setting.convert(attributeValue.raw), + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/key-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/key-spacing.js new file mode 100644 index 00000000..c36d2c83 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/key-spacing.js @@ -0,0 +1,820 @@ +/** + * @fileoverview Rule to specify spacing of object literal keys and values + * @author Brandon Mills + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { getGraphemeCount } = require("../shared/string-utils"); + +/** + * Checks whether a string contains a line terminator as defined in + * https://262.ecma-international.org/5.1/#sec-7.3 + * @param {string} str String to test. + * @returns {boolean} True if str contains a line terminator. + */ +function containsLineTerminator(str) { + return astUtils.LINEBREAK_MATCHER.test(str); +} + +/** + * Gets the last element of an array. + * @param {Array} arr An array. + * @returns {any} Last element of arr. + */ +function last(arr) { + return arr.at(-1); +} + +/** + * Checks whether a node is contained on a single line. + * @param {ASTNode} node AST Node being evaluated. + * @returns {boolean} True if the node is a single line. + */ +function isSingleLine(node) { + return node.loc.end.line === node.loc.start.line; +} + +/** + * Checks whether the properties on a single line. + * @param {ASTNode[]} properties List of Property AST nodes. + * @returns {boolean} True if all properties is on a single line. + */ +function isSingleLineProperties(properties) { + const [firstProp] = properties, + lastProp = last(properties); + + return firstProp.loc.start.line === lastProp.loc.end.line; +} + +/** + * Initializes a single option property from the configuration with defaults for undefined values + * @param {Object} toOptions Object to be initialized + * @param {Object} fromOptions Object to be initialized from + * @returns {Object} The object with correctly initialized options and values + */ +function initOptionProperty(toOptions, fromOptions) { + toOptions.mode = fromOptions.mode || "strict"; + + // Set value of beforeColon + if (typeof fromOptions.beforeColon !== "undefined") { + toOptions.beforeColon = +fromOptions.beforeColon; + } else { + toOptions.beforeColon = 0; + } + + // Set value of afterColon + if (typeof fromOptions.afterColon !== "undefined") { + toOptions.afterColon = +fromOptions.afterColon; + } else { + toOptions.afterColon = 1; + } + + // Set align if exists + if (typeof fromOptions.align !== "undefined") { + if (typeof fromOptions.align === "object") { + toOptions.align = fromOptions.align; + } else { + // "string" + toOptions.align = { + on: fromOptions.align, + mode: toOptions.mode, + beforeColon: toOptions.beforeColon, + afterColon: toOptions.afterColon, + }; + } + } + + return toOptions; +} + +/** + * Initializes all the option values (singleLine, multiLine and align) from the configuration with defaults for undefined values + * @param {Object} toOptions Object to be initialized + * @param {Object} fromOptions Object to be initialized from + * @returns {Object} The object with correctly initialized options and values + */ +function initOptions(toOptions, fromOptions) { + if (typeof fromOptions.align === "object") { + // Initialize the alignment configuration + toOptions.align = initOptionProperty({}, fromOptions.align); + toOptions.align.on = fromOptions.align.on || "colon"; + toOptions.align.mode = fromOptions.align.mode || "strict"; + + toOptions.multiLine = initOptionProperty( + {}, + fromOptions.multiLine || fromOptions, + ); + toOptions.singleLine = initOptionProperty( + {}, + fromOptions.singleLine || fromOptions, + ); + } else { + // string or undefined + toOptions.multiLine = initOptionProperty( + {}, + fromOptions.multiLine || fromOptions, + ); + toOptions.singleLine = initOptionProperty( + {}, + fromOptions.singleLine || fromOptions, + ); + + // If alignment options are defined in multiLine, pull them out into the general align configuration + if (toOptions.multiLine.align) { + toOptions.align = { + on: toOptions.multiLine.align.on, + mode: + toOptions.multiLine.align.mode || toOptions.multiLine.mode, + beforeColon: toOptions.multiLine.align.beforeColon, + afterColon: toOptions.multiLine.align.afterColon, + }; + } + } + + return toOptions; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "key-spacing", + url: "https://eslint.style/rules/key-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing between keys and values in object literal properties", + recommended: false, + url: "https://eslint.org/docs/latest/rules/key-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + anyOf: [ + { + type: "object", + properties: { + align: { + anyOf: [ + { + enum: ["colon", "value"], + }, + { + type: "object", + properties: { + mode: { + enum: ["strict", "minimum"], + }, + on: { + enum: ["colon", "value"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + mode: { + enum: ["strict", "minimum"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + singleLine: { + type: "object", + properties: { + mode: { + enum: ["strict", "minimum"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + multiLine: { + type: "object", + properties: { + align: { + anyOf: [ + { + enum: ["colon", "value"], + }, + { + type: "object", + properties: { + mode: { + enum: [ + "strict", + "minimum", + ], + }, + on: { + enum: [ + "colon", + "value", + ], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + mode: { + enum: ["strict", "minimum"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + singleLine: { + type: "object", + properties: { + mode: { + enum: ["strict", "minimum"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + multiLine: { + type: "object", + properties: { + mode: { + enum: ["strict", "minimum"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + align: { + type: "object", + properties: { + mode: { + enum: ["strict", "minimum"], + }, + on: { + enum: ["colon", "value"], + }, + beforeColon: { + type: "boolean", + }, + afterColon: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + messages: { + extraKey: "Extra space after {{computed}}key '{{key}}'.", + extraValue: + "Extra space before value for {{computed}}key '{{key}}'.", + missingKey: "Missing space after {{computed}}key '{{key}}'.", + missingValue: + "Missing space before value for {{computed}}key '{{key}}'.", + }, + }, + + create(context) { + /** + * OPTIONS + * "key-spacing": [2, { + * beforeColon: false, + * afterColon: true, + * align: "colon" // Optional, or "value" + * } + */ + const options = context.options[0] || {}, + ruleOptions = initOptions({}, options), + multiLineOptions = ruleOptions.multiLine, + singleLineOptions = ruleOptions.singleLine, + alignmentOptions = ruleOptions.align || null; + + const sourceCode = context.sourceCode; + + /** + * Determines if the given property is key-value property. + * @param {ASTNode} property Property node to check. + * @returns {boolean} Whether the property is a key-value property. + */ + function isKeyValueProperty(property) { + return !( + property.method || + property.shorthand || + property.kind !== "init" || + property.type !== "Property" // Could be "ExperimentalSpreadProperty" or "SpreadElement" + ); + } + + /** + * Starting from the given node (a property.key node here) looks forward + * until it finds the colon punctuator and returns it. + * @param {ASTNode} node The node to start looking from. + * @returns {ASTNode} The colon punctuator. + */ + function getNextColon(node) { + return sourceCode.getTokenAfter(node, astUtils.isColonToken); + } + + /** + * Starting from the given node (a property.key node here) looks forward + * until it finds the last token before a colon punctuator and returns it. + * @param {ASTNode} node The node to start looking from. + * @returns {ASTNode} The last token before a colon punctuator. + */ + function getLastTokenBeforeColon(node) { + const colonToken = getNextColon(node); + + return sourceCode.getTokenBefore(colonToken); + } + + /** + * Starting from the given node (a property.key node here) looks forward + * until it finds the first token after a colon punctuator and returns it. + * @param {ASTNode} node The node to start looking from. + * @returns {ASTNode} The first token after a colon punctuator. + */ + function getFirstTokenAfterColon(node) { + const colonToken = getNextColon(node); + + return sourceCode.getTokenAfter(colonToken); + } + + /** + * Checks whether a property is a member of the property group it follows. + * @param {ASTNode} lastMember The last Property known to be in the group. + * @param {ASTNode} candidate The next Property that might be in the group. + * @returns {boolean} True if the candidate property is part of the group. + */ + function continuesPropertyGroup(lastMember, candidate) { + const groupEndLine = lastMember.loc.start.line, + candidateValueStartLine = ( + isKeyValueProperty(candidate) + ? getFirstTokenAfterColon(candidate.key) + : candidate + ).loc.start.line; + + if (candidateValueStartLine - groupEndLine <= 1) { + return true; + } + + /* + * Check that the first comment is adjacent to the end of the group, the + * last comment is adjacent to the candidate property, and that successive + * comments are adjacent to each other. + */ + const leadingComments = sourceCode.getCommentsBefore(candidate); + + if ( + leadingComments.length && + leadingComments[0].loc.start.line - groupEndLine <= 1 && + candidateValueStartLine - last(leadingComments).loc.end.line <= + 1 + ) { + for (let i = 1; i < leadingComments.length; i++) { + if ( + leadingComments[i].loc.start.line - + leadingComments[i - 1].loc.end.line > + 1 + ) { + return false; + } + } + return true; + } + + return false; + } + + /** + * Gets an object literal property's key as the identifier name or string value. + * @param {ASTNode} property Property node whose key to retrieve. + * @returns {string} The property's key. + */ + function getKey(property) { + const key = property.key; + + if (property.computed) { + return sourceCode.getText().slice(key.range[0], key.range[1]); + } + return astUtils.getStaticPropertyName(property); + } + + /** + * Reports an appropriately-formatted error if spacing is incorrect on one + * side of the colon. + * @param {ASTNode} property Key-value pair in an object literal. + * @param {string} side Side being verified - either "key" or "value". + * @param {string} whitespace Actual whitespace string. + * @param {number} expected Expected whitespace length. + * @param {string} mode Value of the mode as "strict" or "minimum" + * @returns {void} + */ + function report(property, side, whitespace, expected, mode) { + const diff = whitespace.length - expected; + + if ( + ((diff && mode === "strict") || + (diff < 0 && mode === "minimum") || + (diff > 0 && !expected && mode === "minimum")) && + !(expected && containsLineTerminator(whitespace)) + ) { + const nextColon = getNextColon(property.key), + tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { + includeComments: true, + }), + tokenAfterColon = sourceCode.getTokenAfter(nextColon, { + includeComments: true, + }), + isKeySide = side === "key", + isExtra = diff > 0, + diffAbs = Math.abs(diff), + spaces = Array(diffAbs + 1).join(" "); + + const locStart = isKeySide + ? tokenBeforeColon.loc.end + : nextColon.loc.start; + const locEnd = isKeySide + ? nextColon.loc.start + : tokenAfterColon.loc.start; + const missingLoc = isKeySide + ? tokenBeforeColon.loc + : tokenAfterColon.loc; + const loc = isExtra + ? { start: locStart, end: locEnd } + : missingLoc; + + let fix; + + if (isExtra) { + let range; + + // Remove whitespace + if (isKeySide) { + range = [ + tokenBeforeColon.range[1], + tokenBeforeColon.range[1] + diffAbs, + ]; + } else { + range = [ + tokenAfterColon.range[0] - diffAbs, + tokenAfterColon.range[0], + ]; + } + fix = function (fixer) { + return fixer.removeRange(range); + }; + } else { + // Add whitespace + if (isKeySide) { + fix = function (fixer) { + return fixer.insertTextAfter( + tokenBeforeColon, + spaces, + ); + }; + } else { + fix = function (fixer) { + return fixer.insertTextBefore( + tokenAfterColon, + spaces, + ); + }; + } + } + + let messageId; + + if (isExtra) { + messageId = side === "key" ? "extraKey" : "extraValue"; + } else { + messageId = side === "key" ? "missingKey" : "missingValue"; + } + + context.report({ + node: property[side], + loc, + messageId, + data: { + computed: property.computed ? "computed " : "", + key: getKey(property), + }, + fix, + }); + } + } + + /** + * Gets the number of characters in a key, including quotes around string + * keys and braces around computed property keys. + * @param {ASTNode} property Property of on object literal. + * @returns {number} Width of the key. + */ + function getKeyWidth(property) { + const startToken = sourceCode.getFirstToken(property); + const endToken = getLastTokenBeforeColon(property.key); + + return getGraphemeCount( + sourceCode + .getText() + .slice(startToken.range[0], endToken.range[1]), + ); + } + + /** + * Gets the whitespace around the colon in an object literal property. + * @param {ASTNode} property Property node from an object literal. + * @returns {Object} Whitespace before and after the property's colon. + */ + function getPropertyWhitespace(property) { + const whitespace = /(\s*):(\s*)/u.exec( + sourceCode + .getText() + .slice(property.key.range[1], property.value.range[0]), + ); + + if (whitespace) { + return { + beforeColon: whitespace[1], + afterColon: whitespace[2], + }; + } + return null; + } + + /** + * Creates groups of properties. + * @param {ASTNode} node ObjectExpression node being evaluated. + * @returns {Array} Groups of property AST node lists. + */ + function createGroups(node) { + if (node.properties.length === 1) { + return [node.properties]; + } + + return node.properties.reduce( + (groups, property) => { + const currentGroup = last(groups), + prev = last(currentGroup); + + if (!prev || continuesPropertyGroup(prev, property)) { + currentGroup.push(property); + } else { + groups.push([property]); + } + + return groups; + }, + [[]], + ); + } + + /** + * Verifies correct vertical alignment of a group of properties. + * @param {ASTNode[]} properties List of Property AST nodes. + * @returns {void} + */ + function verifyGroupAlignment(properties) { + const length = properties.length, + widths = properties.map(getKeyWidth), // Width of keys, including quotes + align = alignmentOptions.on; // "value" or "colon" + let targetWidth = Math.max(...widths), + beforeColon, + afterColon, + mode; + + if (alignmentOptions && length > 1) { + // When aligning values within a group, use the alignment configuration. + beforeColon = alignmentOptions.beforeColon; + afterColon = alignmentOptions.afterColon; + mode = alignmentOptions.mode; + } else { + beforeColon = multiLineOptions.beforeColon; + afterColon = multiLineOptions.afterColon; + mode = alignmentOptions.mode; + } + + // Conditionally include one space before or after colon + targetWidth += align === "colon" ? beforeColon : afterColon; + + for (let i = 0; i < length; i++) { + const property = properties[i]; + const whitespace = getPropertyWhitespace(property); + + if (whitespace) { + // Object literal getters/setters lack a colon + const width = widths[i]; + + if (align === "value") { + report( + property, + "key", + whitespace.beforeColon, + beforeColon, + mode, + ); + report( + property, + "value", + whitespace.afterColon, + targetWidth - width, + mode, + ); + } else { + // align = "colon" + report( + property, + "key", + whitespace.beforeColon, + targetWidth - width, + mode, + ); + report( + property, + "value", + whitespace.afterColon, + afterColon, + mode, + ); + } + } + } + } + + /** + * Verifies spacing of property conforms to specified options. + * @param {ASTNode} node Property node being evaluated. + * @param {Object} lineOptions Configured singleLine or multiLine options + * @returns {void} + */ + function verifySpacing(node, lineOptions) { + const actual = getPropertyWhitespace(node); + + if (actual) { + // Object literal getters/setters lack colons + report( + node, + "key", + actual.beforeColon, + lineOptions.beforeColon, + lineOptions.mode, + ); + report( + node, + "value", + actual.afterColon, + lineOptions.afterColon, + lineOptions.mode, + ); + } + } + + /** + * Verifies spacing of each property in a list. + * @param {ASTNode[]} properties List of Property AST nodes. + * @param {Object} lineOptions Configured singleLine or multiLine options + * @returns {void} + */ + function verifyListSpacing(properties, lineOptions) { + const length = properties.length; + + for (let i = 0; i < length; i++) { + verifySpacing(properties[i], lineOptions); + } + } + + /** + * Verifies vertical alignment, taking into account groups of properties. + * @param {ASTNode} node ObjectExpression node being evaluated. + * @returns {void} + */ + function verifyAlignment(node) { + createGroups(node).forEach(group => { + const properties = group.filter(isKeyValueProperty); + + if ( + properties.length > 0 && + isSingleLineProperties(properties) + ) { + verifyListSpacing(properties, multiLineOptions); + } else { + verifyGroupAlignment(properties); + } + }); + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + if (alignmentOptions) { + // Verify vertical alignment + + return { + ObjectExpression(node) { + if (isSingleLine(node)) { + verifyListSpacing( + node.properties.filter(isKeyValueProperty), + singleLineOptions, + ); + } else { + verifyAlignment(node); + } + }, + }; + } + + // Obey beforeColon and afterColon in each property as configured + return { + Property(node) { + verifySpacing( + node, + isSingleLine(node.parent) + ? singleLineOptions + : multiLineOptions, + ); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/keyword-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/keyword-spacing.js new file mode 100644 index 00000000..d67008a9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/keyword-spacing.js @@ -0,0 +1,701 @@ +/** + * @fileoverview Rule to enforce spacing before and after keywords. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"), + keywords = require("./utils/keywords"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const PREV_TOKEN = /^[)\]}>]$/u; +const NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/u; +const PREV_TOKEN_M = /^[)\]}>*]$/u; +const NEXT_TOKEN_M = /^[{*]$/u; +const TEMPLATE_OPEN_PAREN = /\$\{$/u; +const TEMPLATE_CLOSE_PAREN = /^\}/u; +const CHECK_TYPE = + /^(?:JSXElement|RegularExpression|String|Template|PrivateIdentifier)$/u; +const KEYS = keywords.concat([ + "as", + "async", + "await", + "from", + "get", + "let", + "of", + "set", + "yield", +]); + +// check duplications. +(function () { + KEYS.sort(); + for (let i = 1; i < KEYS.length; ++i) { + if (KEYS[i] === KEYS[i - 1]) { + throw new Error( + `Duplication was found in the keyword list: ${KEYS[i]}`, + ); + } + } +})(); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given token is a "Template" token ends with "${". + * @param {Token} token A token to check. + * @returns {boolean} `true` if the token is a "Template" token ends with "${". + */ +function isOpenParenOfTemplate(token) { + return token.type === "Template" && TEMPLATE_OPEN_PAREN.test(token.value); +} + +/** + * Checks whether or not a given token is a "Template" token starts with "}". + * @param {Token} token A token to check. + * @returns {boolean} `true` if the token is a "Template" token starts with "}". + */ +function isCloseParenOfTemplate(token) { + return token.type === "Template" && TEMPLATE_CLOSE_PAREN.test(token.value); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "keyword-spacing", + url: "https://eslint.style/rules/keyword-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing before and after keywords", + recommended: false, + url: "https://eslint.org/docs/latest/rules/keyword-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + before: { type: "boolean", default: true }, + after: { type: "boolean", default: true }, + overrides: { + type: "object", + properties: KEYS.reduce((retv, key) => { + retv[key] = { + type: "object", + properties: { + before: { type: "boolean" }, + after: { type: "boolean" }, + }, + additionalProperties: false, + }; + return retv; + }, {}), + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + messages: { + expectedBefore: 'Expected space(s) before "{{value}}".', + expectedAfter: 'Expected space(s) after "{{value}}".', + unexpectedBefore: 'Unexpected space(s) before "{{value}}".', + unexpectedAfter: 'Unexpected space(s) after "{{value}}".', + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const tokensToIgnore = new WeakSet(); + + /** + * Reports a given token if there are not space(s) before the token. + * @param {Token} token A token to report. + * @param {RegExp} pattern A pattern of the previous token to check. + * @returns {void} + */ + function expectSpaceBefore(token, pattern) { + const prevToken = sourceCode.getTokenBefore(token); + + if ( + prevToken && + (CHECK_TYPE.test(prevToken.type) || + pattern.test(prevToken.value)) && + !isOpenParenOfTemplate(prevToken) && + !tokensToIgnore.has(prevToken) && + astUtils.isTokenOnSameLine(prevToken, token) && + !sourceCode.isSpaceBetween(prevToken, token) + ) { + context.report({ + loc: token.loc, + messageId: "expectedBefore", + data: token, + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + } + + /** + * Reports a given token if there are space(s) before the token. + * @param {Token} token A token to report. + * @param {RegExp} pattern A pattern of the previous token to check. + * @returns {void} + */ + function unexpectSpaceBefore(token, pattern) { + const prevToken = sourceCode.getTokenBefore(token); + + if ( + prevToken && + (CHECK_TYPE.test(prevToken.type) || + pattern.test(prevToken.value)) && + !isOpenParenOfTemplate(prevToken) && + !tokensToIgnore.has(prevToken) && + astUtils.isTokenOnSameLine(prevToken, token) && + sourceCode.isSpaceBetween(prevToken, token) + ) { + context.report({ + loc: { start: prevToken.loc.end, end: token.loc.start }, + messageId: "unexpectedBefore", + data: token, + fix(fixer) { + return fixer.removeRange([ + prevToken.range[1], + token.range[0], + ]); + }, + }); + } + } + + /** + * Reports a given token if there are not space(s) after the token. + * @param {Token} token A token to report. + * @param {RegExp} pattern A pattern of the next token to check. + * @returns {void} + */ + function expectSpaceAfter(token, pattern) { + const nextToken = sourceCode.getTokenAfter(token); + + if ( + nextToken && + (CHECK_TYPE.test(nextToken.type) || + pattern.test(nextToken.value)) && + !isCloseParenOfTemplate(nextToken) && + !tokensToIgnore.has(nextToken) && + astUtils.isTokenOnSameLine(token, nextToken) && + !sourceCode.isSpaceBetween(token, nextToken) + ) { + context.report({ + loc: token.loc, + messageId: "expectedAfter", + data: token, + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + } + + /** + * Reports a given token if there are space(s) after the token. + * @param {Token} token A token to report. + * @param {RegExp} pattern A pattern of the next token to check. + * @returns {void} + */ + function unexpectSpaceAfter(token, pattern) { + const nextToken = sourceCode.getTokenAfter(token); + + if ( + nextToken && + (CHECK_TYPE.test(nextToken.type) || + pattern.test(nextToken.value)) && + !isCloseParenOfTemplate(nextToken) && + !tokensToIgnore.has(nextToken) && + astUtils.isTokenOnSameLine(token, nextToken) && + sourceCode.isSpaceBetween(token, nextToken) + ) { + context.report({ + loc: { start: token.loc.end, end: nextToken.loc.start }, + messageId: "unexpectedAfter", + data: token, + fix(fixer) { + return fixer.removeRange([ + token.range[1], + nextToken.range[0], + ]); + }, + }); + } + } + + /** + * Parses the option object and determines check methods for each keyword. + * @param {Object|undefined} options The option object to parse. + * @returns {Object} - Normalized option object. + * Keys are keywords (there are for every keyword). + * Values are instances of `{"before": function, "after": function}`. + */ + function parseOptions(options = {}) { + const before = options.before !== false; + const after = options.after !== false; + const defaultValue = { + before: before ? expectSpaceBefore : unexpectSpaceBefore, + after: after ? expectSpaceAfter : unexpectSpaceAfter, + }; + const overrides = (options && options.overrides) || {}; + const retv = Object.create(null); + + for (let i = 0; i < KEYS.length; ++i) { + const key = KEYS[i]; + const override = overrides[key]; + + if (override) { + const thisBefore = + "before" in override ? override.before : before; + const thisAfter = + "after" in override ? override.after : after; + + retv[key] = { + before: thisBefore + ? expectSpaceBefore + : unexpectSpaceBefore, + after: thisAfter + ? expectSpaceAfter + : unexpectSpaceAfter, + }; + } else { + retv[key] = defaultValue; + } + } + + return retv; + } + + const checkMethodMap = parseOptions(context.options[0]); + + /** + * Reports a given token if usage of spacing followed by the token is + * invalid. + * @param {Token} token A token to report. + * @param {RegExp} [pattern] Optional. A pattern of the previous + * token to check. + * @returns {void} + */ + function checkSpacingBefore(token, pattern) { + checkMethodMap[token.value].before(token, pattern || PREV_TOKEN); + } + + /** + * Reports a given token if usage of spacing preceded by the token is + * invalid. + * @param {Token} token A token to report. + * @param {RegExp} [pattern] Optional. A pattern of the next + * token to check. + * @returns {void} + */ + function checkSpacingAfter(token, pattern) { + checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN); + } + + /** + * Reports a given token if usage of spacing around the token is invalid. + * @param {Token} token A token to report. + * @returns {void} + */ + function checkSpacingAround(token) { + checkSpacingBefore(token); + checkSpacingAfter(token); + } + + /** + * Reports the first token of a given node if the first token is a keyword + * and usage of spacing around the token is invalid. + * @param {ASTNode|null} node A node to report. + * @returns {void} + */ + function checkSpacingAroundFirstToken(node) { + const firstToken = node && sourceCode.getFirstToken(node); + + if (firstToken && firstToken.type === "Keyword") { + checkSpacingAround(firstToken); + } + } + + /** + * Reports the first token of a given node if the first token is a keyword + * and usage of spacing followed by the token is invalid. + * + * This is used for unary operators (e.g. `typeof`), `function`, and `super`. + * Other rules are handling usage of spacing preceded by those keywords. + * @param {ASTNode|null} node A node to report. + * @returns {void} + */ + function checkSpacingBeforeFirstToken(node) { + const firstToken = node && sourceCode.getFirstToken(node); + + if (firstToken && firstToken.type === "Keyword") { + checkSpacingBefore(firstToken); + } + } + + /** + * Reports the previous token of a given node if the token is a keyword and + * usage of spacing around the token is invalid. + * @param {ASTNode|null} node A node to report. + * @returns {void} + */ + function checkSpacingAroundTokenBefore(node) { + if (node) { + const token = sourceCode.getTokenBefore( + node, + astUtils.isKeywordToken, + ); + + checkSpacingAround(token); + } + } + + /** + * Reports `async` or `function` keywords of a given node if usage of + * spacing around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForFunction(node) { + const firstToken = node && sourceCode.getFirstToken(node); + + if ( + firstToken && + ((firstToken.type === "Keyword" && + firstToken.value === "function") || + firstToken.value === "async") + ) { + checkSpacingBefore(firstToken); + } + } + + /** + * Reports `class` and `extends` keywords of a given node if usage of + * spacing around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForClass(node) { + checkSpacingAroundFirstToken(node); + checkSpacingAroundTokenBefore(node.superClass); + } + + /** + * Reports `if` and `else` keywords of a given node if usage of spacing + * around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForIfStatement(node) { + checkSpacingAroundFirstToken(node); + checkSpacingAroundTokenBefore(node.alternate); + } + + /** + * Reports `try`, `catch`, and `finally` keywords of a given node if usage + * of spacing around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForTryStatement(node) { + checkSpacingAroundFirstToken(node); + checkSpacingAroundFirstToken(node.handler); + checkSpacingAroundTokenBefore(node.finalizer); + } + + /** + * Reports `do` and `while` keywords of a given node if usage of spacing + * around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForDoWhileStatement(node) { + checkSpacingAroundFirstToken(node); + checkSpacingAroundTokenBefore(node.test); + } + + /** + * Reports `for` and `in` keywords of a given node if usage of spacing + * around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForForInStatement(node) { + checkSpacingAroundFirstToken(node); + + const inToken = sourceCode.getTokenBefore( + node.right, + astUtils.isNotOpeningParenToken, + ); + const previousToken = sourceCode.getTokenBefore(inToken); + + if (previousToken.type !== "PrivateIdentifier") { + checkSpacingBefore(inToken); + } + + checkSpacingAfter(inToken); + } + + /** + * Reports `for` and `of` keywords of a given node if usage of spacing + * around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForForOfStatement(node) { + if (node.await) { + checkSpacingBefore(sourceCode.getFirstToken(node, 0)); + checkSpacingAfter(sourceCode.getFirstToken(node, 1)); + } else { + checkSpacingAroundFirstToken(node); + } + + const ofToken = sourceCode.getTokenBefore( + node.right, + astUtils.isNotOpeningParenToken, + ); + const previousToken = sourceCode.getTokenBefore(ofToken); + + if (previousToken.type !== "PrivateIdentifier") { + checkSpacingBefore(ofToken); + } + + checkSpacingAfter(ofToken); + } + + /** + * Reports `import`, `export`, `as`, and `from` keywords of a given node if + * usage of spacing around those keywords is invalid. + * + * This rule handles the `*` token in module declarations. + * + * import*as A from "./a"; /*error Expected space(s) after "import". + * error Expected space(s) before "as". + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForModuleDeclaration(node) { + const firstToken = sourceCode.getFirstToken(node); + + checkSpacingBefore(firstToken, PREV_TOKEN_M); + checkSpacingAfter(firstToken, NEXT_TOKEN_M); + + if (node.type === "ExportDefaultDeclaration") { + checkSpacingAround(sourceCode.getTokenAfter(firstToken)); + } + + if (node.type === "ExportAllDeclaration" && node.exported) { + const asToken = sourceCode.getTokenBefore(node.exported); + + checkSpacingBefore(asToken, PREV_TOKEN_M); + checkSpacingAfter(asToken, NEXT_TOKEN_M); + } + + if (node.source) { + const fromToken = sourceCode.getTokenBefore(node.source); + + checkSpacingBefore(fromToken, PREV_TOKEN_M); + checkSpacingAfter(fromToken, NEXT_TOKEN_M); + } + } + + /** + * Reports `as` keyword of a given node if usage of spacing around this + * keyword is invalid. + * @param {ASTNode} node An `ImportSpecifier` node to check. + * @returns {void} + */ + function checkSpacingForImportSpecifier(node) { + if (node.imported.range[0] !== node.local.range[0]) { + const asToken = sourceCode.getTokenBefore(node.local); + + checkSpacingBefore(asToken, PREV_TOKEN_M); + } + } + + /** + * Reports `as` keyword of a given node if usage of spacing around this + * keyword is invalid. + * @param {ASTNode} node An `ExportSpecifier` node to check. + * @returns {void} + */ + function checkSpacingForExportSpecifier(node) { + if (node.local.range[0] !== node.exported.range[0]) { + const asToken = sourceCode.getTokenBefore(node.exported); + + checkSpacingBefore(asToken, PREV_TOKEN_M); + checkSpacingAfter(asToken, NEXT_TOKEN_M); + } + } + + /** + * Reports `as` keyword of a given node if usage of spacing around this + * keyword is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForImportNamespaceSpecifier(node) { + const asToken = sourceCode.getFirstToken(node, 1); + + checkSpacingBefore(asToken, PREV_TOKEN_M); + } + + /** + * Reports `static`, `get`, and `set` keywords of a given node if usage of + * spacing around those keywords is invalid. + * @param {ASTNode} node A node to report. + * @throws {Error} If unable to find token get, set, or async beside method name. + * @returns {void} + */ + function checkSpacingForProperty(node) { + if (node.static) { + checkSpacingAroundFirstToken(node); + } + if ( + node.kind === "get" || + node.kind === "set" || + ((node.method || node.type === "MethodDefinition") && + node.value.async) + ) { + const token = sourceCode.getTokenBefore(node.key, tok => { + switch (tok.value) { + case "get": + case "set": + case "async": + return true; + default: + return false; + } + }); + + if (!token) { + throw new Error( + "Failed to find token get, set, or async beside method name", + ); + } + + checkSpacingAround(token); + } + } + + /** + * Reports `await` keyword of a given node if usage of spacing before + * this keyword is invalid. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function checkSpacingForAwaitExpression(node) { + checkSpacingBefore(sourceCode.getFirstToken(node)); + } + + return { + // Statements + DebuggerStatement: checkSpacingAroundFirstToken, + WithStatement: checkSpacingAroundFirstToken, + + // Statements - Control flow + BreakStatement: checkSpacingAroundFirstToken, + ContinueStatement: checkSpacingAroundFirstToken, + ReturnStatement: checkSpacingAroundFirstToken, + ThrowStatement: checkSpacingAroundFirstToken, + TryStatement: checkSpacingForTryStatement, + + // Statements - Choice + IfStatement: checkSpacingForIfStatement, + SwitchStatement: checkSpacingAroundFirstToken, + SwitchCase: checkSpacingAroundFirstToken, + + // Statements - Loops + DoWhileStatement: checkSpacingForDoWhileStatement, + ForInStatement: checkSpacingForForInStatement, + ForOfStatement: checkSpacingForForOfStatement, + ForStatement: checkSpacingAroundFirstToken, + WhileStatement: checkSpacingAroundFirstToken, + + // Statements - Declarations + ClassDeclaration: checkSpacingForClass, + ExportNamedDeclaration: checkSpacingForModuleDeclaration, + ExportDefaultDeclaration: checkSpacingForModuleDeclaration, + ExportAllDeclaration: checkSpacingForModuleDeclaration, + FunctionDeclaration: checkSpacingForFunction, + ImportDeclaration: checkSpacingForModuleDeclaration, + VariableDeclaration: checkSpacingAroundFirstToken, + + // Expressions + ArrowFunctionExpression: checkSpacingForFunction, + AwaitExpression: checkSpacingForAwaitExpression, + ClassExpression: checkSpacingForClass, + FunctionExpression: checkSpacingForFunction, + NewExpression: checkSpacingBeforeFirstToken, + Super: checkSpacingBeforeFirstToken, + ThisExpression: checkSpacingBeforeFirstToken, + UnaryExpression: checkSpacingBeforeFirstToken, + YieldExpression: checkSpacingBeforeFirstToken, + + // Others + ImportSpecifier: checkSpacingForImportSpecifier, + ExportSpecifier: checkSpacingForExportSpecifier, + ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier, + MethodDefinition: checkSpacingForProperty, + PropertyDefinition: checkSpacingForProperty, + StaticBlock: checkSpacingAroundFirstToken, + Property: checkSpacingForProperty, + + // To avoid conflicts with `space-infix-ops`, e.g. `a > this.b` + "BinaryExpression[operator='>']"(node) { + const operatorToken = sourceCode.getTokenBefore( + node.right, + astUtils.isNotOpeningParenToken, + ); + + tokensToIgnore.add(operatorToken); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/line-comment-position.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/line-comment-position.js new file mode 100644 index 00000000..6c164033 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/line-comment-position.js @@ -0,0 +1,157 @@ +/** + * @fileoverview Rule to enforce the position of line comments + * @author Alberto Rodríguez + * @deprecated in ESLint v9.3.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "9.3.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "line-comment-position", + url: "https://eslint.style/rules/line-comment-position", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce position of line comments", + recommended: false, + url: "https://eslint.org/docs/latest/rules/line-comment-position", + }, + + schema: [ + { + oneOf: [ + { + enum: ["above", "beside"], + }, + { + type: "object", + properties: { + position: { + enum: ["above", "beside"], + }, + ignorePattern: { + type: "string", + }, + applyDefaultPatterns: { + type: "boolean", + }, + applyDefaultIgnorePatterns: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + messages: { + above: "Expected comment to be above code.", + beside: "Expected comment to be beside code.", + }, + }, + + create(context) { + const options = context.options[0]; + + let above, + ignorePattern, + applyDefaultIgnorePatterns = true; + + if (!options || typeof options === "string") { + above = !options || options === "above"; + } else { + above = !options.position || options.position === "above"; + ignorePattern = options.ignorePattern; + + if (Object.hasOwn(options, "applyDefaultIgnorePatterns")) { + applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns; + } else { + applyDefaultIgnorePatterns = + options.applyDefaultPatterns !== false; + } + } + + const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN; + const fallThroughRegExp = /^\s*falls?\s?through/u; + const customIgnoreRegExp = new RegExp(ignorePattern, "u"); + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program() { + const comments = sourceCode.getAllComments(); + + comments + .filter(token => token.type === "Line") + .forEach(node => { + if ( + applyDefaultIgnorePatterns && + (defaultIgnoreRegExp.test(node.value) || + fallThroughRegExp.test(node.value)) + ) { + return; + } + + if ( + ignorePattern && + customIgnoreRegExp.test(node.value) + ) { + return; + } + + const previous = sourceCode.getTokenBefore(node, { + includeComments: true, + }); + const isOnSameLine = + previous && + previous.loc.end.line === node.loc.start.line; + + if (above) { + if (isOnSameLine) { + context.report({ + node, + messageId: "above", + }); + } + } else { + if (!isOnSameLine) { + context.report({ + node, + messageId: "beside", + }); + } + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/linebreak-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/linebreak-style.js new file mode 100644 index 00000000..aea1b8ce --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/linebreak-style.js @@ -0,0 +1,135 @@ +/** + * @fileoverview Rule to enforce a single linebreak style. + * @author Erik Mueller + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @import { SourceRange } from "@eslint/core"; + */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "linebreak-style", + url: "https://eslint.style/rules/linebreak-style", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent linebreak style", + recommended: false, + url: "https://eslint.org/docs/latest/rules/linebreak-style", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["unix", "windows"], + }, + ], + messages: { + expectedLF: "Expected linebreaks to be 'LF' but found 'CRLF'.", + expectedCRLF: "Expected linebreaks to be 'CRLF' but found 'LF'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Builds a fix function that replaces text at the specified range in the source text. + * @param {SourceRange} range The range to replace + * @param {string} text The text to insert. + * @returns {Function} Fixer function + * @private + */ + function createFix(range, text) { + return function (fixer) { + return fixer.replaceTextRange(range, text); + }; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: function checkForLinebreakStyle(node) { + const linebreakStyle = context.options[0] || "unix", + expectedLF = linebreakStyle === "unix", + expectedLFChars = expectedLF ? "\n" : "\r\n", + source = sourceCode.getText(), + pattern = astUtils.createGlobalLinebreakMatcher(); + let match; + + let i = 0; + + while ((match = pattern.exec(source)) !== null) { + i++; + if (match[0] === expectedLFChars) { + continue; + } + + const index = match.index; + const range = [index, index + match[0].length]; + + context.report({ + node, + loc: { + start: { + line: i, + column: sourceCode.lines[i - 1].length, + }, + end: { + line: i + 1, + column: 0, + }, + }, + messageId: expectedLF ? "expectedLF" : "expectedCRLF", + fix: createFix(range, expectedLFChars), + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-comment.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-comment.js new file mode 100644 index 00000000..7b2d0ac8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-comment.js @@ -0,0 +1,581 @@ +/** + * @fileoverview Enforces empty lines around comments. + * @author Jamund Ferguson + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Return an array with any line numbers that are empty. + * @param {Array} lines An array of each line of the file. + * @returns {Array} An array of line numbers. + */ +function getEmptyLineNums(lines) { + const emptyLines = lines + .map((line, i) => ({ + code: line.trim(), + num: i + 1, + })) + .filter(line => !line.code) + .map(line => line.num); + + return emptyLines; +} + +/** + * Return an array with any line numbers that contain comments. + * @param {Array} comments An array of comment tokens. + * @returns {Array} An array of line numbers. + */ +function getCommentLineNums(comments) { + const lines = []; + + comments.forEach(token => { + const start = token.loc.start.line; + const end = token.loc.end.line; + + lines.push(start, end); + }); + return lines; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "lines-around-comment", + url: "https://eslint.style/rules/lines-around-comment", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require empty lines around comments", + recommended: false, + url: "https://eslint.org/docs/latest/rules/lines-around-comment", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + beforeBlockComment: { + type: "boolean", + default: true, + }, + afterBlockComment: { + type: "boolean", + default: false, + }, + beforeLineComment: { + type: "boolean", + default: false, + }, + afterLineComment: { + type: "boolean", + default: false, + }, + allowBlockStart: { + type: "boolean", + default: false, + }, + allowBlockEnd: { + type: "boolean", + default: false, + }, + allowClassStart: { + type: "boolean", + }, + allowClassEnd: { + type: "boolean", + }, + allowObjectStart: { + type: "boolean", + }, + allowObjectEnd: { + type: "boolean", + }, + allowArrayStart: { + type: "boolean", + }, + allowArrayEnd: { + type: "boolean", + }, + ignorePattern: { + type: "string", + }, + applyDefaultIgnorePatterns: { + type: "boolean", + }, + afterHashbangComment: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + messages: { + after: "Expected line after comment.", + before: "Expected line before comment.", + }, + }, + + create(context) { + const options = Object.assign({}, context.options[0]); + const ignorePattern = options.ignorePattern; + const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN; + const customIgnoreRegExp = new RegExp(ignorePattern, "u"); + const applyDefaultIgnorePatterns = + options.applyDefaultIgnorePatterns !== false; + + options.beforeBlockComment = + typeof options.beforeBlockComment !== "undefined" + ? options.beforeBlockComment + : true; + + const sourceCode = context.sourceCode; + + const lines = sourceCode.lines, + numLines = lines.length + 1, + comments = sourceCode.getAllComments(), + commentLines = getCommentLineNums(comments), + emptyLines = getEmptyLineNums(lines), + commentAndEmptyLines = new Set(commentLines.concat(emptyLines)); + + /** + * Returns whether or not comments are on lines starting with or ending with code + * @param {token} token The comment token to check. + * @returns {boolean} True if the comment is not alone. + */ + function codeAroundComment(token) { + let currentToken = token; + + do { + currentToken = sourceCode.getTokenBefore(currentToken, { + includeComments: true, + }); + } while (currentToken && astUtils.isCommentToken(currentToken)); + + if ( + currentToken && + astUtils.isTokenOnSameLine(currentToken, token) + ) { + return true; + } + + currentToken = token; + do { + currentToken = sourceCode.getTokenAfter(currentToken, { + includeComments: true, + }); + } while (currentToken && astUtils.isCommentToken(currentToken)); + + if ( + currentToken && + astUtils.isTokenOnSameLine(token, currentToken) + ) { + return true; + } + + return false; + } + + /** + * Returns whether or not comments are inside a node type or not. + * @param {ASTNode} parent The Comment parent node. + * @param {string} nodeType The parent type to check against. + * @returns {boolean} True if the comment is inside nodeType. + */ + function isParentNodeType(parent, nodeType) { + return ( + parent.type === nodeType || + (parent.body && parent.body.type === nodeType) || + (parent.consequent && parent.consequent.type === nodeType) + ); + } + + /** + * Returns the parent node that contains the given token. + * @param {token} token The token to check. + * @returns {ASTNode|null} The parent node that contains the given token. + */ + function getParentNodeOfToken(token) { + const node = sourceCode.getNodeByRangeIndex(token.range[0]); + + /* + * For the purpose of this rule, the comment token is in a `StaticBlock` node only + * if it's inside the braces of that `StaticBlock` node. + * + * Example where this function returns `null`: + * + * static + * // comment + * { + * } + * + * Example where this function returns `StaticBlock` node: + * + * static + * { + * // comment + * } + * + */ + if (node && node.type === "StaticBlock") { + const openingBrace = sourceCode.getFirstToken(node, { + skip: 1, + }); // skip the `static` token + + return token.range[0] >= openingBrace.range[0] ? node : null; + } + + return node; + } + + /** + * Returns whether or not comments are at the parent start or not. + * @param {token} token The Comment token. + * @param {string} nodeType The parent type to check against. + * @returns {boolean} True if the comment is at parent start. + */ + function isCommentAtParentStart(token, nodeType) { + const parent = getParentNodeOfToken(token); + + if (parent && isParentNodeType(parent, nodeType)) { + let parentStartNodeOrToken = parent; + + if (parent.type === "StaticBlock") { + parentStartNodeOrToken = sourceCode.getFirstToken(parent, { + skip: 1, + }); // opening brace of the static block + } else if (parent.type === "SwitchStatement") { + parentStartNodeOrToken = sourceCode.getTokenAfter( + parent.discriminant, + { + filter: astUtils.isOpeningBraceToken, + }, + ); // opening brace of the switch statement + } + + return ( + token.loc.start.line - + parentStartNodeOrToken.loc.start.line === + 1 + ); + } + + return false; + } + + /** + * Returns whether or not comments are at the parent end or not. + * @param {token} token The Comment token. + * @param {string} nodeType The parent type to check against. + * @returns {boolean} True if the comment is at parent end. + */ + function isCommentAtParentEnd(token, nodeType) { + const parent = getParentNodeOfToken(token); + + return ( + !!parent && + isParentNodeType(parent, nodeType) && + parent.loc.end.line - token.loc.end.line === 1 + ); + } + + /** + * Returns whether or not comments are at the block start or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at block start. + */ + function isCommentAtBlockStart(token) { + return ( + isCommentAtParentStart(token, "ClassBody") || + isCommentAtParentStart(token, "BlockStatement") || + isCommentAtParentStart(token, "StaticBlock") || + isCommentAtParentStart(token, "SwitchCase") || + isCommentAtParentStart(token, "SwitchStatement") + ); + } + + /** + * Returns whether or not comments are at the block end or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at block end. + */ + function isCommentAtBlockEnd(token) { + return ( + isCommentAtParentEnd(token, "ClassBody") || + isCommentAtParentEnd(token, "BlockStatement") || + isCommentAtParentEnd(token, "StaticBlock") || + isCommentAtParentEnd(token, "SwitchCase") || + isCommentAtParentEnd(token, "SwitchStatement") + ); + } + + /** + * Returns whether or not comments are at the class start or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at class start. + */ + function isCommentAtClassStart(token) { + return isCommentAtParentStart(token, "ClassBody"); + } + + /** + * Returns whether or not comments are at the class end or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at class end. + */ + function isCommentAtClassEnd(token) { + return isCommentAtParentEnd(token, "ClassBody"); + } + + /** + * Returns whether or not comments are at the object start or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at object start. + */ + function isCommentAtObjectStart(token) { + return ( + isCommentAtParentStart(token, "ObjectExpression") || + isCommentAtParentStart(token, "ObjectPattern") + ); + } + + /** + * Returns whether or not comments are at the object end or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at object end. + */ + function isCommentAtObjectEnd(token) { + return ( + isCommentAtParentEnd(token, "ObjectExpression") || + isCommentAtParentEnd(token, "ObjectPattern") + ); + } + + /** + * Returns whether or not comments are at the array start or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at array start. + */ + function isCommentAtArrayStart(token) { + return ( + isCommentAtParentStart(token, "ArrayExpression") || + isCommentAtParentStart(token, "ArrayPattern") + ); + } + + /** + * Returns whether or not comments are at the array end or not. + * @param {token} token The Comment token. + * @returns {boolean} True if the comment is at array end. + */ + function isCommentAtArrayEnd(token) { + return ( + isCommentAtParentEnd(token, "ArrayExpression") || + isCommentAtParentEnd(token, "ArrayPattern") + ); + } + + /** + * Checks if a comment token has lines around it (ignores inline comments) + * @param {token} token The Comment token. + * @param {Object} opts Options to determine the newline. + * @param {boolean} opts.after Should have a newline after this line. + * @param {boolean} opts.before Should have a newline before this line. + * @returns {void} + */ + function checkForEmptyLine(token, opts) { + if ( + applyDefaultIgnorePatterns && + defaultIgnoreRegExp.test(token.value) + ) { + return; + } + + if (ignorePattern && customIgnoreRegExp.test(token.value)) { + return; + } + + let after = opts.after, + before = opts.before; + + const prevLineNum = token.loc.start.line - 1, + nextLineNum = token.loc.end.line + 1, + commentIsNotAlone = codeAroundComment(token); + + const blockStartAllowed = + options.allowBlockStart && + isCommentAtBlockStart(token) && + !( + options.allowClassStart === false && + isCommentAtClassStart(token) + ), + blockEndAllowed = + options.allowBlockEnd && + isCommentAtBlockEnd(token) && + !( + options.allowClassEnd === false && + isCommentAtClassEnd(token) + ), + classStartAllowed = + options.allowClassStart && isCommentAtClassStart(token), + classEndAllowed = + options.allowClassEnd && isCommentAtClassEnd(token), + objectStartAllowed = + options.allowObjectStart && isCommentAtObjectStart(token), + objectEndAllowed = + options.allowObjectEnd && isCommentAtObjectEnd(token), + arrayStartAllowed = + options.allowArrayStart && isCommentAtArrayStart(token), + arrayEndAllowed = + options.allowArrayEnd && isCommentAtArrayEnd(token); + + const exceptionStartAllowed = + blockStartAllowed || + classStartAllowed || + objectStartAllowed || + arrayStartAllowed; + const exceptionEndAllowed = + blockEndAllowed || + classEndAllowed || + objectEndAllowed || + arrayEndAllowed; + + // ignore top of the file and bottom of the file + if (prevLineNum < 1) { + before = false; + } + if (nextLineNum >= numLines) { + after = false; + } + + // we ignore all inline comments + if (commentIsNotAlone) { + return; + } + + const previousTokenOrComment = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + const nextTokenOrComment = sourceCode.getTokenAfter(token, { + includeComments: true, + }); + + // check for newline before + if ( + !exceptionStartAllowed && + before && + !commentAndEmptyLines.has(prevLineNum) && + !( + astUtils.isCommentToken(previousTokenOrComment) && + astUtils.isTokenOnSameLine(previousTokenOrComment, token) + ) + ) { + const lineStart = token.range[0] - token.loc.start.column; + const range = [lineStart, lineStart]; + + context.report({ + node: token, + messageId: "before", + fix(fixer) { + return fixer.insertTextBeforeRange(range, "\n"); + }, + }); + } + + // check for newline after + if ( + !exceptionEndAllowed && + after && + !commentAndEmptyLines.has(nextLineNum) && + !( + astUtils.isCommentToken(nextTokenOrComment) && + astUtils.isTokenOnSameLine(token, nextTokenOrComment) + ) + ) { + context.report({ + node: token, + messageId: "after", + fix(fixer) { + return fixer.insertTextAfter(token, "\n"); + }, + }); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program() { + comments.forEach(token => { + if (token.type === "Line") { + if ( + options.beforeLineComment || + options.afterLineComment + ) { + checkForEmptyLine(token, { + after: options.afterLineComment, + before: options.beforeLineComment, + }); + } + } else if (token.type === "Block") { + if ( + options.beforeBlockComment || + options.afterBlockComment + ) { + checkForEmptyLine(token, { + after: options.afterBlockComment, + before: options.beforeBlockComment, + }); + } + } else if (token.type === "Shebang") { + if (options.afterHashbangComment) { + checkForEmptyLine(token, { + after: options.afterHashbangComment, + before: false, + }); + } + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-directive.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-directive.js new file mode 100644 index 00000000..bf57154b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-around-directive.js @@ -0,0 +1,249 @@ +/** + * @fileoverview Require or disallow newlines around directives. + * @author Kai Cataldo + * @deprecated in ESLint v4.0.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + docs: { + description: "Require or disallow newlines around directives", + recommended: false, + url: "https://eslint.org/docs/latest/rules/lines-around-directive", + }, + + schema: [ + { + oneOf: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + before: { + enum: ["always", "never"], + }, + after: { + enum: ["always", "never"], + }, + }, + additionalProperties: false, + minProperties: 2, + }, + ], + }, + ], + + fixable: "whitespace", + messages: { + expected: 'Expected newline {{location}} "{{value}}" directive.', + unexpected: + 'Unexpected newline {{location}} "{{value}}" directive.', + }, + deprecated: { + message: "The rule was replaced with a more general rule.", + url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/", + deprecatedSince: "4.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: "The new rule moved to a plugin.", + url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "padding-line-between-statements", + url: "https://eslint.style/rules/padding-line-between-statements", + }, + }, + ], + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const config = context.options[0] || "always"; + const expectLineBefore = + typeof config === "string" ? config : config.before; + const expectLineAfter = + typeof config === "string" ? config : config.after; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Check if node is preceded by a blank newline. + * @param {ASTNode} node Node to check. + * @returns {boolean} Whether or not the passed in node is preceded by a blank newline. + */ + function hasNewlineBefore(node) { + const tokenBefore = sourceCode.getTokenBefore(node, { + includeComments: true, + }); + const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0; + + return node.loc.start.line - tokenLineBefore >= 2; + } + + /** + * Gets the last token of a node that is on the same line as the rest of the node. + * This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing + * semicolon on a different line. + * @param {ASTNode} node A directive node + * @returns {Token} The last token of the node on the line + */ + function getLastTokenOnLine(node) { + const lastToken = sourceCode.getLastToken(node); + const secondToLastToken = sourceCode.getTokenBefore(lastToken); + + return astUtils.isSemicolonToken(lastToken) && + lastToken.loc.start.line > secondToLastToken.loc.end.line + ? secondToLastToken + : lastToken; + } + + /** + * Check if node is followed by a blank newline. + * @param {ASTNode} node Node to check. + * @returns {boolean} Whether or not the passed in node is followed by a blank newline. + */ + function hasNewlineAfter(node) { + const lastToken = getLastTokenOnLine(node); + const tokenAfter = sourceCode.getTokenAfter(lastToken, { + includeComments: true, + }); + + return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2; + } + + /** + * Report errors for newlines around directives. + * @param {ASTNode} node Node to check. + * @param {string} location Whether the error was found before or after the directive. + * @param {boolean} expected Whether or not a newline was expected or unexpected. + * @returns {void} + */ + function reportError(node, location, expected) { + context.report({ + node, + messageId: expected ? "expected" : "unexpected", + data: { + value: node.expression.value, + location, + }, + fix(fixer) { + const lastToken = getLastTokenOnLine(node); + + if (expected) { + return location === "before" + ? fixer.insertTextBefore(node, "\n") + : fixer.insertTextAfter(lastToken, "\n"); + } + return fixer.removeRange( + location === "before" + ? [node.range[0] - 1, node.range[0]] + : [lastToken.range[1], lastToken.range[1] + 1], + ); + }, + }); + } + + /** + * Check lines around directives in node + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkDirectives(node) { + const directives = astUtils.getDirectivePrologue(node); + + if (!directives.length) { + return; + } + + const firstDirective = directives[0]; + const leadingComments = + sourceCode.getCommentsBefore(firstDirective); + + /* + * Only check before the first directive if it is preceded by a comment or if it is at the top of + * the file and expectLineBefore is set to "never". This is to not force a newline at the top of + * the file if there are no comments as well as for compatibility with padded-blocks. + */ + if (leadingComments.length) { + if ( + expectLineBefore === "always" && + !hasNewlineBefore(firstDirective) + ) { + reportError(firstDirective, "before", true); + } + + if ( + expectLineBefore === "never" && + hasNewlineBefore(firstDirective) + ) { + reportError(firstDirective, "before", false); + } + } else if ( + node.type === "Program" && + expectLineBefore === "never" && + !leadingComments.length && + hasNewlineBefore(firstDirective) + ) { + reportError(firstDirective, "before", false); + } + + const lastDirective = directives.at(-1); + const statements = + node.type === "Program" ? node.body : node.body.body; + + /* + * Do not check after the last directive if the body only + * contains a directive prologue and isn't followed by a comment to ensure + * this rule behaves well with padded-blocks. + */ + if ( + lastDirective === statements.at(-1) && + !lastDirective.trailingComments + ) { + return; + } + + if ( + expectLineAfter === "always" && + !hasNewlineAfter(lastDirective) + ) { + reportError(lastDirective, "after", true); + } + + if (expectLineAfter === "never" && hasNewlineAfter(lastDirective)) { + reportError(lastDirective, "after", false); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: checkDirectives, + FunctionDeclaration: checkDirectives, + FunctionExpression: checkDirectives, + ArrowFunctionExpression: checkDirectives, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-between-class-members.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-between-class-members.js new file mode 100644 index 00000000..89616998 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/lines-between-class-members.js @@ -0,0 +1,358 @@ +/** + * @fileoverview Rule to check empty newline between class members + * @author 薛定谔的猫 + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Types of class members. + * Those have `test` method to check it matches to the given class member. + * @private + */ +const ClassMemberTypes = { + "*": { test: () => true }, + field: { test: node => node.type === "PropertyDefinition" }, + method: { test: node => node.type === "MethodDefinition" }, +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "lines-between-class-members", + url: "https://eslint.style/rules/lines-between-class-members", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require or disallow an empty line between class members", + recommended: false, + url: "https://eslint.org/docs/latest/rules/lines-between-class-members", + }, + + fixable: "whitespace", + + schema: [ + { + anyOf: [ + { + type: "object", + properties: { + enforce: { + type: "array", + items: { + type: "object", + properties: { + blankLine: { + enum: ["always", "never"], + }, + prev: { + enum: ["method", "field", "*"], + }, + next: { + enum: ["method", "field", "*"], + }, + }, + additionalProperties: false, + required: ["blankLine", "prev", "next"], + }, + minItems: 1, + }, + }, + additionalProperties: false, + required: ["enforce"], + }, + { + enum: ["always", "never"], + }, + ], + }, + { + type: "object", + properties: { + exceptAfterSingleLine: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + messages: { + never: "Unexpected blank line between class members.", + always: "Expected blank line between class members.", + }, + }, + + create(context) { + const options = []; + + options[0] = context.options[0] || "always"; + options[1] = context.options[1] || { exceptAfterSingleLine: false }; + + const configureList = + typeof options[0] === "object" + ? options[0].enforce + : [{ blankLine: options[0], prev: "*", next: "*" }]; + const sourceCode = context.sourceCode; + + /** + * Gets a pair of tokens that should be used to check lines between two class member nodes. + * + * In most cases, this returns the very last token of the current node and + * the very first token of the next node. + * For example: + * + * class C { + * x = 1; // curLast: `;` nextFirst: `in` + * in = 2 + * } + * + * There is only one exception. If the given node ends with a semicolon, and it looks like + * a semicolon-less style's semicolon - one that is not on the same line as the preceding + * token, but is on the line where the next class member starts - this returns the preceding + * token and the semicolon as boundary tokens. + * For example: + * + * class C { + * x = 1 // curLast: `1` nextFirst: `;` + * ;in = 2 + * } + * When determining the desired layout of the code, we should treat this semicolon as + * a part of the next class member node instead of the one it technically belongs to. + * @param {ASTNode} curNode Current class member node. + * @param {ASTNode} nextNode Next class member node. + * @returns {Token} The actual last token of `node`. + * @private + */ + function getBoundaryTokens(curNode, nextNode) { + const lastToken = sourceCode.getLastToken(curNode); + const prevToken = sourceCode.getTokenBefore(lastToken); + const nextToken = sourceCode.getFirstToken(nextNode); // skip possible lone `;` between nodes + + const isSemicolonLessStyle = + astUtils.isSemicolonToken(lastToken) && + !astUtils.isTokenOnSameLine(prevToken, lastToken) && + astUtils.isTokenOnSameLine(lastToken, nextToken); + + return isSemicolonLessStyle + ? { curLast: prevToken, nextFirst: lastToken } + : { curLast: lastToken, nextFirst: nextToken }; + } + + /** + * Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member. + * @param {Token} prevLastToken The last token in the previous member node. + * @param {Token} nextFirstToken The first token in the next member node. + * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens. + * @returns {Token} The last token among the consecutive tokens. + */ + function findLastConsecutiveTokenAfter( + prevLastToken, + nextFirstToken, + maxLine, + ) { + const after = sourceCode.getTokenAfter(prevLastToken, { + includeComments: true, + }); + + if ( + after !== nextFirstToken && + after.loc.start.line - prevLastToken.loc.end.line <= maxLine + ) { + return findLastConsecutiveTokenAfter( + after, + nextFirstToken, + maxLine, + ); + } + return prevLastToken; + } + + /** + * Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member. + * @param {Token} nextFirstToken The first token in the next member node. + * @param {Token} prevLastToken The last token in the previous member node. + * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens. + * @returns {Token} The first token among the consecutive tokens. + */ + function findFirstConsecutiveTokenBefore( + nextFirstToken, + prevLastToken, + maxLine, + ) { + const before = sourceCode.getTokenBefore(nextFirstToken, { + includeComments: true, + }); + + if ( + before !== prevLastToken && + nextFirstToken.loc.start.line - before.loc.end.line <= maxLine + ) { + return findFirstConsecutiveTokenBefore( + before, + prevLastToken, + maxLine, + ); + } + return nextFirstToken; + } + + /** + * Checks if there is a token or comment between two tokens. + * @param {Token} before The token before. + * @param {Token} after The token after. + * @returns {boolean} True if there is a token or comment between two tokens. + */ + function hasTokenOrCommentBetween(before, after) { + return ( + sourceCode.getTokensBetween(before, after, { + includeComments: true, + }).length !== 0 + ); + } + + /** + * Checks whether the given node matches the given type. + * @param {ASTNode} node The class member node to check. + * @param {string} type The class member type to check. + * @returns {boolean} `true` if the class member node matched the type. + * @private + */ + function match(node, type) { + return ClassMemberTypes[type].test(node); + } + + /** + * Finds the last matched configuration from the configureList. + * @param {ASTNode} prevNode The previous node to match. + * @param {ASTNode} nextNode The current node to match. + * @returns {string|null} Padding type or `null` if no matches were found. + * @private + */ + function getPaddingType(prevNode, nextNode) { + for (let i = configureList.length - 1; i >= 0; --i) { + const configure = configureList[i]; + const matched = + match(prevNode, configure.prev) && + match(nextNode, configure.next); + + if (matched) { + return configure.blankLine; + } + } + return null; + } + + return { + ClassBody(node) { + const body = node.body; + + for (let i = 0; i < body.length - 1; i++) { + const curFirst = sourceCode.getFirstToken(body[i]); + const { curLast, nextFirst } = getBoundaryTokens( + body[i], + body[i + 1], + ); + const isMulti = !astUtils.isTokenOnSameLine( + curFirst, + curLast, + ); + const skip = !isMulti && options[1].exceptAfterSingleLine; + const beforePadding = findLastConsecutiveTokenAfter( + curLast, + nextFirst, + 1, + ); + const afterPadding = findFirstConsecutiveTokenBefore( + nextFirst, + curLast, + 1, + ); + const isPadded = + afterPadding.loc.start.line - + beforePadding.loc.end.line > + 1; + const hasTokenInPadding = hasTokenOrCommentBetween( + beforePadding, + afterPadding, + ); + const curLineLastToken = findLastConsecutiveTokenAfter( + curLast, + nextFirst, + 0, + ); + const paddingType = getPaddingType(body[i], body[i + 1]); + + if (paddingType === "never" && isPadded) { + context.report({ + node: body[i + 1], + messageId: "never", + + fix(fixer) { + if (hasTokenInPadding) { + return null; + } + return fixer.replaceTextRange( + [ + beforePadding.range[1], + afterPadding.range[0], + ], + "\n", + ); + }, + }); + } else if (paddingType === "always" && !skip && !isPadded) { + context.report({ + node: body[i + 1], + messageId: "always", + + fix(fixer) { + if (hasTokenInPadding) { + return null; + } + return fixer.insertTextAfter( + curLineLastToken, + "\n", + ); + }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/logical-assignment-operators.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/logical-assignment-operators.js new file mode 100644 index 00000000..8564b19b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/logical-assignment-operators.js @@ -0,0 +1,691 @@ +/** + * @fileoverview Rule to replace assignment expressions with logical operator assignment + * @author Daniel Martens + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ +const astUtils = require("./utils/ast-utils.js"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const baseTypes = new Set(["Identifier", "Super", "ThisExpression"]); + +/** + * Returns true iff either "undefined" or a void expression (eg. "void 0") + * @param {ASTNode} expression Expression to check + * @param {import('eslint-scope').Scope} scope Scope of the expression + * @returns {boolean} True iff "undefined" or "void ..." + */ +function isUndefined(expression, scope) { + if (expression.type === "Identifier" && expression.name === "undefined") { + return astUtils.isReferenceToGlobalVariable(scope, expression); + } + + return ( + expression.type === "UnaryExpression" && + expression.operator === "void" && + expression.argument.type === "Literal" && + expression.argument.value === 0 + ); +} + +/** + * Returns true iff the reference is either an identifier or member expression + * @param {ASTNode} expression Expression to check + * @returns {boolean} True for identifiers and member expressions + */ +function isReference(expression) { + return ( + (expression.type === "Identifier" && expression.name !== "undefined") || + expression.type === "MemberExpression" + ); +} + +/** + * Returns true iff the expression checks for nullish with loose equals. + * Examples: value == null, value == void 0 + * @param {ASTNode} expression Test condition + * @param {import('eslint-scope').Scope} scope Scope of the expression + * @returns {boolean} True iff implicit nullish comparison + */ +function isImplicitNullishComparison(expression, scope) { + if ( + expression.type !== "BinaryExpression" || + expression.operator !== "==" + ) { + return false; + } + + const reference = isReference(expression.left) ? "left" : "right"; + const nullish = reference === "left" ? "right" : "left"; + + return ( + isReference(expression[reference]) && + (astUtils.isNullLiteral(expression[nullish]) || + isUndefined(expression[nullish], scope)) + ); +} + +/** + * Condition with two equal comparisons. + * @param {ASTNode} expression Condition + * @returns {boolean} True iff matches ? === ? || ? === ? + */ +function isDoubleComparison(expression) { + return ( + expression.type === "LogicalExpression" && + expression.operator === "||" && + expression.left.type === "BinaryExpression" && + expression.left.operator === "===" && + expression.right.type === "BinaryExpression" && + expression.right.operator === "===" + ); +} + +/** + * Returns true iff the expression checks for undefined and null. + * Example: value === null || value === undefined + * @param {ASTNode} expression Test condition + * @param {import('eslint-scope').Scope} scope Scope of the expression + * @returns {boolean} True iff explicit nullish comparison + */ +function isExplicitNullishComparison(expression, scope) { + if (!isDoubleComparison(expression)) { + return false; + } + const leftReference = isReference(expression.left.left) ? "left" : "right"; + const leftNullish = leftReference === "left" ? "right" : "left"; + const rightReference = isReference(expression.right.left) + ? "left" + : "right"; + const rightNullish = rightReference === "left" ? "right" : "left"; + + return ( + astUtils.isSameReference( + expression.left[leftReference], + expression.right[rightReference], + ) && + ((astUtils.isNullLiteral(expression.left[leftNullish]) && + isUndefined(expression.right[rightNullish], scope)) || + (isUndefined(expression.left[leftNullish], scope) && + astUtils.isNullLiteral(expression.right[rightNullish]))) + ); +} + +/** + * Returns true for Boolean(arg) calls + * @param {ASTNode} expression Test condition + * @param {import('eslint-scope').Scope} scope Scope of the expression + * @returns {boolean} Whether the expression is a boolean cast + */ +function isBooleanCast(expression, scope) { + return ( + expression.type === "CallExpression" && + expression.callee.name === "Boolean" && + expression.arguments.length === 1 && + astUtils.isReferenceToGlobalVariable(scope, expression.callee) + ); +} + +/** + * Returns true for: + * truthiness checks: value, Boolean(value), !!value + * falsiness checks: !value, !Boolean(value) + * nullish checks: value == null, value === undefined || value === null + * @param {ASTNode} expression Test condition + * @param {import('eslint-scope').Scope} scope Scope of the expression + * @returns {?{ reference: ASTNode, operator: '??'|'||'|'&&'}} Null if not a known existence + */ +function getExistence(expression, scope) { + const isNegated = + expression.type === "UnaryExpression" && expression.operator === "!"; + const base = isNegated ? expression.argument : expression; + + switch (true) { + case isReference(base): + return { reference: base, operator: isNegated ? "||" : "&&" }; + case base.type === "UnaryExpression" && + base.operator === "!" && + isReference(base.argument): + return { reference: base.argument, operator: "&&" }; + case isBooleanCast(base, scope) && isReference(base.arguments[0]): + return { + reference: base.arguments[0], + operator: isNegated ? "||" : "&&", + }; + case isImplicitNullishComparison(expression, scope): + return { + reference: isReference(expression.left) + ? expression.left + : expression.right, + operator: "??", + }; + case isExplicitNullishComparison(expression, scope): + return { + reference: isReference(expression.left.left) + ? expression.left.left + : expression.left.right, + operator: "??", + }; + default: + return null; + } +} + +/** + * Returns true iff the node is inside a with block + * @param {ASTNode} node Node to check + * @returns {boolean} True iff passed node is inside a with block + */ +function isInsideWithBlock(node) { + if (node.type === "Program") { + return false; + } + + return node.parent.type === "WithStatement" && node.parent.body === node + ? true + : isInsideWithBlock(node.parent); +} + +/** + * Gets the leftmost operand of a consecutive logical expression. + * @param {SourceCode} sourceCode The ESLint source code object + * @param {LogicalExpression} node LogicalExpression + * @returns {Expression} Leftmost operand + */ +function getLeftmostOperand(sourceCode, node) { + let left = node.left; + + while ( + left.type === "LogicalExpression" && + left.operator === node.operator + ) { + if (astUtils.isParenthesised(sourceCode, left)) { + /* + * It should have associativity, + * but ignore it if use parentheses to make the evaluation order clear. + */ + return left; + } + left = left.left; + } + return left; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require or disallow logical assignment operator shorthand", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/logical-assignment-operators", + }, + + schema: { + type: "array", + oneOf: [ + { + items: [ + { const: "always" }, + { + type: "object", + properties: { + enforceForIfStatements: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, // 0 for allowing passing no options + maxItems: 2, + }, + { + items: [{ const: "never" }], + minItems: 1, + maxItems: 1, + }, + ], + }, + + defaultOptions: ["always"], + + fixable: "code", + hasSuggestions: true, + messages: { + assignment: + "Assignment (=) can be replaced with operator assignment ({{operator}}).", + useLogicalOperator: + "Convert this assignment to use the operator {{ operator }}.", + logical: + "Logical expression can be replaced with an assignment ({{ operator }}).", + convertLogical: + "Replace this logical expression with an assignment with the operator {{ operator }}.", + if: "'if' statement can be replaced with a logical operator assignment with operator {{ operator }}.", + convertIf: + "Replace this 'if' statement with a logical assignment with operator {{ operator }}.", + unexpected: + "Unexpected logical operator assignment ({{operator}}) shorthand.", + separate: + "Separate the logical assignment into an assignment with a logical operator.", + }, + }, + + create(context) { + const mode = context.options[0]; + const checkIf = + mode === "always" && + context.options.length > 1 && + context.options[1].enforceForIfStatements; + const sourceCode = context.sourceCode; + const isStrict = sourceCode.getScope(sourceCode.ast).isStrict; + + /** + * Returns false if the access could be a getter + * @param {ASTNode} node Assignment expression + * @returns {boolean} True iff the fix is safe + */ + function cannotBeGetter(node) { + return ( + node.type === "Identifier" && + (isStrict || !isInsideWithBlock(node)) + ); + } + + /** + * Check whether only a single property is accessed + * @param {ASTNode} node reference + * @returns {boolean} True iff a single property is accessed + */ + function accessesSingleProperty(node) { + if (!isStrict && isInsideWithBlock(node)) { + return node.type === "Identifier"; + } + + return ( + node.type === "MemberExpression" && + baseTypes.has(node.object.type) && + (!node.computed || + (node.property.type !== "MemberExpression" && + node.property.type !== "ChainExpression")) + ); + } + + /** + * Adds a fixer or suggestion whether on the fix is safe. + * @param {{ messageId: string, node: ASTNode }} descriptor Report descriptor without fix or suggest + * @param {{ messageId: string, fix: Function }} suggestion Adds the fix or the whole suggestion as only element in "suggest" to suggestion + * @param {boolean} shouldBeFixed Fix iff the condition is true + * @returns {Object} Descriptor with either an added fix or suggestion + */ + function createConditionalFixer(descriptor, suggestion, shouldBeFixed) { + if (shouldBeFixed) { + return { + ...descriptor, + fix: suggestion.fix, + }; + } + + return { + ...descriptor, + suggest: [suggestion], + }; + } + + /** + * Returns the operator token for assignments and binary expressions + * @param {ASTNode} node AssignmentExpression or BinaryExpression + * @returns {import('eslint').AST.Token} Operator token between the left and right expression + */ + function getOperatorToken(node) { + return sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + } + + if (mode === "never") { + return { + // foo ||= bar + AssignmentExpression(assignment) { + if ( + !astUtils.isLogicalAssignmentOperator( + assignment.operator, + ) + ) { + return; + } + + const descriptor = { + messageId: "unexpected", + node: assignment, + data: { operator: assignment.operator }, + }; + const suggestion = { + messageId: "separate", + *fix(ruleFixer) { + if ( + sourceCode.getCommentsInside(assignment) + .length > 0 + ) { + return; + } + + const operatorToken = getOperatorToken(assignment); + + // -> foo = bar + yield ruleFixer.replaceText(operatorToken, "="); + + const assignmentText = sourceCode.getText( + assignment.left, + ); + const operator = assignment.operator.slice(0, -1); + + // -> foo = foo || bar + yield ruleFixer.insertTextAfter( + operatorToken, + ` ${assignmentText} ${operator}`, + ); + + const precedence = + astUtils.getPrecedence(assignment.right) <= + astUtils.getPrecedence({ + type: "LogicalExpression", + operator, + }); + + // ?? and || / && cannot be mixed but have same precedence + const mixed = + assignment.operator === "??=" && + astUtils.isLogicalExpression(assignment.right); + + if ( + !astUtils.isParenthesised( + sourceCode, + assignment.right, + ) && + (precedence || mixed) + ) { + // -> foo = foo || (bar) + yield ruleFixer.insertTextBefore( + assignment.right, + "(", + ); + yield ruleFixer.insertTextAfter( + assignment.right, + ")", + ); + } + }, + }; + + context.report( + createConditionalFixer( + descriptor, + suggestion, + cannotBeGetter(assignment.left), + ), + ); + }, + }; + } + + return { + // foo = foo || bar + "AssignmentExpression[operator='='][right.type='LogicalExpression']"( + assignment, + ) { + const leftOperand = getLeftmostOperand( + sourceCode, + assignment.right, + ); + + if (!astUtils.isSameReference(assignment.left, leftOperand)) { + return; + } + + const descriptor = { + messageId: "assignment", + node: assignment, + data: { operator: `${assignment.right.operator}=` }, + }; + const suggestion = { + messageId: "useLogicalOperator", + data: { operator: `${assignment.right.operator}=` }, + *fix(ruleFixer) { + if ( + sourceCode.getCommentsInside(assignment).length > 0 + ) { + return; + } + + // No need for parenthesis around the assignment based on precedence as the precedence stays the same even with changed operator + const assignmentOperatorToken = + getOperatorToken(assignment); + + // -> foo ||= foo || bar + yield ruleFixer.insertTextBefore( + assignmentOperatorToken, + assignment.right.operator, + ); + + // -> foo ||= bar + const logicalOperatorToken = getOperatorToken( + leftOperand.parent, + ); + const firstRightOperandToken = + sourceCode.getTokenAfter(logicalOperatorToken); + + yield ruleFixer.removeRange([ + leftOperand.parent.range[0], + firstRightOperandToken.range[0], + ]); + }, + }; + + context.report( + createConditionalFixer( + descriptor, + suggestion, + cannotBeGetter(assignment.left), + ), + ); + }, + + // foo || (foo = bar) + 'LogicalExpression[right.type="AssignmentExpression"][right.operator="="]'( + logical, + ) { + // Right side has to be parenthesized, otherwise would be parsed as (foo || foo) = bar which is illegal + if ( + isReference(logical.left) && + astUtils.isSameReference(logical.left, logical.right.left) + ) { + const descriptor = { + messageId: "logical", + node: logical, + data: { operator: `${logical.operator}=` }, + }; + const suggestion = { + messageId: "convertLogical", + data: { operator: `${logical.operator}=` }, + *fix(ruleFixer) { + if ( + sourceCode.getCommentsInside(logical).length > 0 + ) { + return; + } + + const parentPrecedence = astUtils.getPrecedence( + logical.parent, + ); + const requiresOuterParenthesis = + logical.parent.type !== "ExpressionStatement" && + (parentPrecedence === -1 || + astUtils.getPrecedence({ + type: "AssignmentExpression", + }) < parentPrecedence); + + if ( + !astUtils.isParenthesised( + sourceCode, + logical, + ) && + requiresOuterParenthesis + ) { + yield ruleFixer.insertTextBefore(logical, "("); + yield ruleFixer.insertTextAfter(logical, ")"); + } + + // Also removes all opening parenthesis + yield ruleFixer.removeRange([ + logical.range[0], + logical.right.range[0], + ]); // -> foo = bar) + + // Also removes all ending parenthesis + yield ruleFixer.removeRange([ + logical.right.range[1], + logical.range[1], + ]); // -> foo = bar + + const operatorToken = getOperatorToken( + logical.right, + ); + + yield ruleFixer.insertTextBefore( + operatorToken, + logical.operator, + ); // -> foo ||= bar + }, + }; + const fix = + cannotBeGetter(logical.left) || + accessesSingleProperty(logical.left); + + context.report( + createConditionalFixer(descriptor, suggestion, fix), + ); + } + }, + + // if (foo) foo = bar + "IfStatement[alternate=null]"(ifNode) { + if (!checkIf) { + return; + } + + const hasBody = ifNode.consequent.type === "BlockStatement"; + + if (hasBody && ifNode.consequent.body.length !== 1) { + return; + } + + const body = hasBody + ? ifNode.consequent.body[0] + : ifNode.consequent; + const scope = sourceCode.getScope(ifNode); + const existence = getExistence(ifNode.test, scope); + + if ( + body.type === "ExpressionStatement" && + body.expression.type === "AssignmentExpression" && + body.expression.operator === "=" && + existence !== null && + astUtils.isSameReference( + existence.reference, + body.expression.left, + ) + ) { + const descriptor = { + messageId: "if", + node: ifNode, + data: { operator: `${existence.operator}=` }, + }; + const suggestion = { + messageId: "convertIf", + data: { operator: `${existence.operator}=` }, + *fix(ruleFixer) { + if ( + sourceCode.getCommentsInside(ifNode).length > 0 + ) { + return; + } + + const firstBodyToken = + sourceCode.getFirstToken(body); + const prevToken = sourceCode.getTokenBefore(ifNode); + + if ( + prevToken !== null && + prevToken.value !== ";" && + prevToken.value !== "{" && + firstBodyToken.type !== "Identifier" && + firstBodyToken.type !== "Keyword" + ) { + // Do not fix if the fixed statement could be part of the previous statement (eg. fn() if (a == null) (a) = b --> fn()(a) ??= b) + return; + } + + const operatorToken = getOperatorToken( + body.expression, + ); + + yield ruleFixer.insertTextBefore( + operatorToken, + existence.operator, + ); // -> if (foo) foo ||= bar + + yield ruleFixer.removeRange([ + ifNode.range[0], + body.range[0], + ]); // -> foo ||= bar + + yield ruleFixer.removeRange([ + body.range[1], + ifNode.range[1], + ]); // -> foo ||= bar, only present if "if" had a body + + const nextToken = sourceCode.getTokenAfter( + body.expression, + ); + + if ( + hasBody && + nextToken !== null && + nextToken.value !== ";" + ) { + yield ruleFixer.insertTextAfter(ifNode, ";"); + } + }, + }; + const shouldBeFixed = + cannotBeGetter(existence.reference) || + (ifNode.test.type !== "LogicalExpression" && + accessesSingleProperty(existence.reference)); + + context.report( + createConditionalFixer( + descriptor, + suggestion, + shouldBeFixed, + ), + ); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-classes-per-file.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-classes-per-file.js new file mode 100644 index 00000000..6eb9bc68 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-classes-per-file.js @@ -0,0 +1,96 @@ +/** + * @fileoverview Enforce a maximum number of classes per file + * @author James Garbutt + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Enforce a maximum number of classes per file", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-classes-per-file", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 1, + }, + { + type: "object", + properties: { + ignoreExpressions: { + type: "boolean", + }, + max: { + type: "integer", + minimum: 1, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [1], + + messages: { + maximumExceeded: + "File has too many classes ({{ classCount }}). Maximum allowed is {{ max }}.", + }, + }, + create(context) { + const option = context.options[0]; + const [ignoreExpressions, max] = + typeof option === "number" + ? [false, option] + : [option.ignoreExpressions, option.max || 1]; + + let classCount = 0; + + return { + Program() { + classCount = 0; + }, + "Program:exit"(node) { + if (classCount > max) { + context.report({ + node, + loc: { + start: node.body[0].loc.start, + end: node.body.at(-1).loc.end, + }, + messageId: "maximumExceeded", + data: { + classCount, + max, + }, + }); + } + }, + ClassDeclaration() { + classCount++; + }, + ClassExpression() { + if (!ignoreExpressions) { + classCount++; + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-depth.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-depth.js new file mode 100644 index 00000000..173b35ba --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-depth.js @@ -0,0 +1,181 @@ +/** + * @fileoverview A rule to set the maximum depth block can be nested in a function. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Enforce a maximum depth that blocks can be nested", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-depth", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + maximum: { + type: "integer", + minimum: 0, + }, + max: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [4], + + messages: { + tooDeeply: + "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const functionStack = [], + option = context.options[0]; + let maxDepth = 4; + + if ( + typeof option === "object" && + (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) + ) { + maxDepth = option.maximum || option.max; + } + if (typeof option === "number") { + maxDepth = option; + } + + /** + * When parsing a new function, store it in our function stack + * @returns {void} + * @private + */ + function startFunction() { + functionStack.push(0); + } + + /** + * When parsing is done then pop out the reference + * @returns {void} + * @private + */ + function endFunction() { + functionStack.pop(); + } + + /** + * Save the block and Evaluate the node + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function pushBlock(node) { + const len = ++functionStack[functionStack.length - 1]; + + if (len > maxDepth) { + context.report({ + node, + loc: sourceCode.getFirstToken(node).loc, + messageId: "tooDeeply", + data: { depth: len, maxDepth }, + }); + } + } + + /** + * Pop the saved block + * @returns {void} + * @private + */ + function popBlock() { + functionStack[functionStack.length - 1]--; + } + + /** + * Checks whether a node is an else-if statement. + * @param {ASTNode} node node to evaluate + * @returns {boolean} Whether the node is an else-if statement + */ + function isElseIf(node) { + return ( + node.parent.type === "IfStatement" && + node.parent.alternate === node + ); + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + Program: startFunction, + FunctionDeclaration: startFunction, + FunctionExpression: startFunction, + ArrowFunctionExpression: startFunction, + StaticBlock: startFunction, + + IfStatement(node) { + if (!isElseIf(node)) { + pushBlock(node); + } + }, + SwitchStatement: pushBlock, + TryStatement: pushBlock, + DoWhileStatement: pushBlock, + WhileStatement: pushBlock, + WithStatement: pushBlock, + ForStatement: pushBlock, + ForInStatement: pushBlock, + ForOfStatement: pushBlock, + + "IfStatement:exit"(node) { + if (!isElseIf(node)) { + popBlock(); + } + }, + "SwitchStatement:exit": popBlock, + "TryStatement:exit": popBlock, + "DoWhileStatement:exit": popBlock, + "WhileStatement:exit": popBlock, + "WithStatement:exit": popBlock, + "ForStatement:exit": popBlock, + "ForInStatement:exit": popBlock, + "ForOfStatement:exit": popBlock, + + "FunctionDeclaration:exit": endFunction, + "FunctionExpression:exit": endFunction, + "ArrowFunctionExpression:exit": endFunction, + "StaticBlock:exit": endFunction, + "Program:exit": endFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-len.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-len.js new file mode 100644 index 00000000..0abb6645 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-len.js @@ -0,0 +1,497 @@ +/** + * @fileoverview Rule to check for max length on a line. + * @author Matt DuVall + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const OPTIONS_SCHEMA = { + type: "object", + properties: { + code: { + type: "integer", + minimum: 0, + }, + comments: { + type: "integer", + minimum: 0, + }, + tabWidth: { + type: "integer", + minimum: 0, + }, + ignorePattern: { + type: "string", + }, + ignoreComments: { + type: "boolean", + }, + ignoreStrings: { + type: "boolean", + }, + ignoreUrls: { + type: "boolean", + }, + ignoreTemplateLiterals: { + type: "boolean", + }, + ignoreRegExpLiterals: { + type: "boolean", + }, + ignoreTrailingComments: { + type: "boolean", + }, + }, + additionalProperties: false, +}; + +const OPTIONS_OR_INTEGER_SCHEMA = { + anyOf: [ + OPTIONS_SCHEMA, + { + type: "integer", + minimum: 0, + }, + ], +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "max-len", + url: "https://eslint.style/rules/max-len", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce a maximum line length", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-len", + }, + + schema: [ + OPTIONS_OR_INTEGER_SCHEMA, + OPTIONS_OR_INTEGER_SCHEMA, + OPTIONS_SCHEMA, + ], + messages: { + max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.", + maxComment: + "This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}.", + }, + }, + + create(context) { + /* + * Inspired by https://datatracker.ietf.org/doc/html/rfc3986#appendix-B, however: + * - They're matching an entire string that we know is a URI + * - We're matching part of a string where we think there *might* be a URL + * - We're only concerned about URLs, as picking out any URI would cause + * too many false positives + * - We don't care about matching the entire URL, any small segment is fine + */ + const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u; + + const sourceCode = context.sourceCode; + + /** + * Computes the length of a line that may contain tabs. The width of each + * tab will be the number of spaces to the next tab stop. + * @param {string} line The line. + * @param {number} tabWidth The width of each tab stop in spaces. + * @returns {number} The computed line length. + * @private + */ + function computeLineLength(line, tabWidth) { + let extraCharacterCount = 0; + + line.replace(/\t/gu, (match, offset) => { + const totalOffset = offset + extraCharacterCount, + previousTabStopOffset = tabWidth + ? totalOffset % tabWidth + : 0, + spaceCount = tabWidth - previousTabStopOffset; + + extraCharacterCount += spaceCount - 1; // -1 for the replaced tab + }); + return Array.from(line).length + extraCharacterCount; + } + + // The options object must be the last option specified… + const options = Object.assign({}, context.options.at(-1)); + + // …but max code length… + if (typeof context.options[0] === "number") { + options.code = context.options[0]; + } + + // …and tabWidth can be optionally specified directly as integers. + if (typeof context.options[1] === "number") { + options.tabWidth = context.options[1]; + } + + const maxLength = typeof options.code === "number" ? options.code : 80, + tabWidth = + typeof options.tabWidth === "number" ? options.tabWidth : 4, + ignoreComments = !!options.ignoreComments, + ignoreStrings = !!options.ignoreStrings, + ignoreTemplateLiterals = !!options.ignoreTemplateLiterals, + ignoreRegExpLiterals = !!options.ignoreRegExpLiterals, + ignoreTrailingComments = + !!options.ignoreTrailingComments || !!options.ignoreComments, + ignoreUrls = !!options.ignoreUrls, + maxCommentLength = options.comments; + let ignorePattern = options.ignorePattern || null; + + if (ignorePattern) { + ignorePattern = new RegExp(ignorePattern, "u"); + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Tells if a given comment is trailing: it starts on the current line and + * extends to or past the end of the current line. + * @param {string} line The source line we want to check for a trailing comment on + * @param {number} lineNumber The one-indexed line number for line + * @param {ASTNode} comment The comment to inspect + * @returns {boolean} If the comment is trailing on the given line + */ + function isTrailingComment(line, lineNumber, comment) { + return ( + comment && + comment.loc.start.line === lineNumber && + lineNumber <= comment.loc.end.line && + (comment.loc.end.line > lineNumber || + comment.loc.end.column === line.length) + ); + } + + /** + * Tells if a comment encompasses the entire line. + * @param {string} line The source line with a trailing comment + * @param {number} lineNumber The one-indexed line number this is on + * @param {ASTNode} comment The comment to remove + * @returns {boolean} If the comment covers the entire line + */ + function isFullLineComment(line, lineNumber, comment) { + const start = comment.loc.start, + end = comment.loc.end, + isFirstTokenOnLine = !line + .slice(0, comment.loc.start.column) + .trim(); + + return ( + comment && + (start.line < lineNumber || + (start.line === lineNumber && isFirstTokenOnLine)) && + (end.line > lineNumber || + (end.line === lineNumber && end.column === line.length)) + ); + } + + /** + * Check if a node is a JSXEmptyExpression contained in a single line JSXExpressionContainer. + * @param {ASTNode} node A node to check. + * @returns {boolean} True if the node is a JSXEmptyExpression contained in a single line JSXExpressionContainer. + */ + function isJSXEmptyExpressionInSingleLineContainer(node) { + if ( + !node || + !node.parent || + node.type !== "JSXEmptyExpression" || + node.parent.type !== "JSXExpressionContainer" + ) { + return false; + } + + const parent = node.parent; + + return parent.loc.start.line === parent.loc.end.line; + } + + /** + * Gets the line after the comment and any remaining trailing whitespace is + * stripped. + * @param {string} line The source line with a trailing comment + * @param {ASTNode} comment The comment to remove + * @returns {string} Line without comment and trailing whitespace + */ + function stripTrailingComment(line, comment) { + // loc.column is zero-indexed + return line.slice(0, comment.loc.start.column).replace(/\s+$/u, ""); + } + + /** + * Ensure that an array exists at [key] on `object`, and add `value` to it. + * @param {Object} object the object to mutate + * @param {string} key the object's key + * @param {any} value the value to add + * @returns {void} + * @private + */ + function ensureArrayAndPush(object, key, value) { + if (!Array.isArray(object[key])) { + object[key] = []; + } + object[key].push(value); + } + + /** + * Retrieves an array containing all strings (" or ') in the source code. + * @returns {ASTNode[]} An array of string nodes. + */ + function getAllStrings() { + return sourceCode.ast.tokens.filter( + token => + token.type === "String" || + (token.type === "JSXText" && + sourceCode.getNodeByRangeIndex(token.range[0] - 1) + .type === "JSXAttribute"), + ); + } + + /** + * Retrieves an array containing all template literals in the source code. + * @returns {ASTNode[]} An array of template literal nodes. + */ + function getAllTemplateLiterals() { + return sourceCode.ast.tokens.filter( + token => token.type === "Template", + ); + } + + /** + * Retrieves an array containing all RegExp literals in the source code. + * @returns {ASTNode[]} An array of RegExp literal nodes. + */ + function getAllRegExpLiterals() { + return sourceCode.ast.tokens.filter( + token => token.type === "RegularExpression", + ); + } + + /** + * + * reduce an array of AST nodes by line number, both start and end. + * @param {ASTNode[]} arr array of AST nodes + * @returns {Object} accululated AST nodes + */ + function groupArrayByLineNumber(arr) { + const obj = {}; + + for (let i = 0; i < arr.length; i++) { + const node = arr[i]; + + for (let j = node.loc.start.line; j <= node.loc.end.line; ++j) { + ensureArrayAndPush(obj, j, node); + } + } + return obj; + } + + /** + * Returns an array of all comments in the source code. + * If the element in the array is a JSXEmptyExpression contained with a single line JSXExpressionContainer, + * the element is changed with JSXExpressionContainer node. + * @returns {ASTNode[]} An array of comment nodes + */ + function getAllComments() { + const comments = []; + + sourceCode.getAllComments().forEach(commentNode => { + const containingNode = sourceCode.getNodeByRangeIndex( + commentNode.range[0], + ); + + if (isJSXEmptyExpressionInSingleLineContainer(containingNode)) { + // push a unique node only + if (comments.at(-1) !== containingNode.parent) { + comments.push(containingNode.parent); + } + } else { + comments.push(commentNode); + } + }); + + return comments; + } + + /** + * Check the program for max length + * @param {ASTNode} node Node to examine + * @returns {void} + * @private + */ + function checkProgramForMaxLength(node) { + // split (honors line-ending) + const lines = sourceCode.lines, + // list of comments to ignore + comments = + ignoreComments || maxCommentLength || ignoreTrailingComments + ? getAllComments() + : []; + + // we iterate over comments in parallel with the lines + let commentsIndex = 0; + + const strings = getAllStrings(); + const stringsByLine = groupArrayByLineNumber(strings); + + const templateLiterals = getAllTemplateLiterals(); + const templateLiteralsByLine = + groupArrayByLineNumber(templateLiterals); + + const regExpLiterals = getAllRegExpLiterals(); + const regExpLiteralsByLine = groupArrayByLineNumber(regExpLiterals); + + lines.forEach((line, i) => { + // i is zero-indexed, line numbers are one-indexed + const lineNumber = i + 1; + + /* + * if we're checking comment length; we need to know whether this + * line is a comment + */ + let lineIsComment = false; + let textToMeasure; + + /* + * We can short-circuit the comment checks if we're already out of + * comments to check. + */ + if (commentsIndex < comments.length) { + let comment; + + // iterate over comments until we find one past the current line + do { + comment = comments[++commentsIndex]; + } while (comment && comment.loc.start.line <= lineNumber); + + // and step back by one + comment = comments[--commentsIndex]; + + if (isFullLineComment(line, lineNumber, comment)) { + lineIsComment = true; + textToMeasure = line; + } else if ( + ignoreTrailingComments && + isTrailingComment(line, lineNumber, comment) + ) { + textToMeasure = stripTrailingComment(line, comment); + + // ignore multiple trailing comments in the same line + let lastIndex = commentsIndex; + + while ( + isTrailingComment( + textToMeasure, + lineNumber, + comments[--lastIndex], + ) + ) { + textToMeasure = stripTrailingComment( + textToMeasure, + comments[lastIndex], + ); + } + } else { + textToMeasure = line; + } + } else { + textToMeasure = line; + } + if ( + (ignorePattern && ignorePattern.test(textToMeasure)) || + (ignoreUrls && URL_REGEXP.test(textToMeasure)) || + (ignoreStrings && stringsByLine[lineNumber]) || + (ignoreTemplateLiterals && + templateLiteralsByLine[lineNumber]) || + (ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]) + ) { + // ignore this line + return; + } + + const lineLength = computeLineLength(textToMeasure, tabWidth); + const commentLengthApplies = lineIsComment && maxCommentLength; + + if (lineIsComment && ignoreComments) { + return; + } + + const loc = { + start: { + line: lineNumber, + column: 0, + }, + end: { + line: lineNumber, + column: textToMeasure.length, + }, + }; + + if (commentLengthApplies) { + if (lineLength > maxCommentLength) { + context.report({ + node, + loc, + messageId: "maxComment", + data: { + lineLength, + maxCommentLength, + }, + }); + } + } else if (lineLength > maxLength) { + context.report({ + node, + loc, + messageId: "max", + data: { + lineLength, + maxLength, + }, + }); + } + }); + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + Program: checkProgramForMaxLength, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines-per-function.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines-per-function.js new file mode 100644 index 00000000..fb01d8c3 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines-per-function.js @@ -0,0 +1,242 @@ +/** + * @fileoverview A rule to set the maximum number of line of code in a function. + * @author Pete Ward + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { upperCaseFirst } = require("../shared/string-utils"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const OPTIONS_SCHEMA = { + type: "object", + properties: { + max: { + type: "integer", + minimum: 0, + }, + skipComments: { + type: "boolean", + }, + skipBlankLines: { + type: "boolean", + }, + IIFEs: { + type: "boolean", + }, + }, + additionalProperties: false, +}; + +const OPTIONS_OR_INTEGER_SCHEMA = { + oneOf: [ + OPTIONS_SCHEMA, + { + type: "integer", + minimum: 1, + }, + ], +}; + +/** + * Given a list of comment nodes, return a map with numeric keys (source code line numbers) and comment token values. + * @param {Array} comments An array of comment nodes. + * @returns {Map} A map with numeric keys (source code line numbers) and comment token values. + */ +function getCommentLineNumbers(comments) { + const map = new Map(); + + comments.forEach(comment => { + for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) { + map.set(i, comment); + } + }); + return map; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce a maximum number of lines of code in a function", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-lines-per-function", + }, + + schema: [OPTIONS_OR_INTEGER_SCHEMA], + + defaultOptions: [50], + + messages: { + exceed: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const lines = sourceCode.lines; + + const option = context.options[0]; + let maxLines = 50; + let skipComments = false; + let skipBlankLines = false; + let IIFEs = false; + + if (typeof option === "object") { + maxLines = typeof option.max === "number" ? option.max : 50; + skipComments = !!option.skipComments; + skipBlankLines = !!option.skipBlankLines; + IIFEs = !!option.IIFEs; + } else if (typeof option === "number") { + maxLines = option; + } + + const commentLineNumbers = getCommentLineNumbers( + sourceCode.getAllComments(), + ); + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Tells if a comment encompasses the entire line. + * @param {string} line The source line with a trailing comment + * @param {number} lineNumber The one-indexed line number this is on + * @param {ASTNode} comment The comment to remove + * @returns {boolean} If the comment covers the entire line + */ + function isFullLineComment(line, lineNumber, comment) { + const start = comment.loc.start, + end = comment.loc.end, + isFirstTokenOnLine = + start.line === lineNumber && + !line.slice(0, start.column).trim(), + isLastTokenOnLine = + end.line === lineNumber && !line.slice(end.column).trim(); + + return ( + comment && + (start.line < lineNumber || isFirstTokenOnLine) && + (end.line > lineNumber || isLastTokenOnLine) + ); + } + + /** + * Identifies is a node is a FunctionExpression which is part of an IIFE + * @param {ASTNode} node Node to test + * @returns {boolean} True if it's an IIFE + */ + function isIIFE(node) { + return ( + (node.type === "FunctionExpression" || + node.type === "ArrowFunctionExpression") && + node.parent && + node.parent.type === "CallExpression" && + node.parent.callee === node + ); + } + + /** + * Identifies is a node is a FunctionExpression which is embedded within a MethodDefinition or Property + * @param {ASTNode} node Node to test + * @returns {boolean} True if it's a FunctionExpression embedded within a MethodDefinition or Property + */ + function isEmbedded(node) { + if (!node.parent) { + return false; + } + if (node !== node.parent.value) { + return false; + } + if (node.parent.type === "MethodDefinition") { + return true; + } + if (node.parent.type === "Property") { + return ( + node.parent.method === true || + node.parent.kind === "get" || + node.parent.kind === "set" + ); + } + return false; + } + + /** + * Count the lines in the function + * @param {ASTNode} funcNode Function AST node + * @returns {void} + * @private + */ + function processFunction(funcNode) { + const node = isEmbedded(funcNode) ? funcNode.parent : funcNode; + + if (!IIFEs && isIIFE(node)) { + return; + } + let lineCount = 0; + + for (let i = node.loc.start.line - 1; i < node.loc.end.line; ++i) { + const line = lines[i]; + + if (skipComments) { + if ( + commentLineNumbers.has(i + 1) && + isFullLineComment( + line, + i + 1, + commentLineNumbers.get(i + 1), + ) + ) { + continue; + } + } + + if (skipBlankLines) { + if (line.match(/^\s*$/u)) { + continue; + } + } + + lineCount++; + } + + if (lineCount > maxLines) { + const name = upperCaseFirst( + astUtils.getFunctionNameWithKind(funcNode), + ); + + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode), + messageId: "exceed", + data: { name, lineCount, maxLines }, + }); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + FunctionDeclaration: processFunction, + FunctionExpression: processFunction, + ArrowFunctionExpression: processFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines.js new file mode 100644 index 00000000..6847bde0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-lines.js @@ -0,0 +1,192 @@ +/** + * @fileoverview enforce a maximum file length + * @author Alberto Rodríguez + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Creates an array of numbers from `start` up to, but not including, `end` + * @param {number} start The start of the range + * @param {number} end The end of the range + * @returns {number[]} The range of numbers + */ +function range(start, end) { + return [...Array(end - start).keys()].map(x => x + start); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Enforce a maximum number of lines per file", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-lines", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + max: { + type: "integer", + minimum: 0, + }, + skipComments: { + type: "boolean", + }, + skipBlankLines: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [300], + + messages: { + exceed: "File has too many lines ({{actual}}). Maximum allowed is {{max}}.", + }, + }, + + create(context) { + const option = context.options[0]; + let max = 300; + + if (typeof option === "object" && Object.hasOwn(option, "max")) { + max = option.max; + } else if (typeof option === "number") { + max = option; + } + + const skipComments = option && option.skipComments; + const skipBlankLines = option && option.skipBlankLines; + + const sourceCode = context.sourceCode; + + /** + * Returns whether or not a token is a comment node type + * @param {Token} token The token to check + * @returns {boolean} True if the token is a comment node + */ + function isCommentNodeType(token) { + return token && (token.type === "Block" || token.type === "Line"); + } + + /** + * Returns the line numbers of a comment that don't have any code on the same line + * @param {Node} comment The comment node to check + * @returns {number[]} The line numbers + */ + function getLinesWithoutCode(comment) { + let start = comment.loc.start.line; + let end = comment.loc.end.line; + + let token; + + token = comment; + do { + token = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + } while (isCommentNodeType(token)); + + if (token && astUtils.isTokenOnSameLine(token, comment)) { + start += 1; + } + + token = comment; + do { + token = sourceCode.getTokenAfter(token, { + includeComments: true, + }); + } while (isCommentNodeType(token)); + + if (token && astUtils.isTokenOnSameLine(comment, token)) { + end -= 1; + } + + if (start <= end) { + return range(start, end + 1); + } + return []; + } + + return { + "Program:exit"() { + let lines = sourceCode.lines.map((text, i) => ({ + lineNumber: i + 1, + text, + })); + + /* + * If file ends with a linebreak, `sourceCode.lines` will have one extra empty line at the end. + * That isn't a real line, so we shouldn't count it. + */ + if (lines.length > 1 && lines.at(-1).text === "") { + lines.pop(); + } + + if (skipBlankLines) { + lines = lines.filter(l => l.text.trim() !== ""); + } + + if (skipComments) { + const comments = sourceCode.getAllComments(); + + const commentLines = new Set( + comments.flatMap(getLinesWithoutCode), + ); + + lines = lines.filter(l => !commentLines.has(l.lineNumber)); + } + + if (lines.length > max) { + const loc = { + start: { + line: lines[max].lineNumber, + column: 0, + }, + end: { + line: sourceCode.lines.length, + column: sourceCode.lines.at(-1).length, + }, + }; + + context.report({ + loc, + messageId: "exceed", + data: { + max, + actual: lines.length, + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-nested-callbacks.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-nested-callbacks.js new file mode 100644 index 00000000..81d0a796 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-nested-callbacks.js @@ -0,0 +1,146 @@ +/** + * @fileoverview Rule to enforce a maximum number of nested callbacks. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Enforce a maximum depth that callbacks can be nested", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-nested-callbacks", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + maximum: { + type: "integer", + minimum: 0, + }, + max: { + type: "integer", + minimum: 0, + }, + checkConstructorCallCallbacks: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [10], + + messages: { + exceed: "Too many nested callbacks ({{num}}). Maximum allowed is {{max}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Constants + //-------------------------------------------------------------------------- + const option = context.options[0]; + let THRESHOLD = 10; + + if ( + typeof option === "object" && + (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) + ) { + THRESHOLD = option.maximum || option.max; + } else if (typeof option === "number") { + THRESHOLD = option; + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const callbackStack = []; + + /** + * Checks a given function node for too many callbacks. + * @param {ASTNode} node The node to check. + * @returns {void} + * @private + */ + function checkFunction(node) { + const parent = node.parent; + + if ( + (parent.type !== "CallExpression" && + !( + option.checkConstructorCallCallbacks && + parent.type === "NewExpression" + )) || + parent.callee === node + ) { + return; + } + + callbackStack.push(node); + + if (callbackStack.length > THRESHOLD) { + const opts = { num: callbackStack.length, max: THRESHOLD }; + + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + messageId: "exceed", + data: opts, + }); + } + } + + /** + * Pops the call stack. + * @param {ASTNode} node The node to check. + * @returns {void} + * @private + */ + function popStack(node) { + if (callbackStack.at(-1) === node) { + callbackStack.pop(); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + ArrowFunctionExpression: checkFunction, + "ArrowFunctionExpression:exit": popStack, + + FunctionExpression: checkFunction, + "FunctionExpression:exit": popStack, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-params.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-params.js new file mode 100644 index 00000000..115ec7f4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-params.js @@ -0,0 +1,150 @@ +/** + * @fileoverview Rule to flag when a function has too many parameters + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { upperCaseFirst } = require("../shared/string-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce a maximum number of parameters in function definitions", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-params", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + maximum: { + type: "integer", + minimum: 0, + }, + max: { + type: "integer", + minimum: 0, + }, + countVoidThis: { + type: "boolean", + description: + "Whether to count a `this` declaration when the type is `void`.", + }, + countThis: { + enum: ["never", "except-void", "always"], + description: + "Whether to count a `this` declaration.", + }, + }, + additionalProperties: false, + not: { required: ["countVoidThis", "countThis"] }, + }, + ], + }, + ], + + defaultOptions: [3], + + messages: { + exceed: "{{name}} has too many parameters ({{count}}). Maximum allowed is {{max}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0]; + let numParams = 3; + let countThis = "except-void"; + + if (typeof option === "object") { + if ( + Object.hasOwn(option, "maximum") || + Object.hasOwn(option, "max") + ) { + numParams = option.maximum || option.max; + } + + countThis = option.countThis; + if (!countThis && Object.hasOwn(option, "countVoidThis")) { + countThis = option.countVoidThis ? "always" : "except-void"; + } + countThis ||= "except-void"; + } + if (typeof option === "number") { + numParams = option; + } + + /** + * Checks a function to see if it has too many parameters. + * @param {ASTNode} node The node to check. + * @returns {void} + * @private + */ + function checkFunction(node) { + const thisParam = + node.params.length > 0 && + node.params[0].type === "Identifier" && + node.params[0].name === "this" + ? node.params[0] + : null; + + let effectiveParamCount = node.params.length; + if (thisParam) { + if (countThis === "never") { + effectiveParamCount = node.params.length - 1; + } else if ( + countThis === "except-void" && + thisParam.typeAnnotation?.typeAnnotation.type === + "TSVoidKeyword" + ) { + effectiveParamCount = node.params.length - 1; + } + } + + if (effectiveParamCount > numParams) { + context.report({ + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + node, + messageId: "exceed", + data: { + name: upperCaseFirst( + astUtils.getFunctionNameWithKind(node), + ), + count: effectiveParamCount, + max: numParams, + }, + }); + } + } + + return { + FunctionDeclaration: checkFunction, + ArrowFunctionExpression: checkFunction, + FunctionExpression: checkFunction, + TSDeclareFunction: checkFunction, + TSFunctionType: checkFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements-per-line.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements-per-line.js new file mode 100644 index 00000000..48b37f4f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements-per-line.js @@ -0,0 +1,224 @@ +/** + * @fileoverview Specify the maximum number of statements allowed per line. + * @author Kenneth Williams + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "max-statements-per-line", + url: "https://eslint.style/rules/max-statements-per-line", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce a maximum number of statements allowed per line", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-statements-per-line", + }, + + schema: [ + { + type: "object", + properties: { + max: { + type: "integer", + minimum: 1, + default: 1, + }, + }, + additionalProperties: false, + }, + ], + messages: { + exceed: "This line has {{numberOfStatementsOnThisLine}} {{statements}}. Maximum allowed is {{maxStatementsPerLine}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode, + options = context.options[0] || {}, + maxStatementsPerLine = + typeof options.max !== "undefined" ? options.max : 1; + + let lastStatementLine = 0, + numberOfStatementsOnThisLine = 0, + firstExtraStatement; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const SINGLE_CHILD_ALLOWED = + /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/u; + + /** + * Reports with the first extra statement, and clears it. + * @returns {void} + */ + function reportFirstExtraStatementAndClear() { + if (firstExtraStatement) { + context.report({ + node: firstExtraStatement, + messageId: "exceed", + data: { + numberOfStatementsOnThisLine, + maxStatementsPerLine, + statements: + numberOfStatementsOnThisLine === 1 + ? "statement" + : "statements", + }, + }); + } + firstExtraStatement = null; + } + + /** + * Gets the actual last token of a given node. + * @param {ASTNode} node A node to get. This is a node except EmptyStatement. + * @returns {Token} The actual last token. + */ + function getActualLastToken(node) { + return sourceCode.getLastToken(node, astUtils.isNotSemicolonToken); + } + + /** + * Addresses a given node. + * It updates the state of this rule, then reports the node if the node violated this rule. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function enterStatement(node) { + const line = node.loc.start.line; + + /* + * Skip to allow non-block statements if this is direct child of control statements. + * `if (a) foo();` is counted as 1. + * But `if (a) foo(); else foo();` should be counted as 2. + */ + if ( + SINGLE_CHILD_ALLOWED.test(node.parent.type) && + node.parent.alternate !== node + ) { + return; + } + + // Update state. + if (line === lastStatementLine) { + numberOfStatementsOnThisLine += 1; + } else { + reportFirstExtraStatementAndClear(); + numberOfStatementsOnThisLine = 1; + lastStatementLine = line; + } + + // Reports if the node violated this rule. + if (numberOfStatementsOnThisLine === maxStatementsPerLine + 1) { + firstExtraStatement = firstExtraStatement || node; + } + } + + /** + * Updates the state of this rule with the end line of leaving node to check with the next statement. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function leaveStatement(node) { + const line = getActualLastToken(node).loc.end.line; + + // Update state. + if (line !== lastStatementLine) { + reportFirstExtraStatementAndClear(); + numberOfStatementsOnThisLine = 1; + lastStatementLine = line; + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + BreakStatement: enterStatement, + ClassDeclaration: enterStatement, + ContinueStatement: enterStatement, + DebuggerStatement: enterStatement, + DoWhileStatement: enterStatement, + ExpressionStatement: enterStatement, + ForInStatement: enterStatement, + ForOfStatement: enterStatement, + ForStatement: enterStatement, + FunctionDeclaration: enterStatement, + IfStatement: enterStatement, + ImportDeclaration: enterStatement, + LabeledStatement: enterStatement, + ReturnStatement: enterStatement, + SwitchStatement: enterStatement, + ThrowStatement: enterStatement, + TryStatement: enterStatement, + VariableDeclaration: enterStatement, + WhileStatement: enterStatement, + WithStatement: enterStatement, + ExportNamedDeclaration: enterStatement, + ExportDefaultDeclaration: enterStatement, + ExportAllDeclaration: enterStatement, + + "BreakStatement:exit": leaveStatement, + "ClassDeclaration:exit": leaveStatement, + "ContinueStatement:exit": leaveStatement, + "DebuggerStatement:exit": leaveStatement, + "DoWhileStatement:exit": leaveStatement, + "ExpressionStatement:exit": leaveStatement, + "ForInStatement:exit": leaveStatement, + "ForOfStatement:exit": leaveStatement, + "ForStatement:exit": leaveStatement, + "FunctionDeclaration:exit": leaveStatement, + "IfStatement:exit": leaveStatement, + "ImportDeclaration:exit": leaveStatement, + "LabeledStatement:exit": leaveStatement, + "ReturnStatement:exit": leaveStatement, + "SwitchStatement:exit": leaveStatement, + "ThrowStatement:exit": leaveStatement, + "TryStatement:exit": leaveStatement, + "VariableDeclaration:exit": leaveStatement, + "WhileStatement:exit": leaveStatement, + "WithStatement:exit": leaveStatement, + "ExportNamedDeclaration:exit": leaveStatement, + "ExportDefaultDeclaration:exit": leaveStatement, + "ExportAllDeclaration:exit": leaveStatement, + "Program:exit": reportFirstExtraStatementAndClear, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements.js new file mode 100644 index 00000000..5458bc08 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/max-statements.js @@ -0,0 +1,192 @@ +/** + * @fileoverview A rule to set the maximum number of statements in a function. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { upperCaseFirst } = require("../shared/string-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce a maximum number of statements allowed in function blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/max-statements", + }, + + schema: [ + { + oneOf: [ + { + type: "integer", + minimum: 0, + }, + { + type: "object", + properties: { + maximum: { + type: "integer", + minimum: 0, + }, + max: { + type: "integer", + minimum: 0, + }, + }, + additionalProperties: false, + }, + ], + }, + { + type: "object", + properties: { + ignoreTopLevelFunctions: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [10], + + messages: { + exceed: "{{name}} has too many statements ({{count}}). Maximum allowed is {{max}}.", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const functionStack = [], + option = context.options[0], + ignoreTopLevelFunctions = + (context.options[1] && + context.options[1].ignoreTopLevelFunctions) || + false, + topLevelFunctions = []; + let maxStatements = 10; + + if ( + typeof option === "object" && + (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) + ) { + maxStatements = option.maximum || option.max; + } else if (typeof option === "number") { + maxStatements = option; + } + + /** + * Reports a node if it has too many statements + * @param {ASTNode} node node to evaluate + * @param {number} count Number of statements in node + * @param {number} max Maximum number of statements allowed + * @returns {void} + * @private + */ + function reportIfTooManyStatements(node, count, max) { + if (count > max) { + const name = upperCaseFirst( + astUtils.getFunctionNameWithKind(node), + ); + + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, context.sourceCode), + messageId: "exceed", + data: { name, count, max }, + }); + } + } + + /** + * When parsing a new function, store it in our function stack + * @returns {void} + * @private + */ + function startFunction() { + functionStack.push(0); + } + + /** + * Evaluate the node at the end of function + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function endFunction(node) { + const count = functionStack.pop(); + + /* + * This rule does not apply to class static blocks, but we have to track them so + * that statements in them do not count as statements in the enclosing function. + */ + if (node.type === "StaticBlock") { + return; + } + + if (ignoreTopLevelFunctions && functionStack.length === 0) { + topLevelFunctions.push({ node, count }); + } else { + reportIfTooManyStatements(node, count, maxStatements); + } + } + + /** + * Increment the count of the functions + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function countStatements(node) { + functionStack[functionStack.length - 1] += node.body.length; + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + FunctionDeclaration: startFunction, + FunctionExpression: startFunction, + ArrowFunctionExpression: startFunction, + StaticBlock: startFunction, + + BlockStatement: countStatements, + + "FunctionDeclaration:exit": endFunction, + "FunctionExpression:exit": endFunction, + "ArrowFunctionExpression:exit": endFunction, + "StaticBlock:exit": endFunction, + + "Program:exit"() { + if (topLevelFunctions.length === 1) { + return; + } + + topLevelFunctions.forEach(element => { + const count = element.count; + const node = element.node; + + reportIfTooManyStatements(node, count, maxStatements); + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-comment-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-comment-style.js new file mode 100644 index 00000000..463e7a73 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-comment-style.js @@ -0,0 +1,652 @@ +/** + * @fileoverview enforce a particular style for multiline comments + * @author Teddy Katz + * @deprecated in ESLint v9.3.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "9.3.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "multiline-comment-style", + url: "https://eslint.style/rules/multiline-comment-style", + }, + }, + ], + }, + type: "suggestion", + docs: { + description: "Enforce a particular style for multiline comments", + recommended: false, + url: "https://eslint.org/docs/latest/rules/multiline-comment-style", + }, + + fixable: "whitespace", + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["starred-block", "bare-block"], + }, + ], + additionalItems: false, + }, + { + type: "array", + items: [ + { + enum: ["separate-lines"], + }, + { + type: "object", + properties: { + checkJSDoc: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + additionalItems: false, + }, + ], + }, + messages: { + expectedBlock: + "Expected a block comment instead of consecutive line comments.", + expectedBareBlock: + "Expected a block comment without padding stars.", + startNewline: "Expected a linebreak after '/*'.", + endNewline: "Expected a linebreak before '*/'.", + missingStar: "Expected a '*' at the start of this line.", + alignment: + "Expected this line to be aligned with the start of the comment.", + expectedLines: + "Expected multiple line comments instead of a block comment.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0] || "starred-block"; + const params = context.options[1] || {}; + const checkJSDoc = !!params.checkJSDoc; + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Checks if a comment line is starred. + * @param {string} line A string representing a comment line. + * @returns {boolean} Whether or not the comment line is starred. + */ + function isStarredCommentLine(line) { + return /^\s*\*/u.test(line); + } + + /** + * Checks if a comment group is in starred-block form. + * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment. + * @returns {boolean} Whether or not the comment group is in starred block form. + */ + function isStarredBlockComment([firstComment]) { + if (firstComment.type !== "Block") { + return false; + } + + const lines = firstComment.value.split(astUtils.LINEBREAK_MATCHER); + + // The first and last lines can only contain whitespace. + return ( + lines.length > 0 && + lines.every((line, i) => + (i === 0 || i === lines.length - 1 + ? /^\s*$/u + : /^\s*\*/u + ).test(line), + ) + ); + } + + /** + * Checks if a comment group is in JSDoc form. + * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment. + * @returns {boolean} Whether or not the comment group is in JSDoc form. + */ + function isJSDocComment([firstComment]) { + if (firstComment.type !== "Block") { + return false; + } + + const lines = firstComment.value.split(astUtils.LINEBREAK_MATCHER); + + return ( + /^\*\s*$/u.test(lines[0]) && + lines.slice(1, -1).every(line => /^\s* /u.test(line)) && + /^\s*$/u.test(lines.at(-1)) + ); + } + + /** + * Processes a comment group that is currently in separate-line form, calculating the offset for each line. + * @param {Token[]} commentGroup A group of comments containing multiple line comments. + * @returns {string[]} An array of the processed lines. + */ + function processSeparateLineComments(commentGroup) { + const allLinesHaveLeadingSpace = commentGroup + .map(({ value }) => value) + .filter(line => line.trim().length) + .every(line => line.startsWith(" ")); + + return commentGroup.map(({ value }) => + allLinesHaveLeadingSpace ? value.replace(/^ /u, "") : value, + ); + } + + /** + * Processes a comment group that is currently in starred-block form, calculating the offset for each line. + * @param {Token} comment A single block comment token in starred-block form. + * @returns {string[]} An array of the processed lines. + */ + function processStarredBlockComment(comment) { + const lines = comment.value + .split(astUtils.LINEBREAK_MATCHER) + .filter( + (line, i, linesArr) => + !(i === 0 || i === linesArr.length - 1), + ) + .map(line => line.replace(/^\s*$/u, "")); + const allLinesHaveLeadingSpace = lines + .map(line => line.replace(/\s*\*/u, "")) + .filter(line => line.trim().length) + .every(line => line.startsWith(" ")); + + return lines.map(line => + line.replace( + allLinesHaveLeadingSpace ? /\s*\* ?/u : /\s*\*/u, + "", + ), + ); + } + + /** + * Processes a comment group that is currently in bare-block form, calculating the offset for each line. + * @param {Token} comment A single block comment token in bare-block form. + * @returns {string[]} An array of the processed lines. + */ + function processBareBlockComment(comment) { + const lines = comment.value + .split(astUtils.LINEBREAK_MATCHER) + .map(line => line.replace(/^\s*$/u, "")); + const leadingWhitespace = `${sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0])} `; + let offset = ""; + + /* + * Calculate the offset of the least indented line and use that as the basis for offsetting all the lines. + * The first line should not be checked because it is inline with the opening block comment delimiter. + */ + for (const [i, line] of lines.entries()) { + if (!line.trim().length || i === 0) { + continue; + } + + const [, lineOffset] = line.match(/^(\s*\*?\s*)/u); + + if (lineOffset.length < leadingWhitespace.length) { + const newOffset = leadingWhitespace.slice( + lineOffset.length - leadingWhitespace.length, + ); + + if (newOffset.length > offset.length) { + offset = newOffset; + } + } + } + + return lines.map(line => { + const match = line.match(/^(\s*\*?\s*)(.*)/u); + const [, lineOffset, lineContents] = match; + + if (lineOffset.length > leadingWhitespace.length) { + return `${lineOffset.slice(leadingWhitespace.length - (offset.length + lineOffset.length))}${lineContents}`; + } + + if (lineOffset.length < leadingWhitespace.length) { + return `${lineOffset.slice(leadingWhitespace.length)}${lineContents}`; + } + + return lineContents; + }); + } + + /** + * Gets a list of comment lines in a group, formatting leading whitespace as necessary. + * @param {Token[]} commentGroup A group of comments containing either multiple line comments or a single block comment. + * @returns {string[]} A list of comment lines. + */ + function getCommentLines(commentGroup) { + const [firstComment] = commentGroup; + + if (firstComment.type === "Line") { + return processSeparateLineComments(commentGroup); + } + + if (isStarredBlockComment(commentGroup)) { + return processStarredBlockComment(firstComment); + } + + return processBareBlockComment(firstComment); + } + + /** + * Gets the initial offset (whitespace) from the beginning of a line to a given comment token. + * @param {Token} comment The token to check. + * @returns {string} The offset from the beginning of a line to the token. + */ + function getInitialOffset(comment) { + return sourceCode.text.slice( + comment.range[0] - comment.loc.start.column, + comment.range[0], + ); + } + + /** + * Converts a comment into starred-block form + * @param {Token} firstComment The first comment of the group being converted + * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment + * @returns {string} A representation of the comment value in starred-block form, excluding start and end markers + */ + function convertToStarredBlock(firstComment, commentLinesList) { + const initialOffset = getInitialOffset(firstComment); + + return `/*\n${commentLinesList.map(line => `${initialOffset} * ${line}`).join("\n")}\n${initialOffset} */`; + } + + /** + * Converts a comment into separate-line form + * @param {Token} firstComment The first comment of the group being converted + * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment + * @returns {string} A representation of the comment value in separate-line form + */ + function convertToSeparateLines(firstComment, commentLinesList) { + return commentLinesList + .map(line => `// ${line}`) + .join(`\n${getInitialOffset(firstComment)}`); + } + + /** + * Converts a comment into bare-block form + * @param {Token} firstComment The first comment of the group being converted + * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment + * @returns {string} A representation of the comment value in bare-block form + */ + function convertToBlock(firstComment, commentLinesList) { + return `/* ${commentLinesList.join(`\n${getInitialOffset(firstComment)} `)} */`; + } + + /** + * Each method checks a group of comments to see if it's valid according to the given option. + * @param {Token[]} commentGroup A list of comments that appear together. This will either contain a single + * block comment or multiple line comments. + * @returns {void} + */ + const commentGroupCheckers = { + "starred-block"(commentGroup) { + const [firstComment] = commentGroup; + const commentLines = getCommentLines(commentGroup); + + if (commentLines.some(value => value.includes("*/"))) { + return; + } + + if (commentGroup.length > 1) { + context.report({ + loc: { + start: firstComment.loc.start, + end: commentGroup.at(-1).loc.end, + }, + messageId: "expectedBlock", + fix(fixer) { + const range = [ + firstComment.range[0], + commentGroup.at(-1).range[1], + ]; + + return commentLines.some(value => + value.startsWith("/"), + ) + ? null + : fixer.replaceTextRange( + range, + convertToStarredBlock( + firstComment, + commentLines, + ), + ); + }, + }); + } else { + const lines = firstComment.value.split( + astUtils.LINEBREAK_MATCHER, + ); + const expectedLeadingWhitespace = + getInitialOffset(firstComment); + const expectedLinePrefix = `${expectedLeadingWhitespace} *`; + + if (!/^\*?\s*$/u.test(lines[0])) { + const start = firstComment.value.startsWith("*") + ? firstComment.range[0] + 1 + : firstComment.range[0]; + + context.report({ + loc: { + start: firstComment.loc.start, + end: { + line: firstComment.loc.start.line, + column: firstComment.loc.start.column + 2, + }, + }, + messageId: "startNewline", + fix: fixer => + fixer.insertTextAfterRange( + [start, start + 2], + `\n${expectedLinePrefix}`, + ), + }); + } + + if (!/^\s*$/u.test(lines.at(-1))) { + context.report({ + loc: { + start: { + line: firstComment.loc.end.line, + column: firstComment.loc.end.column - 2, + }, + end: firstComment.loc.end, + }, + messageId: "endNewline", + fix: fixer => + fixer.replaceTextRange( + [ + firstComment.range[1] - 2, + firstComment.range[1], + ], + `\n${expectedLinePrefix}/`, + ), + }); + } + + for ( + let lineNumber = firstComment.loc.start.line + 1; + lineNumber <= firstComment.loc.end.line; + lineNumber++ + ) { + const lineText = sourceCode.lines[lineNumber - 1]; + const errorType = isStarredCommentLine(lineText) + ? "alignment" + : "missingStar"; + + if (!lineText.startsWith(expectedLinePrefix)) { + context.report({ + loc: { + start: { line: lineNumber, column: 0 }, + end: { + line: lineNumber, + column: lineText.length, + }, + }, + messageId: errorType, + fix(fixer) { + const lineStartIndex = + sourceCode.getIndexFromLoc({ + line: lineNumber, + column: 0, + }); + + if (errorType === "alignment") { + const [, commentTextPrefix = ""] = + lineText.match(/^(\s*\*)/u) || []; + const commentTextStartIndex = + lineStartIndex + + commentTextPrefix.length; + + return fixer.replaceTextRange( + [ + lineStartIndex, + commentTextStartIndex, + ], + expectedLinePrefix, + ); + } + + const [, commentTextPrefix = ""] = + lineText.match(/^(\s*)/u) || []; + const commentTextStartIndex = + lineStartIndex + + commentTextPrefix.length; + let offset; + + for (const [idx, line] of lines.entries()) { + if (!/\S+/u.test(line)) { + continue; + } + + const lineTextToAlignWith = + sourceCode.lines[ + firstComment.loc.start.line - + 1 + + idx + ]; + const [ + , + prefix = "", + initialOffset = "", + ] = + lineTextToAlignWith.match( + /^(\s*(?:\/?\*)?(\s*))/u, + ) || []; + + offset = `${commentTextPrefix.slice(prefix.length)}${initialOffset}`; + + if ( + /^\s*\//u.test(lineText) && + offset.length === 0 + ) { + offset += " "; + } + break; + } + + return fixer.replaceTextRange( + [lineStartIndex, commentTextStartIndex], + `${expectedLinePrefix}${offset}`, + ); + }, + }); + } + } + } + }, + "separate-lines"(commentGroup) { + const [firstComment] = commentGroup; + + const isJSDoc = isJSDocComment(commentGroup); + + if (firstComment.type !== "Block" || (!checkJSDoc && isJSDoc)) { + return; + } + + let commentLines = getCommentLines(commentGroup); + + if (isJSDoc) { + commentLines = commentLines.slice( + 1, + commentLines.length - 1, + ); + } + + const tokenAfter = sourceCode.getTokenAfter(firstComment, { + includeComments: true, + }); + + if ( + tokenAfter && + firstComment.loc.end.line === tokenAfter.loc.start.line + ) { + return; + } + + context.report({ + loc: { + start: firstComment.loc.start, + end: { + line: firstComment.loc.start.line, + column: firstComment.loc.start.column + 2, + }, + }, + messageId: "expectedLines", + fix(fixer) { + return fixer.replaceText( + firstComment, + convertToSeparateLines(firstComment, commentLines), + ); + }, + }); + }, + "bare-block"(commentGroup) { + if (isJSDocComment(commentGroup)) { + return; + } + + const [firstComment] = commentGroup; + const commentLines = getCommentLines(commentGroup); + + // Disallows consecutive line comments in favor of using a block comment. + if ( + firstComment.type === "Line" && + commentLines.length > 1 && + !commentLines.some(value => value.includes("*/")) + ) { + context.report({ + loc: { + start: firstComment.loc.start, + end: commentGroup.at(-1).loc.end, + }, + messageId: "expectedBlock", + fix(fixer) { + return fixer.replaceTextRange( + [ + firstComment.range[0], + commentGroup.at(-1).range[1], + ], + convertToBlock(firstComment, commentLines), + ); + }, + }); + } + + // Prohibits block comments from having a * at the beginning of each line. + if (isStarredBlockComment(commentGroup)) { + context.report({ + loc: { + start: firstComment.loc.start, + end: { + line: firstComment.loc.start.line, + column: firstComment.loc.start.column + 2, + }, + }, + messageId: "expectedBareBlock", + fix(fixer) { + return fixer.replaceText( + firstComment, + convertToBlock(firstComment, commentLines), + ); + }, + }); + } + }, + }; + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + Program() { + return sourceCode + .getAllComments() + .filter(comment => comment.type !== "Shebang") + .filter( + comment => + !astUtils.COMMENTS_IGNORE_PATTERN.test( + comment.value, + ), + ) + .filter(comment => { + const tokenBefore = sourceCode.getTokenBefore(comment, { + includeComments: true, + }); + + return ( + !tokenBefore || + tokenBefore.loc.end.line < comment.loc.start.line + ); + }) + .reduce((commentGroups, comment, index, commentList) => { + const tokenBefore = sourceCode.getTokenBefore(comment, { + includeComments: true, + }); + + if ( + comment.type === "Line" && + index && + commentList[index - 1].type === "Line" && + tokenBefore && + tokenBefore.loc.end.line === + comment.loc.start.line - 1 && + tokenBefore === commentList[index - 1] + ) { + commentGroups.at(-1).push(comment); + } else { + commentGroups.push([comment]); + } + + return commentGroups; + }, []) + .filter( + commentGroup => + !( + commentGroup.length === 1 && + commentGroup[0].loc.start.line === + commentGroup[0].loc.end.line + ), + ) + .forEach(commentGroupCheckers[option]); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-ternary.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-ternary.js new file mode 100644 index 00000000..5590fe45 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/multiline-ternary.js @@ -0,0 +1,257 @@ +/** + * @fileoverview Enforce newlines between operands of ternary expressions + * @author Kai Cataldo + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "multiline-ternary", + url: "https://eslint.style/rules/multiline-ternary", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce newlines between operands of ternary expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/multiline-ternary", + }, + + schema: [ + { + enum: ["always", "always-multiline", "never"], + }, + ], + + messages: { + expectedTestCons: + "Expected newline between test and consequent of ternary expression.", + expectedConsAlt: + "Expected newline between consequent and alternate of ternary expression.", + unexpectedTestCons: + "Unexpected newline between test and consequent of ternary expression.", + unexpectedConsAlt: + "Unexpected newline between consequent and alternate of ternary expression.", + }, + + fixable: "whitespace", + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0]; + const multiline = option !== "never"; + const allowSingleLine = option === "always-multiline"; + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ConditionalExpression(node) { + const questionToken = sourceCode.getTokenAfter( + node.test, + astUtils.isNotClosingParenToken, + ); + const colonToken = sourceCode.getTokenAfter( + node.consequent, + astUtils.isNotClosingParenToken, + ); + + const firstTokenOfTest = sourceCode.getFirstToken(node); + const lastTokenOfTest = + sourceCode.getTokenBefore(questionToken); + const firstTokenOfConsequent = + sourceCode.getTokenAfter(questionToken); + const lastTokenOfConsequent = + sourceCode.getTokenBefore(colonToken); + const firstTokenOfAlternate = + sourceCode.getTokenAfter(colonToken); + + const areTestAndConsequentOnSameLine = + astUtils.isTokenOnSameLine( + lastTokenOfTest, + firstTokenOfConsequent, + ); + const areConsequentAndAlternateOnSameLine = + astUtils.isTokenOnSameLine( + lastTokenOfConsequent, + firstTokenOfAlternate, + ); + + const hasComments = !!sourceCode.getCommentsInside(node).length; + + if (!multiline) { + if (!areTestAndConsequentOnSameLine) { + context.report({ + node: node.test, + loc: { + start: firstTokenOfTest.loc.start, + end: lastTokenOfTest.loc.end, + }, + messageId: "unexpectedTestCons", + fix(fixer) { + if (hasComments) { + return null; + } + const fixers = []; + const areTestAndQuestionOnSameLine = + astUtils.isTokenOnSameLine( + lastTokenOfTest, + questionToken, + ); + const areQuestionAndConsOnSameLine = + astUtils.isTokenOnSameLine( + questionToken, + firstTokenOfConsequent, + ); + + if (!areTestAndQuestionOnSameLine) { + fixers.push( + fixer.removeRange([ + lastTokenOfTest.range[1], + questionToken.range[0], + ]), + ); + } + if (!areQuestionAndConsOnSameLine) { + fixers.push( + fixer.removeRange([ + questionToken.range[1], + firstTokenOfConsequent.range[0], + ]), + ); + } + + return fixers; + }, + }); + } + + if (!areConsequentAndAlternateOnSameLine) { + context.report({ + node: node.consequent, + loc: { + start: firstTokenOfConsequent.loc.start, + end: lastTokenOfConsequent.loc.end, + }, + messageId: "unexpectedConsAlt", + fix(fixer) { + if (hasComments) { + return null; + } + const fixers = []; + const areConsAndColonOnSameLine = + astUtils.isTokenOnSameLine( + lastTokenOfConsequent, + colonToken, + ); + const areColonAndAltOnSameLine = + astUtils.isTokenOnSameLine( + colonToken, + firstTokenOfAlternate, + ); + + if (!areConsAndColonOnSameLine) { + fixers.push( + fixer.removeRange([ + lastTokenOfConsequent.range[1], + colonToken.range[0], + ]), + ); + } + if (!areColonAndAltOnSameLine) { + fixers.push( + fixer.removeRange([ + colonToken.range[1], + firstTokenOfAlternate.range[0], + ]), + ); + } + + return fixers; + }, + }); + } + } else { + if ( + allowSingleLine && + node.loc.start.line === node.loc.end.line + ) { + return; + } + + if (areTestAndConsequentOnSameLine) { + context.report({ + node: node.test, + loc: { + start: firstTokenOfTest.loc.start, + end: lastTokenOfTest.loc.end, + }, + messageId: "expectedTestCons", + fix: fixer => + hasComments + ? null + : fixer.replaceTextRange( + [ + lastTokenOfTest.range[1], + questionToken.range[0], + ], + "\n", + ), + }); + } + + if (areConsequentAndAlternateOnSameLine) { + context.report({ + node: node.consequent, + loc: { + start: firstTokenOfConsequent.loc.start, + end: lastTokenOfConsequent.loc.end, + }, + messageId: "expectedConsAlt", + fix: fixer => + hasComments + ? null + : fixer.replaceTextRange( + [ + lastTokenOfConsequent.range[1], + colonToken.range[0], + ], + "\n", + ), + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-cap.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-cap.js new file mode 100644 index 00000000..5f6939a8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-cap.js @@ -0,0 +1,297 @@ +/** + * @fileoverview Rule to flag use of constructors without capital letters + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const CAPS_ALLOWED = new Set([ + "Array", + "Boolean", + "Date", + "Error", + "Function", + "Number", + "Object", + "RegExp", + "String", + "Symbol", + "BigInt", +]); + +const GLOBAL_OBJECT_NAMES = new Set(["global", "globalThis", "self", "window"]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require constructor names to begin with a capital letter", + recommended: false, + url: "https://eslint.org/docs/latest/rules/new-cap", + }, + + schema: [ + { + type: "object", + properties: { + newIsCap: { + type: "boolean", + }, + capIsNew: { + type: "boolean", + }, + newIsCapExceptions: { + type: "array", + items: { + type: "string", + }, + }, + newIsCapExceptionPattern: { + type: "string", + }, + capIsNewExceptions: { + type: "array", + items: { + type: "string", + }, + }, + capIsNewExceptionPattern: { + type: "string", + }, + properties: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + capIsNew: true, + capIsNewExceptions: [], + newIsCap: true, + newIsCapExceptions: [], + properties: true, + }, + ], + + messages: { + upper: "A function with a name starting with an uppercase letter should only be used as a constructor.", + lower: "A constructor name should not start with a lowercase letter.", + }, + }, + + create(context) { + const [config] = context.options; + const skipProperties = !config.properties; + + const newIsCapExceptions = new Set(config.newIsCapExceptions); + const newIsCapExceptionPattern = config.newIsCapExceptionPattern + ? new RegExp(config.newIsCapExceptionPattern, "u") + : null; + + const capIsNewExceptions = new Set(config.capIsNewExceptions); + const capIsNewExceptionPattern = config.capIsNewExceptionPattern + ? new RegExp(config.capIsNewExceptionPattern, "u") + : null; + + const listeners = {}; + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Get exact callee name from expression + * @param {ASTNode} node CallExpression or NewExpression node + * @returns {string} name + */ + function extractNameFromExpression(node) { + return node.callee.type === "Identifier" + ? node.callee.name + : astUtils.getStaticPropertyName(node.callee) || ""; + } + + /** + * Returns the capitalization state of the string - + * Whether the first character is uppercase, lowercase, or non-alphabetic + * @param {string} str String + * @returns {string} capitalization state: "non-alpha", "lower", or "upper" + */ + function getCap(str) { + const firstChar = str.charAt(0); + + const firstCharLower = firstChar.toLowerCase(); + const firstCharUpper = firstChar.toUpperCase(); + + if (firstCharLower === firstCharUpper) { + // char has no uppercase variant, so it's non-alphabetic + return "non-alpha"; + } + if (firstChar === firstCharLower) { + return "lower"; + } + return "upper"; + } + + /** + * Checks if the given node is a reference to the global object + * @param {ASTNode} node Node to check + * @returns {boolean} Returns true if the node references the global object + */ + function isGlobalObject(node) { + return ( + node.type === "Identifier" && + GLOBAL_OBJECT_NAMES.has(node.name) && + sourceCode.isGlobalReference(node) + ); + } + + /** + * Checks if the given node references a built-in of the global object, + * such as `Date` or `globalThis.Date` + * @param {ASTNode} node Node to check + * @param {string} name Name of the built-in + * @returns {boolean} Returns true if the node references the built-in of the global object + */ + function isGlobalBuiltIn(node, name) { + const expression = astUtils.skipChainExpression(node); + + if (expression.type === "MemberExpression") { + return ( + astUtils.getStaticPropertyName(expression) === name && + isGlobalObject(expression.object) + ); + } + + return ( + expression.type === "Identifier" && + expression.name === name && + sourceCode.isGlobalReference(expression) + ); + } + + /** + * Check if capitalization is allowed for a CallExpression + * @param {Set} allowedNames Set of allowed callee names + * @param {ASTNode} node CallExpression node + * @param {string} calleeName Capitalized callee name from a CallExpression + * @param {Object} pattern RegExp object from options pattern + * @returns {boolean} Returns true if the callee may be capitalized + */ + function isCapAllowed(allowedNames, node, calleeName, pattern) { + const sourceText = sourceCode.getText(node.callee); + + if (allowedNames.has(calleeName) || allowedNames.has(sourceText)) { + return true; + } + + if (pattern && pattern.test(sourceText)) { + return true; + } + + const callee = astUtils.skipChainExpression(node.callee); + + if (callee.type === "MemberExpression") { + if (skipProperties) { + return true; + } + + if (calleeName === "UTC") { + // allow if callee is the global `Date.UTC` + return isGlobalBuiltIn(callee.object, "Date"); + } + } + + return false; + } + + /** + * Reports the given messageId for the given node. The location will be the start of the property or the callee. + * @param {ASTNode} node CallExpression or NewExpression node. + * @param {string} messageId The messageId to report. + * @returns {void} + */ + function report(node, messageId) { + let callee = astUtils.skipChainExpression(node.callee); + + if (callee.type === "MemberExpression") { + callee = callee.property; + } + + context.report({ node, loc: callee.loc, messageId }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + if (config.newIsCap) { + listeners.NewExpression = function (node) { + const constructorName = extractNameFromExpression(node); + + if (constructorName) { + const capitalization = getCap(constructorName); + const isAllowed = + capitalization !== "lower" || + isCapAllowed( + newIsCapExceptions, + node, + constructorName, + newIsCapExceptionPattern, + ); + + if (!isAllowed) { + report(node, "lower"); + } + } + }; + } + + if (config.capIsNew) { + listeners.CallExpression = function (node) { + const calleeName = extractNameFromExpression(node); + + if (calleeName) { + const capitalization = getCap(calleeName); + const isAllowed = + capitalization !== "upper" || + isCapAllowed( + capIsNewExceptions, + node, + calleeName, + capIsNewExceptionPattern, + ) || + (CAPS_ALLOWED.has(calleeName) && + isGlobalBuiltIn(node.callee, calleeName)); + + if (!isAllowed) { + report(node, "upper"); + } + } + }; + } + + return listeners; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-parens.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-parens.js new file mode 100644 index 00000000..e8cb8db2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/new-parens.js @@ -0,0 +1,120 @@ +/** + * @fileoverview Rule to flag when using constructor without parentheses + * @author Ilya Volodin + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "new-parens", + url: "https://eslint.style/rules/new-parens", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce or disallow parentheses when invoking a constructor with no arguments", + recommended: false, + url: "https://eslint.org/docs/latest/rules/new-parens", + }, + + fixable: "code", + schema: [ + { + enum: ["always", "never"], + }, + ], + messages: { + missing: "Missing '()' invoking a constructor.", + unnecessary: + "Unnecessary '()' invoking a constructor with no arguments.", + }, + }, + + create(context) { + const options = context.options; + const always = options[0] !== "never"; // Default is always + + const sourceCode = context.sourceCode; + + return { + NewExpression(node) { + if (node.arguments.length !== 0) { + return; // if there are arguments, there have to be parens + } + + const lastToken = sourceCode.getLastToken(node); + const hasLastParen = + lastToken && astUtils.isClosingParenToken(lastToken); + + // `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens + const hasParens = + hasLastParen && + astUtils.isOpeningParenToken( + sourceCode.getTokenBefore(lastToken), + ) && + node.callee.range[1] < node.range[1]; + + if (always) { + if (!hasParens) { + context.report({ + node, + messageId: "missing", + fix: fixer => fixer.insertTextAfter(node, "()"), + }); + } + } else { + if (hasParens) { + context.report({ + node, + messageId: "unnecessary", + fix: fixer => [ + fixer.remove( + sourceCode.getTokenBefore(lastToken), + ), + fixer.remove(lastToken), + fixer.insertTextBefore(node, "("), + fixer.insertTextAfter(node, ")"), + ], + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-after-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-after-var.js new file mode 100644 index 00000000..76d29117 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-after-var.js @@ -0,0 +1,307 @@ +/** + * @fileoverview Rule to check empty newline after "var" statement + * @author Gopal Venkatesan + * @deprecated in ESLint v4.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + docs: { + description: + "Require or disallow an empty line after variable declarations", + recommended: false, + url: "https://eslint.org/docs/latest/rules/newline-after-var", + }, + schema: [ + { + enum: ["never", "always"], + }, + ], + fixable: "whitespace", + messages: { + expected: "Expected blank line after variable declarations.", + unexpected: "Unexpected blank line after variable declarations.", + }, + + deprecated: { + message: "The rule was replaced with a more general rule.", + url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/", + deprecatedSince: "4.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: "The new rule moved to a plugin.", + url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "padding-line-between-statements", + url: "https://eslint.style/rules/padding-line-between-statements", + }, + }, + ], + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + // Default `mode` to "always". + const mode = context.options[0] === "never" ? "never" : "always"; + + // Cache starting and ending line numbers of comments for faster lookup + const commentEndLine = sourceCode + .getAllComments() + .reduce((result, token) => { + result[token.loc.start.line] = token.loc.end.line; + return result; + }, {}); + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Gets a token from the given node to compare line to the next statement. + * + * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy. + * + * - The last token is semicolon. + * - The semicolon is on a different line from the previous token of the semicolon. + * + * This behavior would address semicolon-less style code. e.g.: + * + * var foo = 1 + * + * ;(a || b).doSomething() + * @param {ASTNode} node The node to get. + * @returns {Token} The token to compare line to the next statement. + */ + function getLastToken(node) { + const lastToken = sourceCode.getLastToken(node); + + if (lastToken.type === "Punctuator" && lastToken.value === ";") { + const prevToken = sourceCode.getTokenBefore(lastToken); + + if (prevToken.loc.end.line !== lastToken.loc.start.line) { + return prevToken; + } + } + + return lastToken; + } + + /** + * Determine if provided keyword is a variable declaration + * @private + * @param {string} keyword keyword to test + * @returns {boolean} True if `keyword` is a type of var + */ + function isVar(keyword) { + return ( + keyword === "var" || keyword === "let" || keyword === "const" + ); + } + + /** + * Determine if provided keyword is a variant of for specifiers + * @private + * @param {string} keyword keyword to test + * @returns {boolean} True if `keyword` is a variant of for specifier + */ + function isForTypeSpecifier(keyword) { + return ( + keyword === "ForStatement" || + keyword === "ForInStatement" || + keyword === "ForOfStatement" + ); + } + + /** + * Determine if provided keyword is an export specifiers + * @private + * @param {string} nodeType nodeType to test + * @returns {boolean} True if `nodeType` is an export specifier + */ + function isExportSpecifier(nodeType) { + return ( + nodeType === "ExportNamedDeclaration" || + nodeType === "ExportSpecifier" || + nodeType === "ExportDefaultDeclaration" || + nodeType === "ExportAllDeclaration" + ); + } + + /** + * Determine if provided node is the last of their parent block. + * @private + * @param {ASTNode} node node to test + * @returns {boolean} True if `node` is last of their parent block. + */ + function isLastNode(node) { + const token = sourceCode.getTokenAfter(node); + + return ( + !token || (token.type === "Punctuator" && token.value === "}") + ); + } + + /** + * Gets the last line of a group of consecutive comments + * @param {number} commentStartLine The starting line of the group + * @returns {number} The number of the last comment line of the group + */ + function getLastCommentLineOfBlock(commentStartLine) { + const currentCommentEnd = commentEndLine[commentStartLine]; + + return commentEndLine[currentCommentEnd + 1] + ? getLastCommentLineOfBlock(currentCommentEnd + 1) + : currentCommentEnd; + } + + /** + * Determine if a token starts more than one line after a comment ends + * @param {token} token The token being checked + * @param {integer} commentStartLine The line number on which the comment starts + * @returns {boolean} True if `token` does not start immediately after a comment + */ + function hasBlankLineAfterComment(token, commentStartLine) { + return ( + token.loc.start.line > + getLastCommentLineOfBlock(commentStartLine) + 1 + ); + } + + /** + * Checks that a blank line exists after a variable declaration when mode is + * set to "always", or checks that there is no blank line when mode is set + * to "never" + * @private + * @param {ASTNode} node `VariableDeclaration` node to test + * @returns {void} + */ + function checkForBlankLine(node) { + /* + * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will + * sometimes be second-last if there is a semicolon on a different line. + */ + const lastToken = getLastToken(node), + /* + * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken + * is the last token of the node. + */ + nextToken = + lastToken === sourceCode.getLastToken(node) + ? sourceCode.getTokenAfter(node) + : sourceCode.getLastToken(node), + nextLineNum = lastToken.loc.end.line + 1; + + // Ignore if there is no following statement + if (!nextToken) { + return; + } + + // Ignore if parent of node is a for variant + if (isForTypeSpecifier(node.parent.type)) { + return; + } + + // Ignore if parent of node is an export specifier + if (isExportSpecifier(node.parent.type)) { + return; + } + + /* + * Some coding styles use multiple `var` statements, so do nothing if + * the next token is a `var` statement. + */ + if (nextToken.type === "Keyword" && isVar(nextToken.value)) { + return; + } + + // Ignore if it is last statement in a block + if (isLastNode(node)) { + return; + } + + // Next statement is not a `var`... + const noNextLineToken = nextToken.loc.start.line > nextLineNum; + const hasNextLineComment = + typeof commentEndLine[nextLineNum] !== "undefined"; + + if (mode === "never" && noNextLineToken && !hasNextLineComment) { + context.report({ + node, + messageId: "unexpected", + fix(fixer) { + const linesBetween = sourceCode + .getText() + .slice(lastToken.range[1], nextToken.range[0]) + .split(astUtils.LINEBREAK_MATCHER); + + return fixer.replaceTextRange( + [lastToken.range[1], nextToken.range[0]], + `${linesBetween.slice(0, -1).join("")}\n${linesBetween.at(-1)}`, + ); + }, + }); + } + + // Token on the next line, or comment without blank line + if ( + mode === "always" && + (!noNextLineToken || + (hasNextLineComment && + !hasBlankLineAfterComment(nextToken, nextLineNum))) + ) { + context.report({ + node, + messageId: "expected", + fix(fixer) { + if ( + (noNextLineToken + ? getLastCommentLineOfBlock(nextLineNum) + : lastToken.loc.end.line) === + nextToken.loc.start.line + ) { + return fixer.insertTextBefore(nextToken, "\n\n"); + } + + return fixer.insertTextBeforeRange( + [ + nextToken.range[0] - nextToken.loc.start.column, + nextToken.range[1], + ], + "\n", + ); + }, + }); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + VariableDeclaration: checkForBlankLine, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-before-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-before-return.js new file mode 100644 index 00000000..d9ebc9c1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-before-return.js @@ -0,0 +1,242 @@ +/** + * @fileoverview Rule to require newlines before `return` statement + * @author Kai Cataldo + * @deprecated in ESLint v4.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + docs: { + description: "Require an empty line before `return` statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/newline-before-return", + }, + + fixable: "whitespace", + schema: [], + messages: { + expected: "Expected newline before return statement.", + }, + + deprecated: { + message: "The rule was replaced with a more general rule.", + url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/", + deprecatedSince: "4.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: "The new rule moved to a plugin.", + url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "padding-line-between-statements", + url: "https://eslint.style/rules/padding-line-between-statements", + }, + }, + ], + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Tests whether node is preceded by supplied tokens + * @param {ASTNode} node node to check + * @param {Array} testTokens array of tokens to test against + * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens + * @private + */ + function isPrecededByTokens(node, testTokens) { + const tokenBefore = sourceCode.getTokenBefore(node); + + return testTokens.includes(tokenBefore.value); + } + + /** + * Checks whether node is the first node after statement or in block + * @param {ASTNode} node node to check + * @returns {boolean} Whether or not the node is the first node after statement or in block + * @private + */ + function isFirstNode(node) { + const parentType = node.parent.type; + + if (node.parent.body) { + return Array.isArray(node.parent.body) + ? node.parent.body[0] === node + : node.parent.body === node; + } + + if (parentType === "IfStatement") { + return isPrecededByTokens(node, ["else", ")"]); + } + if (parentType === "DoWhileStatement") { + return isPrecededByTokens(node, ["do"]); + } + if (parentType === "SwitchCase") { + return isPrecededByTokens(node, [":"]); + } + return isPrecededByTokens(node, [")"]); + } + + /** + * Returns the number of lines of comments that precede the node + * @param {ASTNode} node node to check for overlapping comments + * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments + * @returns {number} Number of lines of comments that precede the node + * @private + */ + function calcCommentLines(node, lineNumTokenBefore) { + const comments = sourceCode.getCommentsBefore(node); + let numLinesComments = 0; + + if (!comments.length) { + return numLinesComments; + } + + comments.forEach(comment => { + numLinesComments++; + + if (comment.type === "Block") { + numLinesComments += + comment.loc.end.line - comment.loc.start.line; + } + + // avoid counting lines with inline comments twice + if (comment.loc.start.line === lineNumTokenBefore) { + numLinesComments--; + } + + if (comment.loc.end.line === node.loc.start.line) { + numLinesComments--; + } + }); + + return numLinesComments; + } + + /** + * Returns the line number of the token before the node that is passed in as an argument + * @param {ASTNode} node The node to use as the start of the calculation + * @returns {number} Line number of the token before `node` + * @private + */ + function getLineNumberOfTokenBefore(node) { + const tokenBefore = sourceCode.getTokenBefore(node); + let lineNumTokenBefore; + + /** + * Global return (at the beginning of a script) is a special case. + * If there is no token before `return`, then we expect no line + * break before the return. Comments are allowed to occupy lines + * before the global return, just no blank lines. + * Setting lineNumTokenBefore to zero in that case results in the + * desired behavior. + */ + if (tokenBefore) { + lineNumTokenBefore = tokenBefore.loc.end.line; + } else { + lineNumTokenBefore = 0; // global return at beginning of script + } + + return lineNumTokenBefore; + } + + /** + * Checks whether node is preceded by a newline + * @param {ASTNode} node node to check + * @returns {boolean} Whether or not the node is preceded by a newline + * @private + */ + function hasNewlineBefore(node) { + const lineNumNode = node.loc.start.line; + const lineNumTokenBefore = getLineNumberOfTokenBefore(node); + const commentLines = calcCommentLines(node, lineNumTokenBefore); + + return lineNumNode - lineNumTokenBefore - commentLines > 1; + } + + /** + * Checks whether it is safe to apply a fix to a given return statement. + * + * The fix is not considered safe if the given return statement has leading comments, + * as we cannot safely determine if the newline should be added before or after the comments. + * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211 + * @param {ASTNode} node The return statement node to check. + * @returns {boolean} `true` if it can fix the node. + * @private + */ + function canFix(node) { + const leadingComments = sourceCode.getCommentsBefore(node); + const lastLeadingComment = leadingComments.at(-1); + const tokenBefore = sourceCode.getTokenBefore(node); + + if (leadingComments.length === 0) { + return true; + } + + /* + * if the last leading comment ends in the same line as the previous token and + * does not share a line with the `return` node, we can consider it safe to fix. + * Example: + * function a() { + * var b; //comment + * return; + * } + */ + if ( + lastLeadingComment.loc.end.line === tokenBefore.loc.end.line && + lastLeadingComment.loc.end.line !== node.loc.start.line + ) { + return true; + } + + return false; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ReturnStatement(node) { + if (!isFirstNode(node) && !hasNewlineBefore(node)) { + context.report({ + node, + messageId: "expected", + fix(fixer) { + if (canFix(node)) { + const tokenBefore = + sourceCode.getTokenBefore(node); + const newlines = + node.loc.start.line === + tokenBefore.loc.end.line + ? "\n\n" + : "\n"; + + return fixer.insertTextBefore(node, newlines); + } + return null; + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-per-chained-call.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-per-chained-call.js new file mode 100644 index 00000000..c56e9466 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/newline-per-chained-call.js @@ -0,0 +1,159 @@ +/** + * @fileoverview Rule to ensure newline per method call when chaining calls + * @author Rajendra Patil + * @author Burak Yigit Kaya + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "newline-per-chained-call", + url: "https://eslint.style/rules/newline-per-chained-call", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require a newline after each call in a method chain", + recommended: false, + url: "https://eslint.org/docs/latest/rules/newline-per-chained-call", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + ignoreChainWithDepth: { + type: "integer", + minimum: 1, + maximum: 10, + default: 2, + }, + }, + additionalProperties: false, + }, + ], + messages: { + expected: "Expected line break before `{{callee}}`.", + }, + }, + + create(context) { + const options = context.options[0] || {}, + ignoreChainWithDepth = options.ignoreChainWithDepth || 2; + + const sourceCode = context.sourceCode; + + /** + * Get the prefix of a given MemberExpression node. + * If the MemberExpression node is a computed value it returns a + * left bracket. If not it returns a period. + * @param {ASTNode} node A MemberExpression node to get + * @returns {string} The prefix of the node. + */ + function getPrefix(node) { + if (node.computed) { + if (node.optional) { + return "?.["; + } + return "["; + } + if (node.optional) { + return "?."; + } + return "."; + } + + /** + * Gets the property text of a given MemberExpression node. + * If the text is multiline, this returns only the first line. + * @param {ASTNode} node A MemberExpression node to get. + * @returns {string} The property text of the node. + */ + function getPropertyText(node) { + const prefix = getPrefix(node); + const lines = sourceCode + .getText(node.property) + .split(astUtils.LINEBREAK_MATCHER); + const suffix = node.computed && lines.length === 1 ? "]" : ""; + + return prefix + lines[0] + suffix; + } + + return { + "CallExpression:exit"(node) { + const callee = astUtils.skipChainExpression(node.callee); + + if (callee.type !== "MemberExpression") { + return; + } + + let parent = astUtils.skipChainExpression(callee.object); + let depth = 1; + + while (parent && parent.callee) { + depth += 1; + parent = astUtils.skipChainExpression( + astUtils.skipChainExpression(parent.callee).object, + ); + } + + if ( + depth > ignoreChainWithDepth && + astUtils.isTokenOnSameLine(callee.object, callee.property) + ) { + const firstTokenAfterObject = sourceCode.getTokenAfter( + callee.object, + astUtils.isNotClosingParenToken, + ); + + context.report({ + node: callee.property, + loc: { + start: firstTokenAfterObject.loc.start, + end: callee.loc.end, + }, + messageId: "expected", + data: { + callee: getPropertyText(callee), + }, + fix(fixer) { + return fixer.insertTextBefore( + firstTokenAfterObject, + "\n", + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-alert.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-alert.js new file mode 100644 index 00000000..d1a3c5ba --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-alert.js @@ -0,0 +1,149 @@ +/** + * @fileoverview Rule to flag use of alert, confirm, prompt + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + getStaticPropertyName: getPropertyName, + getVariableByName, + skipChainExpression, +} = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks if the given name is a prohibited identifier. + * @param {string} name The name to check + * @returns {boolean} Whether or not the name is prohibited. + */ +function isProhibitedIdentifier(name) { + return /^(?:alert|confirm|prompt)$/u.test(name); +} + +/** + * Finds the eslint-scope reference in the given scope. + * @param {Object} scope The scope to search. + * @param {ASTNode} node The identifier node. + * @returns {Reference|null} Returns the found reference or null if none were found. + */ +function findReference(scope, node) { + const references = scope.references.filter( + reference => + reference.identifier.range[0] === node.range[0] && + reference.identifier.range[1] === node.range[1], + ); + + if (references.length === 1) { + return references[0]; + } + return null; +} + +/** + * Checks if the given identifier node is shadowed in the given scope. + * @param {Object} scope The current scope. + * @param {string} node The identifier node to check + * @returns {boolean} Whether or not the name is shadowed. + */ +function isShadowed(scope, node) { + const reference = findReference(scope, node); + + return ( + reference && reference.resolved && reference.resolved.defs.length > 0 + ); +} + +/** + * Checks if the given identifier node is a ThisExpression in the global scope or the global window property. + * @param {Object} scope The current scope. + * @param {string} node The identifier node to check + * @returns {boolean} Whether or not the node is a reference to the global object. + */ +function isGlobalThisReferenceOrGlobalWindow(scope, node) { + if (scope.type === "global" && node.type === "ThisExpression") { + return true; + } + if ( + node.type === "Identifier" && + (node.name === "window" || + (node.name === "globalThis" && + getVariableByName(scope, "globalThis"))) + ) { + return !isShadowed(scope, node); + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow the use of `alert`, `confirm`, and `prompt`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-alert", + }, + + schema: [], + + messages: { + unexpected: "Unexpected {{name}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + CallExpression(node) { + const callee = skipChainExpression(node.callee), + currentScope = sourceCode.getScope(node); + + // without window. + if (callee.type === "Identifier") { + const name = callee.name; + + if ( + !isShadowed(currentScope, callee) && + isProhibitedIdentifier(callee.name) + ) { + context.report({ + node, + messageId: "unexpected", + data: { name }, + }); + } + } else if ( + callee.type === "MemberExpression" && + isGlobalThisReferenceOrGlobalWindow( + currentScope, + callee.object, + ) + ) { + const name = getPropertyName(callee); + + if (isProhibitedIdentifier(name)) { + context.report({ + node, + messageId: "unexpected", + data: { name }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-array-constructor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-array-constructor.js new file mode 100644 index 00000000..298f845f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-array-constructor.js @@ -0,0 +1,194 @@ +/** + * @fileoverview Disallow construction of dense arrays using the Array constructor + * @author Matt DuVall + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + getVariableByName, + isClosingParenToken, + isOpeningParenToken, + isStartOfExpressionStatement, + needsPrecedingSemicolon, +} = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `Array` constructors", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-array-constructor", + }, + + fixable: "code", + + hasSuggestions: true, + + schema: [], + + messages: { + preferLiteral: "The array literal notation [] is preferable.", + useLiteral: "Replace with an array literal.", + useLiteralAfterSemicolon: + "Replace with an array literal, add preceding semicolon.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Checks if there are comments in Array constructor expressions. + * @param {ASTNode} node A CallExpression or NewExpression node. + * @returns {boolean} True if there are comments, false otherwise. + */ + function hasCommentsInArrayConstructor(node) { + const firstToken = sourceCode.getFirstToken(node); + const lastToken = sourceCode.getLastToken(node); + + let lastRelevantToken = sourceCode.getLastToken(node.callee); + + while ( + lastRelevantToken !== lastToken && + !isOpeningParenToken(lastRelevantToken) + ) { + lastRelevantToken = sourceCode.getTokenAfter(lastRelevantToken); + } + + return sourceCode.commentsExistBetween( + firstToken, + lastRelevantToken, + ); + } + + /** + * Gets the text between the calling parentheses of a CallExpression or NewExpression. + * @param {ASTNode} node A CallExpression or NewExpression node. + * @returns {string} The text between the calling parentheses, or an empty string if there are none. + */ + function getArgumentsText(node) { + const lastToken = sourceCode.getLastToken(node); + + if (!isClosingParenToken(lastToken)) { + return ""; + } + + let firstToken = node.callee; + + do { + firstToken = sourceCode.getTokenAfter(firstToken); + if (!firstToken || firstToken === lastToken) { + return ""; + } + } while (!isOpeningParenToken(firstToken)); + + return sourceCode.text.slice( + firstToken.range[1], + lastToken.range[0], + ); + } + + /** + * Disallow construction of dense arrays using the Array constructor + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function check(node) { + if ( + node.callee.type !== "Identifier" || + node.callee.name !== "Array" || + node.typeArguments || + (node.arguments.length === 1 && + node.arguments[0].type !== "SpreadElement") + ) { + return; + } + + const variable = getVariableByName( + sourceCode.getScope(node), + "Array", + ); + + /* + * Check if `Array` is a predefined global variable: predefined globals have no declarations, + * meaning that the `identifiers` list of the variable object is empty. + */ + if (variable && variable.identifiers.length === 0) { + const argsText = getArgumentsText(node); + let fixText; + let messageId; + + const nonSpreadCount = node.arguments.reduce( + (count, arg) => + arg.type !== "SpreadElement" ? count + 1 : count, + 0, + ); + + const shouldSuggest = + node.optional || + (node.arguments.length > 0 && nonSpreadCount < 2) || + hasCommentsInArrayConstructor(node); + + /* + * Check if the suggested change should include a preceding semicolon or not. + * Due to JavaScript's ASI rules, a missing semicolon may be inserted automatically + * before an expression like `Array()` or `new Array()`, but not when the expression + * is changed into an array literal like `[]`. + */ + if ( + isStartOfExpressionStatement(node) && + needsPrecedingSemicolon(sourceCode, node) + ) { + fixText = `;[${argsText}]`; + messageId = "useLiteralAfterSemicolon"; + } else { + fixText = `[${argsText}]`; + messageId = "useLiteral"; + } + + context.report({ + node, + messageId: "preferLiteral", + fix(fixer) { + if (shouldSuggest) { + return null; + } + + return fixer.replaceText(node, fixText); + }, + suggest: [ + { + messageId, + fix(fixer) { + if (shouldSuggest) { + return fixer.replaceText(node, fixText); + } + + return null; + }, + }, + ], + }); + } + } + + return { + CallExpression: check, + NewExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-async-promise-executor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-async-promise-executor.js new file mode 100644 index 00000000..34906f4e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-async-promise-executor.js @@ -0,0 +1,51 @@ +/** + * @fileoverview disallow using an async function as a Promise executor + * @author Teddy Katz + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow using an async function as a Promise executor", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-async-promise-executor", + }, + + fixable: null, + schema: [], + messages: { + async: "Promise executor functions should not be async.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + "NewExpression[callee.name='Promise'][arguments.0.async=true]"( + node, + ) { + if (!sourceCode.isGlobalReference(node.callee)) { + return; + } + + context.report({ + node: sourceCode.getFirstToken( + node.arguments[0], + token => token.value === "async", + ), + messageId: "async", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-await-in-loop.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-await-in-loop.js new file mode 100644 index 00000000..2945257d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-await-in-loop.js @@ -0,0 +1,115 @@ +/** + * @fileoverview Rule to disallow uses of await inside of loops. + * @author Nat Mote (nmote) + */ +"use strict"; + +/** + * Check whether it should stop traversing ancestors at the given node. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if it should stop traversing. + */ +function isBoundary(node) { + const t = node.type; + + return ( + t === "FunctionDeclaration" || + t === "FunctionExpression" || + t === "ArrowFunctionExpression" || + /* + * Don't report the await expressions on for-await-of loop since it's + * asynchronous iteration intentionally. + */ + (t === "ForOfStatement" && node.await === true) + ); +} + +/** + * Check whether the given node is in loop. + * @param {ASTNode} node A node to check. + * @param {ASTNode} parent A parent node to check. + * @returns {boolean} `true` if the node is in loop. + */ +function isLooped(node, parent) { + switch (parent.type) { + case "ForStatement": + return ( + node === parent.test || + node === parent.update || + node === parent.body + ); + + case "ForOfStatement": + case "ForInStatement": + return ( + node === parent.body || + (node === parent.left && node.kind === "await using") + ); + + case "WhileStatement": + case "DoWhileStatement": + return node === parent.test || node === parent.body; + + default: + return false; + } +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow `await` inside of loops", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-await-in-loop", + }, + + schema: [], + + messages: { + unexpectedAwait: "Unexpected `await` inside a loop.", + }, + }, + create(context) { + /** + * Validate an await expression. + * @param {ASTNode} awaitNode An AwaitExpression or ForOfStatement node to validate. + * @returns {void} + */ + function validate(awaitNode) { + if ( + awaitNode.type === "VariableDeclaration" && + awaitNode.kind !== "await using" + ) { + return; + } + + if (awaitNode.type === "ForOfStatement" && !awaitNode.await) { + return; + } + + let node = awaitNode; + let parent = node.parent; + + while (parent && !isBoundary(parent)) { + if (isLooped(node, parent)) { + context.report({ + node: awaitNode, + messageId: "unexpectedAwait", + }); + return; + } + node = parent; + parent = parent.parent; + } + } + + return { + AwaitExpression: validate, + ForOfStatement: validate, + VariableDeclaration: validate, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-bitwise.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-bitwise.js new file mode 100644 index 00000000..10149ed6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-bitwise.js @@ -0,0 +1,145 @@ +/** + * @fileoverview Rule to flag bitwise identifiers + * @author Nicholas C. Zakas + */ + +"use strict"; + +/* + * + * Set of bitwise operators. + * + */ +const BITWISE_OPERATORS = [ + "^", + "|", + "&", + "<<", + ">>", + ">>>", + "^=", + "|=", + "&=", + "<<=", + ">>=", + ">>>=", + "~", +]; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allow: [], + int32Hint: false, + }, + ], + + docs: { + description: "Disallow bitwise operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-bitwise", + }, + + schema: [ + { + type: "object", + properties: { + allow: { + type: "array", + items: { + enum: BITWISE_OPERATORS, + }, + uniqueItems: true, + }, + int32Hint: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "Unexpected use of '{{operator}}'.", + }, + }, + + create(context) { + const [{ allow: allowed, int32Hint }] = context.options; + + /** + * Reports an unexpected use of a bitwise operator. + * @param {ASTNode} node Node which contains the bitwise operator. + * @returns {void} + */ + function report(node) { + context.report({ + node, + messageId: "unexpected", + data: { operator: node.operator }, + }); + } + + /** + * Checks if the given node has a bitwise operator. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the node has a bitwise operator. + */ + function hasBitwiseOperator(node) { + return BITWISE_OPERATORS.includes(node.operator); + } + + /** + * Checks if exceptions were provided, e.g. `{ allow: ['~', '|'] }`. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the node has a bitwise operator. + */ + function allowedOperator(node) { + return allowed.includes(node.operator); + } + + /** + * Checks if the given bitwise operator is used for integer typecasting, i.e. "|0" + * @param {ASTNode} node The node to check. + * @returns {boolean} whether the node is used in integer typecasting. + */ + function isInt32Hint(node) { + return ( + int32Hint && + node.operator === "|" && + node.right && + node.right.type === "Literal" && + node.right.value === 0 + ); + } + + /** + * Report if the given node contains a bitwise operator. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkNodeForBitwiseOperator(node) { + if ( + hasBitwiseOperator(node) && + !allowedOperator(node) && + !isInt32Hint(node) + ) { + report(node); + } + } + + return { + AssignmentExpression: checkNodeForBitwiseOperator, + BinaryExpression: checkNodeForBitwiseOperator, + UnaryExpression: checkNodeForBitwiseOperator, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-buffer-constructor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-buffer-constructor.js new file mode 100644 index 00000000..6a48b557 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-buffer-constructor.js @@ -0,0 +1,74 @@ +/** + * @fileoverview disallow use of the Buffer() constructor + * @author Teddy Katz + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-deprecated-api", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md", + }, + }, + ], + }, + + type: "problem", + + docs: { + description: "Disallow use of the `Buffer()` constructor", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-buffer-constructor", + }, + + schema: [], + + messages: { + deprecated: + "{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.", + }, + }, + + create(context) { + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + "CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"( + node, + ) { + context.report({ + node, + messageId: "deprecated", + data: { + expr: + node.type === "CallExpression" + ? "Buffer()" + : "new Buffer()", + }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-caller.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-caller.js new file mode 100644 index 00000000..50790ff0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-caller.js @@ -0,0 +1,52 @@ +/** + * @fileoverview Rule to flag use of arguments.callee and arguments.caller. + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow the use of `arguments.caller` or `arguments.callee`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-caller", + }, + + schema: [], + + messages: { + unexpected: "Avoid arguments.{{prop}}.", + }, + }, + + create(context) { + return { + MemberExpression(node) { + const objectName = node.object.name, + propertyName = node.property.name; + + if ( + objectName === "arguments" && + !node.computed && + propertyName && + propertyName.match(/^calle[er]$/u) + ) { + context.report({ + node, + messageId: "unexpected", + data: { prop: propertyName }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-case-declarations.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-case-declarations.js new file mode 100644 index 00000000..168594aa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-case-declarations.js @@ -0,0 +1,80 @@ +/** + * @fileoverview Rule to flag use of an lexical declarations inside a case clause + * @author Erik Arvidsson + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow lexical declarations in case clauses", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-case-declarations", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + addBrackets: "Add {} brackets around the case block.", + unexpected: "Unexpected lexical declaration in case block.", + }, + }, + + create(context) { + /** + * Checks whether or not a node is a lexical declaration. + * @param {ASTNode} node A direct child statement of a switch case. + * @returns {boolean} Whether or not the node is a lexical declaration. + */ + function isLexicalDeclaration(node) { + switch (node.type) { + case "FunctionDeclaration": + case "ClassDeclaration": + return true; + case "VariableDeclaration": + return node.kind !== "var"; + default: + return false; + } + } + + return { + SwitchCase(node) { + for (let i = 0; i < node.consequent.length; i++) { + const statement = node.consequent[i]; + + if (isLexicalDeclaration(statement)) { + context.report({ + node: statement, + messageId: "unexpected", + suggest: [ + { + messageId: "addBrackets", + fix: fixer => [ + fixer.insertTextBefore( + node.consequent[0], + "{ ", + ), + fixer.insertTextAfter( + node.consequent.at(-1), + " }", + ), + ], + }, + ], + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-catch-shadow.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-catch-shadow.js new file mode 100644 index 00000000..b47ac324 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-catch-shadow.js @@ -0,0 +1,96 @@ +/** + * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier + * @author Ian Christian Myers + * @deprecated in ESLint v5.1.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `catch` clause parameters from shadowing variables in the outer scope", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-catch-shadow", + }, + + deprecated: { + message: "This rule was renamed.", + url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/", + deprecatedSince: "5.1.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "no-shadow", + url: "https://eslint.org/docs/rules/no-shadow", + }, + }, + ], + }, + schema: [], + + messages: { + mutable: + "Value of '{{name}}' may be overwritten in IE 8 and earlier.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Check if the parameters are been shadowed + * @param {Object} scope current scope + * @param {string} name parameter name + * @returns {boolean} True is its been shadowed + */ + function paramIsShadowing(scope, name) { + return astUtils.getVariableByName(scope, name) !== null; + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + "CatchClause[param!=null]"(node) { + let scope = sourceCode.getScope(node); + + /* + * When ecmaVersion >= 6, CatchClause creates its own scope + * so start from one upper scope to exclude the current node + */ + if (scope.block === node) { + scope = scope.upper; + } + + if (paramIsShadowing(scope, node.param.name)) { + context.report({ + node, + messageId: "mutable", + data: { name: node.param.name }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-class-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-class-assign.js new file mode 100644 index 00000000..64976959 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-class-assign.js @@ -0,0 +1,66 @@ +/** + * @fileoverview A rule to disallow modifying variables of class declarations + * @author Toru Nagashima + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow reassigning class members", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-class-assign", + }, + + schema: [], + + messages: { + class: "'{{name}}' is a class.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Finds and reports references that are non initializer and writable. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + astUtils + .getModifyingReferences(variable.references) + .forEach(reference => { + context.report({ + node: reference.identifier, + messageId: "class", + data: { name: reference.identifier.name }, + }); + }); + } + + /** + * Finds and reports references that are non initializer and writable. + * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check. + * @returns {void} + */ + function checkForClass(node) { + sourceCode.getDeclaredVariables(node).forEach(checkVariable); + } + + return { + ClassDeclaration: checkForClass, + ClassExpression: checkForClass, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-compare-neg-zero.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-compare-neg-zero.js new file mode 100644 index 00000000..2d8ff3bf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-compare-neg-zero.js @@ -0,0 +1,157 @@ +/** + * @fileoverview The rule should warn against code that tries to compare against -0. + * @author Aladdin-ADD + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getVariableByName } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow comparing against `-0`", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-compare-neg-zero", + }, + + fixable: null, + hasSuggestions: true, + schema: [], + + messages: { + unexpected: + "Do not use the '{{operator}}' operator to compare against -0.", + suggestRemoveMinus: + "Replace '-0' with '0' (keeps the current comparison behavior).", + suggestObjectIs: + "Replace with 'Object.is()' (changes the comparison to distinguish -0 from +0).", + suggestNotObjectIs: + "Replace with '!Object.is()' (changes the comparison to distinguish -0 from +0).", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Checks a given node is -0 + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is -0. + */ + function isNegZero(node) { + return ( + node.type === "UnaryExpression" && + node.operator === "-" && + node.argument.type === "Literal" && + node.argument.value === 0 + ); + } + + /** + * Gets the source text of an operand, keeping parentheses where required. + * @param {ASTNode} operand A comparison operand node. + * @returns {string} The source text of the operand. + */ + function getOperandText(operand) { + const text = sourceCode.getText(operand); + + return operand.type === "SequenceExpression" ? `(${text})` : text; + } + + const OPERATORS_TO_CHECK = new Set([ + ">", + ">=", + "<", + "<=", + "==", + "===", + "!=", + "!==", + ]); + + return { + BinaryExpression(node) { + if (!OPERATORS_TO_CHECK.has(node.operator)) { + return; + } + + const leftIsNegZero = isNegZero(node.left); + const rightIsNegZero = isNegZero(node.right); + + if (!leftIsNegZero && !rightIsNegZero) { + return; + } + + context.report({ + node, + messageId: "unexpected", + data: { operator: node.operator }, + suggest: [ + { + messageId: "suggestRemoveMinus", + *fix(fixer) { + if (leftIsNegZero) { + yield fixer.replaceText(node.left, "0"); + } + if (rightIsNegZero) { + yield fixer.replaceText(node.right, "0"); + } + }, + }, + { + messageId: + node.operator === "===" + ? "suggestObjectIs" + : "suggestNotObjectIs", + fix(fixer) { + if ( + (node.operator !== "===" && + node.operator !== "!==") || + sourceCode.getCommentsInside(node).length > + 0 + ) { + return null; + } + + const objectVariable = getVariableByName( + sourceCode.getScope(node), + "Object", + ); + + if ( + !objectVariable || + objectVariable.identifiers.length > 0 + ) { + return null; + } + + const negation = + node.operator === "===" ? "" : "!"; + + return fixer.replaceText( + node, + `${negation}Object.is(${getOperandText(node.left)}, ${getOperandText(node.right)})`, + ); + }, + }, + ], + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-cond-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-cond-assign.js new file mode 100644 index 00000000..a686e690 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-cond-assign.js @@ -0,0 +1,175 @@ +/** + * @fileoverview Rule to flag assignment in a conditional statement's test expression + * @author Stephen Murray + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const TEST_CONDITION_PARENT_TYPES = new Set([ + "IfStatement", + "WhileStatement", + "DoWhileStatement", + "ForStatement", + "ConditionalExpression", +]); + +const NODE_DESCRIPTIONS = { + DoWhileStatement: "a 'do...while' statement", + ForStatement: "a 'for' statement", + IfStatement: "an 'if' statement", + WhileStatement: "a 'while' statement", +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: ["except-parens"], + + docs: { + description: + "Disallow assignment operators in conditional expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-cond-assign", + }, + + schema: [ + { + enum: ["except-parens", "always"], + }, + ], + + messages: { + unexpected: "Unexpected assignment within {{type}}.", + + // must match JSHint's error message + missing: + "Expected a conditional expression and instead saw an assignment.", + }, + }, + + create(context) { + const [prohibitAssign] = context.options; + const sourceCode = context.sourceCode; + + /** + * Check whether an AST node is the test expression for a conditional statement. + * @param {!Object} node The node to test. + * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`. + */ + function isConditionalTestExpression(node) { + return ( + node.parent && + TEST_CONDITION_PARENT_TYPES.has(node.parent.type) && + node === node.parent.test + ); + } + + /** + * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement. + * @param {!Object} node The node to use at the start of the search. + * @returns {?Object} The closest ancestor node that represents a conditional statement. + */ + function findConditionalAncestor(node) { + let currentAncestor = node; + + do { + if (isConditionalTestExpression(currentAncestor)) { + return currentAncestor.parent; + } + } while ( + (currentAncestor = currentAncestor.parent) && + !astUtils.isFunction(currentAncestor) + ); + + return null; + } + + /** + * Check whether the code represented by an AST node is enclosed in two sets of parentheses. + * @param {!Object} node The node to test. + * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`. + */ + function isParenthesisedTwice(node) { + const previousToken = sourceCode.getTokenBefore(node, 1), + nextToken = sourceCode.getTokenAfter(node, 1); + + return ( + astUtils.isParenthesised(sourceCode, node) && + previousToken && + astUtils.isOpeningParenToken(previousToken) && + previousToken.range[1] <= node.range[0] && + astUtils.isClosingParenToken(nextToken) && + nextToken.range[0] >= node.range[1] + ); + } + + /** + * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses. + * @param {!Object} node The node for the conditional statement. + * @returns {void} + */ + function testForAssign(node) { + if ( + node.test && + node.test.type === "AssignmentExpression" && + (node.type === "ForStatement" + ? !astUtils.isParenthesised(sourceCode, node.test) + : !isParenthesisedTwice(node.test)) + ) { + context.report({ + node: node.test, + messageId: "missing", + }); + } + } + + /** + * Check whether an assignment expression is descended from a conditional statement's test expression. + * @param {!Object} node The node for the assignment expression. + * @returns {void} + */ + function testForConditionalAncestor(node) { + const ancestor = findConditionalAncestor(node); + + if (ancestor) { + context.report({ + node, + messageId: "unexpected", + data: { + type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type, + }, + }); + } + } + + if (prohibitAssign === "always") { + return { + AssignmentExpression: testForConditionalAncestor, + }; + } + + return { + DoWhileStatement: testForAssign, + ForStatement: testForAssign, + IfStatement: testForAssign, + WhileStatement: testForAssign, + ConditionalExpression: testForAssign, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-confusing-arrow.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-confusing-arrow.js new file mode 100644 index 00000000..1b3e7982 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-confusing-arrow.js @@ -0,0 +1,127 @@ +/** + * @fileoverview A rule to warn against using arrow functions when they could be + * confused with comparisons + * @author Jxck + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils.js"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a node is a conditional expression. + * @param {ASTNode} node node to test + * @returns {boolean} `true` if the node is a conditional expression. + */ +function isConditional(node) { + return node && node.type === "ConditionalExpression"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-confusing-arrow", + url: "https://eslint.style/rules/no-confusing-arrow", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: + "Disallow arrow functions where they could be confused with comparisons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-confusing-arrow", + }, + + fixable: "code", + + schema: [ + { + type: "object", + properties: { + allowParens: { type: "boolean", default: true }, + onlyOneSimpleParam: { type: "boolean", default: false }, + }, + additionalProperties: false, + }, + ], + + messages: { + confusing: + "Arrow function used ambiguously with a conditional expression.", + }, + }, + + create(context) { + const config = context.options[0] || {}; + const allowParens = config.allowParens || config.allowParens === void 0; + const onlyOneSimpleParam = config.onlyOneSimpleParam; + const sourceCode = context.sourceCode; + + /** + * Reports if an arrow function contains an ambiguous conditional. + * @param {ASTNode} node A node to check and report. + * @returns {void} + */ + function checkArrowFunc(node) { + const body = node.body; + + if ( + isConditional(body) && + !(allowParens && astUtils.isParenthesised(sourceCode, body)) && + !( + onlyOneSimpleParam && + !( + node.params.length === 1 && + node.params[0].type === "Identifier" + ) + ) + ) { + context.report({ + node, + messageId: "confusing", + fix(fixer) { + // if `allowParens` is not set to true don't bother wrapping in parens + return ( + allowParens && + fixer.replaceText( + node.body, + `(${sourceCode.getText(node.body)})`, + ) + ); + }, + }); + } + } + + return { + ArrowFunctionExpression: checkArrowFunc, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-console.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-console.js new file mode 100644 index 00000000..b7eacd98 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-console.js @@ -0,0 +1,227 @@ +/** + * @fileoverview Rule to flag use of console object + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{}], + + docs: { + description: "Disallow the use of `console`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-console", + }, + + schema: [ + { + type: "object", + properties: { + allow: { + type: "array", + items: { + type: "string", + }, + minItems: 1, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + hasSuggestions: true, + + messages: { + unexpected: "Unexpected console statement.", + limited: + "Unexpected console statement. Only these console methods are allowed: {{ allowed }}.", + removeConsole: "Remove the console.{{ propertyName }}().", + removeMethodCall: "Remove the console method call.", + }, + }, + + create(context) { + const [{ allow: allowed = [] }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Checks whether the given reference is 'console' or not. + * @param {Reference} reference The reference to check. + * @returns {boolean} `true` if the reference is 'console'. + */ + function isConsole(reference) { + const id = reference.identifier; + + return id && id.name === "console"; + } + + /** + * Checks whether the property name of the given MemberExpression node + * is allowed by options or not. + * @param {ASTNode} node The MemberExpression node to check. + * @returns {boolean} `true` if the property name of the node is allowed. + */ + function isAllowed(node) { + const propertyName = astUtils.getStaticPropertyName(node); + + return propertyName && allowed.includes(propertyName); + } + + /** + * Checks whether the given reference is a member access which is not + * allowed by options or not. + * @param {Reference} reference The reference to check. + * @returns {boolean} `true` if the reference is a member access which + * is not allowed by options. + */ + function isMemberAccessExceptAllowed(reference) { + const node = reference.identifier; + const parent = node.parent; + + return ( + parent.type === "MemberExpression" && + parent.object === node && + !isAllowed(parent) + ); + } + + /** + * Checks if removing the ExpressionStatement node will cause ASI to + * break. + * eg. + * foo() + * console.log(); + * [1, 2, 3].forEach(a => doSomething(a)) + * + * Removing the console.log(); statement should leave two statements, but + * here the two statements will become one because [ causes continuation after + * foo(). + * @param {ASTNode} node The ExpressionStatement node to check. + * @returns {boolean} `true` if ASI will break after removing the ExpressionStatement + * node. + */ + function maybeAsiHazard(node) { + const SAFE_TOKENS_BEFORE = /^[:;{]$/u; // One of :;{ + const UNSAFE_CHARS_AFTER = /^[-[(/+`]/u; // One of [(/+-` + + const tokenBefore = sourceCode.getTokenBefore(node); + const tokenAfter = sourceCode.getTokenAfter(node); + + return ( + Boolean(tokenAfter) && + UNSAFE_CHARS_AFTER.test(tokenAfter.value) && + tokenAfter.value !== "++" && + tokenAfter.value !== "--" && + Boolean(tokenBefore) && + !SAFE_TOKENS_BEFORE.test(tokenBefore.value) + ); + } + + /** + * Checks if the MemberExpression node's parent.parent.parent is a + * Program, BlockStatement, StaticBlock, or SwitchCase node. This check + * is necessary to avoid providing a suggestion that might cause a syntax error. + * + * eg. if (a) console.log(b), removing console.log() here will lead to a + * syntax error. + * if (a) { console.log(b) }, removing console.log() here is acceptable. + * + * Additionally, it checks if the callee of the CallExpression node is + * the node itself. + * + * eg. foo(console.log), cannot provide a suggestion here. + * @param {ASTNode} node The MemberExpression node to check. + * @returns {boolean} `true` if a suggestion can be provided for a node. + */ + function canProvideSuggestions(node) { + return ( + node.parent.type === "CallExpression" && + node.parent.callee === node && + node.parent.parent.type === "ExpressionStatement" && + astUtils.STATEMENT_LIST_PARENTS.has( + node.parent.parent.parent.type, + ) && + !maybeAsiHazard(node.parent.parent) + ); + } + + /** + * Reports the given reference as a violation. + * @param {Reference} reference The reference to report. + * @returns {void} + */ + function report(reference) { + const node = reference.identifier.parent; + + const suggest = []; + + if (canProvideSuggestions(node)) { + const suggestion = { + fix(fixer) { + return fixer.remove(node.parent.parent); + }, + }; + + if (node.computed) { + suggestion.messageId = "removeMethodCall"; + } else { + suggestion.messageId = "removeConsole"; + suggestion.data = { propertyName: node.property.name }; + } + suggest.push(suggestion); + } + context.report({ + node, + loc: node.loc, + messageId: allowed.length ? "limited" : "unexpected", + data: { allowed: allowed.join(", ") }, + suggest, + }); + } + + return { + "Program:exit"(node) { + const scope = sourceCode.getScope(node); + const consoleVar = astUtils.getVariableByName(scope, "console"); + const shadowed = consoleVar && consoleVar.defs.length > 0; + + /* + * 'scope.through' includes all references to undefined + * variables. If the variable 'console' is not defined, it uses + * 'scope.through'. + */ + const references = consoleVar + ? consoleVar.references + : scope.through.filter(isConsole); + + if (!shadowed) { + references + .filter(isMemberAccessExceptAllowed) + .forEach(report); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-const-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-const-assign.js new file mode 100644 index 00000000..5e126c80 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-const-assign.js @@ -0,0 +1,73 @@ +/** + * @fileoverview A rule to disallow modifying variables that are declared using `const` + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow reassigning `const`, `using`, and `await using` variables", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-const-assign", + }, + + schema: [], + + messages: { + const: "'{{name}}' is constant.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Finds and reports references that are non initializer and writable. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + astUtils + .getModifyingReferences(variable.references) + .forEach(reference => { + context.report({ + node: reference.identifier, + messageId: "const", + data: { name: reference.identifier.name }, + }); + }); + } + + return { + VariableDeclaration(node) { + if (CONSTANT_BINDINGS.has(node.kind)) { + sourceCode + .getDeclaredVariables(node) + .forEach(checkVariable); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-binary-expression.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-binary-expression.js new file mode 100644 index 00000000..15c3edd9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-binary-expression.js @@ -0,0 +1,669 @@ +/** + * @fileoverview Rule to flag constant comparisons and logical expressions that always/never short circuit + * @author Jordan Eldredge + */ + +"use strict"; + +const { + isNullLiteral, + isConstant, + isReferenceToGlobalVariable, + isLogicalAssignmentOperator, + ECMASCRIPT_GLOBALS, +} = require("./utils/ast-utils"); + +const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set([ + "+", + "-", + "*", + "/", + "%", + "|", + "^", + "&", + "**", + "<<", + ">>", + ">>>", +]); + +const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a node is `null` or `undefined`. Similar to the one + * found in ast-utils.js, but this one correctly handles the edge case that + * `undefined` has been redefined. + * @param {Scope} scope Scope in which the expression was found. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a `null` or `undefined`. + * @public + */ +function isNullOrUndefined(scope, node) { + return ( + isNullLiteral(node) || + (node.type === "Identifier" && + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node)) || + (node.type === "UnaryExpression" && node.operator === "void") + ); +} + +/** + * Test if an AST node has a statically knowable constant nullishness. Meaning, + * it will always resolve to a constant value of either: `null`, `undefined` + * or not `null` _or_ `undefined`. An expression that can vary between those + * three states at runtime would return `false`. + * @param {Scope} scope The scope in which the node was found. + * @param {ASTNode} node The AST node being tested. + * @param {boolean} nonNullish if `true` then nullish values are not considered constant. + * @returns {boolean} Does `node` have constant nullishness? + */ +function hasConstantNullishness(scope, node, nonNullish) { + if (nonNullish && isNullOrUndefined(scope, node)) { + return false; + } + + switch (node.type) { + case "ObjectExpression": // Objects are never nullish + case "ArrayExpression": // Arrays are never nullish + case "ArrowFunctionExpression": // Functions never nullish + case "FunctionExpression": // Functions are never nullish + case "ClassExpression": // Classes are never nullish + case "NewExpression": // Objects are never nullish + case "Literal": // Nullish, or non-nullish, literals never change + case "TemplateLiteral": // A string is never nullish + case "UpdateExpression": // Numbers are never nullish + case "BinaryExpression": // Numbers, strings, or booleans are never nullish + return true; + case "CallExpression": { + if (node.callee.type !== "Identifier") { + return false; + } + const functionName = node.callee.name; + + return ( + (functionName === "Boolean" || + functionName === "String" || + functionName === "Number" || + functionName === "Symbol" || + functionName === "BigInt") && + isReferenceToGlobalVariable(scope, node.callee) + ); + } + case "LogicalExpression": { + return ( + node.operator === "??" && + hasConstantNullishness(scope, node.right, true) + ); + } + case "AssignmentExpression": + if (node.operator === "=") { + return hasConstantNullishness(scope, node.right, nonNullish); + } + + /* + * Handling short-circuiting assignment operators would require + * walking the scope. We won't attempt that (for now...) / + */ + if (isLogicalAssignmentOperator(node.operator)) { + return false; + } + + /* + * The remaining assignment expressions all result in a numeric or + * string (non-nullish) value: + * "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&=" + */ + + return true; + case "UnaryExpression": + /* + * "void" Always returns `undefined` + * "typeof" All types are strings, and thus non-nullish + * "!" Boolean is never nullish + * "delete" Returns a boolean, which is never nullish + * Math operators always return numbers or strings, neither of which + * are non-nullish "+", "-", "~" + */ + + return true; + case "SequenceExpression": { + const last = node.expressions.at(-1); + + return hasConstantNullishness(scope, last, nonNullish); + } + case "Identifier": + return ( + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node) + ); + case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior. + case "JSXFragment": + return false; + default: + return false; + } +} + +/** + * Test if an AST node is a boolean value that never changes. Specifically we + * test for: + * 1. Literal booleans (`true` or `false`) + * 2. Unary `!` expressions with a constant value + * 3. Constant booleans created via the `Boolean` global function + * @param {Scope} scope The scope in which the node was found. + * @param {ASTNode} node The node to test + * @returns {boolean} Is `node` guaranteed to be a boolean? + */ +function isStaticBoolean(scope, node) { + switch (node.type) { + case "Literal": + return typeof node.value === "boolean"; + case "CallExpression": + return ( + node.callee.type === "Identifier" && + node.callee.name === "Boolean" && + isReferenceToGlobalVariable(scope, node.callee) && + (node.arguments.length === 0 || + isConstant(scope, node.arguments[0], true)) + ); + case "UnaryExpression": + return ( + node.operator === "!" && isConstant(scope, node.argument, true) + ); + default: + return false; + } +} + +/** + * Test if an AST node will always give the same result when compared to a + * boolean value. Note that comparison to boolean values is different than + * truthiness. + * https://262.ecma-international.org/5.1/#sec-11.9.3 + * + * JavaScript `==` operator works by converting the boolean to `1` (true) or + * `+0` (false) and then checks the values `==` equality to that number. + * @param {Scope} scope The scope in which node was found. + * @param {ASTNode} node The node to test. + * @returns {boolean} Will `node` always coerce to the same boolean value? + */ +function hasConstantLooseBooleanComparison(scope, node) { + switch (node.type) { + case "ObjectExpression": + case "ClassExpression": + /** + * In theory objects like: + * + * `{toString: () => a}` + * `{valueOf: () => a}` + * + * Or a classes like: + * + * `class { static toString() { return a } }` + * `class { static valueOf() { return a } }` + * + * Are not constant verifiably when `inBooleanPosition` is + * false, but it's an edge case we've opted not to handle. + */ + return true; + case "ArrayExpression": { + const nonSpreadElements = node.elements.filter( + e => + // Elements can be `null` in sparse arrays: `[,,]`; + e !== null && e.type !== "SpreadElement", + ); + + /* + * Possible future direction if needed: We could check if the + * single value would result in variable boolean comparison. + * For now we will err on the side of caution since `[x]` could + * evaluate to `[0]` or `[1]`. + */ + return node.elements.length === 0 || nonSpreadElements.length > 1; + } + case "ArrowFunctionExpression": + case "FunctionExpression": + return true; + case "UnaryExpression": + if ( + node.operator === "void" || // Always returns `undefined` + node.operator === "typeof" // All `typeof` strings, when coerced to number, are not 0 or 1. + ) { + return true; + } + if (node.operator === "!") { + return isConstant(scope, node.argument, true); + } + + /* + * We won't try to reason about +, -, ~, or delete + * In theory, for the mathematical operators, we could look at the + * argument and try to determine if it coerces to a constant numeric + * value. + */ + return false; + case "NewExpression": // Objects might have custom `.valueOf` or `.toString`. + return false; + case "CallExpression": { + if ( + node.callee.type === "Identifier" && + node.callee.name === "Boolean" && + isReferenceToGlobalVariable(scope, node.callee) + ) { + return ( + node.arguments.length === 0 || + isConstant(scope, node.arguments[0], true) + ); + } + return false; + } + case "Literal": // True or false, literals never change + return true; + case "Identifier": + return ( + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node) + ); + case "TemplateLiteral": + /* + * In theory we could try to check if the quasi are sufficient to + * prove that the expression will always be true, but it would be + * tricky to get right. For example: `000.${foo}000` + */ + return node.expressions.length === 0; + case "AssignmentExpression": + if (node.operator === "=") { + return hasConstantLooseBooleanComparison(scope, node.right); + } + + /* + * Handling short-circuiting assignment operators would require + * walking the scope. We won't attempt that (for now...) + * + * The remaining assignment expressions all result in a numeric or + * string (non-nullish) values which could be truthy or falsy: + * "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&=" + */ + return false; + case "SequenceExpression": { + const last = node.expressions.at(-1); + + return hasConstantLooseBooleanComparison(scope, last); + } + case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior. + case "JSXFragment": + return false; + default: + return false; + } +} + +/** + * Test if an AST node will always give the same result when _strictly_ compared + * to a boolean value. This can happen if the expression can never be boolean, or + * if it is always the same boolean value. + * @param {Scope} scope The scope in which the node was found. + * @param {ASTNode} node The node to test + * @returns {boolean} Will `node` always give the same result when compared to a + * static boolean value? + */ +function hasConstantStrictBooleanComparison(scope, node) { + switch (node.type) { + case "ObjectExpression": // Objects are not booleans + case "ArrayExpression": // Arrays are not booleans + case "ArrowFunctionExpression": // Functions are not booleans + case "FunctionExpression": + case "ClassExpression": // Classes are not booleans + case "NewExpression": // Objects are not booleans + case "TemplateLiteral": // Strings are not booleans + case "Literal": // True, false, or not boolean, literals never change. + case "UpdateExpression": // Numbers are not booleans + return true; + case "BinaryExpression": + return NUMERIC_OR_STRING_BINARY_OPERATORS.has(node.operator); + case "UnaryExpression": { + if (node.operator === "delete") { + return false; + } + if (node.operator === "!") { + return isConstant(scope, node.argument, true); + } + + /* + * The remaining operators return either strings or numbers, neither + * of which are boolean. + */ + return true; + } + case "SequenceExpression": { + const last = node.expressions.at(-1); + + return hasConstantStrictBooleanComparison(scope, last); + } + case "Identifier": + return ( + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node) + ); + case "AssignmentExpression": + if (node.operator === "=") { + return hasConstantStrictBooleanComparison(scope, node.right); + } + + /* + * Handling short-circuiting assignment operators would require + * walking the scope. We won't attempt that (for now...) + */ + if (isLogicalAssignmentOperator(node.operator)) { + return false; + } + + /* + * The remaining assignment expressions all result in either a number + * or a string, neither of which can ever be boolean. + */ + return true; + case "CallExpression": { + if (node.callee.type !== "Identifier") { + return false; + } + const functionName = node.callee.name; + + if ( + (functionName === "String" || + functionName === "Number" || + functionName === "BigInt" || + functionName === "Symbol") && + isReferenceToGlobalVariable(scope, node.callee) + ) { + return true; + } + if ( + functionName === "Boolean" && + isReferenceToGlobalVariable(scope, node.callee) + ) { + return ( + node.arguments.length === 0 || + isConstant(scope, node.arguments[0], true) + ); + } + return false; + } + case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior. + case "JSXFragment": + return false; + default: + return false; + } +} + +/** + * Test if an AST node will always result in a newly constructed object + * @param {Scope} scope The scope in which the node was found. + * @param {ASTNode} node The node to test + * @returns {boolean} Will `node` always be new? + */ +function isAlwaysNew(scope, node) { + switch (node.type) { + case "ObjectExpression": + case "ArrayExpression": + case "ArrowFunctionExpression": + case "FunctionExpression": + case "ClassExpression": + return true; + case "NewExpression": { + if (node.callee.type !== "Identifier") { + return false; + } + + /* + * All the built-in constructors are always new, but + * user-defined constructors could return a sentinel + * object. + * + * Catching these is especially useful for primitive constructors + * which return boxed values, a surprising gotcha' in JavaScript. + */ + return ( + Object.hasOwn(ECMASCRIPT_GLOBALS, node.callee.name) && + isReferenceToGlobalVariable(scope, node.callee) + ); + } + case "Literal": + // Regular expressions are objects, and thus always new + return typeof node.regex === "object"; + case "SequenceExpression": { + const last = node.expressions.at(-1); + + return isAlwaysNew(scope, last); + } + case "AssignmentExpression": + if (node.operator === "=") { + return isAlwaysNew(scope, node.right); + } + return false; + case "ConditionalExpression": + return ( + isAlwaysNew(scope, node.consequent) && + isAlwaysNew(scope, node.alternate) + ); + case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior. + case "JSXFragment": + return false; + default: + return false; + } +} + +/** + * Checks if one operand will cause the result to be constant. + * @param {Scope} scope Scope in which the expression was found. + * @param {ASTNode} a One side of the expression + * @param {ASTNode} b The other side of the expression + * @param {string} operator The binary expression operator + * @returns {ASTNode | null} The node which will cause the expression to have a constant result. + */ +function findBinaryExpressionConstantOperand(scope, a, b, operator) { + if (operator === "==" || operator === "!=") { + if ( + (isNullOrUndefined(scope, a) && + hasConstantNullishness(scope, b, false)) || + (isStaticBoolean(scope, a) && + hasConstantLooseBooleanComparison(scope, b)) + ) { + return b; + } + } else if (operator === "===" || operator === "!==") { + if ( + (isNullOrUndefined(scope, a) && + hasConstantNullishness(scope, b, false)) || + (isStaticBoolean(scope, a) && + hasConstantStrictBooleanComparison(scope, b)) + ) { + return b; + } + } + return null; +} + +/** + * Checks if a node is a statically knowable literal. + * @param {Scope} scope The scope in which the node was found. + * @param {ASTNode} node The node to test. + * @returns {boolean} `true` if the node is a literal. + */ +function isStaticLiteral(scope, node) { + switch (node.type) { + case "Literal": + return true; + case "UnaryExpression": + return ( + ["-", "+", "~"].includes(node.operator) && + node.argument.type === "Literal" + ); + case "Identifier": + return ( + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node) + ); + case "TemplateLiteral": + return node.expressions.length === 0; + default: + return false; + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + docs: { + description: + "Disallow expressions where the operation doesn't affect the value", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-constant-binary-expression", + }, + defaultOptions: [ + { + checkRelationalComparisons: false, + }, + ], + schema: [ + { + type: "object", + properties: { + checkRelationalComparisons: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + messages: { + constantBinaryOperand: + "Unexpected constant binary expression. Compares constantly with the {{otherSide}}-hand side of the `{{operator}}`.", + constantShortCircuit: + "Unexpected constant {{property}} on the left-hand side of a `{{operator}}` expression.", + alwaysNew: + "Unexpected comparison to newly constructed object. These two values can never be equal.", + bothAlwaysNew: + "Unexpected comparison of two newly constructed objects. These two values can never be equal.", + constantRelationalComparison: + "Unexpected constant relational comparison. Both sides of the `{{operator}}` are literal values.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const { checkRelationalComparisons } = context.options[0]; + + return { + LogicalExpression(node) { + const { operator, left } = node; + const scope = sourceCode.getScope(node); + + if ( + (operator === "&&" || operator === "||") && + isConstant(scope, left, true) + ) { + context.report({ + node: left, + messageId: "constantShortCircuit", + data: { property: "truthiness", operator }, + }); + } else if ( + operator === "??" && + hasConstantNullishness(scope, left, false) + ) { + context.report({ + node: left, + messageId: "constantShortCircuit", + data: { property: "nullishness", operator }, + }); + } + }, + BinaryExpression(node) { + const scope = sourceCode.getScope(node); + const { right, left, operator } = node; + const rightConstantOperand = + findBinaryExpressionConstantOperand( + scope, + left, + right, + operator, + ); + const leftConstantOperand = findBinaryExpressionConstantOperand( + scope, + right, + left, + operator, + ); + + if (rightConstantOperand) { + context.report({ + node: rightConstantOperand, + messageId: "constantBinaryOperand", + data: { operator, otherSide: "left" }, + }); + } else if (leftConstantOperand) { + context.report({ + node: leftConstantOperand, + messageId: "constantBinaryOperand", + data: { operator, otherSide: "right" }, + }); + } else if (operator === "===" || operator === "!==") { + if (isAlwaysNew(scope, left)) { + context.report({ node: left, messageId: "alwaysNew" }); + } else if (isAlwaysNew(scope, right)) { + context.report({ node: right, messageId: "alwaysNew" }); + } + } else if (operator === "==" || operator === "!=") { + /* + * If both sides are "new", then both sides are objects and + * therefore they will be compared by reference even with `==` + * equality. + */ + if (isAlwaysNew(scope, left) && isAlwaysNew(scope, right)) { + context.report({ + node: left, + messageId: "bothAlwaysNew", + }); + } + } else if ( + checkRelationalComparisons && + RELATIONAL_OPERATORS.has(operator) + ) { + if ( + isStaticLiteral(scope, left) && + isStaticLiteral(scope, right) + ) { + context.report({ + node, + messageId: "constantRelationalComparison", + data: { operator }, + }); + } + } + }, + + /* + * In theory we could handle short-circuiting assignment operators, + * for some constant values, but that would require walking the + * scope to find the value of the variable being assigned. This is + * dependent on https://github.com/eslint/eslint/issues/13776 + * + * AssignmentExpression() {}, + */ + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-condition.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-condition.js new file mode 100644 index 00000000..4ecd5a3d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constant-condition.js @@ -0,0 +1,177 @@ +/** + * @fileoverview Rule to flag use constant conditions + * @author Christian Schulz + */ + +"use strict"; + +const { isConstant } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [{ checkLoops: "allExceptWhileTrue" }], + + docs: { + description: "Disallow constant expressions in conditions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-constant-condition", + }, + + schema: [ + { + type: "object", + properties: { + checkLoops: { + enum: [ + "all", + "allExceptWhileTrue", + "none", + true, + false, + ], + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "Unexpected constant condition.", + }, + }, + + create(context) { + const loopSetStack = []; + const sourceCode = context.sourceCode; + let [{ checkLoops }] = context.options; + + if (checkLoops === true) { + checkLoops = "all"; + } else if (checkLoops === false) { + checkLoops = "none"; + } + + let loopsInCurrentScope = new Set(); + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Tracks when the given node contains a constant condition. + * @param {ASTNode} node The AST node to check. + * @returns {void} + * @private + */ + function trackConstantConditionLoop(node) { + if ( + node.test && + isConstant(sourceCode.getScope(node), node.test, true) + ) { + loopsInCurrentScope.add(node); + } + } + + /** + * Reports when the set contains the given constant condition node + * @param {ASTNode} node The AST node to check. + * @returns {void} + * @private + */ + function checkConstantConditionLoopInSet(node) { + if (loopsInCurrentScope.has(node)) { + loopsInCurrentScope.delete(node); + context.report({ node: node.test, messageId: "unexpected" }); + } + } + + /** + * Reports when the given node contains a constant condition. + * @param {ASTNode} node The AST node to check. + * @returns {void} + * @private + */ + function reportIfConstant(node) { + if ( + node.test && + isConstant(sourceCode.getScope(node), node.test, true) + ) { + context.report({ node: node.test, messageId: "unexpected" }); + } + } + + /** + * Stores current set of constant loops in loopSetStack temporarily + * and uses a new set to track constant loops + * @returns {void} + * @private + */ + function enterFunction() { + loopSetStack.push(loopsInCurrentScope); + loopsInCurrentScope = new Set(); + } + + /** + * Reports when the set still contains stored constant conditions + * @returns {void} + * @private + */ + function exitFunction() { + loopsInCurrentScope = loopSetStack.pop(); + } + + /** + * Checks node when checkLoops option is enabled + * @param {ASTNode} node The AST node to check. + * @returns {void} + * @private + */ + function checkLoop(node) { + if (checkLoops === "all" || checkLoops === "allExceptWhileTrue") { + trackConstantConditionLoop(node); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ConditionalExpression: reportIfConstant, + IfStatement: reportIfConstant, + WhileStatement(node) { + if ( + node.test.type === "Literal" && + node.test.value === true && + checkLoops === "allExceptWhileTrue" + ) { + return; + } + + checkLoop(node); + }, + "WhileStatement:exit": checkConstantConditionLoopInSet, + DoWhileStatement: checkLoop, + "DoWhileStatement:exit": checkConstantConditionLoopInSet, + ForStatement: checkLoop, + "ForStatement > .test": node => checkLoop(node.parent), + "ForStatement:exit": checkConstantConditionLoopInSet, + FunctionDeclaration: enterFunction, + "FunctionDeclaration:exit": exitFunction, + FunctionExpression: enterFunction, + "FunctionExpression:exit": exitFunction, + YieldExpression: () => loopsInCurrentScope.clear(), + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constructor-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constructor-return.js new file mode 100644 index 00000000..ed9e03db --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-constructor-return.js @@ -0,0 +1,62 @@ +/** + * @fileoverview Rule to disallow returning value from constructor. + * @author Pig Fang + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow returning value from constructor", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-constructor-return", + }, + + schema: [], + + fixable: null, + + messages: { + unexpected: "Unexpected return statement in constructor.", + }, + }, + + create(context) { + const stack = []; + + return { + onCodePathStart(_, node) { + stack.push(node); + }, + onCodePathEnd() { + stack.pop(); + }, + ReturnStatement(node) { + const last = stack.at(-1); + + if (!last.parent) { + return; + } + + if ( + last.parent.type === "MethodDefinition" && + last.parent.kind === "constructor" && + node.argument + ) { + context.report({ + node, + messageId: "unexpected", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-continue.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-continue.js new file mode 100644 index 00000000..6671c619 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-continue.js @@ -0,0 +1,38 @@ +/** + * @fileoverview Rule to flag use of continue statement + * @author Borislav Zhivkov + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `continue` statements", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-continue", + }, + + schema: [], + + messages: { + unexpected: "Unexpected use of continue statement.", + }, + }, + + create(context) { + return { + ContinueStatement(node) { + context.report({ node, messageId: "unexpected" }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-control-regex.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-control-regex.js new file mode 100644 index 00000000..b9a8eee6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-control-regex.js @@ -0,0 +1,145 @@ +/** + * @fileoverview Rule to forbid control characters from regular expressions. + * @author Nicholas C. Zakas + */ + +"use strict"; + +const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator; +const collector = new (class { + constructor() { + this._source = ""; + this._controlChars = []; + this._validator = new RegExpValidator(this); + } + + onPatternEnter() { + /* + * `RegExpValidator` may parse the pattern twice in one `validatePattern`. + * So `this._controlChars` should be cleared here as well. + * + * For example, the `/(?\x1f)/` regex will parse the pattern twice. + * This is based on the content described in Annex B. + * If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice. + * See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb + */ + this._controlChars = []; + } + + onCharacter(start, end, cp) { + if ( + cp >= 0x00 && + cp <= 0x1f && + (this._source.codePointAt(start) === cp || + this._source.slice(start, end).startsWith("\\x") || + this._source.slice(start, end).startsWith("\\u")) + ) { + this._controlChars.push(`\\x${`0${cp.toString(16)}`.slice(-2)}`); + } + } + + collectControlChars(regexpStr, flags) { + const uFlag = typeof flags === "string" && flags.includes("u"); + const vFlag = typeof flags === "string" && flags.includes("v"); + + this._controlChars = []; + this._source = regexpStr; + + try { + this._validator.validatePattern(regexpStr, void 0, void 0, { + unicode: uFlag, + unicodeSets: vFlag, + }); // Call onCharacter hook + } catch { + // Ignore syntax errors in RegExp. + } + return this._controlChars; + } +})(); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow control characters in regular expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-control-regex", + }, + + schema: [], + + messages: { + unexpected: + "Unexpected control character(s) in regular expression: {{controlChars}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Get the regex expression + * @param {ASTNode} node `Literal` node to evaluate + * @returns {{ pattern: string, flags: string | null } | null} Regex if found (the given node is either a regex literal + * or a string literal that is the pattern argument of a RegExp constructor call). Otherwise `null`. If flags cannot be determined, + * the `flags` property will be `null`. + * @private + */ + function getRegExp(node) { + if (node.regex) { + return node.regex; + } + if ( + typeof node.value === "string" && + (node.parent.type === "NewExpression" || + node.parent.type === "CallExpression") && + node.parent.callee.type === "Identifier" && + node.parent.callee.name === "RegExp" && + sourceCode.isGlobalReference(node.parent.callee) && + node.parent.arguments[0] === node + ) { + const pattern = node.value; + const flags = + node.parent.arguments.length > 1 && + node.parent.arguments[1].type === "Literal" && + typeof node.parent.arguments[1].value === "string" + ? node.parent.arguments[1].value + : null; + + return { pattern, flags }; + } + + return null; + } + + return { + Literal(node) { + const regExp = getRegExp(node); + + if (regExp) { + const { pattern, flags } = regExp; + const controlCharacters = collector.collectControlChars( + pattern, + flags, + ); + + if (controlCharacters.length > 0) { + context.report({ + node, + messageId: "unexpected", + data: { + controlChars: controlCharacters.join(", "), + }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-debugger.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-debugger.js new file mode 100644 index 00000000..66bc1be1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-debugger.js @@ -0,0 +1,41 @@ +/** + * @fileoverview Rule to flag use of a debugger statement + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow the use of `debugger`", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-debugger", + }, + + fixable: null, + schema: [], + + messages: { + unexpected: "Unexpected 'debugger' statement.", + }, + }, + + create(context) { + return { + DebuggerStatement(node) { + context.report({ + node, + messageId: "unexpected", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-delete-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-delete-var.js new file mode 100644 index 00000000..7dfe002a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-delete-var.js @@ -0,0 +1,42 @@ +/** + * @fileoverview Rule to flag when deleting variables + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow deleting variables", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-delete-var", + }, + + schema: [], + + messages: { + unexpected: "Variables should not be deleted.", + }, + }, + + create(context) { + return { + UnaryExpression(node) { + if ( + node.operator === "delete" && + node.argument.type === "Identifier" + ) { + context.report({ node, messageId: "unexpected" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-div-regex.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-div-regex.js new file mode 100644 index 00000000..69845bbd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-div-regex.js @@ -0,0 +1,60 @@ +/** + * @fileoverview Rule to check for ambiguous div operator in regexes + * @author Matt DuVall + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow equal signs explicitly at the beginning of regular expressions", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-div-regex", + }, + + fixable: "code", + + schema: [], + + messages: { + unexpected: + "A regular expression literal can be confused with '/='.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + Literal(node) { + const token = sourceCode.getFirstToken(node); + + if ( + token.type === "RegularExpression" && + token.value[1] === "=" + ) { + context.report({ + node, + messageId: "unexpected", + fix(fixer) { + return fixer.replaceTextRange( + [token.range[0] + 1, token.range[0] + 2], + "[=]", + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-args.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-args.js new file mode 100644 index 00000000..45629efa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-args.js @@ -0,0 +1,98 @@ +/** + * @fileoverview Rule to flag duplicate arguments + * @author Jamund Ferguson + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Definition} Definition */ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow duplicate arguments in `function` definitions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-dupe-args", + }, + + schema: [], + + messages: { + unexpected: "Duplicate param '{{name}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Checks whether or not a given definition is a parameter's. + * @param {Definition} def A definition to check. + * @returns {boolean} `true` if the definition is a parameter's. + */ + function isParameter(def) { + return def.type === "Parameter"; + } + + /** + * Determines if a given node has duplicate parameters. + * @param {ASTNode} node The node to check. + * @returns {void} + * @private + */ + function checkParams(node) { + const variables = sourceCode.getDeclaredVariables(node); + + for (let i = 0; i < variables.length; ++i) { + const variable = variables[i]; + + // Checks and reports duplications. + const defs = variable.defs.filter(isParameter); + const loc = { + start: astUtils.getOpeningParenOfParams(node, sourceCode) + .loc.start, + end: sourceCode.getTokenBefore(node.body).loc.end, + }; + + if (defs.length >= 2) { + context.report({ + loc, + messageId: "unexpected", + data: { name: variable.name }, + }); + } + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + FunctionDeclaration: checkParams, + FunctionExpression: checkParams, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-class-members.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-class-members.js new file mode 100644 index 00000000..2d38d6e6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-class-members.js @@ -0,0 +1,116 @@ +/** + * @fileoverview A rule to disallow duplicate name in class members. + * @author Toru Nagashima + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow duplicate class members", + dialects: ["JavaScript", "TypeScript"], + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-dupe-class-members", + }, + + schema: [], + + messages: { + unexpected: "Duplicate name '{{name}}'.", + }, + }, + + create(context) { + let stack = []; + + /** + * Gets state of a given member name. + * @param {string} name A name of a member. + * @param {boolean} isStatic A flag which specifies that is a static member. + * @returns {Object} A state of a given member name. + * - retv.init {boolean} A flag which shows the name is declared as normal member. + * - retv.get {boolean} A flag which shows the name is declared as getter. + * - retv.set {boolean} A flag which shows the name is declared as setter. + */ + function getState(name, isStatic) { + const stateMap = stack.at(-1); + const key = `$${name}`; // to avoid "__proto__". + + if (!stateMap[key]) { + stateMap[key] = { + nonStatic: { init: false, get: false, set: false }, + static: { init: false, get: false, set: false }, + }; + } + + return stateMap[key][isStatic ? "static" : "nonStatic"]; + } + + return { + // Initializes the stack of state of member declarations. + Program() { + stack = []; + }, + + // Initializes state of member declarations for the class. + ClassBody() { + stack.push(Object.create(null)); + }, + + // Disposes the state for the class. + "ClassBody:exit"() { + stack.pop(); + }, + + // Reports the node if its name has been declared already. + "MethodDefinition, PropertyDefinition"(node) { + if ( + node.value && + node.value.type === "TSEmptyBodyFunctionExpression" + ) { + return; + } + + const name = astUtils.getStaticPropertyName(node); + const kind = + node.type === "MethodDefinition" ? node.kind : "field"; + + if (name === null || kind === "constructor") { + return; + } + + const state = getState(name, node.static); + let isDuplicate; + + if (kind === "get") { + isDuplicate = state.init || state.get; + state.get = true; + } else if (kind === "set") { + isDuplicate = state.init || state.set; + state.set = true; + } else { + isDuplicate = state.init || state.get || state.set; + state.init = true; + } + + if (isDuplicate) { + context.report({ + loc: node.key.loc, + messageId: "unexpected", + data: { name }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-else-if.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-else-if.js new file mode 100644 index 00000000..7c419581 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-else-if.js @@ -0,0 +1,145 @@ +/** + * @fileoverview Rule to disallow duplicate conditions in if-else-if chains + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the first given array is a subset of the second given array. + * @param {Function} comparator A function to compare two elements, should return `true` if they are equal. + * @param {Array} arrA The array to compare from. + * @param {Array} arrB The array to compare against. + * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`. + */ +function isSubsetByComparator(comparator, arrA, arrB) { + return arrA.every(a => arrB.some(b => comparator(a, b))); +} + +/** + * Splits the given node by the given logical operator. + * @param {string} operator Logical operator `||` or `&&`. + * @param {ASTNode} node The node to split. + * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator. + */ +function splitByLogicalOperator(operator, node) { + if (node.type === "LogicalExpression" && node.operator === operator) { + return [ + ...splitByLogicalOperator(operator, node.left), + ...splitByLogicalOperator(operator, node.right), + ]; + } + return [node]; +} + +const splitByOr = splitByLogicalOperator.bind(null, "||"); +const splitByAnd = splitByLogicalOperator.bind(null, "&&"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow duplicate conditions in if-else-if chains", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-dupe-else-if", + }, + + schema: [], + + messages: { + unexpected: + "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes + * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators. + * @param {ASTNode} a First node. + * @param {ASTNode} b Second node. + * @returns {boolean} `true` if the nodes are considered to be equal. + */ + function equal(a, b) { + if (a.type !== b.type) { + return false; + } + + if ( + a.type === "LogicalExpression" && + (a.operator === "||" || a.operator === "&&") && + a.operator === b.operator + ) { + return ( + (equal(a.left, b.left) && equal(a.right, b.right)) || + (equal(a.left, b.right) && equal(a.right, b.left)) + ); + } + + return astUtils.equalTokens(a, b, sourceCode); + } + + const isSubset = isSubsetByComparator.bind(null, equal); + + return { + IfStatement(node) { + const test = node.test, + conditionsToCheck = + test.type === "LogicalExpression" && + test.operator === "&&" + ? [test, ...splitByAnd(test)] + : [test]; + let current = node, + listToCheck = conditionsToCheck.map(c => + splitByOr(c).map(splitByAnd), + ); + + while ( + current.parent && + current.parent.type === "IfStatement" && + current.parent.alternate === current + ) { + current = current.parent; + + const currentOrOperands = splitByOr(current.test).map( + splitByAnd, + ); + + listToCheck = listToCheck.map(orOperands => + orOperands.filter( + orOperand => + !currentOrOperands.some(currentOrOperand => + isSubset(currentOrOperand, orOperand), + ), + ), + ); + + if ( + listToCheck.some(orOperands => orOperands.length === 0) + ) { + context.report({ node: test, messageId: "unexpected" }); + break; + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-keys.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-keys.js new file mode 100644 index 00000000..a17cb343 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-dupe-keys.js @@ -0,0 +1,165 @@ +/** + * @fileoverview Rule to flag use of duplicate keys in an object. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const GET_KIND = /^(?:init|get)$/u; +const SET_KIND = /^(?:init|set)$/u; + +/** + * The class which stores properties' information of an object. + */ +class ObjectInfo { + /** + * @param {ObjectInfo|null} upper The information of the outer object. + * @param {ASTNode} node The ObjectExpression node of this information. + */ + constructor(upper, node) { + this.upper = upper; + this.node = node; + this.properties = new Map(); + } + + /** + * Gets the information of the given Property node. + * @param {ASTNode} node The Property node to get. + * @returns {{get: boolean, set: boolean}} The information of the property. + */ + getPropertyInfo(node) { + const name = astUtils.getStaticPropertyName(node); + + if (!this.properties.has(name)) { + this.properties.set(name, { get: false, set: false }); + } + return this.properties.get(name); + } + + /** + * Checks whether the given property has been defined already or not. + * @param {ASTNode} node The Property node to check. + * @returns {boolean} `true` if the property has been defined. + */ + isPropertyDefined(node) { + const entry = this.getPropertyInfo(node); + + return ( + (GET_KIND.test(node.kind) && entry.get) || + (SET_KIND.test(node.kind) && entry.set) + ); + } + + /** + * Defines the given property. + * @param {ASTNode} node The Property node to define. + * @returns {void} + */ + defineProperty(node) { + const entry = this.getPropertyInfo(node); + + if (GET_KIND.test(node.kind)) { + entry.get = true; + } + if (SET_KIND.test(node.kind)) { + entry.set = true; + } + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow duplicate keys in object literals", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-dupe-keys", + }, + + schema: [], + + messages: { + unexpected: "Duplicate key '{{name}}'.", + }, + }, + + create(context) { + let info = null; + + return { + ObjectExpression(node) { + info = new ObjectInfo(info, node); + }, + "ObjectExpression:exit"() { + info = info.upper; + }, + + Property(node) { + const name = astUtils.getStaticPropertyName(node); + + // Skip destructuring. + if (node.parent.type !== "ObjectExpression") { + return; + } + + // Skip if the name is not static. + if (name === null) { + return; + } + + /* + * Skip if the property node is a proto setter. + * Proto setter is a special syntax that sets + * object's prototype instead of creating a property. + * It can be in one of the following forms: + * + * __proto__: + * '__proto__': + * "__proto__": + * + * Duplicate proto setters produce parsing errors, + * so we can just skip them to not interfere with + * regular properties named "__proto__". + */ + if ( + name === "__proto__" && + node.kind === "init" && + !node.computed && + !node.shorthand && + !node.method + ) { + return; + } + + // Reports if the name is defined already. + if (info.isPropertyDefined(node)) { + context.report({ + node: info.node, + loc: node.key.loc, + messageId: "unexpected", + data: { name }, + }); + } + + // Update info. + info.defineProperty(node); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-case.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-case.js new file mode 100644 index 00000000..161b1a0b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-case.js @@ -0,0 +1,78 @@ +/** + * @fileoverview Rule to disallow a duplicate case label. + * @author Dieter Oberkofler + * @author Burak Yigit Kaya + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow duplicate case labels", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-duplicate-case", + }, + + schema: [], + + messages: { + unexpected: "Duplicate case label.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Determines whether the two given nodes are considered to be equal. + * @param {ASTNode} a First node. + * @param {ASTNode} b Second node. + * @returns {boolean} `true` if the nodes are considered to be equal. + */ + function equal(a, b) { + if (a.type !== b.type) { + return false; + } + + return astUtils.equalTokens(a, b, sourceCode); + } + return { + SwitchStatement(node) { + const previousTests = []; + + for (const switchCase of node.cases) { + if (switchCase.test) { + const test = switchCase.test; + + if ( + previousTests.some(previousTest => + equal(previousTest, test), + ) + ) { + context.report({ + node: switchCase, + messageId: "unexpected", + }); + } else { + previousTests.push(test); + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-imports.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-imports.js new file mode 100644 index 00000000..5e5653cc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-duplicate-imports.js @@ -0,0 +1,367 @@ +/** + * @fileoverview Restrict usage of duplicate imports. + * @author Simen Bekkhus + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const NAMED_TYPES = ["ImportSpecifier", "ExportSpecifier"]; +const NAMESPACE_TYPES = [ + "ImportNamespaceSpecifier", + "ExportNamespaceSpecifier", +]; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** + * Check if an import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier). + * @param {string} importExportType An import/export type to check. + * @param {string} type Can be "named" or "namespace" + * @returns {boolean} `true` if import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier) and `false` if it doesn't. + */ +function isImportExportSpecifier(importExportType, type) { + const arrayToCheck = type === "named" ? NAMED_TYPES : NAMESPACE_TYPES; + + return arrayToCheck.includes(importExportType); +} + +/** + * Return the type of (import|export). + * @param {ASTNode} node A node to get. + * @returns {string} The type of the (import|export). + */ +function getImportExportType(node) { + if (node.specifiers && node.specifiers.length > 0) { + const nodeSpecifiers = node.specifiers; + const index = nodeSpecifiers.findIndex( + ({ type }) => + isImportExportSpecifier(type, "named") || + isImportExportSpecifier(type, "namespace"), + ); + const i = index > -1 ? index : 0; + + return nodeSpecifiers[i].type; + } + if (node.type === "ExportAllDeclaration") { + if (node.exported) { + return "ExportNamespaceSpecifier"; + } + return "ExportAll"; + } + return "SideEffectImport"; +} + +/** + * Returns a boolean indicates if two (import|export) can be merged + * @param {ASTNode} node1 A node to check. + * @param {ASTNode} node2 A node to check. + * @returns {boolean} `true` if two (import|export) can be merged, `false` if they can't. + */ +function isImportExportCanBeMerged(node1, node2) { + const importExportType1 = getImportExportType(node1); + const importExportType2 = getImportExportType(node2); + + if ( + (node1.importKind === "type" || node1.exportKind === "type") && + (node2.importKind === "type" || node2.exportKind === "type") + ) { + const isDefault1 = importExportType1 === "ImportDefaultSpecifier"; + const isDefault2 = importExportType2 === "ImportDefaultSpecifier"; + const isNamed1 = isImportExportSpecifier(importExportType1, "named"); + const isNamed2 = isImportExportSpecifier(importExportType2, "named"); + + if ((isDefault1 && isNamed2) || (isDefault2 && isNamed1)) { + return false; + } + } + + if ( + (importExportType1 === "ExportAll" && + importExportType2 !== "ExportAll" && + importExportType2 !== "SideEffectImport") || + (importExportType1 !== "ExportAll" && + importExportType1 !== "SideEffectImport" && + importExportType2 === "ExportAll") + ) { + return false; + } + if ( + (isImportExportSpecifier(importExportType1, "namespace") && + isImportExportSpecifier(importExportType2, "named")) || + (isImportExportSpecifier(importExportType2, "namespace") && + isImportExportSpecifier(importExportType1, "named")) + ) { + return false; + } + return true; +} + +/** + * Returns a boolean if we should report (import|export). + * @param {ASTNode} node A node to be reported or not. + * @param {[ASTNode]} previousNodes An array contains previous nodes of the module imported or exported. + * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports. + * @returns {boolean} `true` if the (import|export) should be reported. + */ +function shouldReportImportExport( + node, + previousNodes, + allowSeparateTypeImports, +) { + let i = 0; + + while (i < previousNodes.length) { + const previousNode = previousNodes[i]; + + if (allowSeparateTypeImports) { + const isTypeNode = + node.importKind === "type" || node.exportKind === "type"; + const isTypePrevious = + previousNode.importKind === "type" || + previousNode.exportKind === "type"; + + if (isTypeNode !== isTypePrevious) { + i++; + continue; + } + } + + if (isImportExportCanBeMerged(node, previousNode)) { + return true; + } + i++; + } + return false; +} + +/** + * Returns array contains only nodes with declarations types equal to type. + * @param {[{node: ASTNode, declarationType: string}]} nodes An array contains objects, each object contains a node and a declaration type. + * @param {string} type Declaration type. + * @returns {[ASTNode]} An array contains only nodes with declarations types equal to type. + */ +function getNodesByDeclarationType(nodes, type) { + return nodes + .filter(({ declarationType }) => declarationType === type) + .map(({ node }) => node); +} + +/** + * Returns the name of the module imported or re-exported. + * @param {ASTNode} node A node to get. + * @returns {string} The name of the module, or empty string if no name. + */ +function getModule(node) { + if (node && node.source && node.source.value) { + return node.source.value.trim(); + } + return ""; +} + +/** + * Checks if the (import|export) can be merged with at least one import or one export, and reports if so. + * @param {RuleContext} context The ESLint rule context object. + * @param {ASTNode} node A node to get. + * @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type. + * @param {string} declarationType A declaration type can be an import or export. + * @param {boolean} includeExports Whether or not to check for exports in addition to imports. + * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports. + * @returns {void} No return value. + */ +function checkAndReport( + context, + node, + modules, + declarationType, + includeExports, + allowSeparateTypeImports, +) { + const module = getModule(node); + + if (modules.has(module)) { + const previousNodes = modules.get(module); + const messagesIds = []; + const importNodes = getNodesByDeclarationType(previousNodes, "import"); + let exportNodes; + + if (includeExports) { + exportNodes = getNodesByDeclarationType(previousNodes, "export"); + } + if (declarationType === "import") { + if ( + shouldReportImportExport( + node, + importNodes, + allowSeparateTypeImports, + ) + ) { + messagesIds.push("import"); + } + if (includeExports) { + if ( + shouldReportImportExport( + node, + exportNodes, + allowSeparateTypeImports, + ) + ) { + messagesIds.push("importAs"); + } + } + } else if (declarationType === "export") { + if ( + shouldReportImportExport( + node, + exportNodes, + allowSeparateTypeImports, + ) + ) { + messagesIds.push("export"); + } + if ( + shouldReportImportExport( + node, + importNodes, + allowSeparateTypeImports, + ) + ) { + messagesIds.push("exportAs"); + } + } + messagesIds.forEach(messageId => + context.report({ + node, + messageId, + data: { + module, + }, + }), + ); + } +} + +/** + * @callback nodeCallback + * @param {ASTNode} node A node to handle. + */ + +/** + * Returns a function handling the (imports|exports) of a given file + * @param {RuleContext} context The ESLint rule context object. + * @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type. + * @param {string} declarationType A declaration type can be an import or export. + * @param {boolean} includeExports Whether or not to check for exports in addition to imports. + * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports. + * @returns {nodeCallback} A function passed to ESLint to handle the statement. + */ +function handleImportsExports( + context, + modules, + declarationType, + includeExports, + allowSeparateTypeImports, +) { + return function (node) { + const module = getModule(node); + + if (module) { + checkAndReport( + context, + node, + modules, + declarationType, + includeExports, + allowSeparateTypeImports, + ); + const currentNode = { node, declarationType }; + let nodes = [currentNode]; + + if (modules.has(module)) { + const previousNodes = modules.get(module); + + nodes = [...previousNodes, currentNode]; + } + modules.set(module, nodes); + } + }; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + includeExports: false, + allowSeparateTypeImports: false, + }, + ], + + docs: { + description: "Disallow duplicate module imports", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-duplicate-imports", + }, + + schema: [ + { + type: "object", + properties: { + includeExports: { + type: "boolean", + }, + allowSeparateTypeImports: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + import: "'{{module}}' import is duplicated.", + importAs: "'{{module}}' import is duplicated as export.", + export: "'{{module}}' export is duplicated.", + exportAs: "'{{module}}' export is duplicated as import.", + }, + }, + + create(context) { + const [{ includeExports, allowSeparateTypeImports }] = context.options; + const modules = new Map(); + const handlers = { + ImportDeclaration: handleImportsExports( + context, + modules, + "import", + includeExports, + allowSeparateTypeImports, + ), + }; + + if (includeExports) { + handlers.ExportNamedDeclaration = handleImportsExports( + context, + modules, + "export", + includeExports, + allowSeparateTypeImports, + ); + handlers.ExportAllDeclaration = handleImportsExports( + context, + modules, + "export", + includeExports, + allowSeparateTypeImports, + ); + } + return handlers; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-else-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-else-return.js new file mode 100644 index 00000000..54c1be82 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-else-return.js @@ -0,0 +1,456 @@ +/** + * @fileoverview Rule to flag `else` after a `return` in `if` + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const FixTracker = require("./utils/fix-tracker"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ allowElseIf: true }], + + docs: { + description: + "Disallow `else` blocks after `return` statements in `if` statements", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-else-return", + }, + + schema: [ + { + type: "object", + properties: { + allowElseIf: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + unexpected: "Unnecessary 'else' after 'return'.", + }, + }, + + create(context) { + const [{ allowElseIf }] = context.options; + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Checks whether the given names can be safely used to declare block-scoped variables + * in the given scope. Name collisions can produce redeclaration syntax errors, + * or silently change references and modify behavior of the original code. + * + * This is not a generic function. In particular, it is assumed that the scope is a function scope or + * a function's inner scope, and that the names can be valid identifiers in the given scope. + * @param {string[]} names Array of variable names. + * @param {Scope} scope Function scope or a function's inner scope. + * @returns {boolean} True if all names can be safely declared, false otherwise. + */ + function isSafeToDeclare(names, scope) { + if (names.length === 0) { + return true; + } + + const functionScope = scope.variableScope; + + /* + * If this is a function scope, scope.variables will contain parameters, implicit variables such as "arguments", + * all function-scoped variables ('var'), and block-scoped variables defined in the scope. + * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope. + * + * Redeclaring any of these would cause a syntax error, except for the implicit variables. + */ + const declaredVariables = scope.variables.filter( + ({ defs }) => defs.length > 0, + ); + + if (declaredVariables.some(({ name }) => names.includes(name))) { + return false; + } + + // Redeclaring a catch variable would also cause a syntax error. + if (scope !== functionScope && scope.upper.type === "catch") { + if ( + scope.upper.variables.some(({ name }) => + names.includes(name), + ) + ) { + return false; + } + } + + /* + * Redeclaring an implicit variable, such as "arguments", would not cause a syntax error. + * However, if the variable was used, declaring a new one with the same name would change references + * and modify behavior. + */ + const usedImplicitVariables = scope.variables.filter( + ({ defs, references }) => + defs.length === 0 && references.length > 0, + ); + + if ( + usedImplicitVariables.some(({ name }) => names.includes(name)) + ) { + return false; + } + + /* + * Declaring a variable with a name that was already used to reference a variable from an upper scope + * would change references and modify behavior. + */ + if (scope.through.some(t => names.includes(t.identifier.name))) { + return false; + } + + /* + * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside + * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope. + * + * For example, this would be a syntax error "Identifier 'a' has already been declared": + * function foo() { if (bar) { let a; if (baz) { var a; } } } + */ + if (scope !== functionScope) { + const scopeNodeRange = scope.block.range; + const variablesToCheck = functionScope.variables.filter( + ({ name }) => names.includes(name), + ); + + if ( + variablesToCheck.some(v => + v.defs.some( + ({ node: { range } }) => + scopeNodeRange[0] <= range[0] && + range[1] <= scopeNodeRange[1], + ), + ) + ) { + return false; + } + } + + return true; + } + + /** + * Checks whether the removal of `else` and its braces is safe from variable name collisions. + * @param {Node} node The 'else' node. + * @param {Scope} scope The scope in which the node and the whole 'if' statement is. + * @returns {boolean} True if it is safe, false otherwise. + */ + function isSafeFromNameCollisions(node, scope) { + if (node.type === "FunctionDeclaration") { + // Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently. + return false; + } + + if (node.type !== "BlockStatement") { + return true; + } + + const elseBlockScope = scope.childScopes.find( + ({ block }) => block === node, + ); + + if (!elseBlockScope) { + // ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions. + return true; + } + + /* + * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains + * only block-scoped variables (such as let and const variables or class and function declarations) + * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions. + */ + const namesToCheck = elseBlockScope.variables.map( + ({ name }) => name, + ); + + return isSafeToDeclare(namesToCheck, scope); + } + + /** + * Display the context report if rule is violated + * @param {Node} elseNode The 'else' node + * @returns {void} + */ + function displayReport(elseNode) { + const currentScope = sourceCode.getScope(elseNode.parent); + + context.report({ + node: elseNode, + messageId: "unexpected", + fix(fixer) { + if (!isSafeFromNameCollisions(elseNode, currentScope)) { + return null; + } + + const startToken = sourceCode.getFirstToken(elseNode); + const elseToken = sourceCode.getTokenBefore(startToken); + const source = sourceCode.getText(elseNode); + const lastIfToken = sourceCode.getTokenBefore(elseToken); + let fixedSource, firstTokenOfElseBlock; + + if ( + startToken.type === "Punctuator" && + startToken.value === "{" + ) { + firstTokenOfElseBlock = + sourceCode.getTokenAfter(startToken); + } else { + firstTokenOfElseBlock = startToken; + } + + /* + * If the if block does not have curly braces and does not end in a semicolon + * and the else block starts with (, [, /, +, ` or -, then it is not + * safe to remove the else keyword, because ASI will not add a semicolon + * after the if block + */ + const ifBlockMaybeUnsafe = + elseNode.parent.consequent.type !== "BlockStatement" && + lastIfToken.value !== ";"; + const elseBlockUnsafe = /^[([/+`-]/u.test( + firstTokenOfElseBlock.value, + ); + + if (ifBlockMaybeUnsafe && elseBlockUnsafe) { + return null; + } + + const endToken = sourceCode.getLastToken(elseNode); + const lastTokenOfElseBlock = + sourceCode.getTokenBefore(endToken); + + if (lastTokenOfElseBlock.value !== ";") { + const nextToken = sourceCode.getTokenAfter(endToken); + + const nextTokenUnsafe = + nextToken && /^[([/+`-]/u.test(nextToken.value); + const nextTokenOnSameLine = + nextToken && + nextToken.loc.start.line === + lastTokenOfElseBlock.loc.start.line; + + /* + * If the else block contents does not end in a semicolon, + * and the else block starts with (, [, /, +, ` or -, then it is not + * safe to remove the else block, because ASI will not add a semicolon + * after the remaining else block contents + */ + if ( + nextTokenUnsafe || + (nextTokenOnSameLine && nextToken.value !== "}") + ) { + return null; + } + } + + if ( + startToken.type === "Punctuator" && + startToken.value === "{" + ) { + fixedSource = source.slice(1, -1); + } else { + fixedSource = source; + } + + /* + * Extend the replacement range to include the entire + * function to avoid conflicting with no-useless-return. + * https://github.com/eslint/eslint/issues/8026 + * + * Also, to avoid name collisions between two else blocks. + */ + return new FixTracker(fixer, sourceCode) + .retainEnclosingFunction(elseNode) + .replaceTextRange( + [elseToken.range[0], elseNode.range[1]], + fixedSource, + ); + }, + }); + } + + /** + * Check to see if the node is a ReturnStatement + * @param {Node} node The node being evaluated + * @returns {boolean} True if node is a return + */ + function checkForReturn(node) { + return node.type === "ReturnStatement"; + } + + /** + * Naive return checking, does not iterate through the whole + * BlockStatement because we make the assumption that the ReturnStatement + * will be the last node in the body of the BlockStatement. + * @param {Node} node The consequent/alternate node + * @returns {boolean} True if it has a return + */ + function naiveHasReturn(node) { + if (node.type === "BlockStatement") { + const body = node.body, + lastChildNode = body.at(-1); + + return lastChildNode && checkForReturn(lastChildNode); + } + return checkForReturn(node); + } + + /** + * Check to see if the node is valid for evaluation, + * meaning it has an else. + * @param {Node} node The node being evaluated + * @returns {boolean} True if the node is valid + */ + function hasElse(node) { + return node.alternate && node.consequent; + } + + /** + * If the consequent is an IfStatement, check to see if it has an else + * and both its consequent and alternate path return, meaning this is + * a nested case of rule violation. If-Else not considered currently. + * @param {Node} node The consequent node + * @returns {boolean} True if this is a nested rule violation + */ + function checkForIf(node) { + return ( + node.type === "IfStatement" && + hasElse(node) && + naiveHasReturn(node.alternate) && + naiveHasReturn(node.consequent) + ); + } + + /** + * Check the consequent/body node to make sure it is not + * a ReturnStatement or an IfStatement that returns on both + * code paths. + * @param {Node} node The consequent or body node + * @returns {boolean} `true` if it is a Return/If node that always returns. + */ + function checkForReturnOrIf(node) { + return checkForReturn(node) || checkForIf(node); + } + + /** + * Check whether a node returns in every codepath. + * @param {Node} node The node to be checked + * @returns {boolean} `true` if it returns on every codepath. + */ + function alwaysReturns(node) { + if (node.type === "BlockStatement") { + // If we have a BlockStatement, check each consequent body node. + return node.body.some(checkForReturnOrIf); + } + + /* + * If not a block statement, make sure the consequent isn't a + * ReturnStatement or an IfStatement with returns on both paths. + */ + return checkForReturnOrIf(node); + } + + /** + * Check the if statement, but don't catch else-if blocks. + * @returns {void} + * @param {Node} node The node for the if statement to check + * @private + */ + function checkIfWithoutElse(node) { + const parent = node.parent; + + /* + * Fixing this would require splitting one statement into two, so no error should + * be reported if this node is in a position where only one statement is allowed. + */ + if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) { + return; + } + + const consequents = []; + let alternate; + + for ( + let currentNode = node; + currentNode.type === "IfStatement"; + currentNode = currentNode.alternate + ) { + if (!currentNode.alternate) { + return; + } + consequents.push(currentNode.consequent); + alternate = currentNode.alternate; + } + + if (consequents.every(alwaysReturns)) { + displayReport(alternate); + } + } + + /** + * Check the if statement + * @returns {void} + * @param {Node} node The node for the if statement to check + * @private + */ + function checkIfWithElse(node) { + const parent = node.parent; + + /* + * Fixing this would require splitting one statement into two, so no error should + * be reported if this node is in a position where only one statement is allowed. + */ + if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) { + return; + } + + const alternate = node.alternate; + + if (alternate && alwaysReturns(node.consequent)) { + displayReport(alternate); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + "IfStatement:exit": allowElseIf + ? checkIfWithoutElse + : checkIfWithElse, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-character-class.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-character-class.js new file mode 100644 index 00000000..eccee1d1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-character-class.js @@ -0,0 +1,83 @@ +/** + * @fileoverview Rule to flag the use of empty character classes in regular expressions + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const parser = new RegExpParser(); +const QUICK_TEST_REGEX = /\[\]/u; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow empty character classes in regular expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-empty-character-class", + }, + + schema: [], + + messages: { + unexpected: "Empty class.", + }, + }, + + create(context) { + return { + "Literal[regex]"(node) { + const { pattern, flags } = node.regex; + + if (!QUICK_TEST_REGEX.test(pattern)) { + return; + } + + let regExpAST; + + try { + regExpAST = parser.parsePattern( + pattern, + 0, + pattern.length, + { + unicode: flags.includes("u"), + unicodeSets: flags.includes("v"), + }, + ); + } catch { + // Ignore regular expressions that regexpp cannot parse + return; + } + + visitRegExpAST(regExpAST, { + onCharacterClassEnter(characterClass) { + if ( + !characterClass.negate && + characterClass.elements.length === 0 + ) { + context.report({ node, messageId: "unexpected" }); + } + }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-function.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-function.js new file mode 100644 index 00000000..208ab426 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-function.js @@ -0,0 +1,235 @@ +/** + * @fileoverview Rule to disallow empty functions. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const ALLOW_OPTIONS = Object.freeze([ + "functions", + "arrowFunctions", + "generatorFunctions", + "methods", + "generatorMethods", + "getters", + "setters", + "constructors", + "asyncFunctions", + "asyncMethods", + "privateConstructors", + "protectedConstructors", + "decoratedFunctions", + "overrideMethods", +]); + +/** + * Gets the kind of a given function node. + * @param {ASTNode} node A function node to get. This is one of + * an ArrowFunctionExpression, a FunctionDeclaration, or a + * FunctionExpression. + * @returns {string} The kind of the function. This is one of "functions", + * "arrowFunctions", "generatorFunctions", "asyncFunctions", "methods", + * "generatorMethods", "asyncMethods", "getters", "setters", and + * "constructors". + */ +function getKind(node) { + const parent = node.parent; + let kind; + + if (node.type === "ArrowFunctionExpression") { + return "arrowFunctions"; + } + + // Detects main kind. + if (parent.type === "Property") { + if (parent.kind === "get") { + return "getters"; + } + if (parent.kind === "set") { + return "setters"; + } + kind = parent.method ? "methods" : "functions"; + } else if (parent.type === "MethodDefinition") { + if (parent.kind === "get") { + return "getters"; + } + if (parent.kind === "set") { + return "setters"; + } + if (parent.kind === "constructor") { + return "constructors"; + } + kind = "methods"; + } else { + kind = "functions"; + } + + // Detects prefix. + let prefix; + + if (node.generator) { + prefix = "generator"; + } else if (node.async) { + prefix = "async"; + } else { + return kind; + } + return prefix + kind[0].toUpperCase() + kind.slice(1); +} + +/** + * Checks if a constructor function has parameter properties. + * @param {ASTNode} node The function node to examine. + * @returns {boolean} True if the constructor has parameter properties, false otherwise. + */ +function isParameterPropertiesConstructor(node) { + return node.params.some(param => param.type === "TSParameterProperty"); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "suggestion", + + defaultOptions: [{ allow: [] }], + + docs: { + description: "Disallow empty functions", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-empty-function", + }, + + schema: [ + { + type: "object", + properties: { + allow: { + type: "array", + items: { enum: ALLOW_OPTIONS }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "Unexpected empty {{name}}.", + suggestComment: "Add comment inside empty {{name}}.", + }, + }, + + create(context) { + const [{ allow }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Checks if the given function node is allowed to be empty. + * @param {ASTNode} node The function node to check. + * @returns {boolean} True if the function is allowed to be empty, false otherwise. + */ + function isAllowedEmptyFunction(node) { + const kind = getKind(node); + + if (allow.includes(kind)) { + return true; + } + + if (kind === "constructors") { + if ( + (node.parent.accessibility === "private" && + allow.includes("privateConstructors")) || + (node.parent.accessibility === "protected" && + allow.includes("protectedConstructors")) || + isParameterPropertiesConstructor(node) + ) { + return true; + } + } + + if (/(?:g|s)etters|methods$/iu.test(kind)) { + if ( + (node.parent.decorators?.length && + allow.includes("decoratedFunctions")) || + (node.parent.override && allow.includes("overrideMethods")) + ) { + return true; + } + } + + return false; + } + + /** + * Reports a given function node if the node matches the following patterns. + * + * - Not allowed by options. + * - The body is empty. + * - The body doesn't have any comments. + * @param {ASTNode} node A function node to report. This is one of + * an ArrowFunctionExpression, a FunctionDeclaration, or a + * FunctionExpression. + * @returns {void} + */ + function reportIfEmpty(node) { + const name = astUtils.getFunctionNameWithKind(node); + const innerComments = sourceCode.getTokens(node.body, { + includeComments: true, + filter: astUtils.isCommentToken, + }); + + if ( + !isAllowedEmptyFunction(node) && + node.body.type === "BlockStatement" && + node.body.body.length === 0 && + innerComments.length === 0 + ) { + context.report({ + node, + loc: node.body.loc, + messageId: "unexpected", + data: { name }, + suggest: [ + { + messageId: "suggestComment", + data: { name }, + fix(fixer) { + const range = [ + node.body.range[0] + 1, + node.body.range[1] - 1, + ]; + + return fixer.replaceTextRange( + range, + " /* empty */ ", + ); + }, + }, + ], + }); + } + } + + return { + ArrowFunctionExpression: reportIfEmpty, + FunctionDeclaration: reportIfEmpty, + FunctionExpression: reportIfEmpty, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-pattern.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-pattern.js new file mode 100644 index 00000000..da75ad95 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-pattern.js @@ -0,0 +1,85 @@ +/** + * @fileoverview Rule to disallow an empty pattern + * @author Alberto Rodríguez + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowObjectPatternsAsParameters: false, + }, + ], + + docs: { + description: "Disallow empty destructuring patterns", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-empty-pattern", + }, + + schema: [ + { + type: "object", + properties: { + allowObjectPatternsAsParameters: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "Unexpected empty {{type}} pattern.", + }, + }, + + create(context) { + const [{ allowObjectPatternsAsParameters }] = context.options; + + return { + ObjectPattern(node) { + if (node.properties.length > 0) { + return; + } + + // Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true + if ( + allowObjectPatternsAsParameters && + (astUtils.isFunction(node.parent) || + (node.parent.type === "AssignmentPattern" && + astUtils.isFunction(node.parent.parent) && + node.parent.right.type === "ObjectExpression" && + node.parent.right.properties.length === 0)) + ) { + return; + } + + context.report({ + node, + messageId: "unexpected", + data: { type: "object" }, + }); + }, + ArrayPattern(node) { + if (node.elements.length === 0) { + context.report({ + node, + messageId: "unexpected", + data: { type: "array" }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-static-block.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-static-block.js new file mode 100644 index 00000000..488b5ed7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty-static-block.js @@ -0,0 +1,73 @@ +/** + * @fileoverview Rule to disallow empty static blocks. + * @author Sosuke Suzuki + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "suggestion", + + docs: { + description: "Disallow empty static blocks", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-empty-static-block", + }, + + schema: [], + + messages: { + unexpected: "Unexpected empty static block.", + suggestComment: "Add comment inside empty static block.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + StaticBlock(node) { + if (node.body.length === 0) { + const openingBrace = sourceCode.getFirstToken(node, { + skip: 1, + }); + const closingBrace = sourceCode.getLastToken(node); + + if ( + sourceCode.getCommentsBefore(closingBrace).length === 0 + ) { + context.report({ + loc: { + start: openingBrace.loc.start, + end: closingBrace.loc.end, + }, + messageId: "unexpected", + suggest: [ + { + messageId: "suggestComment", + fix(fixer) { + const range = [ + openingBrace.range[1], + closingBrace.range[0], + ]; + + return fixer.replaceTextRange( + range, + " /* empty */ ", + ); + }, + }, + ], + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty.js new file mode 100644 index 00000000..dd30e419 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-empty.js @@ -0,0 +1,153 @@ +/** + * @fileoverview Rule to flag use of an empty block statement + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "suggestion", + + defaultOptions: [ + { + allowEmptyCatch: false, + }, + ], + + docs: { + description: "Disallow empty block statements", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-empty", + }, + + schema: [ + { + type: "object", + properties: { + allowEmptyCatch: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "Empty {{type}} statement.", + suggestComment: "Add comment inside empty {{type}} statement.", + }, + }, + + create(context) { + const [{ allowEmptyCatch }] = context.options; + const sourceCode = context.sourceCode; + + return { + BlockStatement(node) { + // if the body is not empty, we can just return immediately + if (node.body.length !== 0) { + return; + } + + // a function is generally allowed to be empty + if (astUtils.isFunction(node.parent)) { + return; + } + + if (allowEmptyCatch && node.parent.type === "CatchClause") { + return; + } + + // any other block is only allowed to be empty, if it contains a comment + if (sourceCode.getCommentsInside(node).length > 0) { + return; + } + + context.report({ + node, + messageId: "unexpected", + data: { type: "block" }, + suggest: [ + { + messageId: "suggestComment", + data: { type: "block" }, + fix(fixer) { + const range = [ + node.range[0] + 1, + node.range[1] - 1, + ]; + + return fixer.replaceTextRange( + range, + " /* empty */ ", + ); + }, + }, + ], + }); + }, + + SwitchStatement(node) { + if ( + typeof node.cases === "undefined" || + node.cases.length === 0 + ) { + const openingBrace = sourceCode.getTokenAfter( + node.discriminant, + astUtils.isOpeningBraceToken, + ); + + const closingBrace = sourceCode.getLastToken(node); + + if ( + sourceCode.commentsExistBetween( + openingBrace, + closingBrace, + ) + ) { + return; + } + + context.report({ + node, + loc: { + start: openingBrace.loc.start, + end: closingBrace.loc.end, + }, + messageId: "unexpected", + data: { type: "switch" }, + suggest: [ + { + messageId: "suggestComment", + data: { type: "switch" }, + fix(fixer) { + const range = [ + openingBrace.range[1], + closingBrace.range[0], + ]; + + return fixer.replaceTextRange( + range, + " /* empty */ ", + ); + }, + }, + ], + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eq-null.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eq-null.js new file mode 100644 index 00000000..edda5e6c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eq-null.js @@ -0,0 +1,51 @@ +/** + * @fileoverview Rule to flag comparisons to null without a type-checking + * operator. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `null` comparisons without type-checking operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-eq-null", + }, + + schema: [], + + messages: { + unexpected: "Use '===' to compare with null.", + }, + }, + + create(context) { + return { + BinaryExpression(node) { + const badOperator = + node.operator === "==" || node.operator === "!="; + + if ( + (node.right.type === "Literal" && + node.right.raw === "null" && + badOperator) || + (node.left.type === "Literal" && + node.left.raw === "null" && + badOperator) + ) { + context.report({ node, messageId: "unexpected" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eval.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eval.js new file mode 100644 index 00000000..ff3a9830 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-eval.js @@ -0,0 +1,301 @@ +/** + * @fileoverview Rule to flag use of eval() statement + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const candidatesOfGlobalObject = Object.freeze([ + "global", + "window", + "globalThis", +]); + +/** + * Checks a given node is a MemberExpression node which has the specified name's + * property. + * @param {ASTNode} node A node to check. + * @param {string} name A name to check. + * @returns {boolean} `true` if the node is a MemberExpression node which has + * the specified name's property + */ +function isMember(node, name) { + return astUtils.isSpecificMemberAccess(node, null, name); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowIndirect: false, + }, + ], + + docs: { + description: "Disallow the use of `eval()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-eval", + }, + + schema: [ + { + type: "object", + properties: { + allowIndirect: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: "`eval` can be harmful.", + }, + }, + + create(context) { + const [{ allowIndirect }] = context.options; + const sourceCode = context.sourceCode; + let funcInfo = null; + + /** + * Pushes a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack. + * Top-level scopes are handled separately. + * + * This is used in order to check whether or not `this` binding is a + * reference to the global object. + * @param {ASTNode} node A node of the scope. + * For functions, this is one of FunctionDeclaration, FunctionExpression. + * For class static blocks, this is StaticBlock. + * For class field initializers, this can be any node that is PropertyDefinition#value. + * @returns {void} + */ + function enterThisScope(node) { + const strict = sourceCode.getScope(node).isStrict; + + funcInfo = { + upper: funcInfo, + node, + strict, + isTopLevelOfScript: false, + defaultThis: false, + initialized: strict, + }; + } + + /** + * Pops a variable scope from the stack. + * @returns {void} + */ + function exitThisScope() { + funcInfo = funcInfo.upper; + } + + /** + * Reports a given node. + * + * `node` is `Identifier` or `MemberExpression`. + * The parent of `node` might be `CallExpression`. + * + * The location of the report is always `eval` `Identifier` (or possibly + * `Literal`). The type of the report is `CallExpression` if the parent is + * `CallExpression`. Otherwise, it's the given node type. + * @param {ASTNode} node A node to report. + * @returns {void} + */ + function report(node) { + const parent = node.parent; + const locationNode = + node.type === "MemberExpression" ? node.property : node; + + const reportNode = + parent.type === "CallExpression" && parent.callee === node + ? parent + : node; + + context.report({ + node: reportNode, + loc: locationNode.loc, + messageId: "unexpected", + }); + } + + /** + * Reports accesses of `eval` via the global object. + * @param {Scope} globalScope The global scope. + * @returns {void} + */ + function reportAccessingEvalViaGlobalObject(globalScope) { + for (let i = 0; i < candidatesOfGlobalObject.length; ++i) { + const name = candidatesOfGlobalObject[i]; + const variable = astUtils.getVariableByName(globalScope, name); + + if (!variable) { + continue; + } + + const references = variable.references; + + for (let j = 0; j < references.length; ++j) { + const identifier = references[j].identifier; + let node = identifier.parent; + + // To detect code like `window.window.eval`. + while (isMember(node, name)) { + node = node.parent; + } + + // Reports. + if (isMember(node, "eval")) { + report(node); + } + } + } + } + + /** + * Reports all accesses of `eval` (excludes direct calls to eval). + * @param {Scope} globalScope The global scope. + * @returns {void} + */ + function reportAccessingEval(globalScope) { + const variable = astUtils.getVariableByName(globalScope, "eval"); + + if (!variable) { + return; + } + + const references = variable.references; + + for (let i = 0; i < references.length; ++i) { + const reference = references[i]; + const id = reference.identifier; + + if (id.name === "eval" && !astUtils.isCallee(id)) { + // Is accessing to eval (excludes direct calls to eval) + report(id); + } + } + } + + if (allowIndirect) { + // Checks only direct calls to eval. It's simple! + return { + "CallExpression:exit"(node) { + const callee = node.callee; + + /* + * Optional call (`eval?.("code")`) is not direct eval. + * The direct eval is only step 6.a.vi of https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation + * But the optional call is https://tc39.es/ecma262/#sec-optional-chaining-chain-evaluation + */ + if ( + !node.optional && + astUtils.isSpecificId(callee, "eval") + ) { + report(callee); + } + }, + }; + } + + return { + "CallExpression:exit"(node) { + const callee = node.callee; + + if (astUtils.isSpecificId(callee, "eval")) { + report(callee); + } + }, + + Program(node) { + const scope = sourceCode.getScope(node), + features = + context.languageOptions.parserOptions.ecmaFeatures || + {}, + strict = + scope.isStrict || + node.sourceType === "module" || + (features.globalReturn && + scope.childScopes[0].isStrict), + isTopLevelOfScript = + node.sourceType !== "module" && !features.globalReturn; + + funcInfo = { + upper: null, + node, + strict, + isTopLevelOfScript, + defaultThis: true, + initialized: true, + }; + }, + + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + exitThisScope(); + reportAccessingEval(globalScope); + reportAccessingEvalViaGlobalObject(globalScope); + }, + + FunctionDeclaration: enterThisScope, + "FunctionDeclaration:exit": exitThisScope, + FunctionExpression: enterThisScope, + "FunctionExpression:exit": exitThisScope, + "PropertyDefinition > *.value": enterThisScope, + "PropertyDefinition > *.value:exit": exitThisScope, + StaticBlock: enterThisScope, + "StaticBlock:exit": exitThisScope, + + ThisExpression(node) { + if (!isMember(node.parent, "eval")) { + return; + } + + /* + * `this.eval` is found. + * Checks whether or not the value of `this` is the global object. + */ + if (!funcInfo.initialized) { + funcInfo.initialized = true; + funcInfo.defaultThis = astUtils.isDefaultThisBinding( + funcInfo.node, + sourceCode, + ); + } + + // `this` at the top level of scripts always refers to the global object + if ( + funcInfo.isTopLevelOfScript || + (!funcInfo.strict && funcInfo.defaultThis) + ) { + // `this.eval` is possible built-in `eval`. + report(node.parent); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ex-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ex-assign.js new file mode 100644 index 00000000..6215a5e0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ex-assign.js @@ -0,0 +1,57 @@ +/** + * @fileoverview Rule to flag assignment of the exception parameter + * @author Stephen Murray + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow reassigning exceptions in `catch` clauses", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-ex-assign", + }, + + schema: [], + + messages: { + unexpected: "Do not assign to the exception parameter.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Finds and reports references that are non initializer and writable. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + astUtils + .getModifyingReferences(variable.references) + .forEach(reference => { + context.report({ + node: reference.identifier, + messageId: "unexpected", + }); + }); + } + + return { + CatchClause(node) { + sourceCode.getDeclaredVariables(node).forEach(checkVariable); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extend-native.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extend-native.js new file mode 100644 index 00000000..d1a6d12d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extend-native.js @@ -0,0 +1,180 @@ +/** + * @fileoverview Rule to flag adding properties to native object's prototypes. + * @author David Nelson + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ exceptions: [] }], + + docs: { + description: "Disallow extending native types", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-extend-native", + }, + + schema: [ + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpected: + "{{builtin}} prototype is read only, properties should not be added.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const exceptions = new Set(context.options[0].exceptions); + const modifiedBuiltins = new Set( + Object.keys(astUtils.ECMASCRIPT_GLOBALS) + .filter(builtin => builtin[0].toUpperCase() === builtin[0]) + .filter(builtin => !exceptions.has(builtin)), + ); + + /** + * Reports a lint error for the given node. + * @param {ASTNode} node The node to report. + * @param {string} builtin The name of the native builtin being extended. + * @returns {void} + */ + function reportNode(node, builtin) { + context.report({ + node, + messageId: "unexpected", + data: { + builtin, + }, + }); + } + + /** + * Check to see if the `prototype` property of the given object + * identifier node is being accessed. + * @param {ASTNode} identifierNode The Identifier representing the object + * to check. + * @returns {boolean} True if the identifier is the object of a + * MemberExpression and its `prototype` property is being accessed, + * false otherwise. + */ + function isPrototypePropertyAccessed(identifierNode) { + return Boolean( + identifierNode && + identifierNode.parent && + identifierNode.parent.type === "MemberExpression" && + identifierNode.parent.object === identifierNode && + astUtils.getStaticPropertyName(identifierNode.parent) === + "prototype", + ); + } + + /** + * Check if it's an assignment to the property of the given node. + * Example: `*.prop = 0` // the `*` is the given node. + * @param {ASTNode} node The node to check. + * @returns {boolean} True if an assignment to the property of the node. + */ + function isAssigningToPropertyOf(node) { + return ( + node.parent.type === "MemberExpression" && + node.parent.object === node && + node.parent.parent.type === "AssignmentExpression" && + node.parent.parent.left === node.parent + ); + } + + /** + * Checks if the given node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`. + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`. + */ + function isInDefinePropertyCall(node) { + return ( + node.parent.type === "CallExpression" && + node.parent.arguments[0] === node && + astUtils.isSpecificMemberAccess( + node.parent.callee, + "Object", + /^definePropert(?:y|ies)$/u, + ) + ); + } + + /** + * Check to see if object prototype access is part of a prototype + * extension. There are three ways a prototype can be extended: + * 1. Assignment to prototype property (Object.prototype.foo = 1) + * 2. Object.defineProperty()/Object.defineProperties() on a prototype + * If prototype extension is detected, report the AssignmentExpression + * or CallExpression node. + * @param {ASTNode} identifierNode The Identifier representing the object + * which prototype is being accessed and possibly extended. + * @returns {void} + */ + function checkAndReportPrototypeExtension(identifierNode) { + if (!isPrototypePropertyAccessed(identifierNode)) { + return; // This is not `*.prototype` access. + } + + /* + * `identifierNode.parent` is a MemberExpression `*.prototype`. + * If it's an optional member access, it may be wrapped by a `ChainExpression` node. + */ + const prototypeNode = + identifierNode.parent.parent.type === "ChainExpression" + ? identifierNode.parent.parent + : identifierNode.parent; + + if (isAssigningToPropertyOf(prototypeNode)) { + // `*.prototype` -> MemberExpression -> AssignmentExpression + reportNode(prototypeNode.parent.parent, identifierNode.name); + } else if (isInDefinePropertyCall(prototypeNode)) { + // `*.prototype` -> CallExpression + reportNode(prototypeNode.parent, identifierNode.name); + } + } + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + modifiedBuiltins.forEach(builtin => { + const builtinVar = globalScope.set.get(builtin); + + if (builtinVar && builtinVar.references) { + builtinVar.references + .map(ref => ref.identifier) + .forEach(checkAndReportPrototypeExtension); + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-bind.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-bind.js new file mode 100644 index 00000000..820b1681 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-bind.js @@ -0,0 +1,234 @@ +/** + * @fileoverview Rule to flag unnecessary bind calls + * @author Bence Dányi + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SIDE_EFFECT_FREE_NODE_TYPES = new Set([ + "Literal", + "Identifier", + "ThisExpression", + "FunctionExpression", +]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unnecessary calls to `.bind()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-extra-bind", + }, + + schema: [], + fixable: "code", + + messages: { + unexpected: "The function binding is unnecessary.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + let scopeInfo = null; + + /** + * Checks if a node is free of side effects. + * + * This check is stricter than it needs to be, in order to keep the implementation simple. + * @param {ASTNode} node A node to check. + * @returns {boolean} True if the node is known to be side-effect free, false otherwise. + */ + function isSideEffectFree(node) { + return SIDE_EFFECT_FREE_NODE_TYPES.has(node.type); + } + + /** + * Reports a given function node. + * @param {ASTNode} node A node to report. This is a FunctionExpression or + * an ArrowFunctionExpression. + * @returns {void} + */ + function report(node) { + const memberNode = node.parent; + const callNode = + memberNode.parent.type === "ChainExpression" + ? memberNode.parent.parent + : memberNode.parent; + + context.report({ + node: callNode, + messageId: "unexpected", + loc: memberNode.property.loc, + + fix(fixer) { + if (!isSideEffectFree(callNode.arguments[0])) { + return null; + } + + /* + * The list of the first/last token pair of a removal range. + * This is two parts because closing parentheses may exist between the method name and arguments. + * E.g. `(function(){}.bind ) (obj)` + * ^^^^^ ^^^^^ < removal ranges + * E.g. `(function(){}?.['bind'] ) ?.(obj)` + * ^^^^^^^^^^ ^^^^^^^ < removal ranges + */ + const tokenPairs = [ + [ + // `.`, `?.`, or `[` token. + sourceCode.getTokenAfter( + memberNode.object, + astUtils.isNotClosingParenToken, + ), + + // property name or `]` token. + sourceCode.getLastToken(memberNode), + ], + [ + // `?.` or `(` token of arguments. + sourceCode.getTokenAfter( + memberNode, + astUtils.isNotClosingParenToken, + ), + + // `)` token of arguments. + sourceCode.getLastToken(callNode), + ], + ]; + const firstTokenToRemove = tokenPairs[0][0]; + const lastTokenToRemove = tokenPairs[1][1]; + + if ( + sourceCode.commentsExistBetween( + firstTokenToRemove, + lastTokenToRemove, + ) + ) { + return null; + } + + return tokenPairs.map(([start, end]) => + fixer.removeRange([start.range[0], end.range[1]]), + ); + }, + }); + } + + /** + * Checks whether or not a given function node is the callee of `.bind()` + * method. + * + * e.g. `(function() {}.bind(foo))` + * @param {ASTNode} node A node to report. This is a FunctionExpression or + * an ArrowFunctionExpression. + * @returns {boolean} `true` if the node is the callee of `.bind()` method. + */ + function isCalleeOfBindMethod(node) { + if (!astUtils.isSpecificMemberAccess(node.parent, null, "bind")) { + return false; + } + + // The node of `*.bind` member access. + const bindNode = + node.parent.parent.type === "ChainExpression" + ? node.parent.parent + : node.parent; + + return ( + bindNode.parent.type === "CallExpression" && + bindNode.parent.callee === bindNode && + bindNode.parent.arguments.length === 1 && + bindNode.parent.arguments[0].type !== "SpreadElement" + ); + } + + /** + * Adds a scope information object to the stack. + * @param {ASTNode} node A node to add. This node is a FunctionExpression + * or a FunctionDeclaration node. + * @returns {void} + */ + function enterFunction(node) { + scopeInfo = { + isBound: isCalleeOfBindMethod(node), + thisFound: false, + upper: scopeInfo, + }; + } + + /** + * Removes the scope information object from the top of the stack. + * At the same time, this reports the function node if the function has + * `.bind()` and the `this` keywords found. + * @param {ASTNode} node A node to remove. This node is a + * FunctionExpression or a FunctionDeclaration node. + * @returns {void} + */ + function exitFunction(node) { + if (scopeInfo.isBound && !scopeInfo.thisFound) { + report(node); + } + + scopeInfo = scopeInfo.upper; + } + + /** + * Reports a given arrow function if the function is callee of `.bind()` + * method. + * @param {ASTNode} node A node to report. This node is an + * ArrowFunctionExpression. + * @returns {void} + */ + function exitArrowFunction(node) { + if (isCalleeOfBindMethod(node)) { + report(node); + } + } + + /** + * Set the mark as the `this` keyword was found in this scope. + * @returns {void} + */ + function markAsThisFound() { + if (scopeInfo) { + scopeInfo.thisFound = true; + } + } + + return { + "ArrowFunctionExpression:exit": exitArrowFunction, + FunctionDeclaration: enterFunction, + "FunctionDeclaration:exit": exitFunction, + FunctionExpression: enterFunction, + "FunctionExpression:exit": exitFunction, + + /* + * Class field initializers and static blocks have their own `this` binding. + * Enter the scope after the key, which is evaluated in the enclosing scope. + */ + "PropertyDefinition > *.key:exit": enterFunction, + "PropertyDefinition:exit": exitFunction, + StaticBlock: enterFunction, + "StaticBlock:exit": exitFunction, + + ThisExpression: markAsThisFound, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-boolean-cast.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-boolean-cast.js new file mode 100644 index 00000000..2aa6df58 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-boolean-cast.js @@ -0,0 +1,422 @@ +/** + * @fileoverview Rule to flag unnecessary double negation in Boolean contexts + * @author Brandon Mills + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const eslintUtils = require("@eslint-community/eslint-utils"); + +const precedence = astUtils.getPrecedence; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{}], + + docs: { + description: "Disallow unnecessary boolean casts", + recommended: true, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-extra-boolean-cast", + }, + + schema: [ + { + anyOf: [ + { + type: "object", + properties: { + enforceForInnerExpressions: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + + // deprecated + { + type: "object", + properties: { + enforceForLogicalOperands: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + fixable: "code", + + messages: { + unexpectedCall: "Redundant Boolean call.", + unexpectedNegation: "Redundant double negation.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ enforceForLogicalOperands, enforceForInnerExpressions }] = + context.options; + + // Node types which have a test which will coerce values to booleans. + const BOOLEAN_NODE_TYPES = new Set([ + "IfStatement", + "DoWhileStatement", + "WhileStatement", + "ConditionalExpression", + "ForStatement", + ]); + + /** + * Check if a node is a Boolean function or constructor. + * @param {ASTNode} node the node + * @returns {boolean} If the node is Boolean function or constructor + */ + function isBooleanFunctionOrConstructorCall(node) { + // Boolean() and new Boolean() + return ( + (node.type === "CallExpression" || + node.type === "NewExpression") && + node.callee.type === "Identifier" && + node.callee.name === "Boolean" && + sourceCode.isGlobalReference(node.callee) + ); + } + + /** + * Check if a node is in a context where its value would be coerced to a boolean at runtime. + * @param {ASTNode} node The node + * @returns {boolean} If it is in a boolean context + */ + function isInBooleanContext(node) { + return ( + (isBooleanFunctionOrConstructorCall(node.parent) && + node === node.parent.arguments[0]) || + (BOOLEAN_NODE_TYPES.has(node.parent.type) && + node === node.parent.test) || + // ! + (node.parent.type === "UnaryExpression" && + node.parent.operator === "!") + ); + } + + /** + * Checks whether the node is a context that should report an error + * Acts recursively if it is in a logical context + * @param {ASTNode} node the node + * @returns {boolean} If the node is in one of the flagged contexts + */ + function isInFlaggedContext(node) { + if (node.parent.type === "ChainExpression") { + return isInFlaggedContext(node.parent); + } + + /* + * legacy behavior - enforceForLogicalOperands will only recurse on + * logical expressions, not on other contexts. + * enforceForInnerExpressions will recurse on logical expressions + * as well as the other recursive syntaxes. + */ + + if (enforceForLogicalOperands || enforceForInnerExpressions) { + if (node.parent.type === "LogicalExpression") { + if ( + node.parent.operator === "||" || + node.parent.operator === "&&" + ) { + return isInFlaggedContext(node.parent); + } + + // Check the right hand side of a `??` operator. + if ( + enforceForInnerExpressions && + node.parent.operator === "??" && + node.parent.right === node + ) { + return isInFlaggedContext(node.parent); + } + } + } + + if (enforceForInnerExpressions) { + if ( + node.parent.type === "ConditionalExpression" && + (node.parent.consequent === node || + node.parent.alternate === node) + ) { + return isInFlaggedContext(node.parent); + } + + /* + * Check last expression only in a sequence, i.e. if ((1, 2, Boolean(3))) {}, since + * the others don't affect the result of the expression. + */ + if ( + node.parent.type === "SequenceExpression" && + node.parent.expressions.at(-1) === node + ) { + return isInFlaggedContext(node.parent); + } + } + + return isInBooleanContext(node); + } + + /** + * Check if a node has comments inside. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if it has comments inside. + */ + function hasCommentsInside(node) { + return Boolean(sourceCode.getCommentsInside(node).length); + } + + /** + * Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is parenthesized. + * @private + */ + function isParenthesized(node) { + return eslintUtils.isParenthesized(1, node, sourceCode); + } + + /** + * Determines whether the given node needs to be parenthesized when replacing the previous node. + * It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list + * of possible parent node types. By the same assumption, the node's role in a particular parent is already known. + * @param {ASTNode} previousNode Previous node. + * @param {ASTNode} node The node to check. + * @throws {Error} (Unreachable.) + * @returns {boolean} `true` if the node needs to be parenthesized. + */ + function needsParens(previousNode, node) { + if (previousNode.parent.type === "ChainExpression") { + return needsParens(previousNode.parent, node); + } + + if (isParenthesized(previousNode)) { + // parentheses around the previous node will stay, so there is no need for an additional pair + return false; + } + + // parent of the previous node will become parent of the replacement node + const parent = previousNode.parent; + + switch (parent.type) { + case "CallExpression": + case "NewExpression": + return node.type === "SequenceExpression"; + case "IfStatement": + case "DoWhileStatement": + case "WhileStatement": + case "ForStatement": + case "SequenceExpression": + return false; + case "ConditionalExpression": + if (previousNode === parent.test) { + return precedence(node) <= precedence(parent); + } + if ( + previousNode === parent.consequent || + previousNode === parent.alternate + ) { + return ( + precedence(node) < + precedence({ type: "AssignmentExpression" }) + ); + } + + /* c8 ignore next */ + throw new Error( + "Ternary child must be test, consequent, or alternate.", + ); + case "UnaryExpression": + return precedence(node) < precedence(parent); + case "LogicalExpression": + if ( + astUtils.isMixedLogicalAndCoalesceExpressions( + node, + parent, + ) + ) { + return true; + } + if (previousNode === parent.left) { + return precedence(node) < precedence(parent); + } + return precedence(node) <= precedence(parent); + + /* c8 ignore next */ + default: + throw new Error(`Unexpected parent type: ${parent.type}`); + } + } + + return { + UnaryExpression(node) { + const parent = node.parent; + + // Exit early if it's guaranteed not to match + if ( + node.operator !== "!" || + parent.type !== "UnaryExpression" || + parent.operator !== "!" + ) { + return; + } + + if (isInFlaggedContext(parent)) { + context.report({ + node: parent, + messageId: "unexpectedNegation", + fix(fixer) { + if (hasCommentsInside(parent)) { + return null; + } + + if (needsParens(parent, node.argument)) { + return fixer.replaceText( + parent, + `(${sourceCode.getText(node.argument)})`, + ); + } + + let prefix = ""; + const tokenBefore = + sourceCode.getTokenBefore(parent); + const firstReplacementToken = + sourceCode.getFirstToken(node.argument); + + if ( + tokenBefore && + tokenBefore.range[1] === parent.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBefore, + firstReplacementToken, + ) + ) { + prefix = " "; + } + + return fixer.replaceText( + parent, + prefix + sourceCode.getText(node.argument), + ); + }, + }); + } + }, + + CallExpression(node) { + if ( + node.callee.type !== "Identifier" || + node.callee.name !== "Boolean" || + !sourceCode.isGlobalReference(node.callee) + ) { + return; + } + + if (isInFlaggedContext(node)) { + context.report({ + node, + messageId: "unexpectedCall", + fix(fixer) { + const parent = node.parent; + + if (node.arguments.length === 0) { + if ( + parent.type === "UnaryExpression" && + parent.operator === "!" + ) { + /* + * !Boolean() -> true + */ + + if (hasCommentsInside(parent)) { + return null; + } + + const replacement = "true"; + let prefix = ""; + const tokenBefore = + sourceCode.getTokenBefore(parent); + + if ( + tokenBefore && + tokenBefore.range[1] === + parent.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBefore, + replacement, + ) + ) { + prefix = " "; + } + + return fixer.replaceText( + parent, + prefix + replacement, + ); + } + + /* + * Boolean() -> false + */ + + if (hasCommentsInside(node)) { + return null; + } + + return fixer.replaceText(node, "false"); + } + + if (node.arguments.length === 1) { + const argument = node.arguments[0]; + + if ( + argument.type === "SpreadElement" || + hasCommentsInside(node) + ) { + return null; + } + + /* + * Boolean(expression) -> expression + */ + + if (needsParens(node, argument)) { + return fixer.replaceText( + node, + `(${sourceCode.getText(argument)})`, + ); + } + + return fixer.replaceText( + node, + sourceCode.getText(argument), + ); + } + + // two or more arguments + return null; + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-label.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-label.js new file mode 100644 index 00000000..c191eee7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-label.js @@ -0,0 +1,169 @@ +/** + * @fileoverview Rule to disallow unnecessary labels + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unnecessary labels", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-extra-label", + }, + + schema: [], + fixable: "code", + + messages: { + unexpected: "This label '{{name}}' is unnecessary.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + let scopeInfo = null; + + /** + * Creates a new scope with a breakable statement. + * @param {ASTNode} node A node to create. This is a BreakableStatement. + * @returns {void} + */ + function enterBreakableStatement(node) { + scopeInfo = { + label: + node.parent.type === "LabeledStatement" + ? node.parent.label + : null, + breakable: true, + upper: scopeInfo, + }; + } + + /** + * Removes the top scope of the stack. + * @returns {void} + */ + function exitBreakableStatement() { + scopeInfo = scopeInfo.upper; + } + + /** + * Creates a new scope with a labeled statement. + * + * This ignores it if the body is a breakable statement. + * In this case it's handled in the `enterBreakableStatement` function. + * @param {ASTNode} node A node to create. This is a LabeledStatement. + * @returns {void} + */ + function enterLabeledStatement(node) { + if (!astUtils.isBreakableStatement(node.body)) { + scopeInfo = { + label: node.label, + breakable: false, + upper: scopeInfo, + }; + } + } + + /** + * Removes the top scope of the stack. + * + * This ignores it if the body is a breakable statement. + * In this case it's handled in the `exitBreakableStatement` function. + * @param {ASTNode} node A node. This is a LabeledStatement. + * @returns {void} + */ + function exitLabeledStatement(node) { + if (!astUtils.isBreakableStatement(node.body)) { + scopeInfo = scopeInfo.upper; + } + } + + /** + * Reports a given control node if it's unnecessary. + * @param {ASTNode} node A node. This is a BreakStatement or a + * ContinueStatement. + * @returns {void} + */ + function reportIfUnnecessary(node) { + if (!node.label) { + return; + } + + const labelNode = node.label; + + for (let info = scopeInfo; info !== null; info = info.upper) { + if ( + info.breakable || + (info.label && info.label.name === labelNode.name) + ) { + if ( + info.breakable && + info.label && + info.label.name === labelNode.name + ) { + context.report({ + node: labelNode, + messageId: "unexpected", + data: labelNode, + fix(fixer) { + const breakOrContinueToken = + sourceCode.getFirstToken(node); + + if ( + sourceCode.commentsExistBetween( + breakOrContinueToken, + labelNode, + ) + ) { + return null; + } + + return fixer.removeRange([ + breakOrContinueToken.range[1], + labelNode.range[1], + ]); + }, + }); + } + return; + } + } + } + + return { + WhileStatement: enterBreakableStatement, + "WhileStatement:exit": exitBreakableStatement, + DoWhileStatement: enterBreakableStatement, + "DoWhileStatement:exit": exitBreakableStatement, + ForStatement: enterBreakableStatement, + "ForStatement:exit": exitBreakableStatement, + ForInStatement: enterBreakableStatement, + "ForInStatement:exit": exitBreakableStatement, + ForOfStatement: enterBreakableStatement, + "ForOfStatement:exit": exitBreakableStatement, + SwitchStatement: enterBreakableStatement, + "SwitchStatement:exit": exitBreakableStatement, + LabeledStatement: enterLabeledStatement, + "LabeledStatement:exit": exitLabeledStatement, + BreakStatement: reportIfUnnecessary, + ContinueStatement: reportIfUnnecessary, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-parens.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-parens.js new file mode 100644 index 00000000..133ad0b3 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-parens.js @@ -0,0 +1,1669 @@ +/** + * @fileoverview Disallow parenthesising higher precedence subexpressions. + * @author Michael Ficarra + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const { + isParenthesized: isParenthesizedRaw, +} = require("@eslint-community/eslint-utils"); +const astUtils = require("./utils/ast-utils.js"); + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-extra-parens", + url: "https://eslint.style/rules/no-extra-parens", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow unnecessary parentheses", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-extra-parens", + }, + + fixable: "code", + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["functions"], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["all"], + }, + { + type: "object", + properties: { + conditionalAssign: { type: "boolean" }, + ternaryOperandBinaryExpressions: { + type: "boolean", + }, + nestedBinaryExpressions: { type: "boolean" }, + returnAssign: { type: "boolean" }, + ignoreJSX: { + enum: [ + "none", + "all", + "single-line", + "multi-line", + ], + }, + enforceForArrowConditionals: { + type: "boolean", + }, + enforceForSequenceExpressions: { + type: "boolean", + }, + enforceForNewInMemberExpressions: { + type: "boolean", + }, + enforceForFunctionPrototypeMethods: { + type: "boolean", + }, + allowParensAfterCommentPattern: { + type: "string", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + messages: { + unexpected: "Unnecessary parentheses around expression.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const tokensToIgnore = new WeakSet(); + const precedence = astUtils.getPrecedence; + const ALL_NODES = context.options[0] !== "functions"; + const EXCEPT_COND_ASSIGN = + ALL_NODES && + context.options[1] && + context.options[1].conditionalAssign === false; + const EXCEPT_COND_TERNARY = + ALL_NODES && + context.options[1] && + context.options[1].ternaryOperandBinaryExpressions === false; + const NESTED_BINARY = + ALL_NODES && + context.options[1] && + context.options[1].nestedBinaryExpressions === false; + const EXCEPT_RETURN_ASSIGN = + ALL_NODES && + context.options[1] && + context.options[1].returnAssign === false; + const IGNORE_JSX = + ALL_NODES && context.options[1] && context.options[1].ignoreJSX; + const IGNORE_ARROW_CONDITIONALS = + ALL_NODES && + context.options[1] && + context.options[1].enforceForArrowConditionals === false; + const IGNORE_SEQUENCE_EXPRESSIONS = + ALL_NODES && + context.options[1] && + context.options[1].enforceForSequenceExpressions === false; + const IGNORE_NEW_IN_MEMBER_EXPR = + ALL_NODES && + context.options[1] && + context.options[1].enforceForNewInMemberExpressions === false; + const IGNORE_FUNCTION_PROTOTYPE_METHODS = + ALL_NODES && + context.options[1] && + context.options[1].enforceForFunctionPrototypeMethods === false; + const ALLOW_PARENS_AFTER_COMMENT_PATTERN = + ALL_NODES && + context.options[1] && + context.options[1].allowParensAfterCommentPattern; + + const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ + type: "AssignmentExpression", + }); + const PRECEDENCE_OF_UPDATE_EXPR = precedence({ + type: "UpdateExpression", + }); + + let reportsBuffer; + + /** + * Determines whether the given node is a `call` or `apply` method call, invoked directly on a `FunctionExpression` node. + * Example: function(){}.call() + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is an immediate `call` or `apply` method call. + * @private + */ + function isImmediateFunctionPrototypeMethodCall(node) { + const callNode = astUtils.skipChainExpression(node); + + if (callNode.type !== "CallExpression") { + return false; + } + const callee = astUtils.skipChainExpression(callNode.callee); + + return ( + callee.type === "MemberExpression" && + callee.object.type === "FunctionExpression" && + ["call", "apply"].includes( + astUtils.getStaticPropertyName(callee), + ) + ); + } + + /** + * Determines if this rule should be enforced for a node given the current configuration. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the rule should be enforced for this node. + * @private + */ + function ruleApplies(node) { + if (node.type === "JSXElement" || node.type === "JSXFragment") { + const isSingleLine = node.loc.start.line === node.loc.end.line; + + switch (IGNORE_JSX) { + // Exclude this JSX element from linting + case "all": + return false; + + // Exclude this JSX element if it is multi-line element + case "multi-line": + return isSingleLine; + + // Exclude this JSX element if it is single-line element + case "single-line": + return !isSingleLine; + + // Nothing special to be done for JSX elements + case "none": + break; + + // no default + } + } + + if ( + node.type === "SequenceExpression" && + IGNORE_SEQUENCE_EXPRESSIONS + ) { + return false; + } + + if ( + isImmediateFunctionPrototypeMethodCall(node) && + IGNORE_FUNCTION_PROTOTYPE_METHODS + ) { + return false; + } + + return ( + ALL_NODES || + node.type === "FunctionExpression" || + node.type === "ArrowFunctionExpression" + ); + } + + /** + * Determines if a node is surrounded by parentheses. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is parenthesised. + * @private + */ + function isParenthesised(node) { + return isParenthesizedRaw(1, node, sourceCode); + } + + /** + * Determines if a node is surrounded by parentheses twice. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is doubly parenthesised. + * @private + */ + function isParenthesisedTwice(node) { + return isParenthesizedRaw(2, node, sourceCode); + } + + /** + * Determines if a node is surrounded by (potentially) invalid parentheses. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is incorrectly parenthesised. + * @private + */ + function hasExcessParens(node) { + return ruleApplies(node) && isParenthesised(node); + } + + /** + * Determines if a node that is expected to be parenthesised is surrounded by + * (potentially) invalid extra parentheses. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is has an unexpected extra pair of parentheses. + * @private + */ + function hasDoubleExcessParens(node) { + return ruleApplies(node) && isParenthesisedTwice(node); + } + + /** + * Determines if a node that is expected to be parenthesised is surrounded by + * (potentially) invalid extra parentheses with considering precedence level of the node. + * If the preference level of the node is not higher or equal to precedence lower limit, it also checks + * whether the node is surrounded by parentheses twice or not. + * @param {ASTNode} node The node to be checked. + * @param {number} precedenceLowerLimit The lower limit of precedence. + * @returns {boolean} True if the node is has an unexpected extra pair of parentheses. + * @private + */ + function hasExcessParensWithPrecedence(node, precedenceLowerLimit) { + if (ruleApplies(node) && isParenthesised(node)) { + if ( + precedence(node) >= precedenceLowerLimit || + isParenthesisedTwice(node) + ) { + return true; + } + } + return false; + } + + /** + * Determines if a node test expression is allowed to have a parenthesised assignment + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the assignment can be parenthesised. + * @private + */ + function isCondAssignException(node) { + return ( + EXCEPT_COND_ASSIGN && node.test.type === "AssignmentExpression" + ); + } + + /** + * Determines if a node is in a return statement + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is in a return statement. + * @private + */ + function isInReturnStatement(node) { + for ( + let currentNode = node; + currentNode; + currentNode = currentNode.parent + ) { + if ( + currentNode.type === "ReturnStatement" || + (currentNode.type === "ArrowFunctionExpression" && + currentNode.body.type !== "BlockStatement") + ) { + return true; + } + } + + return false; + } + + /** + * Determines if a constructor function is newed-up with parens + * @param {ASTNode} newExpression The NewExpression node to be checked. + * @returns {boolean} True if the constructor is called with parens. + * @private + */ + function isNewExpressionWithParens(newExpression) { + const lastToken = sourceCode.getLastToken(newExpression); + const penultimateToken = sourceCode.getTokenBefore(lastToken); + + return ( + newExpression.arguments.length > 0 || + // The expression should end with its own parens, e.g., new new foo() is not a new expression with parens + (astUtils.isOpeningParenToken(penultimateToken) && + astUtils.isClosingParenToken(lastToken) && + newExpression.callee.range[1] < newExpression.range[1]) + ); + } + + /** + * Determines if a node is or contains an assignment expression + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is or contains an assignment expression. + * @private + */ + function containsAssignment(node) { + if (node.type === "AssignmentExpression") { + return true; + } + if ( + node.type === "ConditionalExpression" && + (node.consequent.type === "AssignmentExpression" || + node.alternate.type === "AssignmentExpression") + ) { + return true; + } + if ( + (node.left && node.left.type === "AssignmentExpression") || + (node.right && node.right.type === "AssignmentExpression") + ) { + return true; + } + + return false; + } + + /** + * Determines if a node is contained by or is itself a return statement and is allowed to have a parenthesised assignment + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the assignment can be parenthesised. + * @private + */ + function isReturnAssignException(node) { + if (!EXCEPT_RETURN_ASSIGN || !isInReturnStatement(node)) { + return false; + } + + if (node.type === "ReturnStatement") { + return node.argument && containsAssignment(node.argument); + } + if ( + node.type === "ArrowFunctionExpression" && + node.body.type !== "BlockStatement" + ) { + return containsAssignment(node.body); + } + return containsAssignment(node); + } + + /** + * Determines if a node following a [no LineTerminator here] restriction is + * surrounded by (potentially) invalid extra parentheses. + * @param {Token} token The token preceding the [no LineTerminator here] restriction. + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is incorrectly parenthesised. + * @private + */ + function hasExcessParensNoLineTerminator(token, node) { + if (token.loc.end.line === node.loc.start.line) { + return hasExcessParens(node); + } + + return hasDoubleExcessParens(node); + } + + /** + * Determines whether a node should be preceded by an additional space when removing parens + * @param {ASTNode} node node to evaluate; must be surrounded by parentheses + * @returns {boolean} `true` if a space should be inserted before the node + * @private + */ + function requiresLeadingSpace(node) { + const leftParenToken = sourceCode.getTokenBefore(node); + const tokenBeforeLeftParen = sourceCode.getTokenBefore( + leftParenToken, + { includeComments: true }, + ); + const tokenAfterLeftParen = sourceCode.getTokenAfter( + leftParenToken, + { includeComments: true }, + ); + + return ( + tokenBeforeLeftParen && + tokenBeforeLeftParen.range[1] === leftParenToken.range[0] && + leftParenToken.range[1] === tokenAfterLeftParen.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBeforeLeftParen, + tokenAfterLeftParen, + ) + ); + } + + /** + * Determines whether a node should be followed by an additional space when removing parens + * @param {ASTNode} node node to evaluate; must be surrounded by parentheses + * @returns {boolean} `true` if a space should be inserted after the node + * @private + */ + function requiresTrailingSpace(node) { + const nextTwoTokens = sourceCode.getTokensAfter(node, { count: 2 }); + const rightParenToken = nextTwoTokens[0]; + const tokenAfterRightParen = nextTwoTokens[1]; + const tokenBeforeRightParen = sourceCode.getLastToken(node); + + return ( + rightParenToken && + tokenAfterRightParen && + !sourceCode.isSpaceBetween( + rightParenToken, + tokenAfterRightParen, + ) && + !astUtils.canTokensBeAdjacent( + tokenBeforeRightParen, + tokenAfterRightParen, + ) + ); + } + + /** + * Determines if a given expression node is an IIFE + * @param {ASTNode} node The node to check + * @returns {boolean} `true` if the given node is an IIFE + */ + function isIIFE(node) { + const maybeCallNode = astUtils.skipChainExpression(node); + + return ( + maybeCallNode.type === "CallExpression" && + maybeCallNode.callee.type === "FunctionExpression" + ); + } + + /** + * Determines if the given node can be the assignment target in destructuring or the LHS of an assignment. + * This is to avoid an autofix that could change behavior because parsers mistakenly allow invalid syntax, + * such as `(a = b) = c` and `[(a = b) = c] = []`. Ideally, this function shouldn't be necessary. + * @param {ASTNode} [node] The node to check + * @returns {boolean} `true` if the given node can be a valid assignment target + */ + function canBeAssignmentTarget(node) { + return ( + node && + (node.type === "Identifier" || node.type === "MemberExpression") + ); + } + + /** + * Checks if a node is fixable. + * A node is fixable if removing a single pair of surrounding parentheses does not turn it + * into a directive after fixing other nodes. + * Almost all nodes are fixable, except if all of the following conditions are met: + * The node is a string Literal + * It has a single pair of parentheses + * It is the only child of an ExpressionStatement + * @param {ASTNode} node The node to evaluate. + * @returns {boolean} Whether or not the node is fixable. + * @private + */ + function isFixable(node) { + // if it's not a string literal it can be autofixed + if (node.type !== "Literal" || typeof node.value !== "string") { + return true; + } + if (isParenthesisedTwice(node)) { + return true; + } + return !astUtils.isTopLevelExpressionStatement(node.parent); + } + + /** + * Report the node + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function report(node) { + const leftParenToken = sourceCode.getTokenBefore(node); + const rightParenToken = sourceCode.getTokenAfter(node); + + if (!isParenthesisedTwice(node)) { + if (tokensToIgnore.has(sourceCode.getFirstToken(node))) { + return; + } + + if (isIIFE(node) && !isParenthesised(node.callee)) { + return; + } + + if (ALLOW_PARENS_AFTER_COMMENT_PATTERN) { + const commentsBeforeLeftParenToken = + sourceCode.getCommentsBefore(leftParenToken); + const totalCommentsBeforeLeftParenTokenCount = + commentsBeforeLeftParenToken.length; + const ignorePattern = new RegExp( + ALLOW_PARENS_AFTER_COMMENT_PATTERN, + "u", + ); + + if ( + totalCommentsBeforeLeftParenTokenCount > 0 && + ignorePattern.test( + commentsBeforeLeftParenToken[ + totalCommentsBeforeLeftParenTokenCount - 1 + ].value, + ) + ) { + return; + } + } + } + + /** + * Finishes reporting + * @returns {void} + * @private + */ + function finishReport() { + context.report({ + node, + loc: leftParenToken.loc, + messageId: "unexpected", + fix: isFixable(node) + ? fixer => { + const parenthesizedSource = + sourceCode.text.slice( + leftParenToken.range[1], + rightParenToken.range[0], + ); + + return fixer.replaceTextRange( + [ + leftParenToken.range[0], + rightParenToken.range[1], + ], + (requiresLeadingSpace(node) ? " " : "") + + parenthesizedSource + + (requiresTrailingSpace(node) + ? " " + : ""), + ); + } + : null, + }); + } + + if (reportsBuffer) { + reportsBuffer.reports.push({ node, finishReport }); + return; + } + + finishReport(); + } + + /** + * Evaluate a argument of the node. + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkArgumentWithPrecedence(node) { + if ( + hasExcessParensWithPrecedence(node.argument, precedence(node)) + ) { + report(node.argument); + } + } + + /** + * Check if a member expression contains a call expression + * @param {ASTNode} node MemberExpression node to evaluate + * @returns {boolean} true if found, false if not + */ + function doesMemberExpressionContainCallExpression(node) { + let currentNode = node.object; + let currentNodeType = node.object.type; + + while (currentNodeType === "MemberExpression") { + currentNode = currentNode.object; + currentNodeType = currentNode.type; + } + + return currentNodeType === "CallExpression"; + } + + /** + * Evaluate a new call + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkCallNew(node) { + const callee = node.callee; + + if (hasExcessParensWithPrecedence(callee, precedence(node))) { + if ( + hasDoubleExcessParens(callee) || + !( + isIIFE(node) || + // (new A)(); new (new A)(); + (callee.type === "NewExpression" && + !isNewExpressionWithParens(callee) && + !( + node.type === "NewExpression" && + !isNewExpressionWithParens(node) + )) || + // new (a().b)(); new (a.b().c); + (node.type === "NewExpression" && + callee.type === "MemberExpression" && + doesMemberExpressionContainCallExpression( + callee, + )) || + // (a?.b)(); (a?.())(); + (!node.optional && callee.type === "ChainExpression") + ) + ) { + report(node.callee); + } + } + node.arguments + .filter(arg => + hasExcessParensWithPrecedence( + arg, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ), + ) + .forEach(report); + } + + /** + * Evaluate binary logicals + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkBinaryLogical(node) { + const prec = precedence(node); + const leftPrecedence = precedence(node.left); + const rightPrecedence = precedence(node.right); + const isExponentiation = node.operator === "**"; + const shouldSkipLeft = + NESTED_BINARY && + (node.left.type === "BinaryExpression" || + node.left.type === "LogicalExpression"); + const shouldSkipRight = + NESTED_BINARY && + (node.right.type === "BinaryExpression" || + node.right.type === "LogicalExpression"); + + if (!shouldSkipLeft && hasExcessParens(node.left)) { + if ( + (!( + ["AwaitExpression", "UnaryExpression"].includes( + node.left.type, + ) && isExponentiation + ) && + !astUtils.isMixedLogicalAndCoalesceExpressions( + node.left, + node, + ) && + (leftPrecedence > prec || + (leftPrecedence === prec && !isExponentiation))) || + isParenthesisedTwice(node.left) + ) { + report(node.left); + } + } + + if (!shouldSkipRight && hasExcessParens(node.right)) { + if ( + (!astUtils.isMixedLogicalAndCoalesceExpressions( + node.right, + node, + ) && + (rightPrecedence > prec || + (rightPrecedence === prec && isExponentiation))) || + isParenthesisedTwice(node.right) + ) { + report(node.right); + } + } + } + + /** + * Check the parentheses around the super class of the given class definition. + * @param {ASTNode} node The node of class declarations to check. + * @returns {void} + */ + function checkClass(node) { + if (!node.superClass) { + return; + } + + /* + * If `node.superClass` is a LeftHandSideExpression, parentheses are extra. + * Otherwise, parentheses are needed. + */ + const hasExtraParens = + precedence(node.superClass) > PRECEDENCE_OF_UPDATE_EXPR + ? hasExcessParens(node.superClass) + : hasDoubleExcessParens(node.superClass); + + if (hasExtraParens) { + report(node.superClass); + } + } + + /** + * Check the parentheses around the argument of the given spread operator. + * @param {ASTNode} node The node of spread elements/properties to check. + * @returns {void} + */ + function checkSpreadOperator(node) { + if ( + hasExcessParensWithPrecedence( + node.argument, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.argument); + } + } + + /** + * Checks the parentheses for an ExpressionStatement or ExportDefaultDeclaration + * @param {ASTNode} node The ExpressionStatement.expression or ExportDefaultDeclaration.declaration node + * @returns {void} + */ + function checkExpressionOrExportStatement(node) { + const firstToken = isParenthesised(node) + ? sourceCode.getTokenBefore(node) + : sourceCode.getFirstToken(node); + const secondToken = sourceCode.getTokenAfter( + firstToken, + astUtils.isNotOpeningParenToken, + ); + const thirdToken = secondToken + ? sourceCode.getTokenAfter(secondToken) + : null; + const tokenAfterClosingParens = secondToken + ? sourceCode.getTokenAfter( + secondToken, + astUtils.isNotClosingParenToken, + ) + : null; + + if ( + astUtils.isOpeningParenToken(firstToken) && + (astUtils.isOpeningBraceToken(secondToken) || + (secondToken.type === "Keyword" && + (secondToken.value === "function" || + secondToken.value === "class" || + (secondToken.value === "let" && + tokenAfterClosingParens && + (astUtils.isOpeningBracketToken( + tokenAfterClosingParens, + ) || + tokenAfterClosingParens.type === + "Identifier")))) || + (secondToken && + secondToken.type === "Identifier" && + secondToken.value === "async" && + thirdToken && + thirdToken.type === "Keyword" && + thirdToken.value === "function")) + ) { + tokensToIgnore.add(secondToken); + } + + const hasExtraParens = + node.parent.type === "ExportDefaultDeclaration" + ? hasExcessParensWithPrecedence( + node, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + : hasExcessParens(node); + + if (hasExtraParens) { + report(node); + } + } + + /** + * Finds the path from the given node to the specified ancestor. + * @param {ASTNode} node First node in the path. + * @param {ASTNode} ancestor Last node in the path. + * @returns {ASTNode[]} Path, including both nodes. + * @throws {Error} If the given node does not have the specified ancestor. + */ + function pathToAncestor(node, ancestor) { + const path = [node]; + let currentNode = node; + + while (currentNode !== ancestor) { + currentNode = currentNode.parent; + + /* c8 ignore start */ + if (currentNode === null) { + throw new Error( + "Nodes are not in the ancestor-descendant relationship.", + ); + } /* c8 ignore stop */ + + path.push(currentNode); + } + + return path; + } + + /** + * Finds the path from the given node to the specified descendant. + * @param {ASTNode} node First node in the path. + * @param {ASTNode} descendant Last node in the path. + * @returns {ASTNode[]} Path, including both nodes. + * @throws {Error} If the given node does not have the specified descendant. + */ + function pathToDescendant(node, descendant) { + return pathToAncestor(descendant, node).reverse(); + } + + /** + * Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer + * is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop. + * @param {ASTNode} node Ancestor of an 'in' expression. + * @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself. + * @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis. + */ + function isSafelyEnclosingInExpression(node, child) { + switch (node.type) { + case "ArrayExpression": + case "ArrayPattern": + case "BlockStatement": + case "ObjectExpression": + case "ObjectPattern": + case "TemplateLiteral": + return true; + case "ArrowFunctionExpression": + case "FunctionExpression": + return node.params.includes(child); + case "CallExpression": + case "NewExpression": + return node.arguments.includes(child); + case "MemberExpression": + return node.computed && node.property === child; + case "ConditionalExpression": + return node.consequent === child; + default: + return false; + } + } + + /** + * Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately. + * An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings. + * @returns {void} + */ + function startNewReportsBuffering() { + reportsBuffer = { + upper: reportsBuffer, + inExpressionNodes: [], + reports: [], + }; + } + + /** + * Ends the current reports buffering. + * @returns {void} + */ + function endCurrentReportsBuffering() { + const { upper, inExpressionNodes, reports } = reportsBuffer; + + if (upper) { + upper.inExpressionNodes.push(...inExpressionNodes); + upper.reports.push(...reports); + } else { + // flush remaining reports + reports.forEach(({ finishReport }) => finishReport()); + } + + reportsBuffer = upper; + } + + /** + * Checks whether the given node is in the current reports buffer. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is in the current buffer, false otherwise. + */ + function isInCurrentReportsBuffer(node) { + return reportsBuffer.reports.some(r => r.node === node); + } + + /** + * Removes the given node from the current reports buffer. + * @param {ASTNode} node Node to remove. + * @returns {void} + */ + function removeFromCurrentReportsBuffer(node) { + reportsBuffer.reports = reportsBuffer.reports.filter( + r => r.node !== node, + ); + } + + /** + * Checks whether a node is a MemberExpression at NewExpression's callee. + * @param {ASTNode} node node to check. + * @returns {boolean} True if the node is a MemberExpression at NewExpression's callee. false otherwise. + */ + function isMemberExpInNewCallee(node) { + if (node.type === "MemberExpression") { + return node.parent.type === "NewExpression" && + node.parent.callee === node + ? true + : node.parent.object === node && + isMemberExpInNewCallee(node.parent); + } + return false; + } + + /** + * Checks if the left-hand side of an assignment is an identifier, the operator is one of + * `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous class or function. + * + * As per https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation, an + * assignment involving one of the operators `=`, `&&=`, `||=` or `??=` where the right-hand + * side is an anonymous class or function and the left-hand side is an *unparenthesized* + * identifier has different semantics than other assignments. + * Specifically, when an expression like `foo = function () {}` is evaluated, `foo.name` + * will be set to the string "foo", i.e. the identifier name. The same thing does not happen + * when evaluating `(foo) = function () {}`. + * Since the parenthesizing of the identifier in the left-hand side is significant in this + * special case, the parentheses, if present, should not be flagged as unnecessary. + * @param {ASTNode} node an AssignmentExpression node. + * @returns {boolean} `true` if the left-hand side of the assignment is an identifier, the + * operator is one of `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous + * class or function; otherwise, `false`. + */ + function isAnonymousFunctionAssignmentException({ + left, + operator, + right, + }) { + if ( + left.type === "Identifier" && + ["=", "&&=", "||=", "??="].includes(operator) + ) { + const rhsType = right.type; + + if (rhsType === "ArrowFunctionExpression") { + return true; + } + if ( + (rhsType === "FunctionExpression" || + rhsType === "ClassExpression") && + !right.id + ) { + return true; + } + } + return false; + } + + return { + ArrayExpression(node) { + node.elements + .filter( + e => + e && + hasExcessParensWithPrecedence( + e, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ), + ) + .forEach(report); + }, + + ArrayPattern(node) { + node.elements + .filter(e => canBeAssignmentTarget(e) && hasExcessParens(e)) + .forEach(report); + }, + + ArrowFunctionExpression(node) { + if (isReturnAssignException(node)) { + return; + } + + if ( + node.body.type === "ConditionalExpression" && + IGNORE_ARROW_CONDITIONALS + ) { + return; + } + + if (node.body.type !== "BlockStatement") { + const firstBodyToken = sourceCode.getFirstToken( + node.body, + astUtils.isNotOpeningParenToken, + ); + const tokenBeforeFirst = + sourceCode.getTokenBefore(firstBodyToken); + + if ( + astUtils.isOpeningParenToken(tokenBeforeFirst) && + astUtils.isOpeningBraceToken(firstBodyToken) + ) { + tokensToIgnore.add(firstBodyToken); + } + if ( + hasExcessParensWithPrecedence( + node.body, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.body); + } + } + }, + + AssignmentExpression(node) { + if ( + canBeAssignmentTarget(node.left) && + hasExcessParens(node.left) && + (!isAnonymousFunctionAssignmentException(node) || + isParenthesisedTwice(node.left)) + ) { + report(node.left); + } + + if ( + !isReturnAssignException(node) && + hasExcessParensWithPrecedence(node.right, precedence(node)) + ) { + report(node.right); + } + }, + + BinaryExpression(node) { + if (reportsBuffer && node.operator === "in") { + reportsBuffer.inExpressionNodes.push(node); + } + + checkBinaryLogical(node); + }, + + CallExpression: checkCallNew, + + ConditionalExpression(node) { + if (isReturnAssignException(node)) { + return; + } + + const availableTypes = new Set([ + "BinaryExpression", + "LogicalExpression", + ]); + + if ( + !( + EXCEPT_COND_TERNARY && + availableTypes.has(node.test.type) + ) && + !isCondAssignException(node) && + hasExcessParensWithPrecedence( + node.test, + precedence({ + type: "LogicalExpression", + operator: "||", + }), + ) + ) { + report(node.test); + } + + if ( + !( + EXCEPT_COND_TERNARY && + availableTypes.has(node.consequent.type) + ) && + hasExcessParensWithPrecedence( + node.consequent, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.consequent); + } + + if ( + !( + EXCEPT_COND_TERNARY && + availableTypes.has(node.alternate.type) + ) && + hasExcessParensWithPrecedence( + node.alternate, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.alternate); + } + }, + + DoWhileStatement(node) { + if ( + hasExcessParens(node.test) && + !isCondAssignException(node) + ) { + report(node.test); + } + }, + + ExportDefaultDeclaration: node => + checkExpressionOrExportStatement(node.declaration), + ExpressionStatement: node => + checkExpressionOrExportStatement(node.expression), + + ForInStatement(node) { + if (node.left.type !== "VariableDeclaration") { + const firstLeftToken = sourceCode.getFirstToken( + node.left, + astUtils.isNotOpeningParenToken, + ); + + if ( + firstLeftToken.value === "let" && + astUtils.isOpeningBracketToken( + sourceCode.getTokenAfter( + firstLeftToken, + astUtils.isNotClosingParenToken, + ), + ) + ) { + // ForInStatement#left expression cannot start with `let[`. + tokensToIgnore.add(firstLeftToken); + } + } + + if (hasExcessParens(node.left)) { + report(node.left); + } + + if (hasExcessParens(node.right)) { + report(node.right); + } + }, + + ForOfStatement(node) { + if (node.left.type !== "VariableDeclaration") { + const firstLeftToken = sourceCode.getFirstToken( + node.left, + astUtils.isNotOpeningParenToken, + ); + + if (firstLeftToken.value === "let") { + // ForOfStatement#left expression cannot start with `let`. + tokensToIgnore.add(firstLeftToken); + } + } + + if (hasExcessParens(node.left)) { + report(node.left); + } + + if ( + hasExcessParensWithPrecedence( + node.right, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.right); + } + }, + + ForStatement(node) { + if ( + node.test && + hasExcessParens(node.test) && + !isCondAssignException(node) + ) { + report(node.test); + } + + if (node.update && hasExcessParens(node.update)) { + report(node.update); + } + + if (node.init) { + if (node.init.type !== "VariableDeclaration") { + const firstToken = sourceCode.getFirstToken( + node.init, + astUtils.isNotOpeningParenToken, + ); + + if ( + firstToken.value === "let" && + astUtils.isOpeningBracketToken( + sourceCode.getTokenAfter( + firstToken, + astUtils.isNotClosingParenToken, + ), + ) + ) { + // ForStatement#init expression cannot start with `let[`. + tokensToIgnore.add(firstToken); + } + } + + startNewReportsBuffering(); + + if (hasExcessParens(node.init)) { + report(node.init); + } + } + }, + + "ForStatement > *.init:exit"(node) { + /* + * Removing parentheses around `in` expressions might change semantics and cause errors. + * + * For example, this valid for loop: + * for (let a = (b in c); ;); + * after removing parentheses would be treated as an invalid for-in loop: + * for (let a = b in c; ;); + */ + + if (reportsBuffer.reports.length) { + reportsBuffer.inExpressionNodes.forEach( + inExpressionNode => { + const path = pathToDescendant( + node, + inExpressionNode, + ); + let nodeToExclude; + + for (let i = 0; i < path.length; i++) { + const pathNode = path[i]; + + if (i < path.length - 1) { + const nextPathNode = path[i + 1]; + + if ( + isSafelyEnclosingInExpression( + pathNode, + nextPathNode, + ) + ) { + // The 'in' expression in safely enclosed by the syntax of its ancestor nodes (e.g. by '{}' or '[]'). + return; + } + } + + if (isParenthesised(pathNode)) { + if (isInCurrentReportsBuffer(pathNode)) { + // This node was supposed to be reported, but parentheses might be necessary. + + if (isParenthesisedTwice(pathNode)) { + /* + * This node is parenthesised twice, it certainly has at least one pair of `extra` parentheses. + * If the --fix option is on, the current fixing iteration will remove only one pair of parentheses. + * The remaining pair is safely enclosing the 'in' expression. + */ + return; + } + + // Exclude the outermost node only. + if (!nodeToExclude) { + nodeToExclude = pathNode; + } + + // Don't break the loop here, there might be some safe nodes or parentheses that will stay inside. + } else { + // This node will stay parenthesised, the 'in' expression in safely enclosed by '()'. + return; + } + } + } + + // Exclude the node from the list (i.e. treat parentheses as necessary) + removeFromCurrentReportsBuffer(nodeToExclude); + }, + ); + } + + endCurrentReportsBuffering(); + }, + + IfStatement(node) { + if ( + hasExcessParens(node.test) && + !isCondAssignException(node) + ) { + report(node.test); + } + }, + + ImportExpression(node) { + const { source } = node; + + if (source.type === "SequenceExpression") { + if (hasDoubleExcessParens(source)) { + report(source); + } + } else if (hasExcessParens(source)) { + report(source); + } + }, + + LogicalExpression: checkBinaryLogical, + + MemberExpression(node) { + const shouldAllowWrapOnce = + isMemberExpInNewCallee(node) && + doesMemberExpressionContainCallExpression(node); + const nodeObjHasExcessParens = shouldAllowWrapOnce + ? hasDoubleExcessParens(node.object) + : hasExcessParens(node.object) && + !( + isImmediateFunctionPrototypeMethodCall( + node.parent, + ) && + node.parent.callee === node && + IGNORE_FUNCTION_PROTOTYPE_METHODS + ); + + if ( + nodeObjHasExcessParens && + precedence(node.object) >= precedence(node) && + (node.computed || + !( + astUtils.isDecimalInteger(node.object) || + // RegExp literal is allowed to have parens (#1589) + (node.object.type === "Literal" && + node.object.regex) + )) + ) { + report(node.object); + } + + if ( + nodeObjHasExcessParens && + node.object.type === "CallExpression" + ) { + report(node.object); + } + + if ( + nodeObjHasExcessParens && + !IGNORE_NEW_IN_MEMBER_EXPR && + node.object.type === "NewExpression" && + isNewExpressionWithParens(node.object) + ) { + report(node.object); + } + + if ( + nodeObjHasExcessParens && + node.optional && + node.object.type === "ChainExpression" + ) { + report(node.object); + } + + if (node.computed && hasExcessParens(node.property)) { + report(node.property); + } + }, + + "MethodDefinition[computed=true]"(node) { + if ( + hasExcessParensWithPrecedence( + node.key, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.key); + } + }, + + NewExpression: checkCallNew, + + ObjectExpression(node) { + node.properties + .filter( + property => + property.value && + hasExcessParensWithPrecedence( + property.value, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ), + ) + .forEach(property => report(property.value)); + }, + + ObjectPattern(node) { + node.properties + .filter(property => { + const value = property.value; + + return ( + canBeAssignmentTarget(value) && + hasExcessParens(value) + ); + }) + .forEach(property => report(property.value)); + }, + + Property(node) { + if (node.computed) { + const { key } = node; + + if ( + key && + hasExcessParensWithPrecedence( + key, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(key); + } + } + }, + + PropertyDefinition(node) { + if ( + node.computed && + hasExcessParensWithPrecedence( + node.key, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.key); + } + + if ( + node.value && + hasExcessParensWithPrecedence( + node.value, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(node.value); + } + }, + + RestElement(node) { + const argument = node.argument; + + if ( + canBeAssignmentTarget(argument) && + hasExcessParens(argument) + ) { + report(argument); + } + }, + + ReturnStatement(node) { + const returnToken = sourceCode.getFirstToken(node); + + if (isReturnAssignException(node)) { + return; + } + + if ( + node.argument && + hasExcessParensNoLineTerminator( + returnToken, + node.argument, + ) && + // RegExp literal is allowed to have parens (#1589) + !(node.argument.type === "Literal" && node.argument.regex) + ) { + report(node.argument); + } + }, + + SequenceExpression(node) { + const precedenceOfNode = precedence(node); + + node.expressions + .filter(e => + hasExcessParensWithPrecedence(e, precedenceOfNode), + ) + .forEach(report); + }, + + SwitchCase(node) { + if (node.test && hasExcessParens(node.test)) { + report(node.test); + } + }, + + SwitchStatement(node) { + if (hasExcessParens(node.discriminant)) { + report(node.discriminant); + } + }, + + ThrowStatement(node) { + const throwToken = sourceCode.getFirstToken(node); + + if ( + hasExcessParensNoLineTerminator(throwToken, node.argument) + ) { + report(node.argument); + } + }, + + UnaryExpression: checkArgumentWithPrecedence, + UpdateExpression(node) { + if (node.prefix) { + checkArgumentWithPrecedence(node); + } else { + const { argument } = node; + const operatorToken = sourceCode.getLastToken(node); + + if ( + argument.loc.end.line === operatorToken.loc.start.line + ) { + checkArgumentWithPrecedence(node); + } else { + if (hasDoubleExcessParens(argument)) { + report(argument); + } + } + } + }, + AwaitExpression: checkArgumentWithPrecedence, + + VariableDeclarator(node) { + if ( + node.init && + hasExcessParensWithPrecedence( + node.init, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) && + // RegExp literal is allowed to have parens (#1589) + !(node.init.type === "Literal" && node.init.regex) + ) { + report(node.init); + } + }, + + WhileStatement(node) { + if ( + hasExcessParens(node.test) && + !isCondAssignException(node) + ) { + report(node.test); + } + }, + + WithStatement(node) { + if (hasExcessParens(node.object)) { + report(node.object); + } + }, + + YieldExpression(node) { + if (node.argument) { + const yieldToken = sourceCode.getFirstToken(node); + + if ( + (precedence(node.argument) >= precedence(node) && + hasExcessParensNoLineTerminator( + yieldToken, + node.argument, + )) || + hasDoubleExcessParens(node.argument) + ) { + report(node.argument); + } + } + }, + + ClassDeclaration: checkClass, + ClassExpression: checkClass, + + SpreadElement: checkSpreadOperator, + SpreadProperty: checkSpreadOperator, + ExperimentalSpreadProperty: checkSpreadOperator, + + TemplateLiteral(node) { + node.expressions + .filter(e => e && hasExcessParens(e)) + .forEach(report); + }, + + AssignmentPattern(node) { + const { left, right } = node; + + if (canBeAssignmentTarget(left) && hasExcessParens(left)) { + report(left); + } + + if ( + right && + hasExcessParensWithPrecedence( + right, + PRECEDENCE_OF_ASSIGNMENT_EXPR, + ) + ) { + report(right); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-semi.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-semi.js new file mode 100644 index 00000000..a408edaf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-extra-semi.js @@ -0,0 +1,167 @@ +/** + * @fileoverview Rule to flag use of unnecessary semicolons + * @author Nicholas C. Zakas + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const FixTracker = require("./utils/fix-tracker"); +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-extra-semi", + url: "https://eslint.style/rules/no-extra-semi", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: "Disallow unnecessary semicolons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-extra-semi", + }, + + fixable: "code", + schema: [], + + messages: { + unexpected: "Unnecessary semicolon.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Checks if a node or token is fixable. + * A node is fixable if it can be removed without turning a subsequent statement into a directive after fixing other nodes. + * @param {Token} nodeOrToken The node or token to check. + * @returns {boolean} Whether or not the node is fixable. + */ + function isFixable(nodeOrToken) { + const nextToken = sourceCode.getTokenAfter(nodeOrToken); + + if (!nextToken || nextToken.type !== "String") { + return true; + } + const stringNode = sourceCode.getNodeByRangeIndex( + nextToken.range[0], + ); + + return !astUtils.isTopLevelExpressionStatement(stringNode.parent); + } + + /** + * Reports an unnecessary semicolon error. + * @param {Node|Token} nodeOrToken A node or a token to be reported. + * @returns {void} + */ + function report(nodeOrToken) { + context.report({ + node: nodeOrToken, + messageId: "unexpected", + fix: isFixable(nodeOrToken) + ? fixer => + /* + * Expand the replacement range to include the surrounding + * tokens to avoid conflicting with semi. + * https://github.com/eslint/eslint/issues/7928 + */ + new FixTracker(fixer, context.sourceCode) + .retainSurroundingTokens(nodeOrToken) + .remove(nodeOrToken) + : null, + }); + } + + /** + * Checks for a part of a class body. + * This checks tokens from a specified token to a next MethodDefinition or the end of class body. + * @param {Token} firstToken The first token to check. + * @returns {void} + */ + function checkForPartOfClassBody(firstToken) { + for ( + let token = firstToken; + token.type === "Punctuator" && + !astUtils.isClosingBraceToken(token); + token = sourceCode.getTokenAfter(token) + ) { + if (astUtils.isSemicolonToken(token)) { + report(token); + } + } + } + + return { + /** + * Reports this empty statement, except if the parent node is a loop. + * @param {Node} node A EmptyStatement node to be reported. + * @returns {void} + */ + EmptyStatement(node) { + const parent = node.parent, + allowedParentTypes = [ + "ForStatement", + "ForInStatement", + "ForOfStatement", + "WhileStatement", + "DoWhileStatement", + "IfStatement", + "LabeledStatement", + "WithStatement", + ]; + + if (!allowedParentTypes.includes(parent.type)) { + report(node); + } + }, + + /** + * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body. + * @param {Node} node A ClassBody node to check. + * @returns {void} + */ + ClassBody(node) { + checkForPartOfClassBody(sourceCode.getFirstToken(node, 1)); // 0 is `{`. + }, + + /** + * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body. + * @param {Node} node A MethodDefinition node of the start point. + * @returns {void} + */ + "MethodDefinition, PropertyDefinition, StaticBlock"(node) { + checkForPartOfClassBody(sourceCode.getTokenAfter(node)); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-fallthrough.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-fallthrough.js new file mode 100644 index 00000000..5a2caae0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-fallthrough.js @@ -0,0 +1,246 @@ +/** + * @fileoverview Rule to flag fall-through cases in switch statements. + * @author Matt DuVall + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { directivesPattern } = require("../shared/directives"); +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu; + +/** + * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive. + * @param {string} comment The comment string to check. + * @param {RegExp} fallthroughCommentPattern The regular expression used for checking for fallthrough comments. + * @returns {boolean} `true` if the comment string is truly a fallthrough comment. + */ +function isFallThroughComment(comment, fallthroughCommentPattern) { + return ( + fallthroughCommentPattern.test(comment) && + !directivesPattern.test(comment.trim()) + ); +} + +/** + * Checks whether or not a given case has a fallthrough comment. + * @param {ASTNode} caseWhichFallsThrough SwitchCase node which falls through. + * @param {ASTNode} subsequentCase The case after caseWhichFallsThrough. + * @param {RuleContext} context A rule context which stores comments. + * @param {RegExp} fallthroughCommentPattern A pattern to match comment to. + * @returns {null | object} the comment if the case has a valid fallthrough comment, otherwise null + */ +function getFallthroughComment( + caseWhichFallsThrough, + subsequentCase, + context, + fallthroughCommentPattern, +) { + const sourceCode = context.sourceCode; + + if ( + caseWhichFallsThrough.consequent.length === 1 && + caseWhichFallsThrough.consequent[0].type === "BlockStatement" + ) { + const trailingCloseBrace = sourceCode.getLastToken( + caseWhichFallsThrough.consequent[0], + ); + const commentInBlock = sourceCode + .getCommentsBefore(trailingCloseBrace) + .pop(); + + if ( + commentInBlock && + isFallThroughComment( + commentInBlock.value, + fallthroughCommentPattern, + ) + ) { + return commentInBlock; + } + } + + const comment = sourceCode.getCommentsBefore(subsequentCase).pop(); + + if ( + comment && + isFallThroughComment(comment.value, fallthroughCommentPattern) + ) { + return comment; + } + + return null; +} + +/** + * Checks whether a node and a token are separated by blank lines + * @param {ASTNode} node The node to check + * @param {Token} token The token to compare against + * @returns {boolean} `true` if there are blank lines between node and token + */ +function hasBlankLinesBetween(node, token) { + return token.loc.start.line > node.loc.end.line + 1; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowEmptyCase: false, + reportUnusedFallthroughComment: false, + }, + ], + + docs: { + description: "Disallow fallthrough of `case` statements", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-fallthrough", + }, + + schema: [ + { + type: "object", + properties: { + commentPattern: { + type: "string", + }, + allowEmptyCase: { + type: "boolean", + }, + reportUnusedFallthroughComment: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + messages: { + unusedFallthroughComment: + "Found a comment that would permit fallthrough, but case cannot fall through.", + case: "Expected a 'break' statement before 'case'.", + default: "Expected a 'break' statement before 'default'.", + }, + }, + + create(context) { + const codePathSegments = []; + let currentCodePathSegments = new Set(); + const sourceCode = context.sourceCode; + const [ + { allowEmptyCase, commentPattern, reportUnusedFallthroughComment }, + ] = context.options; + const fallthroughCommentPattern = commentPattern + ? new RegExp(commentPattern, "u") + : DEFAULT_FALLTHROUGH_COMMENT; + + /* + * We need to use leading comments of the next SwitchCase node because + * trailing comments is wrong if semicolons are omitted. + */ + let previousCase = null; + + return { + onCodePathStart() { + codePathSegments.push(currentCodePathSegments); + currentCodePathSegments = new Set(); + }, + + onCodePathEnd() { + currentCodePathSegments = codePathSegments.pop(); + }, + + onUnreachableCodePathSegmentStart(segment) { + currentCodePathSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + onCodePathSegmentStart(segment) { + currentCodePathSegments.add(segment); + }, + + onCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + SwitchCase(node) { + /* + * Checks whether or not there is a fallthrough comment. + * And reports the previous fallthrough node if that does not exist. + */ + + if (previousCase && previousCase.node.parent === node.parent) { + const previousCaseFallthroughComment = + getFallthroughComment( + previousCase.node, + node, + context, + fallthroughCommentPattern, + ); + + if ( + previousCase.isFallthrough && + !previousCaseFallthroughComment + ) { + context.report({ + messageId: node.test ? "case" : "default", + node, + }); + } else if ( + reportUnusedFallthroughComment && + !previousCase.isSwitchExitReachable && + previousCaseFallthroughComment + ) { + context.report({ + messageId: "unusedFallthroughComment", + node: previousCaseFallthroughComment, + }); + } + } + previousCase = null; + }, + + "SwitchCase:exit"(node) { + const nextToken = sourceCode.getTokenAfter(node); + + /* + * `reachable` meant fall through because statements preceded by + * `break`, `return`, or `throw` are unreachable. + * And allows empty cases and the last case. + */ + const isSwitchExitReachable = isAnySegmentReachable( + currentCodePathSegments, + ); + const isFallthrough = + isSwitchExitReachable && + (node.consequent.length > 0 || + (!allowEmptyCase && + hasBlankLinesBetween(node, nextToken))) && + node.parent.cases.at(-1) !== node; + + previousCase = { + node, + isSwitchExitReachable, + isFallthrough, + }; + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-floating-decimal.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-floating-decimal.js new file mode 100644 index 00000000..569be727 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-floating-decimal.js @@ -0,0 +1,99 @@ +/** + * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal + * @author James Allardice + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-floating-decimal", + url: "https://eslint.style/rules/no-floating-decimal", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: + "Disallow leading or trailing decimal points in numeric literals", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-floating-decimal", + }, + + schema: [], + fixable: "code", + messages: { + leading: "A leading decimal point can be confused with a dot.", + trailing: "A trailing decimal point can be confused with a dot.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + Literal(node) { + if (typeof node.value === "number") { + if (node.raw.startsWith(".")) { + context.report({ + node, + messageId: "leading", + fix(fixer) { + const tokenBefore = + sourceCode.getTokenBefore(node); + const needsSpaceBefore = + tokenBefore && + tokenBefore.range[1] === node.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBefore, + `0${node.raw}`, + ); + + return fixer.insertTextBefore( + node, + needsSpaceBefore ? " 0" : "0", + ); + }, + }); + } + if (node.raw.indexOf(".") === node.raw.length - 1) { + context.report({ + node, + messageId: "trailing", + fix: fixer => fixer.insertTextAfter(node, "0"), + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-func-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-func-assign.js new file mode 100644 index 00000000..a17d4b8e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-func-assign.js @@ -0,0 +1,77 @@ +/** + * @fileoverview Rule to flag use of function declaration identifiers as variables. + * @author Ian Christian Myers + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow reassigning `function` declarations", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-func-assign", + }, + + schema: [], + + messages: { + isAFunction: "'{{name}}' is a function.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Reports a reference if is non initializer and writable. + * @param {References} references Collection of reference to check. + * @returns {void} + */ + function checkReference(references) { + astUtils.getModifyingReferences(references).forEach(reference => { + context.report({ + node: reference.identifier, + messageId: "isAFunction", + data: { + name: reference.identifier.name, + }, + }); + }); + } + + /** + * Finds and reports references that are non initializer and writable. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + if (variable.defs[0].type === "FunctionName") { + checkReference(variable.references); + } + } + + /** + * Checks parameters of a given function node. + * @param {ASTNode} node A function node to check. + * @returns {void} + */ + function checkForFunction(node) { + sourceCode.getDeclaredVariables(node).forEach(checkVariable); + } + + return { + FunctionDeclaration: checkForFunction, + FunctionExpression: checkForFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-global-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-global-assign.js new file mode 100644 index 00000000..6f238449 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-global-assign.js @@ -0,0 +1,101 @@ +/** + * @fileoverview Rule to disallow assignments to native objects or read-only global variables + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ exceptions: [] }], + + docs: { + description: + "Disallow assignments to native objects or read-only global variables", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-global-assign", + }, + + schema: [ + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { type: "string" }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + globalShouldNotBeModified: + "Read-only global '{{name}}' should not be modified.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ exceptions }] = context.options; + + /** + * Reports write references. + * @param {Reference} reference A reference to check. + * @param {number} index The index of the reference in the references. + * @param {Reference[]} references The array that the reference belongs to. + * @returns {void} + */ + function checkReference(reference, index, references) { + const identifier = reference.identifier; + + if ( + reference.init === false && + reference.isWrite() && + /* + * Destructuring assignments can have multiple default value, + * so possibly there are multiple writeable references for the same identifier. + */ + (index === 0 || references[index - 1].identifier !== identifier) + ) { + context.report({ + node: identifier, + messageId: "globalShouldNotBeModified", + data: { + name: identifier.name, + }, + }); + } + } + + /** + * Reports write references if a given variable is read-only builtin. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + if ( + variable.writeable === false && + !exceptions.includes(variable.name) + ) { + variable.references.forEach(checkReference); + } + } + + return { + Program(node) { + const globalScope = sourceCode.getScope(node); + + globalScope.variables.forEach(checkVariable); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-coercion.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-coercion.js new file mode 100644 index 00000000..ed67d7cc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-coercion.js @@ -0,0 +1,482 @@ +/** + * @fileoverview A rule to disallow the type conversions with shorter notations. + * @author Toru Nagashima + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u; +const ALLOWABLE_OPERATORS = ["~", "!!", "+", "- -", "-", "*"]; + +/** + * Checks whether or not a node is a double logical negating. + * @param {ASTNode} node An UnaryExpression node to check. + * @returns {boolean} Whether or not the node is a double logical negating. + */ +function isDoubleLogicalNegating(node) { + return ( + node.operator === "!" && + node.argument.type === "UnaryExpression" && + node.argument.operator === "!" + ); +} + +/** + * Checks whether or not a node is a binary negating of `.indexOf()` method calling. + * @param {ASTNode} node An UnaryExpression node to check. + * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling. + */ +function isBinaryNegatingOfIndexOf(node) { + if (node.operator !== "~") { + return false; + } + const callNode = astUtils.skipChainExpression(node.argument); + + return ( + callNode.type === "CallExpression" && + astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN) + ); +} + +/** + * Checks whether or not a node is a multiplying by one. + * @param {BinaryExpression} node A BinaryExpression node to check. + * @returns {boolean} Whether or not the node is a multiplying by one. + */ +function isMultiplyByOne(node) { + return ( + node.operator === "*" && + ((node.left.type === "Literal" && node.left.value === 1) || + (node.right.type === "Literal" && node.right.value === 1)) + ); +} + +/** + * Checks whether the given node logically represents multiplication by a fraction of `1`. + * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the + * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`. + * @param {BinaryExpression} node A BinaryExpression node to check. + * @param {SourceCode} sourceCode The source code object. + * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`. + */ +function isMultiplyByFractionOfOne(node, sourceCode) { + return ( + node.type === "BinaryExpression" && + node.operator === "*" && + node.right.type === "Literal" && + node.right.value === 1 && + node.parent.type === "BinaryExpression" && + node.parent.operator === "/" && + node.parent.left === node && + !astUtils.isParenthesised(sourceCode, node) + ); +} + +/** + * Checks whether the result of a node is numeric or not + * @param {ASTNode} node The node to test + * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call + */ +function isNumeric(node) { + return ( + (node.type === "Literal" && typeof node.value === "number") || + (node.type === "CallExpression" && + (node.callee.name === "Number" || + node.callee.name === "parseInt" || + node.callee.name === "parseFloat")) + ); +} + +/** + * Returns the first non-numeric operand in a BinaryExpression. Designed to be + * used from bottom to up since it walks up the BinaryExpression trees using + * node.parent to find the result. + * @param {BinaryExpression} node The BinaryExpression node to be walked up on + * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null + */ +function getNonNumericOperand(node) { + const left = node.left, + right = node.right; + + if (right.type !== "BinaryExpression" && !isNumeric(right)) { + return right; + } + + if (left.type !== "BinaryExpression" && !isNumeric(left)) { + return left; + } + + return null; +} + +/** + * Checks whether an expression evaluates to a string. + * @param {ASTNode} node node that represents the expression to check. + * @returns {boolean} Whether or not the expression evaluates to a string. + */ +function isStringType(node) { + return ( + astUtils.isStringLiteral(node) || + (node.type === "CallExpression" && + node.callee.type === "Identifier" && + node.callee.name === "String") + ); +} + +/** + * Checks whether a node is an empty string literal or not. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the passed in node is an + * empty string literal or not. + */ +function isEmptyString(node) { + return ( + astUtils.isStringLiteral(node) && + (node.value === "" || + (node.type === "TemplateLiteral" && + node.quasis.length === 1 && + node.quasis[0].value.cooked === "")) + ); +} + +/** + * Checks whether or not a node is a concatenating with an empty string. + * @param {ASTNode} node A BinaryExpression node to check. + * @returns {boolean} Whether or not the node is a concatenating with an empty string. + */ +function isConcatWithEmptyString(node) { + return ( + node.operator === "+" && + ((isEmptyString(node.left) && !isStringType(node.right)) || + (isEmptyString(node.right) && !isStringType(node.left))) + ); +} + +/** + * Checks whether or not a node is appended with an empty string. + * @param {ASTNode} node An AssignmentExpression node to check. + * @returns {boolean} Whether or not the node is appended with an empty string. + */ +function isAppendEmptyString(node) { + return node.operator === "+=" && isEmptyString(node.right); +} + +/** + * Returns the operand that is not an empty string from a flagged BinaryExpression. + * @param {ASTNode} node The flagged BinaryExpression node to check. + * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression. + */ +function getNonEmptyOperand(node) { + return isEmptyString(node.left) ? node.right : node.left; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "suggestion", + + docs: { + description: "Disallow shorthand type conversions", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-implicit-coercion", + }, + + fixable: "code", + + schema: [ + { + type: "object", + properties: { + boolean: { + type: "boolean", + }, + number: { + type: "boolean", + }, + string: { + type: "boolean", + }, + disallowTemplateShorthand: { + type: "boolean", + }, + allow: { + type: "array", + items: { + enum: ALLOWABLE_OPERATORS, + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + allow: [], + boolean: true, + disallowTemplateShorthand: false, + number: true, + string: true, + }, + ], + + messages: { + implicitCoercion: + "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.", + useRecommendation: "Use `{{recommendation}}` instead.", + }, + }, + + create(context) { + const [options] = context.options; + const sourceCode = context.sourceCode; + + /** + * Gets the source text of a node to be used as the argument of a + * `Boolean()`, `Number()`, or `String()` call in a recommendation. A + * `SequenceExpression` operand must be parenthesized, otherwise its commas + * would be parsed as argument separators, which changes the evaluated + * operand (for example `!!(a, b)` becomes `Boolean(a, b)`). + * @param {ASTNode} node The operand node. + * @returns {string} The source text, parenthesized if needed. + */ + function getOperandText(node) { + const text = sourceCode.getText(node); + + return node.type === "SequenceExpression" ? `(${text})` : text; + } + + /** + * Reports an error and autofixes the node + * @param {ASTNode} node An ast node to report the error on. + * @param {string} recommendation The recommended code for the issue + * @param {bool} shouldSuggest Whether this report should offer a suggestion + * @param {bool} shouldFix Whether this report should fix the node + * @returns {void} + */ + function report(node, recommendation, shouldSuggest, shouldFix) { + /** + * Fix function + * @param {RuleFixer} fixer The fixer to fix. + * @returns {Fix} The fix object. + */ + function fix(fixer) { + const tokenBefore = sourceCode.getTokenBefore(node); + + if ( + tokenBefore?.range[1] === node.range[0] && + !astUtils.canTokensBeAdjacent(tokenBefore, recommendation) + ) { + return fixer.replaceText(node, ` ${recommendation}`); + } + + return fixer.replaceText(node, recommendation); + } + + context.report({ + node, + messageId: "implicitCoercion", + data: { recommendation }, + fix(fixer) { + if (!shouldFix) { + return null; + } + + return fix(fixer); + }, + suggest: [ + { + messageId: "useRecommendation", + data: { recommendation }, + fix(fixer) { + if (shouldFix || !shouldSuggest) { + return null; + } + + return fix(fixer); + }, + }, + ], + }); + } + + return { + UnaryExpression(node) { + let operatorAllowed; + + // !!foo + operatorAllowed = options.allow.includes("!!"); + if ( + !operatorAllowed && + options.boolean && + isDoubleLogicalNegating(node) + ) { + const recommendation = `Boolean(${getOperandText(node.argument.argument)})`; + const variable = astUtils.getVariableByName( + sourceCode.getScope(node), + "Boolean", + ); + const booleanExists = variable?.identifiers.length === 0; + + report(node, recommendation, true, booleanExists); + } + + // ~foo.indexOf(bar) + operatorAllowed = options.allow.includes("~"); + if ( + !operatorAllowed && + options.boolean && + isBinaryNegatingOfIndexOf(node) + ) { + // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case. + const comparison = + node.argument.type === "ChainExpression" + ? ">= 0" + : "!== -1"; + const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`; + + report(node, recommendation, false, false); + } + + // +foo + operatorAllowed = options.allow.includes("+"); + if ( + !operatorAllowed && + options.number && + node.operator === "+" && + !isNumeric(node.argument) + ) { + const recommendation = `Number(${getOperandText(node.argument)})`; + + report(node, recommendation, true, false); + } + + // -(-foo) + operatorAllowed = options.allow.includes("- -"); + if ( + !operatorAllowed && + options.number && + node.operator === "-" && + node.argument.type === "UnaryExpression" && + node.argument.operator === "-" && + !isNumeric(node.argument.argument) + ) { + const recommendation = `Number(${getOperandText(node.argument.argument)})`; + + report(node, recommendation, true, false); + } + }, + + // Use `:exit` to prevent double reporting + "BinaryExpression:exit"(node) { + let operatorAllowed; + + // 1 * foo + operatorAllowed = options.allow.includes("*"); + const nonNumericOperand = + !operatorAllowed && + options.number && + isMultiplyByOne(node) && + !isMultiplyByFractionOfOne(node, sourceCode) && + getNonNumericOperand(node); + + if (nonNumericOperand) { + const recommendation = `Number(${getOperandText(nonNumericOperand)})`; + + report(node, recommendation, true, false); + } + + // foo - 0 + operatorAllowed = options.allow.includes("-"); + if ( + !operatorAllowed && + options.number && + node.operator === "-" && + node.right.type === "Literal" && + node.right.value === 0 && + !isNumeric(node.left) + ) { + const recommendation = `Number(${getOperandText(node.left)})`; + + report(node, recommendation, true, false); + } + + // "" + foo + operatorAllowed = options.allow.includes("+"); + if ( + !operatorAllowed && + options.string && + isConcatWithEmptyString(node) + ) { + const recommendation = `String(${getOperandText(getNonEmptyOperand(node))})`; + + report(node, recommendation, true, false); + } + }, + + AssignmentExpression(node) { + // foo += "" + const operatorAllowed = options.allow.includes("+"); + + if ( + !operatorAllowed && + options.string && + isAppendEmptyString(node) + ) { + const code = sourceCode.getText(getNonEmptyOperand(node)); + const recommendation = `${code} = String(${code})`; + + report(node, recommendation, true, false); + } + }, + + TemplateLiteral(node) { + if (!options.disallowTemplateShorthand) { + return; + } + + // tag`${foo}` + if (node.parent.type === "TaggedTemplateExpression") { + return; + } + + // `` or `${foo}${bar}` + if (node.expressions.length !== 1) { + return; + } + + // `prefix${foo}` + if (node.quasis[0].value.cooked !== "") { + return; + } + + // `${foo}postfix` + if (node.quasis[1].value.cooked !== "") { + return; + } + + // if the expression is already a string, then this isn't a coercion + if (isStringType(node.expressions[0])) { + return; + } + + const recommendation = `String(${getOperandText(node.expressions[0])})`; + + report(node, recommendation, true, false); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-globals.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-globals.js new file mode 100644 index 00000000..c291cd86 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implicit-globals.js @@ -0,0 +1,187 @@ +/** + * @fileoverview Rule to check for implicit global variables, functions and classes. + * @author Joshua Peek + */ + +"use strict"; + +const ASSIGNMENT_NODES = new Set([ + "AssignmentExpression", + "ForInStatement", + "ForOfStatement", +]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + lexicalBindings: false, + }, + ], + + docs: { + description: "Disallow declarations in the global scope", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-implicit-globals", + }, + + schema: [ + { + type: "object", + properties: { + lexicalBindings: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + globalNonLexicalBinding: + "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.", + globalLexicalBinding: + "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.", + globalVariableLeak: + "Global variable leak, declare the variable if it is intended to be local.", + assignmentToReadonlyGlobal: + "Unexpected assignment to read-only global variable.", + redeclarationOfReadonlyGlobal: + "Unexpected redeclaration of read-only global variable.", + }, + }, + + create(context) { + const [{ lexicalBindings: checkLexicalBindings }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Reports the node. + * @param {ASTNode} node Node to report. + * @param {string} messageId Id of the message to report. + * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class. + * @returns {void} + */ + function report(node, messageId, kind) { + context.report({ + node, + messageId, + data: { + kind, + }, + }); + } + + return { + Program(node) { + const scope = sourceCode.getScope(node); + + scope.variables.forEach(variable => { + // Only ESLint global variables have the `writable` key. + const isReadonlyEslintGlobalVariable = + variable.writeable === false; + const isWritableEslintGlobalVariable = + variable.writeable === true; + + if (isWritableEslintGlobalVariable) { + // Everything is allowed with writable ESLint global variables. + return; + } + + // Variables exported by "exported" block comments + if (variable.eslintExported) { + return; + } + + variable.defs.forEach(def => { + const defNode = def.node; + + if ( + def.type === "FunctionName" || + (def.type === "Variable" && + def.parent.kind === "var") + ) { + if (isReadonlyEslintGlobalVariable) { + report( + defNode, + "redeclarationOfReadonlyGlobal", + ); + } else { + report( + defNode, + "globalNonLexicalBinding", + def.type === "FunctionName" + ? "function" + : `'${def.parent.kind}'`, + ); + } + } + + if (checkLexicalBindings) { + if ( + def.type === "ClassName" || + (def.type === "Variable" && + (def.parent.kind === "let" || + def.parent.kind === "const")) + ) { + if (isReadonlyEslintGlobalVariable) { + report( + defNode, + "redeclarationOfReadonlyGlobal", + ); + } else { + report( + defNode, + "globalLexicalBinding", + def.type === "ClassName" + ? "class" + : `'${def.parent.kind}'`, + ); + } + } + } + }); + + if ( + isReadonlyEslintGlobalVariable && + variable.defs.length === 0 + ) { + variable.references.forEach(reference => { + if (reference.isWrite() && !reference.isRead()) { + let assignmentParent = + reference.identifier.parent; + + while ( + assignmentParent && + !ASSIGNMENT_NODES.has(assignmentParent.type) + ) { + assignmentParent = assignmentParent.parent; + } + + report( + assignmentParent ?? reference.identifier, + "assignmentToReadonlyGlobal", + ); + } + }); + } + }); + + // Undeclared assigned variables. + scope.implicit.variables.forEach(variable => { + // def.node is an AssignmentExpression, ForInStatement or ForOfStatement. + variable.defs.forEach(def => { + report(def.node, "globalVariableLeak"); + }); + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implied-eval.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implied-eval.js new file mode 100644 index 00000000..b5fdac4f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-implied-eval.js @@ -0,0 +1,171 @@ +/** + * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval + * @author James Allardice + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { getStaticValue } = require("@eslint-community/eslint-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow the use of `eval()`-like methods", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-implied-eval", + }, + + schema: [], + + messages: { + impliedEval: + "Implied eval. Consider passing a function instead of a string.", + execScript: "Implied eval. Do not use execScript().", + }, + }, + + create(context) { + const GLOBAL_CANDIDATES = Object.freeze([ + "global", + "window", + "globalThis", + "self", + ]); + const EVAL_LIKE_FUNC_PATTERN = + /^(?:set(?:Interval|Timeout)|execScript)$/u; + const sourceCode = context.sourceCode; + + /** + * Checks whether a node is evaluated as a string or not. + * @param {ASTNode} node A node to check. + * @returns {boolean} True if the node is evaluated as a string. + */ + function isEvaluatedString(node) { + if ( + (node.type === "Literal" && typeof node.value === "string") || + node.type === "TemplateLiteral" + ) { + return true; + } + if (node.type === "BinaryExpression" && node.operator === "+") { + return ( + isEvaluatedString(node.left) || + isEvaluatedString(node.right) + ); + } + return false; + } + + /** + * Reports if the `CallExpression` node has evaluated argument. + * @param {ASTNode} node A CallExpression to check. + * @returns {void} + */ + function reportImpliedEvalCallExpression(node) { + const [firstArgument] = node.arguments; + + if (firstArgument) { + const staticValue = getStaticValue( + firstArgument, + sourceCode.getScope(node), + ); + const isStaticString = + staticValue && typeof staticValue.value === "string"; + const isString = + isStaticString || isEvaluatedString(firstArgument); + + if (isString) { + const calleeName = + node.callee.type === "Identifier" + ? node.callee.name + : astUtils.getStaticPropertyName(node.callee); + const isExecScript = calleeName === "execScript"; + context.report({ + node, + messageId: isExecScript ? "execScript" : "impliedEval", + }); + } + } + } + + /** + * Reports calls of `implied eval` via the global references. + * @param {Variable} globalVar A global variable to check. + * @returns {void} + */ + function reportImpliedEvalViaGlobal(globalVar) { + const { references, name } = globalVar; + + references.forEach(ref => { + const identifier = ref.identifier; + let node = identifier.parent; + + while (astUtils.isSpecificMemberAccess(node, null, name)) { + node = node.parent; + } + + if ( + astUtils.isSpecificMemberAccess( + node, + null, + EVAL_LIKE_FUNC_PATTERN, + ) + ) { + const calleeNode = + node.parent.type === "ChainExpression" + ? node.parent + : node; + const parent = calleeNode.parent; + + if ( + parent.type === "CallExpression" && + parent.callee === calleeNode + ) { + reportImpliedEvalCallExpression(parent); + } + } + }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + CallExpression(node) { + if ( + astUtils.isSpecificId( + node.callee, + EVAL_LIKE_FUNC_PATTERN, + ) && + sourceCode.isGlobalReference(node.callee) + ) { + reportImpliedEvalCallExpression(node); + } + }, + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + GLOBAL_CANDIDATES.map(candidate => + astUtils.getVariableByName(globalScope, candidate), + ) + .filter( + globalVar => !!globalVar && globalVar.defs.length === 0, + ) + .forEach(reportImpliedEvalViaGlobal); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-import-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-import-assign.js new file mode 100644 index 00000000..7fe526b6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-import-assign.js @@ -0,0 +1,227 @@ +/** + * @fileoverview Rule to flag updates of imported bindings. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const { findVariable } = require("@eslint-community/eslint-utils"); +const astUtils = require("./utils/ast-utils"); + +const WellKnownMutationFunctions = { + Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u, + Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u, +}; + +/** + * Check if a given node is LHS of an assignment node. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is LHS. + */ +function isAssignmentLeft(node) { + const { parent } = node; + + return ( + (parent.type === "AssignmentExpression" && parent.left === node) || + // Destructuring assignments + parent.type === "ArrayPattern" || + (parent.type === "Property" && + parent.value === node && + parent.parent.type === "ObjectPattern") || + parent.type === "RestElement" || + (parent.type === "AssignmentPattern" && parent.left === node) + ); +} + +/** + * Check if a given node is the operand of mutation unary operator. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is the operand of mutation unary operator. + */ +function isOperandOfMutationUnaryOperator(node) { + const argumentNode = + node.parent.type === "ChainExpression" ? node.parent : node; + const { parent } = argumentNode; + + return ( + (parent.type === "UpdateExpression" && + parent.argument === argumentNode) || + (parent.type === "UnaryExpression" && + parent.operator === "delete" && + parent.argument === argumentNode) + ); +} + +/** + * Check if a given node is the iteration variable of `for-in`/`for-of` syntax. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is the iteration variable. + */ +function isIterationVariable(node) { + const { parent } = node; + + return ( + (parent.type === "ForInStatement" && parent.left === node) || + (parent.type === "ForOfStatement" && parent.left === node) + ); +} + +/** + * Check if a given node is at the first argument of a well-known mutation function. + * - `Object.assign` + * - `Object.defineProperty` + * - `Object.defineProperties` + * - `Object.freeze` + * - `Object.setPrototypeOf` + * - `Reflect.defineProperty` + * - `Reflect.deleteProperty` + * - `Reflect.set` + * - `Reflect.setPrototypeOf` + * @param {ASTNode} node The node to check. + * @param {Scope} scope A `escope.Scope` object to find variable (whichever). + * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function. + */ +function isArgumentOfWellKnownMutationFunction(node, scope) { + const { parent } = node; + + if (parent.type !== "CallExpression" || parent.arguments[0] !== node) { + return false; + } + const callee = astUtils.skipChainExpression(parent.callee); + + if ( + !astUtils.isSpecificMemberAccess( + callee, + "Object", + WellKnownMutationFunctions.Object, + ) && + !astUtils.isSpecificMemberAccess( + callee, + "Reflect", + WellKnownMutationFunctions.Reflect, + ) + ) { + return false; + } + const variable = findVariable(scope, callee.object); + + return variable !== null && variable.scope.type === "global"; +} + +/** + * Check if the identifier node is placed at to update members. + * @param {ASTNode} id The Identifier node to check. + * @param {Scope} scope A `escope.Scope` object to find variable (whichever). + * @returns {boolean} `true` if the member of `id` was updated. + */ +function isMemberWrite(id, scope) { + const { parent } = id; + + return ( + (parent.type === "MemberExpression" && + parent.object === id && + (isAssignmentLeft(parent) || + isOperandOfMutationUnaryOperator(parent) || + isIterationVariable(parent))) || + isArgumentOfWellKnownMutationFunction(id, scope) + ); +} + +/** + * Get the mutation node. + * @param {ASTNode} id The Identifier node to get. + * @returns {ASTNode} The mutation node. + */ +function getWriteNode(id) { + let node = id.parent; + + while ( + node && + node.type !== "AssignmentExpression" && + node.type !== "UpdateExpression" && + node.type !== "UnaryExpression" && + node.type !== "CallExpression" && + node.type !== "ForInStatement" && + node.type !== "ForOfStatement" + ) { + node = node.parent; + } + + return node || id; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow assigning to imported bindings", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-import-assign", + }, + + schema: [], + + messages: { + readonly: "'{{name}}' is read-only.", + readonlyMember: "The members of '{{name}}' are read-only.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + ImportDeclaration(node) { + const scope = sourceCode.getScope(node); + + for (const variable of sourceCode.getDeclaredVariables(node)) { + const shouldCheckMembers = variable.defs.some( + d => d.node.type === "ImportNamespaceSpecifier", + ); + let prevIdNode = null; + + for (const reference of variable.references) { + const idNode = reference.identifier; + + /* + * AssignmentPattern (e.g. `[a = 0] = b`) makes two write + * references for the same identifier. This should skip + * the one of the two in order to prevent redundant reports. + */ + if (idNode === prevIdNode) { + continue; + } + prevIdNode = idNode; + + if (reference.isWrite()) { + context.report({ + node: getWriteNode(idNode), + messageId: "readonly", + data: { name: idNode.name }, + }); + } else if ( + shouldCheckMembers && + isMemberWrite(idNode, scope) + ) { + context.report({ + node: getWriteNode(idNode), + messageId: "readonlyMember", + data: { name: idNode.name }, + }); + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inline-comments.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inline-comments.js new file mode 100644 index 00000000..dac9eec1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inline-comments.js @@ -0,0 +1,115 @@ +/** + * @fileoverview Enforces or disallows inline comments. + * @author Greg Cochard + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{}], + + docs: { + description: "Disallow inline comments after code", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-inline-comments", + }, + + schema: [ + { + type: "object", + properties: { + ignorePattern: { + type: "string", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedInlineComment: "Unexpected comment inline with code.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ ignorePattern }] = context.options; + const customIgnoreRegExp = + ignorePattern && new RegExp(ignorePattern, "u"); + + /** + * Will check that comments are not on lines starting with or ending with code + * @param {ASTNode} node The comment node to check + * @private + * @returns {void} + */ + function testCodeAroundComment(node) { + const startLine = String(sourceCode.lines[node.loc.start.line - 1]), + endLine = String(sourceCode.lines[node.loc.end.line - 1]), + preamble = startLine.slice(0, node.loc.start.column).trim(), + postamble = endLine.slice(node.loc.end.column).trim(), + isPreambleEmpty = !preamble, + isPostambleEmpty = !postamble; + + // Nothing on both sides + if (isPreambleEmpty && isPostambleEmpty) { + return; + } + + // Matches the ignore pattern + if (customIgnoreRegExp && customIgnoreRegExp.test(node.value)) { + return; + } + + // JSX Exception + if ( + (isPreambleEmpty || preamble === "{") && + (isPostambleEmpty || postamble === "}") + ) { + const enclosingNode = sourceCode.getNodeByRangeIndex( + node.range[0], + ); + + if ( + enclosingNode && + enclosingNode.type === "JSXEmptyExpression" + ) { + return; + } + } + + // Don't report ESLint directive comments + if (astUtils.isDirectiveComment(node)) { + return; + } + + context.report({ + node, + messageId: "unexpectedInlineComment", + }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program() { + sourceCode + .getAllComments() + .filter(token => token.type !== "Shebang") + .forEach(testCodeAroundComment); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inner-declarations.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inner-declarations.js new file mode 100644 index 00000000..ec6c4952 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-inner-declarations.js @@ -0,0 +1,147 @@ +/** + * @fileoverview Rule to enforce declarations in program or function body root. + * @author Brandon Mills + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const validParent = new Set([ + "Program", + "StaticBlock", + "ExportNamedDeclaration", + "ExportDefaultDeclaration", +]); +const validBlockStatementParent = new Set([ + "FunctionDeclaration", + "FunctionExpression", + "ArrowFunctionExpression", +]); + +/** + * Finds the nearest enclosing context where this rule allows declarations and returns its description. + * @param {ASTNode} node Node to search from. + * @returns {string} Description. One of "program", "function body", "class static block body". + */ +function getAllowedBodyDescription(node) { + let { parent } = node; + + while (parent) { + if (parent.type === "StaticBlock") { + return "class static block body"; + } + + if (astUtils.isFunction(parent)) { + return "function body"; + } + + ({ parent } = parent); + } + + return "program"; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: ["functions", { blockScopedFunctions: "allow" }], + + docs: { + description: + "Disallow variable or `function` declarations in nested blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-inner-declarations", + }, + + schema: [ + { + enum: ["functions", "both"], + }, + { + type: "object", + properties: { + blockScopedFunctions: { + enum: ["allow", "disallow"], + }, + }, + additionalProperties: false, + }, + ], + + messages: { + moveDeclToRoot: "Move {{type}} declaration to {{body}} root.", + }, + }, + + create(context) { + const both = context.options[0] === "both"; + const { blockScopedFunctions } = context.options[1]; + + const sourceCode = context.sourceCode; + const ecmaVersion = context.languageOptions.ecmaVersion; + + /** + * Ensure that a given node is at a program or function body's root. + * @param {ASTNode} node Declaration node to check. + * @returns {void} + */ + function check(node) { + const parent = node.parent; + + if ( + parent.type === "BlockStatement" && + validBlockStatementParent.has(parent.parent.type) + ) { + return; + } + + if (validParent.has(parent.type)) { + return; + } + + context.report({ + node, + messageId: "moveDeclToRoot", + data: { + type: + node.type === "FunctionDeclaration" + ? "function" + : "variable", + body: getAllowedBodyDescription(node), + }, + }); + } + + return { + FunctionDeclaration(node) { + const isInStrictCode = sourceCode.getScope(node).upper.isStrict; + + if ( + blockScopedFunctions === "allow" && + ecmaVersion >= 2015 && + isInStrictCode + ) { + return; + } + + check(node); + }, + VariableDeclaration(node) { + if (both && node.kind === "var") { + check(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-regexp.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-regexp.js new file mode 100644 index 00000000..9a49fb9f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-regexp.js @@ -0,0 +1,246 @@ +/** + * @fileoverview Validate strings passed to the RegExp constructor + * @author Michael Ficarra + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator; +const validator = new RegExpValidator(); +const validFlags = "dgimsuvy"; +const undefined1 = void 0; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [{}], + + docs: { + description: + "Disallow invalid regular expression strings in `RegExp` constructors", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-invalid-regexp", + }, + + schema: [ + { + type: "object", + properties: { + allowConstructorFlags: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + regexMessage: "{{message}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ allowConstructorFlags }] = context.options; + let allowedFlags = []; + + if (allowConstructorFlags) { + const temp = allowConstructorFlags + .join("") + .replace(new RegExp(`[${validFlags}]`, "gu"), ""); + + if (temp) { + allowedFlags = [...new Set(temp)]; + } + } + + /** + * Reports error with the provided message. + * @param {ASTNode} node The node holding the invalid RegExp + * @param {string} message The message to report. + * @returns {void} + */ + function report(node, message) { + context.report({ + node, + messageId: "regexMessage", + data: { message }, + }); + } + + /** + * Check if node is a string + * @param {ASTNode} node node to evaluate + * @returns {boolean} True if its a string + * @private + */ + function isString(node) { + return ( + node && + node.type === "Literal" && + typeof node.value === "string" + ); + } + + /** + * Gets flags of a regular expression created by the given `RegExp()` or `new RegExp()` call + * Examples: + * new RegExp(".") // => "" + * new RegExp(".", "gu") // => "gu" + * new RegExp(".", flags) // => null + * @param {ASTNode} node `CallExpression` or `NewExpression` node + * @returns {string|null} flags if they can be determined, `null` otherwise + * @private + */ + function getFlags(node) { + if (node.arguments.length < 2) { + return ""; + } + + if (isString(node.arguments[1])) { + return node.arguments[1].value; + } + + return null; + } + + /** + * Check syntax error in a given pattern. + * @param {string} pattern The RegExp pattern to validate. + * @param {Object} flags The RegExp flags to validate. + * @param {boolean} [flags.unicode] The Unicode flag. + * @param {boolean} [flags.unicodeSets] The UnicodeSets flag. + * @returns {string|null} The syntax error. + */ + function validateRegExpPattern(pattern, flags) { + try { + validator.validatePattern( + pattern, + undefined1, + undefined1, + flags, + ); + return null; + } catch (err) { + return err.message; + } + } + + /** + * Check syntax error in a given flags. + * @param {string|null} flags The RegExp flags to validate. + * @param {string|null} flagsToCheck The RegExp invalid flags. + * @param {string} allFlags all valid and allowed flags. + * @returns {string|null} The syntax error. + */ + function validateRegExpFlags(flags, flagsToCheck, allFlags) { + const duplicateFlags = []; + + if (typeof flagsToCheck === "string") { + for (const flag of flagsToCheck) { + if (allFlags.includes(flag)) { + duplicateFlags.push(flag); + } + } + } + + /* + * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`, + * but this rule may check only the flag when the pattern is unidentifiable, so check it here. + * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern + */ + if (flags && flags.includes("u") && flags.includes("v")) { + return "Regex 'u' and 'v' flags cannot be used together"; + } + + if (duplicateFlags.length > 0) { + return `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor`; + } + + if (!flagsToCheck) { + return null; + } + + return `Invalid flags supplied to RegExp constructor '${flagsToCheck}'`; + } + + return { + "CallExpression, NewExpression"(node) { + if ( + node.callee.type !== "Identifier" || + node.callee.name !== "RegExp" || + !sourceCode.isGlobalReference(node.callee) + ) { + return; + } + + const flags = getFlags(node); + let flagsToCheck = flags; + const allFlags = + allowedFlags.length > 0 + ? validFlags.split("").concat(allowedFlags) + : validFlags.split(""); + + if (flags) { + allFlags.forEach(flag => { + flagsToCheck = flagsToCheck.replace(flag, ""); + }); + } + + let message = validateRegExpFlags( + flags, + flagsToCheck, + allFlags, + ); + + if (message) { + report(node, message); + return; + } + + if (!isString(node.arguments[0])) { + return; + } + + const pattern = node.arguments[0].value; + + message = + // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag + flags === null + ? validateRegExpPattern(pattern, { + unicode: true, + unicodeSets: false, + }) && + validateRegExpPattern(pattern, { + unicode: false, + unicodeSets: true, + }) && + validateRegExpPattern(pattern, { + unicode: false, + unicodeSets: false, + }) + : validateRegExpPattern(pattern, { + unicode: flags.includes("u"), + unicodeSets: flags.includes("v"), + }); + + if (message) { + report(node, message); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-this.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-this.js new file mode 100644 index 00000000..41fa6b28 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-invalid-this.js @@ -0,0 +1,177 @@ +/** + * @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines if the given code path is a code path with lexical `this` binding. + * That is, if `this` within the code path refers to `this` of surrounding code path. + * @param {CodePath} codePath Code path. + * @param {ASTNode} node Node that started the code path. + * @returns {boolean} `true` if it is a code path with lexical `this` binding. + */ +function isCodePathWithLexicalThis(codePath, node) { + return ( + codePath.origin === "function" && + node.type === "ArrowFunctionExpression" + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ capIsConstructor: true }], + + docs: { + description: + "Disallow use of `this` in contexts where the value of `this` is `undefined`", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-invalid-this", + }, + + schema: [ + { + type: "object", + properties: { + capIsConstructor: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedThis: "Unexpected 'this'.", + }, + }, + + create(context) { + const [{ capIsConstructor }] = context.options; + const stack = [], + sourceCode = context.sourceCode; + + /** + * Gets the current checking context. + * + * The return value has a flag that whether or not `this` keyword is valid. + * The flag is initialized when got at the first time. + * @returns {{valid: boolean}} + * an object which has a flag that whether or not `this` keyword is valid. + */ + stack.getCurrent = function () { + const current = this.at(-1); + + if (!current.init) { + current.init = true; + current.valid = !astUtils.isDefaultThisBinding( + current.node, + sourceCode, + { capIsConstructor }, + ); + } + return current; + }; + + return { + onCodePathStart(codePath, node) { + if (isCodePathWithLexicalThis(codePath, node)) { + return; + } + + if (codePath.origin === "program") { + const scope = sourceCode.getScope(node); + const features = + context.languageOptions.parserOptions.ecmaFeatures || + {}; + + // `this` at the top level of scripts always refers to the global object + stack.push({ + init: true, + node, + valid: !( + node.sourceType === "module" || + (features.globalReturn && + scope.childScopes[0].isStrict) + ), + }); + + return; + } + + /* + * `init: false` means that `valid` isn't determined yet. + * Most functions don't use `this`, and the calculation for `valid` + * is relatively costly, so we'll calculate it lazily when the first + * `this` within the function is traversed. A special case are non-strict + * functions, because `this` refers to the global object and therefore is + * always valid, so we can set `init: true` right away. + */ + stack.push({ + init: !sourceCode.getScope(node).isStrict, + node, + valid: true, + }); + }, + + onCodePathEnd(codePath, node) { + if (isCodePathWithLexicalThis(codePath, node)) { + return; + } + + stack.pop(); + }, + + "AccessorProperty > *.value"(node) { + stack.push({ + init: true, + node, + valid: true, + }); + }, + + "AccessorProperty:exit"() { + stack.pop(); + }, + + // Reports if `this` of the current context is invalid. + ThisExpression(node) { + // Special case: skip `this` if it's the value of an AccessorProperty + if ( + node.parent.type === "AccessorProperty" && + node.parent.value === node + ) { + return; + } + + const current = stack.getCurrent(); + + if (current && !current.valid) { + context.report({ + node, + messageId: "unexpectedThis", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-irregular-whitespace.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-irregular-whitespace.js new file mode 100644 index 00000000..4aaaad1d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-irregular-whitespace.js @@ -0,0 +1,292 @@ +/** + * @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed + * @author Jonathan Kingston + * @author Christophe Porteneuve + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const ALL_IRREGULARS = + /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u; +const IRREGULAR_WHITESPACE = + /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu; +const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu; +const LINE_BREAK = astUtils.createGlobalLinebreakMatcher(); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + skipComments: false, + skipJSXText: false, + skipRegExps: false, + skipStrings: true, + skipTemplates: false, + }, + ], + + docs: { + description: "Disallow irregular whitespace", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-irregular-whitespace", + }, + + schema: [ + { + type: "object", + properties: { + skipComments: { + type: "boolean", + }, + skipStrings: { + type: "boolean", + }, + skipTemplates: { + type: "boolean", + }, + skipRegExps: { + type: "boolean", + }, + skipJSXText: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + noIrregularWhitespace: "Irregular whitespace not allowed.", + }, + }, + + create(context) { + const [ + { + skipComments, + skipStrings, + skipRegExps, + skipTemplates, + skipJSXText, + }, + ] = context.options; + + const sourceCode = context.sourceCode; + const commentNodes = sourceCode.getAllComments(); + + // Module store of errors that we have found + let errors = []; + + /** + * Removes errors that occur inside the given node + * @param {ASTNode} node to check for matching errors. + * @returns {void} + * @private + */ + function removeWhitespaceError(node) { + const locStart = node.loc.start; + const locEnd = node.loc.end; + + errors = errors.filter( + ({ loc: { start: errorLocStart } }) => + errorLocStart.line < locStart.line || + (errorLocStart.line === locStart.line && + errorLocStart.column < locStart.column) || + (errorLocStart.line === locEnd.line && + errorLocStart.column >= locEnd.column) || + errorLocStart.line > locEnd.line, + ); + } + + /** + * Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors + * @param {ASTNode} node to check for matching errors. + * @returns {void} + * @private + */ + function removeInvalidNodeErrorsInLiteral(node) { + const shouldCheckStrings = + skipStrings && typeof node.value === "string"; + const shouldCheckRegExps = skipRegExps && Boolean(node.regex); + + if (shouldCheckStrings || shouldCheckRegExps) { + // If we have irregular characters remove them from the errors list + if (ALL_IRREGULARS.test(node.raw)) { + removeWhitespaceError(node); + } + } + } + + /** + * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors + * @param {ASTNode} node to check for matching errors. + * @returns {void} + * @private + */ + function removeInvalidNodeErrorsInTemplateLiteral(node) { + if (typeof node.value.raw === "string") { + if (ALL_IRREGULARS.test(node.value.raw)) { + removeWhitespaceError(node); + } + } + } + + /** + * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors + * @param {ASTNode} node to check for matching errors. + * @returns {void} + * @private + */ + function removeInvalidNodeErrorsInComment(node) { + if (ALL_IRREGULARS.test(node.value)) { + removeWhitespaceError(node); + } + } + + /** + * Checks JSX nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors + * @param {ASTNode} node to check for matching errors. + * @returns {void} + * @private + */ + function removeInvalidNodeErrorsInJSXText(node) { + if (ALL_IRREGULARS.test(node.raw)) { + removeWhitespaceError(node); + } + } + + /** + * Checks the program source for irregular whitespace + * @param {ASTNode} node The program node + * @returns {void} + * @private + */ + function checkForIrregularWhitespace(node) { + const sourceLines = sourceCode.lines; + + sourceLines.forEach((sourceLine, lineIndex) => { + const lineNumber = lineIndex + 1; + let match; + + while ( + (match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null + ) { + errors.push({ + node, + messageId: "noIrregularWhitespace", + loc: { + start: { + line: lineNumber, + column: match.index, + }, + end: { + line: lineNumber, + column: match.index + match[0].length, + }, + }, + }); + } + }); + } + + /** + * Checks the program source for irregular line terminators + * @param {ASTNode} node The program node + * @returns {void} + * @private + */ + function checkForIrregularLineTerminators(node) { + const source = sourceCode.getText(), + sourceLines = sourceCode.lines, + linebreaks = source.match(LINE_BREAK); + let lastLineIndex = -1, + match; + + while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) { + const lineIndex = + linebreaks.indexOf(match[0], lastLineIndex + 1) || 0; + + errors.push({ + node, + messageId: "noIrregularWhitespace", + loc: { + start: { + line: lineIndex + 1, + column: sourceLines[lineIndex].length, + }, + end: { + line: lineIndex + 2, + column: 0, + }, + }, + }); + + lastLineIndex = lineIndex; + } + } + + /** + * A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`. + * @returns {void} + * @private + */ + function noop() {} + + const nodes = {}; + + if (ALL_IRREGULARS.test(sourceCode.getText())) { + nodes.Program = function (node) { + /* + * As we can easily fire warnings for all white space issues with + * all the source its simpler to fire them here. + * This means we can check all the application code without having + * to worry about issues caused in the parser tokens. + * When writing this code also evaluating per node was missing out + * connecting tokens in some cases. + * We can later filter the errors when they are found to be not an + * issue in nodes we don't care about. + */ + checkForIrregularWhitespace(node); + checkForIrregularLineTerminators(node); + }; + + nodes.Literal = removeInvalidNodeErrorsInLiteral; + nodes.TemplateElement = skipTemplates + ? removeInvalidNodeErrorsInTemplateLiteral + : noop; + nodes.JSXText = skipJSXText + ? removeInvalidNodeErrorsInJSXText + : noop; + nodes["Program:exit"] = function () { + if (skipComments) { + // First strip errors occurring in comment nodes. + commentNodes.forEach(removeInvalidNodeErrorsInComment); + } + + // If we have any errors remaining report on them + errors.forEach(error => context.report(error)); + }; + } else { + nodes.Program = noop; + } + + return nodes; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-iterator.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-iterator.js new file mode 100644 index 00000000..6451e334 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-iterator.js @@ -0,0 +1,48 @@ +/** + * @fileoverview Rule to flag usage of __iterator__ property + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getStaticPropertyName } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow the use of the `__iterator__` property", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-iterator", + }, + + schema: [], + + messages: { + noIterator: "Reserved name '__iterator__'.", + }, + }, + + create(context) { + return { + MemberExpression(node) { + if (getStaticPropertyName(node) === "__iterator__") { + context.report({ + node, + messageId: "noIterator", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-label-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-label-var.js new file mode 100644 index 00000000..a8789413 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-label-var.js @@ -0,0 +1,78 @@ +/** + * @fileoverview Rule to flag labels that are the same as an identifier + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow labels that share a name with a variable", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-label-var", + }, + + schema: [], + + messages: { + identifierClashWithLabel: + "Found identifier with same name as label.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Check if the identifier is present inside current scope + * @param {Object} scope current scope + * @param {string} name To evaluate + * @returns {boolean} True if its present + * @private + */ + function findIdentifier(scope, name) { + return astUtils.getVariableByName(scope, name) !== null; + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + LabeledStatement(node) { + // Fetch the innermost scope. + const scope = sourceCode.getScope(node); + + /* + * Recursively find the identifier walking up the scope, starting + * with the innermost scope. + */ + if (findIdentifier(scope, node.label.name)) { + context.report({ + node, + messageId: "identifierClashWithLabel", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-labels.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-labels.js new file mode 100644 index 00000000..45eb8af7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-labels.js @@ -0,0 +1,156 @@ +/** + * @fileoverview Disallow Labeled Statements + * @author Nicholas C. Zakas + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowLoop: false, + allowSwitch: false, + }, + ], + + docs: { + description: "Disallow labeled statements", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-labels", + }, + + schema: [ + { + type: "object", + properties: { + allowLoop: { + type: "boolean", + }, + allowSwitch: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedLabel: "Unexpected labeled statement.", + unexpectedLabelInBreak: "Unexpected label in break statement.", + unexpectedLabelInContinue: + "Unexpected label in continue statement.", + }, + }, + + create(context) { + const [{ allowLoop, allowSwitch }] = context.options; + let scopeInfo = null; + + /** + * Gets the kind of a given node. + * @param {ASTNode} node A node to get. + * @returns {string} The kind of the node. + */ + function getBodyKind(node) { + if (astUtils.isLoop(node)) { + return "loop"; + } + if (node.type === "SwitchStatement") { + return "switch"; + } + return "other"; + } + + /** + * Checks whether the label of a given kind is allowed or not. + * @param {string} kind A kind to check. + * @returns {boolean} `true` if the kind is allowed. + */ + function isAllowed(kind) { + switch (kind) { + case "loop": + return allowLoop; + case "switch": + return allowSwitch; + default: + return false; + } + } + + /** + * Checks whether a given name is a label of a loop or not. + * @param {string} label A name of a label to check. + * @returns {boolean} `true` if the name is a label of a loop. + */ + function getKind(label) { + let info = scopeInfo; + + while (info) { + if (info.label === label) { + return info.kind; + } + info = info.upper; + } + + /* c8 ignore next */ + return "other"; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + LabeledStatement(node) { + scopeInfo = { + label: node.label.name, + kind: getBodyKind(node.body), + upper: scopeInfo, + }; + }, + + "LabeledStatement:exit"(node) { + if (!isAllowed(scopeInfo.kind)) { + context.report({ + node, + messageId: "unexpectedLabel", + }); + } + + scopeInfo = scopeInfo.upper; + }, + + BreakStatement(node) { + if (node.label && !isAllowed(getKind(node.label.name))) { + context.report({ + node, + messageId: "unexpectedLabelInBreak", + }); + } + }, + + ContinueStatement(node) { + if (node.label && !isAllowed(getKind(node.label.name))) { + context.report({ + node, + messageId: "unexpectedLabelInContinue", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lone-blocks.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lone-blocks.js new file mode 100644 index 00000000..94421b8f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lone-blocks.js @@ -0,0 +1,140 @@ +/** + * @fileoverview Rule to flag blocks with no reason to exist + * @author Brandon Mills + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unnecessary nested blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-lone-blocks", + }, + + schema: [], + + messages: { + redundantBlock: "Block is redundant.", + redundantNestedBlock: "Nested block is redundant.", + }, + }, + + create(context) { + // A stack of lone blocks to be checked for block-level bindings + const loneBlocks = []; + let ruleDef; + const sourceCode = context.sourceCode; + + /** + * Reports a node as invalid. + * @param {ASTNode} node The node to be reported. + * @returns {void} + */ + function report(node) { + const messageId = + node.parent.type === "BlockStatement" || + node.parent.type === "StaticBlock" + ? "redundantNestedBlock" + : "redundantBlock"; + + context.report({ + node, + messageId, + }); + } + + /** + * Checks for any occurrence of a BlockStatement in a place where lists of statements can appear + * @param {ASTNode} node The node to check + * @returns {boolean} True if the node is a lone block. + */ + function isLoneBlock(node) { + return ( + node.parent.type === "BlockStatement" || + node.parent.type === "StaticBlock" || + node.parent.type === "Program" || + // Don't report blocks in switch cases if the block is the only statement of the case. + (node.parent.type === "SwitchCase" && + !( + node.parent.consequent[0] === node && + node.parent.consequent.length === 1 + )) + ); + } + + /** + * Checks the enclosing block of the current node for block-level bindings, + * and "marks it" as valid if any. + * @param {ASTNode} node The current node to check. + * @returns {void} + */ + function markLoneBlock(node) { + if (loneBlocks.length === 0) { + return; + } + + const block = node.parent; + + if (loneBlocks.at(-1) === block) { + loneBlocks.pop(); + } + } + + // Default rule definition: report all lone blocks + ruleDef = { + BlockStatement(node) { + if (isLoneBlock(node)) { + report(node); + } + }, + }; + + // ES6: report blocks without block-level bindings, or that's only child of another block + if (context.languageOptions.ecmaVersion >= 2015) { + ruleDef = { + BlockStatement(node) { + if (isLoneBlock(node)) { + loneBlocks.push(node); + } + }, + "BlockStatement:exit"(node) { + if (loneBlocks.length > 0 && loneBlocks.at(-1) === node) { + loneBlocks.pop(); + report(node); + } else if ( + (node.parent.type === "BlockStatement" || + node.parent.type === "StaticBlock") && + node.parent.body.length === 1 + ) { + report(node); + } + }, + }; + + ruleDef.VariableDeclaration = function (node) { + if (node.kind !== "var") { + markLoneBlock(node); + } + }; + + ruleDef.FunctionDeclaration = function (node) { + if (sourceCode.getScope(node).isStrict) { + markLoneBlock(node); + } + }; + + ruleDef.ClassDeclaration = markLoneBlock; + } + + return ruleDef; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lonely-if.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lonely-if.js new file mode 100644 index 00000000..65af9607 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-lonely-if.js @@ -0,0 +1,126 @@ +/** + * @fileoverview Rule to disallow if as the only statement in an else block + * @author Brandon Mills + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `if` statements as the only statement in `else` blocks", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-lonely-if", + }, + + schema: [], + fixable: "code", + + messages: { + unexpectedLonelyIf: + "Unexpected if as the only statement in an else block.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + IfStatement(node) { + const parent = node.parent, + grandparent = parent.parent; + + if ( + parent && + parent.type === "BlockStatement" && + parent.body.length === 1 && + !astUtils.areBracesNecessary(parent, sourceCode) && + grandparent && + grandparent.type === "IfStatement" && + parent === grandparent.alternate + ) { + context.report({ + node, + messageId: "unexpectedLonelyIf", + fix(fixer) { + const openingElseCurly = + sourceCode.getFirstToken(parent); + const closingElseCurly = + sourceCode.getLastToken(parent); + const elseKeyword = + sourceCode.getTokenBefore(openingElseCurly); + const tokenAfterElseBlock = + sourceCode.getTokenAfter(closingElseCurly); + const lastIfToken = sourceCode.getLastToken( + node.consequent, + ); + const sourceText = sourceCode.getText(); + + if ( + sourceText + .slice( + openingElseCurly.range[1], + node.range[0], + ) + .trim() || + sourceText + .slice( + node.range[1], + closingElseCurly.range[0], + ) + .trim() + ) { + // Don't fix if there are any non-whitespace characters interfering (e.g. comments) + return null; + } + + if ( + node.consequent.type !== "BlockStatement" && + lastIfToken.value !== ";" && + tokenAfterElseBlock && + (node.consequent.loc.end.line === + tokenAfterElseBlock.loc.start.line || + /^[([/+`-]/u.test( + tokenAfterElseBlock.value, + ) || + lastIfToken.value === "++" || + lastIfToken.value === "--") + ) { + /* + * If the `if` statement has no block, and is not followed by a semicolon, make sure that fixing + * the issue would not change semantics due to ASI. If this would happen, don't do a fix. + */ + return null; + } + + return fixer.replaceTextRange( + [ + openingElseCurly.range[0], + closingElseCurly.range[1], + ], + (elseKeyword.range[1] === + openingElseCurly.range[0] + ? " " + : "") + sourceCode.getText(node), + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loop-func.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loop-func.js new file mode 100644 index 00000000..a986a18e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loop-func.js @@ -0,0 +1,272 @@ +/** + * @fileoverview Rule to flag creation of function inside a loop + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]); + +/** + * Identifies is a node is a FunctionExpression which is part of an IIFE + * @param {ASTNode} node Node to test + * @returns {boolean} True if it's an IIFE + */ +function isIIFE(node) { + return ( + (node.type === "FunctionExpression" || + node.type === "ArrowFunctionExpression") && + node.parent && + node.parent.type === "CallExpression" && + node.parent.callee === node + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow function declarations that contain unsafe references inside loop statements", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-loop-func", + }, + + schema: [], + + messages: { + unsafeRefs: + "Function declared in a loop contains unsafe references to variable(s) {{ varNames }}.", + }, + }, + + create(context) { + const SKIPPED_IIFE_NODES = new Set(); + const sourceCode = context.sourceCode; + + /** + * Gets the containing loop node of a specified node. + * + * We don't need to check nested functions, so this ignores those, with the exception of IIFE. + * `Scope.through` contains references of nested functions. + * @param {ASTNode} node An AST node to get. + * @returns {ASTNode|null} The containing loop node of the specified node, or + * `null`. + */ + function getContainingLoopNode(node) { + for ( + let currentNode = node; + currentNode.parent; + currentNode = currentNode.parent + ) { + const parent = currentNode.parent; + + switch (parent.type) { + case "WhileStatement": + case "DoWhileStatement": + return parent; + + case "ForStatement": + // `init` is outside of the loop. + if (parent.init !== currentNode) { + return parent; + } + break; + + case "ForInStatement": + case "ForOfStatement": + // `right` is outside of the loop. + if (parent.right !== currentNode) { + return parent; + } + break; + + case "ArrowFunctionExpression": + case "FunctionExpression": + case "FunctionDeclaration": + // We need to check nested functions only in case of IIFE. + if (SKIPPED_IIFE_NODES.has(parent)) { + break; + } + + return null; + default: + break; + } + } + + return null; + } + + /** + * Gets the containing loop node of a given node. + * If the loop was nested, this returns the most outer loop. + * @param {ASTNode} node A node to get. This is a loop node. + * @param {ASTNode|null} excludedNode A node that the result node should not + * include. + * @returns {ASTNode} The most outer loop node. + */ + function getTopLoopNode(node, excludedNode) { + const border = excludedNode ? excludedNode.range[1] : 0; + let retv = node; + let containingLoopNode = node; + + while ( + containingLoopNode && + containingLoopNode.range[0] >= border + ) { + retv = containingLoopNode; + containingLoopNode = getContainingLoopNode(containingLoopNode); + } + + return retv; + } + + /** + * Checks whether a given reference which refers to an upper scope's variable is + * safe or not. + * @param {ASTNode} loopNode A containing loop node. + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is safe or not. + */ + function isSafe(loopNode, reference) { + const variable = reference.resolved; + const definition = variable && variable.defs[0]; + const declaration = definition && definition.parent; + const kind = + declaration && declaration.type === "VariableDeclaration" + ? declaration.kind + : ""; + + // Constant variables are safe. + if (CONSTANT_BINDINGS.has(kind)) { + return true; + } + + /* + * Variables which are declared by `let` in the loop is safe. + * It's a different instance from the next loop step's. + */ + if ( + kind === "let" && + declaration.range[0] > loopNode.range[0] && + declaration.range[1] < loopNode.range[1] + ) { + return true; + } + + /* + * WriteReferences which exist after this border are unsafe because those + * can modify the variable. + */ + const border = getTopLoopNode( + loopNode, + kind === "let" ? declaration : null, + ).range[0]; + + /** + * Checks whether a given reference is safe or not. + * The reference is every reference of the upper scope's variable we are + * looking now. + * + * It's safe if the reference matches one of the following condition. + * - is readonly. + * - doesn't exist inside a local function and after the border. + * @param {Reference} upperRef A reference to check. + * @returns {boolean} `true` if the reference is safe. + */ + function isSafeReference(upperRef) { + const id = upperRef.identifier; + + return ( + !upperRef.isWrite() || + (variable.scope.variableScope === + upperRef.from.variableScope && + id.range[0] < border) + ); + } + + return ( + Boolean(variable) && variable.references.every(isSafeReference) + ); + } + + /** + * Reports functions which match the following condition: + * + * - has a loop node in ancestors. + * - has any references which refers to an unsafe variable. + * @param {ASTNode} node The AST node to check. + * @returns {void} + */ + function checkForLoops(node) { + const loopNode = getContainingLoopNode(node); + + if (!loopNode) { + return; + } + + const references = sourceCode.getScope(node).through; + + // Check if the function is not asynchronous or a generator function + if (!(node.async || node.generator)) { + if (isIIFE(node)) { + const isFunctionExpression = + node.type === "FunctionExpression"; + + // Check if the function is referenced elsewhere in the code + const isFunctionReferenced = + isFunctionExpression && node.id + ? references.some( + r => r.identifier.name === node.id.name, + ) + : false; + + if (!isFunctionReferenced) { + SKIPPED_IIFE_NODES.add(node); + return; + } + } + } + + const unsafeRefs = [ + ...new Set( + references + .filter(r => r.resolved && !isSafe(loopNode, r)) + .map(r => r.identifier.name), + ), + ]; + + if (unsafeRefs.length > 0) { + context.report({ + node, + messageId: "unsafeRefs", + data: { varNames: `'${unsafeRefs.join("', '")}'` }, + }); + } + } + + return { + ArrowFunctionExpression: checkForLoops, + FunctionExpression: checkForLoops, + FunctionDeclaration: checkForLoops, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loss-of-precision.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loss-of-precision.js new file mode 100644 index 00000000..17786a0f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-loss-of-precision.js @@ -0,0 +1,253 @@ +/** + * @fileoverview Rule to flag numbers that will lose significant figure precision at runtime + * @author Jacob Moore + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** Class representing a number in scientific notation. */ +class ScientificNotation { + /** @type {string} The digits of the coefficient. A decimal point is implied after the first digit. */ + coefficient; + + /** @type {number} The order of magnitude. */ + magnitude; + + constructor(coefficient, magnitude) { + this.coefficient = coefficient; + this.magnitude = magnitude; + } + + /* c8 ignore start -- debug only */ + toString() { + return `${this.coefficient[0]}${this.coefficient.length > 1 ? `.${this.coefficient.slice(1)}` : ""}e${this.magnitude}`; + } + /* c8 ignore stop */ +} + +/** + * Returns whether the node is number literal + * @param {Node} node the node literal being evaluated + * @returns {boolean} true if the node is a number literal + */ +function isNumber(node) { + return typeof node.value === "number"; +} + +/** + * Gets the source code of the given number literal. Removes `_` numeric separators from the result. + * @param {Node} node the number `Literal` node + * @returns {string} raw source code of the literal, without numeric separators + */ +function getRaw(node) { + return node.raw.replace(/_/gu, ""); +} + +/** + * Checks whether the number is base ten + * @param {ASTNode} node the node being evaluated + * @returns {boolean} true if the node is in base ten + */ +function isBaseTen(node) { + const prefixes = ["0x", "0X", "0b", "0B", "0o", "0O"]; + + return ( + prefixes.every(prefix => !node.raw.startsWith(prefix)) && + !/^0[0-7]+$/u.test(node.raw) + ); +} + +/** + * Checks that the user-intended non-base ten number equals the actual number after is has been converted to the Number type + * @param {Node} node the node being evaluated + * @returns {boolean} true if they do not match + */ +function notBaseTenLosesPrecision(node) { + const rawString = getRaw(node).toUpperCase(); + let base; + + if (rawString.startsWith("0B")) { + base = 2; + } else if (rawString.startsWith("0X")) { + base = 16; + } else { + base = 8; + } + + return !rawString.endsWith(node.value.toString(base).toUpperCase()); +} + +/** + * Returns the number stripped of leading zeros + * @param {string} numberAsString the string representation of the number + * @returns {string} the stripped string + */ +function removeLeadingZeros(numberAsString) { + for (let i = 0; i < numberAsString.length; i++) { + if (numberAsString[i] !== "0") { + return numberAsString.slice(i); + } + } + return numberAsString; +} + +/** + * Returns the number stripped of trailing zeros + * @param {string} numberAsString the string representation of the number + * @returns {string} the stripped string + */ +function removeTrailingZeros(numberAsString) { + for (let i = numberAsString.length - 1; i >= 0; i--) { + if (numberAsString[i] !== "0") { + return numberAsString.slice(0, i + 1); + } + } + return numberAsString; +} + +/** + * Converts an integer to an object containing the integer's coefficient and order of magnitude + * @param {string} stringInteger the string representation of the integer being converted + * @returns {ScientificNotation} the object containing the integer's coefficient and order of magnitude + */ +function normalizeInteger(stringInteger) { + const trimmedInteger = removeLeadingZeros(stringInteger); + const significantDigits = removeTrailingZeros(trimmedInteger); + + return new ScientificNotation(significantDigits, trimmedInteger.length - 1); +} + +/** + * Converts a float to an object containing the float's coefficient and order of magnitude + * @param {string} stringFloat the string representation of the float being converted + * @returns {ScientificNotation} the object containing the float's coefficient and order of magnitude + */ +function normalizeFloat(stringFloat) { + const trimmedFloat = removeLeadingZeros(stringFloat); + const indexOfDecimalPoint = trimmedFloat.indexOf("."); + + switch (indexOfDecimalPoint) { + case 0: { + const significantDigits = removeLeadingZeros(trimmedFloat.slice(1)); + + return new ScientificNotation( + significantDigits, + significantDigits.length - trimmedFloat.length, + ); + } + case -1: + return new ScientificNotation( + trimmedFloat, + trimmedFloat.length - 1, + ); + default: + return new ScientificNotation( + trimmedFloat.replace(".", ""), + indexOfDecimalPoint - 1, + ); + } +} + +/** + * Converts a base ten number to proper scientific notation + * @param {string} stringNumber the string representation of the base ten number to be converted + * @param {boolean} parseAsFloat if true, the coefficient will be always parsed as a float, regardless of whether a decimal point is present + * @returns {ScientificNotation} the object containing the number's coefficient and order of magnitude + */ +function convertNumberToScientificNotation(stringNumber, parseAsFloat) { + const splitNumber = stringNumber.split("e"); + const originalCoefficient = splitNumber[0]; + const normalizedNumber = + parseAsFloat || stringNumber.includes(".") + ? normalizeFloat(originalCoefficient) + : normalizeInteger(originalCoefficient); + if (splitNumber.length > 1) { + normalizedNumber.magnitude += parseInt(splitNumber[1], 10); + } + + return normalizedNumber; +} + +/** + * Checks that the user-intended base ten number equals the actual number after is has been converted to the Number type + * @param {Node} node the node being evaluated + * @returns {boolean} true if they do not match + */ +function baseTenLosesPrecision(node) { + const rawNumber = getRaw(node).toLowerCase().replace(/\.$/u, ""); + const normalizedRawNumber = convertNumberToScientificNotation( + rawNumber, + false, + ); + + if (node.value === 0) { + return !/^0+$/u.test(normalizedRawNumber.coefficient); + } + + const requestedPrecision = normalizedRawNumber.coefficient.length; + + if (requestedPrecision > 100) { + return true; + } + const storedNumber = node.value.toPrecision(requestedPrecision); + const normalizedStoredNumber = convertNumberToScientificNotation( + storedNumber, + true, + ); + + return ( + normalizedRawNumber.magnitude !== normalizedStoredNumber.magnitude || + normalizedRawNumber.coefficient !== normalizedStoredNumber.coefficient + ); +} + +/** + * Checks that the user-intended number equals the actual number after is has been converted to the Number type + * @param {Node} node the node being evaluated + * @returns {boolean} true if they do not match + */ +function losesPrecision(node) { + return isBaseTen(node) + ? baseTenLosesPrecision(node) + : notBaseTenLosesPrecision(node); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow literal numbers that lose precision", + dialects: ["JavaScript", "TypeScript"], + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-loss-of-precision", + }, + schema: [], + messages: { + noLossOfPrecision: + "This number literal will lose precision at runtime.", + }, + }, + + create(context) { + return { + Literal(node) { + if (isNumber(node) && losesPrecision(node)) { + context.report({ + messageId: "noLossOfPrecision", + node, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-magic-numbers.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-magic-numbers.js new file mode 100644 index 00000000..f5eeb5fa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-magic-numbers.js @@ -0,0 +1,370 @@ +/** + * @fileoverview Rule to flag statements that use magic numbers (adapted from https://github.com/danielstjules/buddy.js) + * @author Vincent Lemeunier + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +// Maximum array length by the ECMAScript Specification. +const MAX_ARRAY_LENGTH = 2 ** 32 - 1; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** + * Convert the value to bigint if it's a string. Otherwise return the value as-is. + * @param {bigint|number|string} x The value to normalize. + * @returns {bigint|number} The normalized value. + */ +function normalizeIgnoreValue(x) { + if (typeof x === "string") { + return BigInt(x.slice(0, -1)); + } + return x; +} + +/** + * Checks if the node parent is a TypeScript enum member + * @param {ASTNode} node The node to be validated + * @returns {boolean} True if the node parent is a TypeScript enum member + */ +function isParentTSEnumDeclaration(node) { + return node.parent.type === "TSEnumMember"; +} + +/** + * Checks if the node is a valid TypeScript numeric literal type. + * @param {ASTNode} node The node to be validated + * @returns {boolean} True if the node is a TypeScript numeric literal type + */ +function isTSNumericLiteralType(node) { + let ancestor = node.parent; + + // Go up while we're part of a type union + while (ancestor.parent.type === "TSUnionType") { + ancestor = ancestor.parent; + } + + // Check if the final ancestor is in a type alias declaration + return ancestor.parent.type === "TSTypeAliasDeclaration"; +} + +/** + * Checks if the node parent is a readonly class property + * @param {ASTNode} node The node to be validated + * @returns {boolean} True if the node parent is a readonly class property + */ +function isParentTSReadonlyPropertyDefinition(node) { + if (node.parent?.type === "PropertyDefinition" && node.parent.readonly) { + return true; + } + + return false; +} + +/** + * Checks if the node is part of a type indexed access (eg. Foo[4]) + * @param {ASTNode} node The node to be validated + * @returns {boolean} True if the node is part of an indexed access + */ +function isAncestorTSIndexedAccessType(node) { + let ancestor = node.parent; + + /* + * Go up another level while we're part of a type union (eg. 1 | 2) or + * intersection (eg. 1 & 2) + */ + while ( + ancestor.parent.type === "TSUnionType" || + ancestor.parent.type === "TSIntersectionType" + ) { + ancestor = ancestor.parent; + } + + return ancestor.parent.type === "TSIndexedAccessType"; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow magic numbers", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-magic-numbers", + }, + + schema: [ + { + type: "object", + properties: { + detectObjects: { + type: "boolean", + }, + enforceConst: { + type: "boolean", + }, + ignore: { + type: "array", + items: { + anyOf: [ + { type: "number" }, + { + type: "string", + pattern: "^[+-]?(?:0|[1-9][0-9]*)n$", + }, + ], + }, + uniqueItems: true, + }, + ignoreArrayIndexes: { + type: "boolean", + }, + ignoreDefaultValues: { + type: "boolean", + }, + ignoreClassFieldInitialValues: { + type: "boolean", + }, + ignoreEnums: { + type: "boolean", + }, + ignoreNumericLiteralTypes: { + type: "boolean", + }, + ignoreReadonlyClassProperties: { + type: "boolean", + }, + ignoreTypeIndexes: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + detectObjects: false, + enforceConst: false, + ignore: [], + ignoreArrayIndexes: false, + ignoreDefaultValues: false, + ignoreClassFieldInitialValues: false, + ignoreEnums: false, + ignoreNumericLiteralTypes: false, + ignoreReadonlyClassProperties: false, + ignoreTypeIndexes: false, + }, + ], + + messages: { + useConst: "Number constants declarations must use 'const'.", + noMagic: "No magic number: {{raw}}.", + }, + }, + + create(context) { + const { + detectObjects, + enforceConst, + ignore: rawIgnore, + ignoreArrayIndexes, + ignoreDefaultValues, + ignoreClassFieldInitialValues, + ignoreEnums, + ignoreNumericLiteralTypes, + ignoreReadonlyClassProperties, + ignoreTypeIndexes, + } = context.options[0]; + const ignore = new Set(rawIgnore.map(normalizeIgnoreValue)); + + const okTypes = detectObjects + ? [] + : ["ObjectExpression", "Property", "AssignmentExpression"]; + + /** + * Returns whether the rule is configured to ignore the given value + * @param {bigint|number} value The value to check + * @returns {boolean} true if the value is ignored + */ + function isIgnoredValue(value) { + return ignore.has(value); + } + + /** + * Returns whether the number is a default value assignment. + * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node + * @returns {boolean} true if the number is a default value + */ + function isDefaultValue(fullNumberNode) { + const parent = fullNumberNode.parent; + + return ( + parent.type === "AssignmentPattern" && + parent.right === fullNumberNode + ); + } + + /** + * Returns whether the number is the initial value of a class field. + * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node + * @returns {boolean} true if the number is the initial value of a class field. + */ + function isClassFieldInitialValue(fullNumberNode) { + const parent = fullNumberNode.parent; + + return ( + parent.type === "PropertyDefinition" && + parent.value === fullNumberNode + ); + } + + /** + * Returns whether the given node is used as a radix within parseInt() or Number.parseInt() + * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node + * @returns {boolean} true if the node is radix + */ + function isParseIntRadix(fullNumberNode) { + const parent = fullNumberNode.parent; + + return ( + parent.type === "CallExpression" && + fullNumberNode === parent.arguments[1] && + (astUtils.isSpecificId(parent.callee, "parseInt") || + astUtils.isSpecificMemberAccess( + parent.callee, + "Number", + "parseInt", + )) + ); + } + + /** + * Returns whether the given node is a direct child of a JSX node. + * In particular, it aims to detect numbers used as prop values in JSX tags. + * Example: + * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node + * @returns {boolean} true if the node is a JSX number + */ + function isJSXNumber(fullNumberNode) { + return fullNumberNode.parent.type.indexOf("JSX") === 0; + } + + /** + * Returns whether the given node is used as an array index. + * Value must coerce to a valid array index name: "0", "1", "2" ... "4294967294". + * + * All other values, like "-1", "2.5", or "4294967295", are just "normal" object properties, + * which can be created and accessed on an array in addition to the array index properties, + * but they don't affect array's length and are not considered by methods such as .map(), .forEach() etc. + * + * The maximum array length by the specification is 2 ** 32 - 1 = 4294967295, + * thus the maximum valid index is 2 ** 32 - 2 = 4294967294. + * + * All notations are allowed, as long as the value coerces to one of "0", "1", "2" ... "4294967294". + * + * Valid examples: + * a[0], a[1], a[1.2e1], a[0xAB], a[0n], a[1n] + * a[-0] (same as a[0] because -0 coerces to "0") + * a[-0n] (-0n evaluates to 0n) + * + * Invalid examples: + * a[-1], a[-0xAB], a[-1n], a[2.5], a[1.23e1], a[12e-1] + * a[4294967295] (above the max index, it's an access to a regular property a["4294967295"]) + * a[999999999999999999999] (even if it wasn't above the max index, it would be a["1e+21"]) + * a[1e310] (same as a["Infinity"]) + * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node + * @param {bigint|number} value Value expressed by the fullNumberNode + * @returns {boolean} true if the node is a valid array index + */ + function isArrayIndex(fullNumberNode, value) { + const parent = fullNumberNode.parent; + + return ( + parent.type === "MemberExpression" && + parent.property === fullNumberNode && + (Number.isInteger(value) || typeof value === "bigint") && + value >= 0 && + value < MAX_ARRAY_LENGTH + ); + } + + return { + Literal(node) { + if (!astUtils.isNumericLiteral(node)) { + return; + } + + let fullNumberNode; + let value; + let raw; + + // Treat unary minus/plus as a part of the number + if ( + node.parent.type === "UnaryExpression" && + ["-", "+"].includes(node.parent.operator) + ) { + fullNumberNode = node.parent; + value = + node.parent.operator === "-" ? -node.value : node.value; + raw = `${node.parent.operator}${node.raw}`; + } else { + fullNumberNode = node; + value = node.value; + raw = node.raw; + } + + const parent = fullNumberNode.parent; + + // Always allow radix arguments and JSX props + if ( + isIgnoredValue(value) || + (ignoreDefaultValues && isDefaultValue(fullNumberNode)) || + (ignoreClassFieldInitialValues && + isClassFieldInitialValue(fullNumberNode)) || + (ignoreEnums && + isParentTSEnumDeclaration(fullNumberNode)) || + (ignoreNumericLiteralTypes && + isTSNumericLiteralType(fullNumberNode)) || + (ignoreTypeIndexes && + isAncestorTSIndexedAccessType(fullNumberNode)) || + (ignoreReadonlyClassProperties && + isParentTSReadonlyPropertyDefinition(fullNumberNode)) || + isParseIntRadix(fullNumberNode) || + isJSXNumber(fullNumberNode) || + (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value)) + ) { + return; + } + + if (parent.type === "VariableDeclarator") { + if (enforceConst && parent.parent.kind !== "const") { + context.report({ + node: fullNumberNode, + messageId: "useConst", + }); + } + } else if ( + !okTypes.includes(parent.type) || + (parent.type === "AssignmentExpression" && + parent.left.type === "Identifier") + ) { + context.report({ + node: fullNumberNode, + messageId: "noMagic", + data: { + raw, + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-misleading-character-class.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-misleading-character-class.js new file mode 100644 index 00000000..c7223335 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-misleading-character-class.js @@ -0,0 +1,595 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +const { + CALL, + CONSTRUCT, + ReferenceTracker, + getStaticValue, + getStringIfConstant, +} = require("@eslint-community/eslint-utils"); +const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp"); +const { + isCombiningCharacter, + isEmojiModifier, + isRegionalIndicatorSymbol, + isSurrogatePair, +} = require("./utils/unicode"); +const astUtils = require("./utils/ast-utils.js"); +const { isValidWithUnicodeFlag } = require("./utils/regular-expressions"); +const { + parseStringLiteral, + parseTemplateToken, +} = require("./utils/char-source"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * @typedef {import('@eslint-community/regexpp').AST.Character} Character + * @typedef {import('@eslint-community/regexpp').AST.CharacterClassElement} CharacterClassElement + */ + +/** + * Iterate character sequences of a given nodes. + * + * CharacterClassRange syntax can steal a part of character sequence, + * so this function reverts CharacterClassRange syntax and restore the sequence. + * @param {CharacterClassElement[]} nodes The node list to iterate character sequences. + * @returns {IterableIterator} The list of character sequences. + */ +function* iterateCharacterSequence(nodes) { + /** @type {Character[]} */ + let seq = []; + + for (const node of nodes) { + switch (node.type) { + case "Character": + seq.push(node); + break; + + case "CharacterClassRange": + seq.push(node.min); + yield seq; + seq = [node.max]; + break; + + case "CharacterSet": + case "CharacterClass": // [[]] nesting character class + case "ClassStringDisjunction": // \q{...} + case "ExpressionCharacterClass": // [A--B] + if (seq.length > 0) { + yield seq; + seq = []; + } + break; + + // no default + } + } + + if (seq.length > 0) { + yield seq; + } +} + +/** + * Checks whether the given character node is a Unicode code point escape or not. + * @param {Character} char the character node to check. + * @returns {boolean} `true` if the character node is a Unicode code point escape. + */ +function isUnicodeCodePointEscape(char) { + return /^\\u\{[\da-f]+\}$/iu.test(char.raw); +} + +/** + * Each function returns matched characters if it detects that kind of problem. + * @type {Record IterableIterator>} + */ +const findCharacterSequences = { + *surrogatePairWithoutUFlag(chars) { + for (const [index, char] of chars.entries()) { + const previous = chars[index - 1]; + + if ( + previous && + char && + isSurrogatePair(previous.value, char.value) && + !isUnicodeCodePointEscape(previous) && + !isUnicodeCodePointEscape(char) + ) { + yield [previous, char]; + } + } + }, + + *surrogatePair(chars) { + for (const [index, char] of chars.entries()) { + const previous = chars[index - 1]; + + if ( + previous && + char && + isSurrogatePair(previous.value, char.value) && + (isUnicodeCodePointEscape(previous) || + isUnicodeCodePointEscape(char)) + ) { + yield [previous, char]; + } + } + }, + + *combiningClass(chars, unfilteredChars) { + /* + * When `allowEscape` is `true`, a combined character should only be allowed if the combining mark appears as an escape sequence. + * This means that the base character should be considered even if it's escaped. + */ + for (const [index, char] of chars.entries()) { + const previous = unfilteredChars[index - 1]; + + if ( + previous && + char && + isCombiningCharacter(char.value) && + !isCombiningCharacter(previous.value) + ) { + yield [previous, char]; + } + } + }, + + *emojiModifier(chars) { + for (const [index, char] of chars.entries()) { + const previous = chars[index - 1]; + + if ( + previous && + char && + isEmojiModifier(char.value) && + !isEmojiModifier(previous.value) + ) { + yield [previous, char]; + } + } + }, + + *regionalIndicatorSymbol(chars) { + for (const [index, char] of chars.entries()) { + const previous = chars[index - 1]; + + if ( + previous && + char && + isRegionalIndicatorSymbol(char.value) && + isRegionalIndicatorSymbol(previous.value) + ) { + yield [previous, char]; + } + } + }, + + *zwj(chars) { + let sequence = null; + + for (const [index, char] of chars.entries()) { + const previous = chars[index - 1]; + const next = chars[index + 1]; + + if ( + previous && + char && + next && + char.value === 0x200d && + previous.value !== 0x200d && + next.value !== 0x200d + ) { + if (sequence) { + if (sequence.at(-1) === previous) { + sequence.push(char, next); // append to the sequence + } else { + yield sequence; + sequence = chars.slice(index - 1, index + 2); + } + } else { + sequence = chars.slice(index - 1, index + 2); + } + } + } + + if (sequence) { + yield sequence; + } + }, +}; + +const kinds = Object.keys(findCharacterSequences); + +/** + * Gets the value of the given node if it's a static value other than a regular expression object, + * or the node's `regex` property. + * The purpose of this method is to provide a replacement for `getStaticValue` in environments where certain regular expressions cannot be evaluated. + * A known example is Node.js 18 which does not support the `v` flag. + * Calling `getStaticValue` on a regular expression node with the `v` flag on Node.js 18 always returns `null`. + * A limitation of this method is that it can only detect a regular expression if the specified node is itself a regular expression literal node. + * @param {ASTNode | undefined} node The node to be inspected. + * @param {Scope} initialScope Scope to start finding variables. This function tries to resolve identifier references which are in the given scope. + * @returns {{ value: any } | { regex: { pattern: string, flags: string } } | null} The static value of the node, or `null`. + */ +function getStaticValueOrRegex(node, initialScope) { + if (!node) { + return null; + } + if (node.type === "Literal" && node.regex) { + return { regex: node.regex }; + } + + const staticValue = getStaticValue(node, initialScope); + + if (staticValue?.value instanceof RegExp) { + return null; + } + return staticValue; +} + +/** + * Checks whether a specified regexpp character is represented as an acceptable escape sequence. + * This function requires the source text of the character to be known. + * @param {Character} char Character to check. + * @param {string} charSource Source text of the character to check. + * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence. + */ +function checkForAcceptableEscape(char, charSource) { + if (!charSource.startsWith("\\")) { + return false; + } + const match = /(?<=^\\+).$/su.exec(charSource); + + return match?.[0] !== String.fromCodePoint(char.value); +} + +/** + * Checks whether a specified regexpp character is represented as an acceptable escape sequence. + * This function works with characters that are produced by a string or template literal. + * It requires the source text and the CodeUnit list of the literal to be known. + * @param {Character} char Character to check. + * @param {string} nodeSource Source text of the string or template literal that produces the character. + * @param {CodeUnit[]} codeUnits List of CodeUnit objects of the literal that produces the character. + * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence. + */ +function checkForAcceptableEscapeInString(char, nodeSource, codeUnits) { + const firstIndex = char.start; + const lastIndex = char.end - 1; + const start = codeUnits[firstIndex].start; + const end = codeUnits[lastIndex].end; + const charSource = nodeSource.slice(start, end); + + return checkForAcceptableEscape(char, charSource); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowEscape: false, + }, + ], + + docs: { + description: + "Disallow characters which are made with multiple code points in character class syntax", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-misleading-character-class", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + allowEscape: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + surrogatePairWithoutUFlag: + "Unexpected surrogate pair in character class. Use 'u' flag.", + surrogatePair: "Unexpected surrogate pair in character class.", + combiningClass: "Unexpected combined character in character class.", + emojiModifier: "Unexpected modified Emoji in character class.", + regionalIndicatorSymbol: + "Unexpected national flag in character class.", + zwj: "Unexpected joined character sequence in character class.", + suggestUnicodeFlag: "Add unicode 'u' flag to regex.", + }, + }, + create(context) { + const [{ allowEscape }] = context.options; + const sourceCode = context.sourceCode; + const parser = new RegExpParser(); + const checkedPatternNodes = new Set(); + + /** + * Verify a given regular expression. + * @param {Node} node The node to report. + * @param {string} pattern The regular expression pattern to verify. + * @param {string} flags The flags of the regular expression. + * @param {Function} unicodeFixer Fixer for missing "u" flag. + * @returns {void} + */ + function verify(node, pattern, flags, unicodeFixer) { + let patternNode; + + try { + patternNode = parser.parsePattern(pattern, 0, pattern.length, { + unicode: flags.includes("u"), + unicodeSets: flags.includes("v"), + }); + } catch { + // Ignore regular expressions with syntax errors + return; + } + + let codeUnits = null; + + /** + * Checks whether a specified regexpp character is represented as an acceptable escape sequence. + * For the purposes of this rule, an escape sequence is considered acceptable if it consists of one or more backslashes followed by the character being escaped. + * @param {Character} char Character to check. + * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence. + */ + function isAcceptableEscapeSequence(char) { + if (node.type === "Literal" && node.regex) { + return checkForAcceptableEscape(char, char.raw); + } + if (node.type === "Literal" && typeof node.value === "string") { + const nodeSource = node.raw; + + codeUnits ??= parseStringLiteral(nodeSource); + + return checkForAcceptableEscapeInString( + char, + nodeSource, + codeUnits, + ); + } + if (astUtils.isStaticTemplateLiteral(node)) { + const nodeSource = sourceCode.getText(node); + + codeUnits ??= parseTemplateToken(nodeSource); + + return checkForAcceptableEscapeInString( + char, + nodeSource, + codeUnits, + ); + } + return false; + } + + const foundKindMatches = new Map(); + + visitRegExpAST(patternNode, { + onCharacterClassEnter(ccNode) { + for (const unfilteredChars of iterateCharacterSequence( + ccNode.elements, + )) { + let chars; + + if (allowEscape) { + // Replace escape sequences with null to avoid having them flagged. + chars = unfilteredChars.map(char => + isAcceptableEscapeSequence(char) ? null : char, + ); + } else { + chars = unfilteredChars; + } + for (const kind of kinds) { + const matches = findCharacterSequences[kind]( + chars, + unfilteredChars, + ); + + if (foundKindMatches.has(kind)) { + foundKindMatches.get(kind).push(...matches); + } else { + foundKindMatches.set(kind, [...matches]); + } + } + } + }, + }); + + /** + * Finds the report loc(s) for a range of matches. + * Only literals and expression-less templates generate granular errors. + * @param {Character[][]} matches Lists of individual characters being reported on. + * @returns {Location[]} locs for context.report. + * @see https://github.com/eslint/eslint/pull/17515 + */ + function getNodeReportLocations(matches) { + if ( + !astUtils.isStaticTemplateLiteral(node) && + node.type !== "Literal" + ) { + return matches.length ? [node.loc] : []; + } + return matches.map(chars => { + const firstIndex = chars[0].start; + const lastIndex = chars.at(-1).end - 1; + let start; + let end; + + if (node.type === "TemplateLiteral") { + const source = sourceCode.getText(node); + const offset = node.range[0]; + + codeUnits ??= parseTemplateToken(source); + start = offset + codeUnits[firstIndex].start; + end = offset + codeUnits[lastIndex].end; + } else if (typeof node.value === "string") { + // String Literal + const source = node.raw; + const offset = node.range[0]; + + codeUnits ??= parseStringLiteral(source); + start = offset + codeUnits[firstIndex].start; + end = offset + codeUnits[lastIndex].end; + } else { + // RegExp Literal + const offset = node.range[0] + 1; // Add 1 to skip the leading slash. + + start = offset + firstIndex; + end = offset + lastIndex + 1; + } + + return { + start: sourceCode.getLocFromIndex(start), + end: sourceCode.getLocFromIndex(end), + }; + }); + } + + for (const [kind, matches] of foundKindMatches) { + let suggest; + + if (kind === "surrogatePairWithoutUFlag") { + suggest = [ + { + messageId: "suggestUnicodeFlag", + fix: unicodeFixer, + }, + ]; + } + + const locs = getNodeReportLocations(matches); + + for (const loc of locs) { + context.report({ + node, + loc, + messageId: kind, + suggest, + }); + } + } + } + + return { + "Literal[regex]"(node) { + if (checkedPatternNodes.has(node)) { + return; + } + verify(node, node.regex.pattern, node.regex.flags, fixer => { + if ( + !isValidWithUnicodeFlag( + context.languageOptions.ecmaVersion, + node.regex.pattern, + ) + ) { + return null; + } + + return fixer.insertTextAfter(node, "u"); + }); + }, + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + + /* + * Iterate calls of RegExp. + * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`, + * `const {RegExp: a} = window; new a()`, etc... + */ + for (const { node: refNode } of tracker.iterateGlobalReferences( + { + RegExp: { [CALL]: true, [CONSTRUCT]: true }, + }, + )) { + let pattern, flags; + const [patternNode, flagsNode] = refNode.arguments; + const evaluatedPattern = getStaticValueOrRegex( + patternNode, + scope, + ); + + if (!evaluatedPattern) { + continue; + } + if (flagsNode) { + if (evaluatedPattern.regex) { + pattern = evaluatedPattern.regex.pattern; + checkedPatternNodes.add(patternNode); + } else { + pattern = String(evaluatedPattern.value); + } + flags = getStringIfConstant(flagsNode, scope); + } else { + if (evaluatedPattern.regex) { + continue; + } + pattern = String(evaluatedPattern.value); + flags = ""; + } + + if (typeof flags === "string") { + verify(patternNode, pattern, flags, fixer => { + if ( + !isValidWithUnicodeFlag( + context.languageOptions.ecmaVersion, + pattern, + ) + ) { + return null; + } + + if (refNode.arguments.length === 1) { + const penultimateToken = + sourceCode.getLastToken(refNode, { + skip: 1, + }); // skip closing parenthesis + + return fixer.insertTextAfter( + penultimateToken, + astUtils.isCommaToken(penultimateToken) + ? ' "u",' + : ', "u"', + ); + } + + if ( + (flagsNode.type === "Literal" && + typeof flagsNode.value === "string") || + flagsNode.type === "TemplateLiteral" + ) { + const range = [ + flagsNode.range[0], + flagsNode.range[1] - 1, + ]; + + return fixer.insertTextAfterRange(range, "u"); + } + + return null; + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-operators.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-operators.js new file mode 100644 index 00000000..73dc127a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-operators.js @@ -0,0 +1,253 @@ +/** + * @fileoverview Rule to disallow mixed binary operators. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils.js"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"]; +const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"]; +const COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="]; +const LOGICAL_OPERATORS = ["&&", "||"]; +const RELATIONAL_OPERATORS = ["in", "instanceof"]; +const TERNARY_OPERATOR = ["?:"]; +const COALESCE_OPERATOR = ["??"]; +const ALL_OPERATORS = [].concat( + ARITHMETIC_OPERATORS, + BITWISE_OPERATORS, + COMPARISON_OPERATORS, + LOGICAL_OPERATORS, + RELATIONAL_OPERATORS, + TERNARY_OPERATOR, + COALESCE_OPERATOR, +); +const DEFAULT_GROUPS = [ + ARITHMETIC_OPERATORS, + BITWISE_OPERATORS, + COMPARISON_OPERATORS, + LOGICAL_OPERATORS, + RELATIONAL_OPERATORS, +]; +const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u; + +/** + * Normalizes options. + * @param {Object|undefined} options A options object to normalize. + * @returns {Object} Normalized option object. + */ +function normalizeOptions(options = {}) { + const hasGroups = options.groups && options.groups.length > 0; + const groups = hasGroups ? options.groups : DEFAULT_GROUPS; + const allowSamePrecedence = options.allowSamePrecedence !== false; + + return { + groups, + allowSamePrecedence, + }; +} + +/** + * Checks whether any group which includes both given operator exists or not. + * @param {Array} groups A list of groups to check. + * @param {string} left An operator. + * @param {string} right Another operator. + * @returns {boolean} `true` if such group existed. + */ +function includesBothInAGroup(groups, left, right) { + return groups.some(group => group.includes(left) && group.includes(right)); +} + +/** + * Checks whether the given node is a conditional expression and returns the test node else the left node. + * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node. + * This parent node can be BinaryExpression, LogicalExpression + * , or a ConditionalExpression node + * @returns {ASTNode} node the appropriate node(left or test). + */ +function getChildNode(node) { + return node.type === "ConditionalExpression" ? node.test : node.left; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-mixed-operators", + url: "https://eslint.style/rules/no-mixed-operators", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: "Disallow mixed binary operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-mixed-operators", + }, + + schema: [ + { + type: "object", + properties: { + groups: { + type: "array", + items: { + type: "array", + items: { enum: ALL_OPERATORS }, + minItems: 2, + uniqueItems: true, + }, + uniqueItems: true, + }, + allowSamePrecedence: { + type: "boolean", + default: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedMixedOperator: + "Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const options = normalizeOptions(context.options[0]); + + /** + * Checks whether a given node should be ignored by options or not. + * @param {ASTNode} node A node to check. This is a BinaryExpression + * node or a LogicalExpression node. This parent node is one of + * them, too. + * @returns {boolean} `true` if the node should be ignored. + */ + function shouldIgnore(node) { + const a = node; + const b = node.parent; + + return ( + !includesBothInAGroup( + options.groups, + a.operator, + b.type === "ConditionalExpression" ? "?:" : b.operator, + ) || + (options.allowSamePrecedence && + astUtils.getPrecedence(a) === astUtils.getPrecedence(b)) + ); + } + + /** + * Checks whether the operator of a given node is mixed with parent + * node's operator or not. + * @param {ASTNode} node A node to check. This is a BinaryExpression + * node or a LogicalExpression node. This parent node is one of + * them, too. + * @returns {boolean} `true` if the node was mixed. + */ + function isMixedWithParent(node) { + return ( + node.operator !== node.parent.operator && + !astUtils.isParenthesised(sourceCode, node) + ); + } + + /** + * Gets the operator token of a given node. + * @param {ASTNode} node A node to check. This is a BinaryExpression + * node or a LogicalExpression node. + * @returns {Token} The operator token of the node. + */ + function getOperatorToken(node) { + return sourceCode.getTokenAfter( + getChildNode(node), + astUtils.isNotClosingParenToken, + ); + } + + /** + * Reports both the operator of a given node and the operator of the + * parent node. + * @param {ASTNode} node A node to check. This is a BinaryExpression + * node or a LogicalExpression node. This parent node is one of + * them, too. + * @returns {void} + */ + function reportBothOperators(node) { + const parent = node.parent; + const left = getChildNode(parent) === node ? node : parent; + const right = getChildNode(parent) !== node ? node : parent; + const data = { + leftOperator: left.operator || "?:", + rightOperator: right.operator || "?:", + }; + + context.report({ + node: left, + loc: getOperatorToken(left).loc, + messageId: "unexpectedMixedOperator", + data, + }); + context.report({ + node: right, + loc: getOperatorToken(right).loc, + messageId: "unexpectedMixedOperator", + data, + }); + } + + /** + * Checks between the operator of this node and the operator of the + * parent node. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function check(node) { + if ( + TARGET_NODE_TYPE.test(node.parent.type) && + isMixedWithParent(node) && + !shouldIgnore(node) + ) { + reportBothOperators(node); + } + } + + return { + BinaryExpression: check, + LogicalExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-requires.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-requires.js new file mode 100644 index 00000000..0d8bb558 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-requires.js @@ -0,0 +1,267 @@ +/** + * @fileoverview Rule to enforce grouped require statements for Node.JS + * @author Raphael Pigulla + * @deprecated in ESLint v7.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-mixed-requires", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-mixed-requires.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: + "Disallow `require` calls to be mixed with regular variable declarations", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-mixed-requires", + }, + + schema: [ + { + oneOf: [ + { + type: "boolean", + }, + { + type: "object", + properties: { + grouping: { + type: "boolean", + }, + allowCall: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + noMixRequire: "Do not mix 'require' and other declarations.", + noMixCoreModuleFileComputed: + "Do not mix core, module, file and computed requires.", + }, + }, + + create(context) { + const options = context.options[0]; + let grouping = false, + allowCall = false; + + if (typeof options === "object") { + grouping = options.grouping; + allowCall = options.allowCall; + } else { + grouping = !!options; + } + + /** + * Returns the list of built-in modules. + * @returns {string[]} An array of built-in Node.js modules. + */ + function getBuiltinModules() { + /* + * This list is generated using: + * `require("repl")._builtinLibs.concat('repl').sort()` + * This particular list is as per nodejs v0.12.2 and iojs v0.7.1 + */ + return [ + "assert", + "buffer", + "child_process", + "cluster", + "crypto", + "dgram", + "dns", + "domain", + "events", + "fs", + "http", + "https", + "net", + "os", + "path", + "punycode", + "querystring", + "readline", + "repl", + "smalloc", + "stream", + "string_decoder", + "tls", + "tty", + "url", + "util", + "v8", + "vm", + "zlib", + ]; + } + + const BUILTIN_MODULES = getBuiltinModules(); + + const DECL_REQUIRE = "require", + DECL_UNINITIALIZED = "uninitialized", + DECL_OTHER = "other"; + + const REQ_CORE = "core", + REQ_FILE = "file", + REQ_MODULE = "module", + REQ_COMPUTED = "computed"; + + /** + * Determines the type of a declaration statement. + * @param {ASTNode} initExpression The init node of the VariableDeclarator. + * @returns {string} The type of declaration represented by the expression. + */ + function getDeclarationType(initExpression) { + if (!initExpression) { + // "var x;" + return DECL_UNINITIALIZED; + } + + if ( + initExpression.type === "CallExpression" && + initExpression.callee.type === "Identifier" && + initExpression.callee.name === "require" + ) { + // "var x = require('util');" + return DECL_REQUIRE; + } + if ( + allowCall && + initExpression.type === "CallExpression" && + initExpression.callee.type === "CallExpression" + ) { + // "var x = require('diagnose')('sub-module');" + return getDeclarationType(initExpression.callee); + } + if (initExpression.type === "MemberExpression") { + // "var x = require('glob').Glob;" + return getDeclarationType(initExpression.object); + } + + // "var x = 42;" + return DECL_OTHER; + } + + /** + * Determines the type of module that is loaded via require. + * @param {ASTNode} initExpression The init node of the VariableDeclarator. + * @returns {string} The module type. + */ + function inferModuleType(initExpression) { + if (initExpression.type === "MemberExpression") { + // "var x = require('glob').Glob;" + return inferModuleType(initExpression.object); + } + if (initExpression.arguments.length === 0) { + // "var x = require();" + return REQ_COMPUTED; + } + + const arg = initExpression.arguments[0]; + + if (arg.type !== "Literal" || typeof arg.value !== "string") { + // "var x = require(42);" + return REQ_COMPUTED; + } + + if (BUILTIN_MODULES.includes(arg.value)) { + // "var fs = require('fs');" + return REQ_CORE; + } + if (/^\.{0,2}\//u.test(arg.value)) { + // "var utils = require('./utils');" + return REQ_FILE; + } + + // "var async = require('async');" + return REQ_MODULE; + } + + /** + * Check if the list of variable declarations is mixed, i.e. whether it + * contains both require and other declarations. + * @param {ASTNode} declarations The list of VariableDeclarators. + * @returns {boolean} True if the declarations are mixed, false if not. + */ + function isMixed(declarations) { + const contains = {}; + + declarations.forEach(declaration => { + const type = getDeclarationType(declaration.init); + + contains[type] = true; + }); + + return !!( + contains[DECL_REQUIRE] && + (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER]) + ); + } + + /** + * Check if all require declarations in the given list are of the same + * type. + * @param {ASTNode} declarations The list of VariableDeclarators. + * @returns {boolean} True if the declarations are grouped, false if not. + */ + function isGrouped(declarations) { + const found = {}; + + declarations.forEach(declaration => { + if (getDeclarationType(declaration.init) === DECL_REQUIRE) { + found[inferModuleType(declaration.init)] = true; + } + }); + + return Object.keys(found).length <= 1; + } + + return { + VariableDeclaration(node) { + if (isMixed(node.declarations)) { + context.report({ + node, + messageId: "noMixRequire", + }); + } else if (grouping && !isGrouped(node.declarations)) { + context.report({ + node, + messageId: "noMixCoreModuleFileComputed", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js new file mode 100644 index 00000000..c6f16752 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js @@ -0,0 +1,146 @@ +/** + * @fileoverview Disallow mixed spaces and tabs for indentation + * @author Jary Niebur + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-mixed-spaces-and-tabs", + url: "https://eslint.style/rules/no-mixed-spaces-and-tabs", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow mixed spaces and tabs for indentation", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs", + }, + + schema: [ + { + enum: ["smart-tabs", true, false], + }, + ], + + messages: { + mixedSpacesAndTabs: "Mixed spaces and tabs.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + let smartTabs; + + switch (context.options[0]) { + case true: // Support old syntax, maybe add deprecation warning here + case "smart-tabs": + smartTabs = true; + break; + default: + smartTabs = false; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + "Program:exit"(node) { + const lines = sourceCode.lines, + comments = sourceCode.getAllComments(), + ignoredCommentLines = new Set(); + + // Add all lines except the first ones. + comments.forEach(comment => { + for ( + let i = comment.loc.start.line + 1; + i <= comment.loc.end.line; + i++ + ) { + ignoredCommentLines.add(i); + } + }); + + /* + * At least one space followed by a tab + * or the reverse before non-tab/-space + * characters begin. + */ + let regex = /^(?=( +|\t+))\1(?:\t| )/u; + + if (smartTabs) { + /* + * At least one space followed by a tab + * before non-tab/-space characters begin. + */ + // eslint-disable-next-line regexp/no-empty-lookarounds-assertion -- False positive + regex = /^(?=(\t*))\1(?=( +))\2\t/u; + } + + lines.forEach((line, i) => { + const match = regex.exec(line); + + if (match) { + const lineNumber = i + 1; + const loc = { + start: { + line: lineNumber, + column: match[0].length - 2, + }, + end: { + line: lineNumber, + column: match[0].length, + }, + }; + + if (!ignoredCommentLines.has(lineNumber)) { + const containingNode = + sourceCode.getNodeByRangeIndex( + sourceCode.getIndexFromLoc(loc.start), + ); + + if (!( + containingNode && + ["Literal", "TemplateElement"].includes( + containingNode.type, + ) + )) { + context.report({ + node, + loc, + messageId: "mixedSpacesAndTabs", + }); + } + } + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-assign.js new file mode 100644 index 00000000..b4d6ddb4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-assign.js @@ -0,0 +1,66 @@ +/** + * @fileoverview Rule to check use of chained assignment expressions + * @author Stewart Rand + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + ignoreNonDeclaration: false, + }, + ], + + docs: { + description: "Disallow use of chained assignment expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-multi-assign", + }, + + schema: [ + { + type: "object", + properties: { + ignoreNonDeclaration: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedChain: "Unexpected chained assignment.", + }, + }, + + create(context) { + const [{ ignoreNonDeclaration }] = context.options; + const selectors = [ + "VariableDeclarator > AssignmentExpression.init", + "PropertyDefinition > AssignmentExpression.value", + ]; + + if (!ignoreNonDeclaration) { + selectors.push("AssignmentExpression > AssignmentExpression.right"); + } + + return { + [selectors](node) { + context.report({ + node, + messageId: "unexpectedChain", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-spaces.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-spaces.js new file mode 100644 index 00000000..93704760 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-spaces.js @@ -0,0 +1,179 @@ +/** + * @fileoverview Disallow use of multiple spaces. + * @author Nicholas C. Zakas + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-multi-spaces", + url: "https://eslint.style/rules/no-multi-spaces", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow multiple spaces", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-multi-spaces", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + exceptions: { + type: "object", + patternProperties: { + "^([A-Z][a-z]*)+$": { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ignoreEOLComments: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + multipleSpaces: "Multiple spaces found before '{{displayValue}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const options = context.options[0] || {}; + const ignoreEOLComments = options.ignoreEOLComments; + const exceptions = Object.assign( + { Property: true }, + options.exceptions, + ); + const hasExceptions = Object.keys(exceptions).some( + key => exceptions[key], + ); + + /** + * Formats value of given comment token for error message by truncating its length. + * @param {Token} token comment token + * @returns {string} formatted value + * @private + */ + function formatReportedCommentValue(token) { + const valueLines = token.value.split("\n"); + const value = valueLines[0]; + const formattedValue = `${value.slice(0, 12)}...`; + + return valueLines.length === 1 && value.length <= 12 + ? value + : formattedValue; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program() { + sourceCode.tokensAndComments.forEach( + (leftToken, leftIndex, tokensAndComments) => { + if (leftIndex === tokensAndComments.length - 1) { + return; + } + const rightToken = tokensAndComments[leftIndex + 1]; + + // Ignore tokens that don't have 2 spaces between them or are on different lines + if ( + !sourceCode.text + .slice(leftToken.range[1], rightToken.range[0]) + .includes(" ") || + leftToken.loc.end.line < rightToken.loc.start.line + ) { + return; + } + + // Ignore comments that are the last token on their line if `ignoreEOLComments` is active. + if ( + ignoreEOLComments && + astUtils.isCommentToken(rightToken) && + (leftIndex === tokensAndComments.length - 2 || + rightToken.loc.end.line < + tokensAndComments[leftIndex + 2].loc.start + .line) + ) { + return; + } + + // Ignore tokens that are in a node in the "exceptions" object + if (hasExceptions) { + const parentNode = sourceCode.getNodeByRangeIndex( + rightToken.range[0] - 1, + ); + + if (parentNode && exceptions[parentNode.type]) { + return; + } + } + + let displayValue; + + if (rightToken.type === "Block") { + displayValue = `/*${formatReportedCommentValue(rightToken)}*/`; + } else if (rightToken.type === "Line") { + displayValue = `//${formatReportedCommentValue(rightToken)}`; + } else { + displayValue = rightToken.value; + } + + context.report({ + node: rightToken, + loc: { + start: leftToken.loc.end, + end: rightToken.loc.start, + }, + messageId: "multipleSpaces", + data: { displayValue }, + fix: fixer => + fixer.replaceTextRange( + [leftToken.range[1], rightToken.range[0]], + " ", + ), + }); + }, + ); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-str.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-str.js new file mode 100644 index 00000000..4258dc2e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multi-str.js @@ -0,0 +1,67 @@ +/** + * @fileoverview Rule to flag when using multiline strings + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow multiline strings", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-multi-str", + }, + + schema: [], + + messages: { + multilineString: + "Multiline support is limited to browsers supporting ES5 only.", + }, + }, + + create(context) { + /** + * Determines if a given node is part of JSX syntax. + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node is a JSX node, false if not. + * @private + */ + function isJSXElement(node) { + return node.type.indexOf("JSX") === 0; + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + Literal(node) { + if ( + astUtils.LINEBREAK_MATCHER.test(node.raw) && + !isJSXElement(node.parent) + ) { + context.report({ + node, + messageId: "multilineString", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multiple-empty-lines.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multiple-empty-lines.js new file mode 100644 index 00000000..1f6d7264 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-multiple-empty-lines.js @@ -0,0 +1,210 @@ +/** + * @fileoverview Disallows multiple blank lines. + * implementation adapted from the no-trailing-spaces rule. + * @author Greg Cochard + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-multiple-empty-lines", + url: "https://eslint.style/rules/no-multiple-empty-lines", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow multiple empty lines", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + max: { + type: "integer", + minimum: 0, + }, + maxEOF: { + type: "integer", + minimum: 0, + }, + maxBOF: { + type: "integer", + minimum: 0, + }, + }, + required: ["max"], + additionalProperties: false, + }, + ], + + messages: { + blankBeginningOfFile: + "Too many blank lines at the beginning of file. Max of {{max}} allowed.", + blankEndOfFile: + "Too many blank lines at the end of file. Max of {{max}} allowed.", + consecutiveBlank: + "More than {{max}} blank {{pluralizedLines}} not allowed.", + }, + }, + + create(context) { + // Use options.max or 2 as default + let max = 2, + maxEOF = max, + maxBOF = max; + + if (context.options.length) { + max = context.options[0].max; + maxEOF = + typeof context.options[0].maxEOF !== "undefined" + ? context.options[0].maxEOF + : max; + maxBOF = + typeof context.options[0].maxBOF !== "undefined" + ? context.options[0].maxBOF + : max; + } + + const sourceCode = context.sourceCode; + + // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue + const allLines = + sourceCode.lines.at(-1) === "" + ? sourceCode.lines.slice(0, -1) + : sourceCode.lines; + const templateLiteralLines = new Set(); + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + TemplateLiteral(node) { + node.quasis.forEach(literalPart => { + // Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines. + for ( + let ignoredLine = literalPart.loc.start.line; + ignoredLine < literalPart.loc.end.line; + ignoredLine++ + ) { + templateLiteralLines.add(ignoredLine); + } + }); + }, + "Program:exit"(node) { + return ( + allLines + + // Given a list of lines, first get a list of line numbers that are non-empty. + .reduce((nonEmptyLineNumbers, line, index) => { + if ( + line.trim() || + templateLiteralLines.has(index + 1) + ) { + nonEmptyLineNumbers.push(index + 1); + } + return nonEmptyLineNumbers; + }, []) + + // Add a value at the end to allow trailing empty lines to be checked. + .concat(allLines.length + 1) + + // Given two line numbers of non-empty lines, report the lines between if the difference is too large. + .reduce((lastLineNumber, lineNumber) => { + let messageId, maxAllowed; + + if (lastLineNumber === 0) { + messageId = "blankBeginningOfFile"; + maxAllowed = maxBOF; + } else if (lineNumber === allLines.length + 1) { + messageId = "blankEndOfFile"; + maxAllowed = maxEOF; + } else { + messageId = "consecutiveBlank"; + maxAllowed = max; + } + + if (lineNumber - lastLineNumber - 1 > maxAllowed) { + context.report({ + node, + loc: { + start: { + line: + lastLineNumber + maxAllowed + 1, + column: 0, + }, + end: { line: lineNumber, column: 0 }, + }, + messageId, + data: { + max: maxAllowed, + pluralizedLines: + maxAllowed === 1 ? "line" : "lines", + }, + fix(fixer) { + const rangeStart = + sourceCode.getIndexFromLoc({ + line: lastLineNumber + 1, + column: 0, + }); + + /* + * The end of the removal range is usually the start index of the next line. + * However, at the end of the file there is no next line, so the end of the + * range is just the length of the text. + */ + const lineNumberAfterRemovedLines = + lineNumber - maxAllowed; + const rangeEnd = + lineNumberAfterRemovedLines <= + allLines.length + ? sourceCode.getIndexFromLoc({ + line: lineNumberAfterRemovedLines, + column: 0, + }) + : sourceCode.text.length; + + return fixer.removeRange([ + rangeStart, + rangeEnd, + ]); + }, + }); + } + + return lineNumber; + }, 0) + ); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-native-reassign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-native-reassign.js new file mode 100644 index 00000000..f4eef063 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-native-reassign.js @@ -0,0 +1,114 @@ +/** + * @fileoverview Rule to disallow assignments to native objects or read-only global variables + * @author Ilya Volodin + * @deprecated in ESLint v3.3.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow assignments to native objects or read-only global variables", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-native-reassign", + }, + + deprecated: { + message: "Renamed rule.", + url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules", + deprecatedSince: "3.3.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "no-global-assign", + url: "https://eslint.org/docs/rules/no-global-assign", + }, + }, + ], + }, + + schema: [ + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { type: "string" }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + nativeReassign: + "Read-only global '{{name}}' should not be modified.", + }, + }, + + create(context) { + const config = context.options[0]; + const exceptions = (config && config.exceptions) || []; + const sourceCode = context.sourceCode; + + /** + * Reports write references. + * @param {Reference} reference A reference to check. + * @param {number} index The index of the reference in the references. + * @param {Reference[]} references The array that the reference belongs to. + * @returns {void} + */ + function checkReference(reference, index, references) { + const identifier = reference.identifier; + + if ( + reference.init === false && + reference.isWrite() && + /* + * Destructuring assignments can have multiple default value, + * so possibly there are multiple writeable references for the same identifier. + */ + (index === 0 || references[index - 1].identifier !== identifier) + ) { + context.report({ + node: identifier, + messageId: "nativeReassign", + data: identifier, + }); + } + } + + /** + * Reports write references if a given variable is read-only builtin. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + if ( + variable.writeable === false && + !exceptions.includes(variable.name) + ) { + variable.references.forEach(checkReference); + } + } + + return { + Program(node) { + const globalScope = sourceCode.getScope(node); + + globalScope.variables.forEach(checkVariable); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-condition.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-condition.js new file mode 100644 index 00000000..33c150e8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-condition.js @@ -0,0 +1,100 @@ +/** + * @fileoverview Rule to disallow a negated condition + * @author Alberto Rodríguez + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow negated conditions", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-negated-condition", + }, + + schema: [], + + messages: { + unexpectedNegated: "Unexpected negated condition.", + }, + }, + + create(context) { + /** + * Determines if a given node is an if-else without a condition on the else + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node has an else without an if. + * @private + */ + function hasElseWithoutCondition(node) { + return node.alternate && node.alternate.type !== "IfStatement"; + } + + /** + * Determines if a given node is a negated unary expression + * @param {Object} test The test object to check. + * @returns {boolean} True if the node is a negated unary expression. + * @private + */ + function isNegatedUnaryExpression(test) { + return test.type === "UnaryExpression" && test.operator === "!"; + } + + /** + * Determines if a given node is a negated binary expression + * @param {Test} test The test to check. + * @returns {boolean} True if the node is a negated binary expression. + * @private + */ + function isNegatedBinaryExpression(test) { + return ( + test.type === "BinaryExpression" && + (test.operator === "!=" || test.operator === "!==") + ); + } + + /** + * Determines if a given node has a negated if expression + * @param {ASTNode} node The node to check. + * @returns {boolean} True if the node has a negated if expression. + * @private + */ + function isNegatedIf(node) { + return ( + isNegatedUnaryExpression(node.test) || + isNegatedBinaryExpression(node.test) + ); + } + + return { + IfStatement(node) { + if (!hasElseWithoutCondition(node)) { + return; + } + + if (isNegatedIf(node)) { + context.report({ + node, + messageId: "unexpectedNegated", + }); + } + }, + ConditionalExpression(node) { + if (isNegatedIf(node)) { + context.report({ + node, + messageId: "unexpectedNegated", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-in-lhs.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-in-lhs.js new file mode 100644 index 00000000..f003cb30 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-negated-in-lhs.js @@ -0,0 +1,59 @@ +/** + * @fileoverview A rule to disallow negated left operands of the `in` operator + * @author Michael Ficarra + * @deprecated in ESLint v3.3.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow negating the left operand in `in` expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-negated-in-lhs", + }, + + deprecated: { + message: "Renamed rule.", + url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules", + deprecatedSince: "3.3.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "no-unsafe-negation", + url: "https://eslint.org/docs/rules/no-unsafe-negation", + }, + }, + ], + }, + schema: [], + + messages: { + negatedLHS: "The 'in' expression's left operand is negated.", + }, + }, + + create(context) { + return { + BinaryExpression(node) { + if ( + node.operator === "in" && + node.left.type === "UnaryExpression" && + node.left.operator === "!" + ) { + context.report({ node, messageId: "negatedLHS" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nested-ternary.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nested-ternary.js new file mode 100644 index 00000000..8e5dbb78 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nested-ternary.js @@ -0,0 +1,46 @@ +/** + * @fileoverview Rule to flag nested ternary expressions + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow nested ternary expressions", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-nested-ternary", + }, + + schema: [], + + messages: { + noNestedTernary: "Do not nest ternary expressions.", + }, + }, + + create(context) { + return { + ConditionalExpression(node) { + if ( + node.alternate.type === "ConditionalExpression" || + node.consequent.type === "ConditionalExpression" + ) { + context.report({ + node, + messageId: "noNestedTernary", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-func.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-func.js new file mode 100644 index 00000000..760dc640 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-func.js @@ -0,0 +1,96 @@ +/** + * @fileoverview Rule to flag when using new Function + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const callMethods = new Set(["apply", "bind", "call"]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `new` operators with the `Function` object", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new-func", + }, + + schema: [], + + messages: { + noFunctionConstructor: "The Function constructor is eval.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + const variable = globalScope.set.get("Function"); + + if (variable && variable.defs.length === 0) { + variable.references.forEach(ref => { + const idNode = ref.identifier; + const { parent } = idNode; + let evalNode; + + if (parent) { + if ( + idNode === parent.callee && + (parent.type === "NewExpression" || + parent.type === "CallExpression") + ) { + evalNode = parent; + } else if ( + parent.type === "MemberExpression" && + idNode === parent.object && + callMethods.has( + astUtils.getStaticPropertyName(parent), + ) + ) { + const maybeCallee = + parent.parent.type === "ChainExpression" + ? parent.parent + : parent; + + if ( + maybeCallee.parent.type === + "CallExpression" && + maybeCallee.parent.callee === maybeCallee + ) { + evalNode = maybeCallee.parent; + } + } + } + + if (evalNode) { + context.report({ + node: evalNode, + messageId: "noFunctionConstructor", + }); + } + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js new file mode 100644 index 00000000..0ae892cd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js @@ -0,0 +1,70 @@ +/** + * @fileoverview Rule to disallow use of the new operator with global non-constructor functions + * @author Sosuke Suzuki + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const nonConstructorGlobalFunctionNames = ["Symbol", "BigInt"]; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow `new` operators with global non-constructor functions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor", + }, + + schema: [], + + messages: { + noNewNonconstructor: + "`{{name}}` cannot be called as a constructor.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + for (const nonConstructorName of nonConstructorGlobalFunctionNames) { + const variable = globalScope.set.get(nonConstructorName); + + if (variable && variable.defs.length === 0) { + variable.references.forEach(ref => { + const idNode = ref.identifier; + const parent = idNode.parent; + + if ( + parent && + parent.type === "NewExpression" && + parent.callee === idNode + ) { + context.report({ + node: idNode, + messageId: "noNewNonconstructor", + data: { name: nonConstructorName }, + }); + } + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-object.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-object.js new file mode 100644 index 00000000..f18bf974 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-object.js @@ -0,0 +1,76 @@ +/** + * @fileoverview A rule to disallow calls to the Object constructor + * @author Matt DuVall + * @deprecated in ESLint v8.50.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `Object` constructors", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new-object", + }, + + deprecated: { + message: + "The new rule flags more situations where object literal syntax can be used, and it does not report a problem when the `Object` constructor is invoked with an argument.", + url: "https://eslint.org/blog/2023/09/eslint-v8.50.0-released/", + deprecatedSince: "8.50.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "no-object-constructor", + url: "https://eslint.org/docs/rules/no-object-constructor", + }, + }, + ], + }, + + schema: [], + + messages: { + preferLiteral: "The object literal notation {} is preferable.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + NewExpression(node) { + const variable = astUtils.getVariableByName( + sourceCode.getScope(node), + node.callee.name, + ); + + if (variable && variable.identifiers.length > 0) { + return; + } + + if (node.callee.name === "Object") { + context.report({ + node, + messageId: "preferLiteral", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-require.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-require.js new file mode 100644 index 00000000..09d136c8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-require.js @@ -0,0 +1,67 @@ +/** + * @fileoverview Rule to disallow use of new operator with the `require` function + * @author Wil Moore III + * @deprecated in ESLint v7.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-new-require", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-new-require.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow `new` operators with calls to `require`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new-require", + }, + + schema: [], + + messages: { + noNewRequire: "Unexpected use of new with require.", + }, + }, + + create(context) { + return { + NewExpression(node) { + if ( + node.callee.type === "Identifier" && + node.callee.name === "require" + ) { + context.report({ + node, + messageId: "noNewRequire", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-symbol.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-symbol.js new file mode 100644 index 00000000..838f502f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-symbol.js @@ -0,0 +1,74 @@ +/** + * @fileoverview Rule to disallow use of the new operator with the `Symbol` object + * @author Alberto Rodríguez + * @deprecated in ESLint v9.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow `new` operators with the `Symbol` object", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new-symbol", + }, + + deprecated: { + message: "The rule was replaced with a more general rule.", + url: "https://eslint.org/docs/latest/use/migrate-to-9.0.0#eslint-recommended", + deprecatedSince: "9.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + rule: { + name: "no-new-native-nonconstructor", + url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor", + }, + }, + ], + }, + + schema: [], + + messages: { + noNewSymbol: "`Symbol` cannot be called as a constructor.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + const variable = globalScope.set.get("Symbol"); + + if (variable && variable.defs.length === 0) { + variable.references.forEach(ref => { + const idNode = ref.identifier; + const parent = idNode.parent; + + if ( + parent && + parent.type === "NewExpression" && + parent.callee === idNode + ) { + context.report({ + node: idNode, + messageId: "noNewSymbol", + }); + } + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-wrappers.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-wrappers.js new file mode 100644 index 00000000..84025dbf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new-wrappers.js @@ -0,0 +1,62 @@ +/** + * @fileoverview Rule to flag when using constructor for wrapper objects + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getVariableByName } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `new` operators with the `String`, `Number`, and `Boolean` objects", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new-wrappers", + }, + + schema: [], + + messages: { + noConstructor: "Do not use {{fn}} as a constructor.", + }, + }, + + create(context) { + const { sourceCode } = context; + + return { + NewExpression(node) { + const wrapperObjects = ["String", "Number", "Boolean"]; + const { name } = node.callee; + + if (wrapperObjects.includes(name)) { + const variable = getVariableByName( + sourceCode.getScope(node), + name, + ); + + if (variable && variable.identifiers.length === 0) { + context.report({ + node, + messageId: "noConstructor", + data: { fn: name }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new.js new file mode 100644 index 00000000..8f91835b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-new.js @@ -0,0 +1,42 @@ +/** + * @fileoverview Rule to flag statements with function invocation preceded by + * "new" and not part of assignment + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `new` operators outside of assignments or comparisons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-new", + }, + + schema: [], + + messages: { + noNewStatement: "Do not use 'new' for side effects.", + }, + }, + + create(context) { + return { + "ExpressionStatement > NewExpression"(node) { + context.report({ + node: node.parent, + messageId: "noNewStatement", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js new file mode 100644 index 00000000..d09b7994 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js @@ -0,0 +1,176 @@ +/** + * @fileoverview Rule to disallow `\8` and `\9` escape sequences in string literals. + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @import { SourceRange } from "@eslint/core"; + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const QUICK_TEST_REGEX = /\\[89]/u; + +/** + * Returns unicode escape sequence that represents the given character. + * @param {string} character A single code unit. + * @returns {string} "\uXXXX" sequence. + */ +function getUnicodeEscape(character) { + return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `\\8` and `\\9` escape sequences in string literals", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.", + + // suggestions + refactor: + "Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.", + escapeBackslash: + "Replace '{{original}}' with '{{replacement}}' to include the actual backslash character.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Creates a new Suggestion object. + * @param {string} messageId "refactor" or "escapeBackslash". + * @param {SourceRange} range The range to replace. + * @param {string} replacement New text for the range. + * @returns {Object} Suggestion + */ + function createSuggestion(messageId, range, replacement) { + return { + messageId, + data: { + original: sourceCode.getText().slice(...range), + replacement, + }, + fix(fixer) { + return fixer.replaceTextRange(range, replacement); + }, + }; + } + + return { + Literal(node) { + if (typeof node.value !== "string") { + return; + } + + if (!QUICK_TEST_REGEX.test(node.raw)) { + return; + } + + const regex = + /(?:[^\\]|(?\\.))*?(?\\[89])/suy; + let match; + + while ((match = regex.exec(node.raw))) { + const { previousEscape, decimalEscape } = match.groups; + const decimalEscapeRangeEnd = + node.range[0] + match.index + match[0].length; + const decimalEscapeRangeStart = + decimalEscapeRangeEnd - decimalEscape.length; + const decimalEscapeRange = [ + decimalEscapeRangeStart, + decimalEscapeRangeEnd, + ]; + const suggest = []; + + // When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape` + if (previousEscape === "\\0") { + /* + * Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8". + * Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing + * an octal escape while fixing a decimal escape, we provide different suggestions. + */ + suggest.push( + createSuggestion( + // "\0\8" -> "\u00008" + "refactor", + [ + decimalEscapeRangeStart - + previousEscape.length, + decimalEscapeRangeEnd, + ], + `${getUnicodeEscape("\0")}${decimalEscape[1]}`, + ), + createSuggestion( + // "\8" -> "\u0038" + "refactor", + decimalEscapeRange, + getUnicodeEscape(decimalEscape[1]), + ), + ); + } else { + suggest.push( + createSuggestion( + // "\8" -> "8" + "refactor", + decimalEscapeRange, + decimalEscape[1], + ), + ); + } + + suggest.push( + createSuggestion( + // "\8" -> "\\8" + "escapeBackslash", + decimalEscapeRange, + `\\${decimalEscape}`, + ), + ); + + context.report({ + node, + loc: { + start: sourceCode.getLocFromIndex( + decimalEscapeRangeStart, + ), + end: sourceCode.getLocFromIndex( + decimalEscapeRangeEnd, + ), + }, + messageId: "decimalEscape", + data: { + decimalEscape, + }, + suggest, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-obj-calls.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-obj-calls.js new file mode 100644 index 00000000..b999eefb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-obj-calls.js @@ -0,0 +1,106 @@ +/** + * @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function + * @author James Allardice + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + CALL, + CONSTRUCT, + ReferenceTracker, +} = require("@eslint-community/eslint-utils"); +const getPropertyName = require("./utils/ast-utils").getStaticPropertyName; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const nonCallableGlobals = [ + "Atomics", + "JSON", + "Math", + "Reflect", + "Intl", + "Temporal", +]; + +/** + * Returns the name of the node to report + * @param {ASTNode} node A node to report + * @returns {string} name to report + */ +function getReportNodeName(node) { + if (node.type === "ChainExpression") { + return getReportNodeName(node.expression); + } + if (node.type === "MemberExpression") { + return getPropertyName(node); + } + return node.name; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow calling global object properties as functions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-obj-calls", + }, + + schema: [], + + messages: { + unexpectedCall: "'{{name}}' is not a function.", + unexpectedRefCall: + "'{{name}}' is reference to '{{ref}}', which is not a function.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const traceMap = {}; + + for (const g of nonCallableGlobals) { + traceMap[g] = { + [CALL]: true, + [CONSTRUCT]: true, + }; + } + + for (const { + node: refNode, + path, + } of tracker.iterateGlobalReferences(traceMap)) { + const name = getReportNodeName(refNode.callee); + const ref = path[0]; + const messageId = + name === ref ? "unexpectedCall" : "unexpectedRefCall"; + + context.report({ + node: refNode, + messageId, + data: { name, ref }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-object-constructor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-object-constructor.js new file mode 100644 index 00000000..fffa6122 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-object-constructor.js @@ -0,0 +1,124 @@ +/** + * @fileoverview Rule to disallow calls to the `Object` constructor without an argument + * @author Francesco Trotta + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + getVariableByName, + isArrowToken, + isStartOfExpressionStatement, + needsPrecedingSemicolon, +} = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow calls to the `Object` constructor without an argument", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-object-constructor", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + preferLiteral: "The object literal notation {} is preferable.", + useLiteral: "Replace with '{{replacement}}'.", + useLiteralAfterSemicolon: + "Replace with '{{replacement}}', add preceding semicolon.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Determines whether or not an object literal that replaces a specified node needs to be enclosed in parentheses. + * @param {ASTNode} node The node to be replaced. + * @returns {boolean} Whether or not parentheses around the object literal are required. + */ + function needsParentheses(node) { + if (isStartOfExpressionStatement(node)) { + return true; + } + + const prevToken = sourceCode.getTokenBefore(node); + + if (prevToken && isArrowToken(prevToken)) { + return true; + } + + return false; + } + + /** + * Reports on nodes where the `Object` constructor is called without arguments. + * @param {ASTNode} node The node to evaluate. + * @returns {void} + */ + function check(node) { + if ( + node.callee.type !== "Identifier" || + node.callee.name !== "Object" || + node.arguments.length + ) { + return; + } + + const variable = getVariableByName( + sourceCode.getScope(node), + "Object", + ); + + if (variable && variable.identifiers.length === 0) { + let replacement; + let fixText; + let messageId = "useLiteral"; + + if (needsParentheses(node)) { + replacement = "({})"; + if (needsPrecedingSemicolon(sourceCode, node)) { + fixText = ";({})"; + messageId = "useLiteralAfterSemicolon"; + } else { + fixText = "({})"; + } + } else { + replacement = fixText = "{}"; + } + + context.report({ + node, + messageId: "preferLiteral", + suggest: [ + { + messageId, + data: { replacement }, + fix: fixer => fixer.replaceText(node, fixText), + }, + ], + }); + } + } + + return { + CallExpression: check, + NewExpression: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal-escape.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal-escape.js new file mode 100644 index 00000000..975b3085 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal-escape.js @@ -0,0 +1,53 @@ +/** + * @fileoverview Rule to flag octal escape sequences in string literals. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow octal escape sequences in string literals", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-octal-escape", + }, + + schema: [], + + messages: { + octalEscapeSequence: + "Don't use octal: '\\{{sequence}}'. Use '\\u....' instead.", + }, + }, + + create(context) { + return { + Literal(node) { + if (typeof node.value !== "string") { + return; + } + + // \0 represents a valid NULL character if it isn't followed by a digit. + const match = node.raw.match( + /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su, + ); + + if (match) { + context.report({ + node, + messageId: "octalEscapeSequence", + data: { sequence: match[1] }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal.js new file mode 100644 index 00000000..e5ea9bda --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-octal.js @@ -0,0 +1,42 @@ +/** + * @fileoverview Rule to flag when initializing octal literal + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow octal literals", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-octal", + }, + + schema: [], + + messages: { + noOctal: "Octal literals should not be used.", + }, + }, + + create(context) { + return { + Literal(node) { + if (typeof node.value === "number" && /^0\d/u.test(node.raw)) { + context.report({ + node, + messageId: "noOctal", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-param-reassign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-param-reassign.js new file mode 100644 index 00000000..ec22030a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-param-reassign.js @@ -0,0 +1,248 @@ +/** + * @fileoverview Disallow reassigning function parameters. + * @author Nat Burns + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const stopNodePattern = + /(?:Statement|Declaration|Function(?:Expression)?|Program)$/u; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow reassigning function parameters", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-param-reassign", + }, + + schema: [ + { + oneOf: [ + { + type: "object", + properties: { + props: { + enum: [false], + }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + props: { + enum: [true], + }, + ignorePropertyModificationsFor: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + ignorePropertyModificationsForRegex: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + assignmentToFunctionParam: + "Assignment to function parameter '{{name}}'.", + assignmentToFunctionParamProp: + "Assignment to property of function parameter '{{name}}'.", + }, + }, + + create(context) { + const props = context.options[0] && context.options[0].props; + const ignoredPropertyAssignmentsFor = + (context.options[0] && + context.options[0].ignorePropertyModificationsFor) || + []; + const ignoredPropertyAssignmentsForRegex = + (context.options[0] && + context.options[0].ignorePropertyModificationsForRegex) || + []; + const sourceCode = context.sourceCode; + + /** + * Checks whether or not the reference modifies properties of its variable. + * @param {Reference} reference A reference to check. + * @returns {boolean} Whether or not the reference modifies properties of its variable. + */ + function isModifyingProp(reference) { + let node = reference.identifier; + let parent = node.parent; + + while ( + parent && + (!stopNodePattern.test(parent.type) || + parent.type === "ForInStatement" || + parent.type === "ForOfStatement") + ) { + switch (parent.type) { + // e.g. foo.a = 0; + case "AssignmentExpression": + return parent.left === node; + + // e.g. ++foo.a; + case "UpdateExpression": + return true; + + // e.g. delete foo.a; + case "UnaryExpression": + if (parent.operator === "delete") { + return true; + } + break; + + // e.g. for (foo.a in b) {} + case "ForInStatement": + case "ForOfStatement": + if (parent.left === node) { + return true; + } + + // this is a stop node for parent.right and parent.body + return false; + + // EXCLUDES: e.g. cache.get(foo.a).b = 0; + case "CallExpression": + if (parent.callee !== node) { + return false; + } + break; + + // EXCLUDES: e.g. cache[foo.a] = 0; + case "MemberExpression": + if (parent.property === node) { + return false; + } + break; + + // EXCLUDES: e.g. ({ [foo]: a }) = bar; + case "Property": + if (parent.key === node) { + return false; + } + + break; + + // EXCLUDES: e.g. (foo ? a : b).c = bar; + case "ConditionalExpression": + if (parent.test === node) { + return false; + } + + break; + + // no default + } + + node = parent; + parent = node.parent; + } + + return false; + } + + /** + * Tests that an identifier name matches any of the ignored property assignments. + * First we test strings in ignoredPropertyAssignmentsFor. + * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings. + * @param {string} identifierName A string that describes the name of an identifier to + * ignore property assignments for. + * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not. + */ + function isIgnoredPropertyAssignment(identifierName) { + return ( + ignoredPropertyAssignmentsFor.includes(identifierName) || + ignoredPropertyAssignmentsForRegex.some(ignored => + new RegExp(ignored, "u").test(identifierName), + ) + ); + } + + /** + * Reports a reference if is non initializer and writable. + * @param {Reference} reference A reference to check. + * @param {number} index The index of the reference in the references. + * @param {Reference[]} references The array that the reference belongs to. + * @returns {void} + */ + function checkReference(reference, index, references) { + const identifier = reference.identifier; + + if ( + identifier && + !reference.init && + /* + * Destructuring assignments can have multiple default value, + * so possibly there are multiple writeable references for the same identifier. + */ + (index === 0 || references[index - 1].identifier !== identifier) + ) { + if (reference.isWrite()) { + context.report({ + node: identifier, + messageId: "assignmentToFunctionParam", + data: { name: identifier.name }, + }); + } else if ( + props && + isModifyingProp(reference) && + !isIgnoredPropertyAssignment(identifier.name) + ) { + context.report({ + node: identifier, + messageId: "assignmentToFunctionParamProp", + data: { name: identifier.name }, + }); + } + } + } + + /** + * Finds and reports references that are non initializer and writable. + * @param {Variable} variable A variable to check. + * @returns {void} + */ + function checkVariable(variable) { + if (variable.defs[0].type === "Parameter") { + variable.references.forEach(checkReference); + } + } + + /** + * Checks parameters of a given function node. + * @param {ASTNode} node A function node to check. + * @returns {void} + */ + function checkForFunction(node) { + sourceCode.getDeclaredVariables(node).forEach(checkVariable); + } + + return { + // `:exit` is needed for the `node.parent` property of identifier nodes. + "FunctionDeclaration:exit": checkForFunction, + "FunctionExpression:exit": checkForFunction, + "ArrowFunctionExpression:exit": checkForFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-path-concat.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-path-concat.js new file mode 100644 index 00000000..230a3943 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-path-concat.js @@ -0,0 +1,79 @@ +/** + * @fileoverview Disallow string concatenation when using __dirname and __filename + * @author Nicholas C. Zakas + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-path-concat", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-path-concat.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: + "Disallow string concatenation with `__dirname` and `__filename`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-path-concat", + }, + + schema: [], + + messages: { + usePathFunctions: + "Use path.join() or path.resolve() instead of + to create paths.", + }, + }, + + create(context) { + const MATCHER = /^__(?:dir|file)name$/u; + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + BinaryExpression(node) { + const left = node.left, + right = node.right; + + if ( + node.operator === "+" && + ((left.type === "Identifier" && MATCHER.test(left.name)) || + (right.type === "Identifier" && + MATCHER.test(right.name))) + ) { + context.report({ + node, + messageId: "usePathFunctions", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-plusplus.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-plusplus.js new file mode 100644 index 00000000..1f3a9f0f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-plusplus.js @@ -0,0 +1,102 @@ +/** + * @fileoverview Rule to flag use of unary increment and decrement operators. + * @author Ian Christian Myers + * @author Brody McKee (github.com/mrmckeb) + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the given node is the update node of a `ForStatement`. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is `ForStatement` update. + */ +function isForStatementUpdate(node) { + const parent = node.parent; + + return parent.type === "ForStatement" && parent.update === node; +} + +/** + * Determines whether the given node is considered to be a for loop "afterthought" by the logic of this rule. + * In particular, it returns `true` if the given node is either: + * - The update node of a `ForStatement`: for (;; i++) {} + * - An operand of a sequence expression that is the update node: for (;; foo(), i++) {} + * - An operand of a sequence expression that is child of another sequence expression, etc., + * up to the sequence expression that is the update node: for (;; foo(), (bar(), (baz(), i++))) {} + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a for loop afterthought. + */ +function isForLoopAfterthought(node) { + const parent = node.parent; + + if (parent.type === "SequenceExpression") { + return isForLoopAfterthought(parent); + } + + return isForStatementUpdate(node); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowForLoopAfterthoughts: false, + }, + ], + + docs: { + description: "Disallow the unary operators `++` and `--`", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-plusplus", + }, + + schema: [ + { + type: "object", + properties: { + allowForLoopAfterthoughts: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedUnaryOp: "Unary operator '{{operator}}' used.", + }, + }, + + create(context) { + const [{ allowForLoopAfterthoughts }] = context.options; + + return { + UpdateExpression(node) { + if (allowForLoopAfterthoughts && isForLoopAfterthought(node)) { + return; + } + + context.report({ + node, + messageId: "unexpectedUnaryOp", + data: { + operator: node.operator, + }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-env.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-env.js new file mode 100644 index 00000000..c9dc353f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-env.js @@ -0,0 +1,68 @@ +/** + * @fileoverview Disallow the use of process.env() + * @author Vignesh Anand + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-process-env", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-env.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow the use of `process.env`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-process-env", + }, + + schema: [], + + messages: { + unexpectedProcessEnv: "Unexpected use of process.env.", + }, + }, + + create(context) { + return { + MemberExpression(node) { + const objectName = node.object.name, + propertyName = node.property.name; + + if ( + objectName === "process" && + !node.computed && + propertyName && + propertyName === "env" + ) { + context.report({ node, messageId: "unexpectedProcessEnv" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-exit.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-exit.js new file mode 100644 index 00000000..79f8153a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-process-exit.js @@ -0,0 +1,67 @@ +/** + * @fileoverview Disallow the use of process.exit() + * @author Nicholas C. Zakas + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-process-exit", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-exit.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow the use of `process.exit()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-process-exit", + }, + + schema: [], + + messages: { + noProcessExit: "Don't use process.exit(); throw an error instead.", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + "CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']"( + node, + ) { + context.report({ + node: node.parent, + messageId: "noProcessExit", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-promise-executor-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-promise-executor-return.js new file mode 100644 index 00000000..406b2965 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-promise-executor-return.js @@ -0,0 +1,263 @@ +/** + * @fileoverview Rule to disallow returning values from Promise executor functions + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const functionTypesToCheck = new Set([ + "ArrowFunctionExpression", + "FunctionExpression", +]); + +/** + * Determines whether the given function node is used as a Promise executor. + * @param {ASTNode} node The node to check. + * @param {SourceCode} sourceCode Source code to which the node belongs. + * @returns {boolean} `true` if the node is a Promise executor. + */ +function isPromiseExecutor(node, sourceCode) { + const parent = node.parent; + + return ( + parent.type === "NewExpression" && + parent.arguments[0] === node && + parent.callee.type === "Identifier" && + parent.callee.name === "Promise" && + sourceCode.isGlobalReference(parent.callee) + ); +} + +/** + * Checks if the given node is a void expression. + * @param {ASTNode} node The node to check. + * @returns {boolean} - `true` if the node is a void expression + */ +function expressionIsVoid(node) { + return node.type === "UnaryExpression" && node.operator === "void"; +} + +/** + * Fixes the linting error by prepending "void " to the given node + * @param {Object} sourceCode context given by context.sourceCode + * @param {ASTNode} node The node to fix. + * @param {Object} fixer The fixer object provided by ESLint. + * @returns {Array} - An array of fix objects to apply to the node. + */ +function voidPrependFixer(sourceCode, node, fixer) { + const requiresParens = + // prepending `void ` will fail if the node has a lower precedence than void + astUtils.getPrecedence(node) < + astUtils.getPrecedence({ + type: "UnaryExpression", + operator: "void", + }) && + // check if there are parentheses around the node to avoid redundant parentheses + !astUtils.isParenthesised(sourceCode, node); + + // avoid parentheses issues + const returnOrArrowToken = sourceCode.getTokenBefore( + node, + node.parent.type === "ArrowFunctionExpression" + ? astUtils.isArrowToken + : // isReturnToken + token => token.type === "Keyword" && token.value === "return", + ); + + const firstToken = sourceCode.getTokenAfter(returnOrArrowToken); + + const prependSpace = + // is return token, as => allows void to be adjacent + returnOrArrowToken.value === "return" && + // If two tokens (return and "(") are adjacent + returnOrArrowToken.range[1] === firstToken.range[0]; + + return [ + fixer.insertTextBefore( + firstToken, + `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`, + ), + fixer.insertTextAfter(node, requiresParens ? ")" : ""), + ]; +} + +/** + * Fixes the linting error by `wrapping {}` around the given node's body. + * @param {Object} sourceCode context given by context.sourceCode + * @param {ASTNode} node The node to fix. + * @param {Object} fixer The fixer object provided by ESLint. + * @returns {Array} - An array of fix objects to apply to the node. + */ +function curlyWrapFixer(sourceCode, node, fixer) { + // https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923 + const arrowToken = sourceCode.getTokenBefore( + node.body, + astUtils.isArrowToken, + ); + const firstToken = sourceCode.getTokenAfter(arrowToken); + const lastToken = sourceCode.getLastToken(node); + + return [ + fixer.insertTextBefore(firstToken, "{"), + fixer.insertTextAfter(lastToken, "}"), + ]; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowVoid: false, + }, + ], + + docs: { + description: + "Disallow returning values from Promise executor functions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-promise-executor-return", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + allowVoid: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + returnsValue: + "Return values from promise executor functions cannot be read.", + + // arrow and function suggestions + prependVoid: "Prepend `void` to the expression.", + + // only arrow suggestions + wrapBraces: "Wrap the expression in `{}`.", + }, + }, + + create(context) { + let funcInfo = null; + const sourceCode = context.sourceCode; + const [{ allowVoid }] = context.options; + + return { + onCodePathStart(_, node) { + funcInfo = { + upper: funcInfo, + shouldCheck: + functionTypesToCheck.has(node.type) && + isPromiseExecutor(node, sourceCode), + }; + + if ( + // Is a Promise executor + funcInfo.shouldCheck && + node.type === "ArrowFunctionExpression" && + node.expression && + // Except void + !(allowVoid && expressionIsVoid(node.body)) + ) { + const suggest = []; + + // prevent useless refactors + if (allowVoid) { + suggest.push({ + messageId: "prependVoid", + fix(fixer) { + return voidPrependFixer( + sourceCode, + node.body, + fixer, + ); + }, + }); + } + + // Do not suggest wrapping an unnamed function or class expression in braces as that would be invalid syntax. + if (!( + (node.body.type === "FunctionExpression" || + node.body.type === "ClassExpression") && + !node.body.id + )) { + suggest.push({ + messageId: "wrapBraces", + fix(fixer) { + return curlyWrapFixer(sourceCode, node, fixer); + }, + }); + } + + context.report({ + node: node.body, + messageId: "returnsValue", + suggest, + }); + } + }, + + onCodePathEnd() { + funcInfo = funcInfo.upper; + }, + + ReturnStatement(node) { + if (!(funcInfo.shouldCheck && node.argument)) { + return; + } + + // node is `return ` + if (!allowVoid) { + context.report({ node, messageId: "returnsValue" }); + return; + } + + if (expressionIsVoid(node.argument)) { + return; + } + + // allowVoid && !expressionIsVoid + context.report({ + node, + messageId: "returnsValue", + suggest: [ + { + messageId: "prependVoid", + fix(fixer) { + return voidPrependFixer( + sourceCode, + node.argument, + fixer, + ); + }, + }, + ], + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-proto.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-proto.js new file mode 100644 index 00000000..d68509e1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-proto.js @@ -0,0 +1,45 @@ +/** + * @fileoverview Rule to flag usage of __proto__ property + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { getStaticPropertyName } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow the use of the `__proto__` property", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-proto", + }, + + schema: [], + + messages: { + unexpectedProto: "The '__proto__' property is deprecated.", + }, + }, + + create(context) { + return { + MemberExpression(node) { + if (getStaticPropertyName(node) === "__proto__") { + context.report({ node, messageId: "unexpectedProto" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-prototype-builtins.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-prototype-builtins.js new file mode 100644 index 00000000..c75fdacf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-prototype-builtins.js @@ -0,0 +1,181 @@ +/** + * @fileoverview Rule to disallow use of Object.prototype builtins on objects + * @author Andrew Levine + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Returns true if the node or any of the objects + * to the left of it in the member/call chain is optional. + * + * e.g. `a?.b`, `a?.b.c`, `a?.()`, `a()?.()` + * @param {ASTNode} node The expression to check + * @returns {boolean} `true` if there is a short-circuiting optional `?.` + * in the same option chain to the left of this call or member expression, + * or the node itself is an optional call or member `?.`. + */ +function isAfterOptional(node) { + let leftNode; + + if (node.type === "MemberExpression") { + leftNode = node.object; + } else if (node.type === "CallExpression") { + leftNode = node.callee; + } else { + return false; + } + if (node.optional) { + return true; + } + return isAfterOptional(leftNode); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow calling some `Object.prototype` methods directly on objects", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-prototype-builtins", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + prototypeBuildIn: + "Do not access Object.prototype method '{{prop}}' from target object.", + callObjectPrototype: "Call Object.prototype.{{prop}} explicitly.", + }, + }, + + create(context) { + const DISALLOWED_PROPS = new Set([ + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + ]); + + /** + * Reports if a disallowed property is used in a CallExpression + * @param {ASTNode} node The CallExpression node. + * @returns {void} + */ + function disallowBuiltIns(node) { + const callee = astUtils.skipChainExpression(node.callee); + + if (callee.type !== "MemberExpression") { + return; + } + + const propName = astUtils.getStaticPropertyName(callee); + + if (propName !== null && DISALLOWED_PROPS.has(propName)) { + context.report({ + messageId: "prototypeBuildIn", + loc: callee.property.loc, + data: { prop: propName }, + node, + suggest: [ + { + messageId: "callObjectPrototype", + data: { prop: propName }, + fix(fixer) { + const sourceCode = context.sourceCode; + + /* + * A call after an optional chain (e.g. a?.b.hasOwnProperty(c)) + * must be fixed manually because the call can be short-circuited + */ + if (isAfterOptional(node)) { + return null; + } + + /* + * A call on a ChainExpression (e.g. (a?.hasOwnProperty)(c)) will trigger + * no-unsafe-optional-chaining which should be fixed before this suggestion + */ + if (node.callee.type === "ChainExpression") { + return null; + } + + const objectVariable = + astUtils.getVariableByName( + sourceCode.getScope(node), + "Object", + ); + + /* + * We can't use Object if the global Object was shadowed, + * or Object does not exist in the global scope for some reason + */ + if ( + !objectVariable || + objectVariable.scope.type !== "global" || + objectVariable.defs.length > 0 + ) { + return null; + } + + let objectText = sourceCode.getText( + callee.object, + ); + + if ( + astUtils.getPrecedence(callee.object) <= + astUtils.getPrecedence({ + type: "SequenceExpression", + }) + ) { + objectText = `(${objectText})`; + } + + const openParenToken = sourceCode.getTokenAfter( + node.callee, + astUtils.isOpeningParenToken, + ); + const isEmptyParameters = + node.arguments.length === 0; + const delim = isEmptyParameters ? "" : ", "; + const fixes = [ + fixer.replaceText( + callee, + `Object.prototype.${propName}.call`, + ), + fixer.insertTextAfter( + openParenToken, + objectText + delim, + ), + ]; + + return fixes; + }, + }, + ], + }); + } + } + + return { + CallExpression: disallowBuiltIns, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-redeclare.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-redeclare.js new file mode 100644 index 00000000..4f8c06c9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-redeclare.js @@ -0,0 +1,173 @@ +/** + * @fileoverview Rule to flag when the same variable is declared more then once. + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ builtinGlobals: true }], + + docs: { + description: "Disallow variable redeclaration", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-redeclare", + }, + + messages: { + redeclared: "'{{id}}' is already defined.", + redeclaredAsBuiltin: + "'{{id}}' is already defined as a built-in global variable.", + redeclaredBySyntax: + "'{{id}}' is already defined by a variable declaration.", + }, + + schema: [ + { + type: "object", + properties: { + builtinGlobals: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + }, + + create(context) { + const [{ builtinGlobals }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Iterate declarations of a given variable. + * @param {escope.variable} variable The variable object to iterate declarations. + * @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations. + */ + function* iterateDeclarations(variable) { + if ( + builtinGlobals && + (variable.eslintImplicitGlobalSetting === "readonly" || + variable.eslintImplicitGlobalSetting === "writable") + ) { + yield { type: "builtin" }; + } + + for (const id of variable.identifiers) { + yield { type: "syntax", node: id, loc: id.loc }; + } + + if (variable.eslintExplicitGlobalComments) { + for (const comment of variable.eslintExplicitGlobalComments) { + yield { + type: "comment", + node: comment, + loc: astUtils.getNameLocationInGlobalDirectiveComment( + sourceCode, + comment, + variable.name, + ), + }; + } + } + } + + /** + * Find variables in a given scope and flag redeclared ones. + * @param {Scope} scope An eslint-scope scope object. + * @returns {void} + * @private + */ + function findVariablesInScope(scope) { + for (const variable of scope.variables) { + const [declaration, ...extraDeclarations] = + iterateDeclarations(variable); + + if (extraDeclarations.length === 0) { + continue; + } + + /* + * If the type of a declaration is different from the type of + * the first declaration, it shows the location of the first + * declaration. + */ + const detailMessageId = + declaration.type === "builtin" + ? "redeclaredAsBuiltin" + : "redeclaredBySyntax"; + const data = { id: variable.name }; + + // Report extra declarations. + for (const { type, node, loc } of extraDeclarations) { + const messageId = + type === declaration.type + ? "redeclared" + : detailMessageId; + + context.report({ node, loc, messageId, data }); + } + } + } + + /** + * Find variables in the current scope. + * @param {ASTNode} node The node of the current scope. + * @returns {void} + * @private + */ + function checkForBlock(node) { + const scope = sourceCode.getScope(node); + + /* + * In ES5, some node type such as `BlockStatement` doesn't have that scope. + * `scope.block` is a different node in such a case. + */ + if (scope.block === node) { + findVariablesInScope(scope); + } + } + + return { + Program(node) { + const scope = sourceCode.getScope(node); + + findVariablesInScope(scope); + + // Node.js or ES modules has a special scope. + if ( + scope.type === "global" && + scope.childScopes[0] && + // The special scope's block is the Program node. + scope.block === scope.childScopes[0].block + ) { + findVariablesInScope(scope.childScopes[0]); + } + }, + + FunctionDeclaration: checkForBlock, + FunctionExpression: checkForBlock, + ArrowFunctionExpression: checkForBlock, + + StaticBlock: checkForBlock, + + BlockStatement: checkForBlock, + ForStatement: checkForBlock, + ForInStatement: checkForBlock, + ForOfStatement: checkForBlock, + SwitchStatement: checkForBlock, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-regex-spaces.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-regex-spaces.js new file mode 100644 index 00000000..71924097 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-regex-spaces.js @@ -0,0 +1,219 @@ +/** + * @fileoverview Rule to count multiple spaces in regular expressions + * @author Matt DuVall + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const regexpp = require("@eslint-community/regexpp"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const regExpParser = new regexpp.RegExpParser(); +const DOUBLE_SPACE = / {2}/u; + +/** + * Check if node is a string + * @param {ASTNode} node node to evaluate + * @returns {boolean} True if its a string + * @private + */ +function isString(node) { + return node && node.type === "Literal" && typeof node.value === "string"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow multiple spaces in regular expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-regex-spaces", + }, + + schema: [], + fixable: "code", + + messages: { + multipleSpaces: "Spaces are hard to count. Use {{{length}}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Validate regular expression + * @param {ASTNode} nodeToReport Node to report. + * @param {string} pattern Regular expression pattern to validate. + * @param {string} rawPattern Raw representation of the pattern in the source code. + * @param {number} rawPatternStartRange Start range of the pattern in the source code. + * @param {string} flags Regular expression flags. + * @returns {void} + * @private + */ + function checkRegex( + nodeToReport, + pattern, + rawPattern, + rawPatternStartRange, + flags, + ) { + // Skip if there are no consecutive spaces in the source code, to avoid reporting e.g., RegExp(' \ '). + if (!DOUBLE_SPACE.test(rawPattern)) { + return; + } + + const characterClassNodes = []; + let regExpAST; + + try { + regExpAST = regExpParser.parsePattern( + pattern, + 0, + pattern.length, + { + unicode: flags.includes("u"), + unicodeSets: flags.includes("v"), + }, + ); + } catch { + // Ignore regular expressions with syntax errors + return; + } + + regexpp.visitRegExpAST(regExpAST, { + onCharacterClassEnter(ccNode) { + characterClassNodes.push(ccNode); + }, + }); + + const spacesPattern = /( {2,})(?: [+*{?]|[^+*{?]|$)/gu; + let match; + + while ((match = spacesPattern.exec(pattern))) { + const { + 1: { length }, + index, + } = match; + + // Report only consecutive spaces that are not in character classes. + if ( + characterClassNodes.every( + ({ start, end }) => index < start || end <= index, + ) + ) { + context.report({ + node: nodeToReport, + messageId: "multipleSpaces", + data: { length }, + fix(fixer) { + if (pattern !== rawPattern) { + return null; + } + return fixer.replaceTextRange( + [ + rawPatternStartRange + index, + rawPatternStartRange + index + length, + ], + ` {${length}}`, + ); + }, + }); + + // Report only the first occurrence of consecutive spaces + return; + } + } + } + + /** + * Validate regular expression literals + * @param {ASTNode} node node to validate + * @returns {void} + * @private + */ + function checkLiteral(node) { + if (node.regex) { + const pattern = node.regex.pattern; + const rawPattern = node.raw.slice(1, node.raw.lastIndexOf("/")); + const rawPatternStartRange = node.range[0] + 1; + const flags = node.regex.flags; + + checkRegex( + node, + pattern, + rawPattern, + rawPatternStartRange, + flags, + ); + } + } + + /** + * Validate strings passed to the RegExp constructor + * @param {ASTNode} node node to validate + * @returns {void} + * @private + */ + function checkFunction(node) { + const scope = sourceCode.getScope(node); + const regExpVar = astUtils.getVariableByName(scope, "RegExp"); + const shadowed = regExpVar && regExpVar.defs.length > 0; + const patternNode = node.arguments[0]; + + if ( + node.callee.type === "Identifier" && + node.callee.name === "RegExp" && + isString(patternNode) && + !shadowed + ) { + const pattern = patternNode.value; + const rawPattern = patternNode.raw.slice(1, -1); + const rawPatternStartRange = patternNode.range[0] + 1; + let flags; + + if (node.arguments.length < 2) { + // It has no flags. + flags = ""; + } else { + const flagsNode = node.arguments[1]; + + if (isString(flagsNode)) { + flags = flagsNode.value; + } else { + // The flags cannot be determined. + return; + } + } + + checkRegex( + node, + pattern, + rawPattern, + rawPatternStartRange, + flags, + ); + } + } + + return { + Literal: checkLiteral, + CallExpression: checkFunction, + NewExpression: checkFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-exports.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-exports.js new file mode 100644 index 00000000..89c02105 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-exports.js @@ -0,0 +1,227 @@ +/** + * @fileoverview Rule to disallow specified names in exports + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow specified names in exports", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-exports", + }, + + schema: [ + { + anyOf: [ + { + type: "object", + properties: { + restrictedNamedExports: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + restrictedNamedExportsPattern: { type: "string" }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + restrictedNamedExports: { + type: "array", + items: { + type: "string", + pattern: "^(?!default$)", + }, + uniqueItems: true, + }, + restrictedNamedExportsPattern: { type: "string" }, + restrictDefaultExports: { + type: "object", + properties: { + // Allow/Disallow `export default foo; export default 42; export default function foo() {}` format + direct: { + type: "boolean", + }, + + // Allow/Disallow `export { foo as default };` declarations + named: { + type: "boolean", + }, + + // Allow/Disallow `export { default } from "mod"; export { default as default } from "mod";` declarations + defaultFrom: { + type: "boolean", + }, + + // Allow/Disallow `export { foo as default } from "mod";` declarations + namedFrom: { + type: "boolean", + }, + + // Allow/Disallow `export * as default from "mod"`; declarations + namespaceFrom: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [{}], + + messages: { + restrictedNamed: + "'{{name}}' is restricted from being used as an exported name.", + restrictedDefault: "Exporting 'default' is restricted.", + }, + }, + + create(context) { + const { + restrictedNamedExports, + restrictedNamedExportsPattern: restrictedNamePattern, + restrictDefaultExports, + } = context.options[0]; + const restrictedNames = new Set(restrictedNamedExports); + const sourceCode = context.sourceCode; + + /** + * Checks and reports given exported name. + * @param {ASTNode} node exported `Identifier` or string `Literal` node to check. + * @returns {void} + */ + function checkExportedName(node) { + const name = astUtils.getModuleExportName(node); + + let matchesRestrictedNamePattern = false; + + if (restrictedNamePattern && name !== "default") { + const patternRegex = new RegExp(restrictedNamePattern, "u"); + + matchesRestrictedNamePattern = patternRegex.test(name); + } + + if (matchesRestrictedNamePattern || restrictedNames.has(name)) { + context.report({ + node, + messageId: "restrictedNamed", + data: { name }, + }); + return; + } + + if (name === "default") { + if (node.parent.type === "ExportAllDeclaration") { + if ( + restrictDefaultExports && + restrictDefaultExports.namespaceFrom + ) { + context.report({ + node, + messageId: "restrictedDefault", + }); + } + } else { + // ExportSpecifier + const isSourceSpecified = !!node.parent.parent.source; + const specifierLocalName = astUtils.getModuleExportName( + node.parent.local, + ); + + if ( + !isSourceSpecified && + restrictDefaultExports && + restrictDefaultExports.named + ) { + context.report({ + node, + messageId: "restrictedDefault", + }); + return; + } + + if (isSourceSpecified && restrictDefaultExports) { + if ( + (specifierLocalName === "default" && + restrictDefaultExports.defaultFrom) || + (specifierLocalName !== "default" && + restrictDefaultExports.namedFrom) + ) { + context.report({ + node, + messageId: "restrictedDefault", + }); + } + } + } + } + } + + return { + ExportAllDeclaration(node) { + if (node.exported) { + checkExportedName(node.exported); + } + }, + + ExportDefaultDeclaration(node) { + if (restrictDefaultExports && restrictDefaultExports.direct) { + context.report({ + node, + messageId: "restrictedDefault", + }); + } + }, + + ExportNamedDeclaration(node) { + const declaration = node.declaration; + + if (declaration) { + if ( + declaration.type === "FunctionDeclaration" || + declaration.type === "ClassDeclaration" + ) { + checkExportedName(declaration.id); + } else if (declaration.type === "VariableDeclaration") { + sourceCode + .getDeclaredVariables(declaration) + .map(v => + v.defs.find(d => d.parent === declaration), + ) + .map(d => d.name) // Identifier nodes + .forEach(checkExportedName); + } + } else { + node.specifiers + .map(s => s.exported) + .forEach(checkExportedName); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-globals.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-globals.js new file mode 100644 index 00000000..26985b77 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-globals.js @@ -0,0 +1,265 @@ +/** + * @fileoverview Restrict usage of specified globals. + * @author Benoît Zugmeyer + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const TYPE_NODES = new Set([ + "TSTypeReference", + "TSInterfaceHeritage", + "TSClassImplements", + "TSTypeQuery", + "TSQualifiedName", +]); + +const GLOBAL_OBJECTS = new Set(["globalThis", "self", "window"]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const arrayOfGlobals = { + type: "array", + items: { + oneOf: [ + { + type: "string", + }, + { + type: "object", + properties: { + name: { type: "string" }, + message: { type: "string" }, + }, + required: ["name"], + additionalProperties: false, + }, + ], + }, + uniqueItems: true, + minItems: 0, +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow specified global variables", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-globals", + }, + + schema: { + anyOf: [ + arrayOfGlobals, + { + type: "array", + items: [ + { + type: "object", + properties: { + globals: arrayOfGlobals, + checkGlobalObject: { + type: "boolean", + }, + globalObjects: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + }, + required: ["globals"], + additionalProperties: false, + }, + ], + additionalItems: false, + }, + ], + }, + + messages: { + defaultMessage: "Unexpected use of '{{name}}'.", + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + customMessage: "Unexpected use of '{{name}}'. {{customMessage}}", + }, + }, + + create(context) { + const { sourceCode, options } = context; + + const isGlobalsObject = + typeof options[0] === "object" && + Object.hasOwn(options[0], "globals"); + + const restrictedGlobals = isGlobalsObject + ? options[0].globals + : options; + const checkGlobalObject = isGlobalsObject + ? options[0].checkGlobalObject + : false; + const userGlobalObjects = isGlobalsObject + ? options[0].globalObjects || [] + : []; + + const globalObjects = new Set([ + ...GLOBAL_OBJECTS, + ...userGlobalObjects, + ]); + + // If no globals are restricted, we don't need to do anything + if (restrictedGlobals.length === 0) { + return {}; + } + + const restrictedGlobalMessages = restrictedGlobals.reduce( + (memo, option) => { + if (typeof option === "string") { + memo[option] = null; + } else { + memo[option.name] = option.message; + } + + return memo; + }, + {}, + ); + + /** + * Report a variable to be used as a restricted global. + * @param {Reference} reference the variable reference + * @returns {void} + * @private + */ + function reportReference(reference) { + const name = reference.identifier.name, + customMessage = restrictedGlobalMessages[name], + messageId = customMessage ? "customMessage" : "defaultMessage"; + + context.report({ + node: reference.identifier, + messageId, + data: { + name, + customMessage, + }, + }); + } + + /** + * Check if the given name is a restricted global name. + * @param {string} name name of a variable + * @returns {boolean} whether the variable is a restricted global or not + * @private + */ + function isRestricted(name) { + return Object.hasOwn(restrictedGlobalMessages, name); + } + + /** + * Check if the given reference occurs within a TypeScript type context. + * @param {Reference} reference The variable reference to check. + * @returns {boolean} Whether the reference is in a type context. + * @private + */ + function isInTypeContext(reference) { + const parent = reference.identifier.parent; + + return TYPE_NODES.has(parent.type); + } + + return { + Program(node) { + const scope = sourceCode.getScope(node); + + // Report variables declared elsewhere (ex: variables defined as "global" by eslint) + scope.variables.forEach(variable => { + if (!variable.defs.length && isRestricted(variable.name)) { + variable.references.forEach(reference => { + if (!isInTypeContext(reference)) { + reportReference(reference); + } + }); + } + }); + + // Report variables not declared at all + scope.through.forEach(reference => { + if ( + isRestricted(reference.identifier.name) && + !isInTypeContext(reference) + ) { + reportReference(reference); + } + }); + }, + + "Program:exit"(node) { + if (!checkGlobalObject) { + return; + } + + const globalScope = sourceCode.getScope(node); + globalObjects.forEach(globalObjectName => { + const variable = astUtils.getVariableByName( + globalScope, + globalObjectName, + ); + + if (!variable) { + return; + } + + variable.references.forEach(reference => { + const identifier = reference.identifier; + let parent = identifier.parent; + + // To detect code like `window.window.Promise`. + while ( + astUtils.isSpecificMemberAccess( + parent, + null, + globalObjectName, + ) + ) { + parent = parent.parent; + } + + const propertyName = + astUtils.getStaticPropertyName(parent); + if (propertyName && isRestricted(propertyName)) { + const customMessage = + restrictedGlobalMessages[propertyName]; + const messageId = customMessage + ? "customMessage" + : "defaultMessage"; + + context.report({ + node: parent.property, + messageId, + data: { + name: propertyName, + customMessage, + }, + }); + } + }); + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-imports.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-imports.js new file mode 100644 index 00000000..2df8caa6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-imports.js @@ -0,0 +1,891 @@ +/** + * @fileoverview Restrict usage of specified node imports. + * @author Guy Ellis + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Format import names for error messages. + * @param {string[]} importNames The import names to format. + * @returns {string} The formatted import names. + */ +function formatImportNames(importNames) { + return new Intl.ListFormat("en-US").format( + importNames.map(name => `'${name}'`), + ); +} + +/** + * Returns "is" or "are" based on the number of import names. + * @param {string[]} importNames The import names to check. + * @returns {string} "is" if one import name, otherwise "are". + */ +function isOrAre(importNames) { + return importNames.length === 1 ? "is" : "are"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const ignore = require("ignore"); + +const arrayOfStringsOrObjects = { + type: "array", + items: { + anyOf: [ + { type: "string" }, + { + type: "object", + properties: { + name: { type: "string" }, + message: { + type: "string", + minLength: 1, + }, + importNames: { + type: "array", + items: { + type: "string", + }, + }, + allowImportNames: { + type: "array", + items: { + type: "string", + }, + }, + allowTypeImports: { + type: "boolean", + description: + "Whether to allow type-only imports for a path.", + }, + }, + additionalProperties: false, + required: ["name"], + not: { required: ["importNames", "allowImportNames"] }, + }, + ], + }, + uniqueItems: true, +}; + +const arrayOfStringsOrObjectPatterns = { + anyOf: [ + { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + { + type: "array", + items: { + type: "object", + properties: { + importNames: { + type: "array", + items: { + type: "string", + }, + minItems: 1, + uniqueItems: true, + }, + allowImportNames: { + type: "array", + items: { + type: "string", + }, + minItems: 1, + uniqueItems: true, + }, + group: { + type: "array", + items: { + type: "string", + }, + minItems: 1, + uniqueItems: true, + }, + regex: { + type: "string", + }, + importNamePattern: { + type: "string", + }, + allowImportNamePattern: { + type: "string", + }, + message: { + type: "string", + minLength: 1, + }, + caseSensitive: { + type: "boolean", + }, + allowTypeImports: { + type: "boolean", + description: + "Whether to allow type-only imports for a pattern.", + }, + }, + additionalProperties: false, + not: { + anyOf: [ + { required: ["importNames", "allowImportNames"] }, + { + required: [ + "importNamePattern", + "allowImportNamePattern", + ], + }, + { required: ["importNames", "allowImportNamePattern"] }, + { required: ["importNamePattern", "allowImportNames"] }, + { + required: [ + "allowImportNames", + "allowImportNamePattern", + ], + }, + ], + }, + oneOf: [{ required: ["group"] }, { required: ["regex"] }], + }, + uniqueItems: true, + }, + ], +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow specified modules when loaded by `import`", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-imports", + }, + + messages: { + path: "'{{importSource}}' import is restricted from being used.", + pathWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importSource}}' import is restricted from being used. {{customMessage}}", + + patterns: + "'{{importSource}}' import is restricted from being used by a pattern.", + patternWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importSource}}' import is restricted from being used by a pattern. {{customMessage}}", + + patternAndImportName: + "'{{importName}}' import from '{{importSource}}' is restricted from being used by a pattern.", + patternAndImportNameWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importName}}' import from '{{importSource}}' is restricted from being used by a pattern. {{customMessage}}", + + patternAndEverything: + "* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern.", + + patternAndEverythingWithRegexImportName: + "* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used.", + patternAndEverythingWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted from being used by a pattern. {{customMessage}}", + patternAndEverythingWithRegexImportNameAndCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "* import is invalid because import name matching '{{importNames}}' pattern from '{{importSource}}' is restricted from being used. {{customMessage}}", + + everything: + "* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted.", + everythingWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "* import is invalid because {{importNames}} from '{{importSource}}' {{isOrAre}} restricted. {{customMessage}}", + + importName: + "'{{importName}}' import from '{{importSource}}' is restricted.", + importNameWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}", + + allowedImportName: + "'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed.", + allowedImportNameWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importName}}' import from '{{importSource}}' is restricted because only {{allowedImportNames}} {{isOrAre}} allowed. {{customMessage}}", + + everythingWithAllowImportNames: + "* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed.", + everythingWithAllowImportNamesAndCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "* import is invalid because only {{allowedImportNames}} from '{{importSource}}' {{isOrAre}} allowed. {{customMessage}}", + + allowedImportNamePattern: + "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'.", + allowedImportNamePatternWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'. {{customMessage}}", + + everythingWithAllowedImportNamePattern: + "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed.", + everythingWithAllowedImportNamePatternWithCustomMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed. {{customMessage}}", + }, + + schema: { + anyOf: [ + arrayOfStringsOrObjects, + { + type: "array", + items: [ + { + type: "object", + properties: { + paths: arrayOfStringsOrObjects, + patterns: arrayOfStringsOrObjectPatterns, + }, + additionalProperties: false, + }, + ], + additionalItems: false, + }, + ], + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const options = Array.isArray(context.options) ? context.options : []; + const isPathAndPatternsObject = + typeof options[0] === "object" && + (Object.hasOwn(options[0], "paths") || + Object.hasOwn(options[0], "patterns")); + + const restrictedPaths = + (isPathAndPatternsObject ? options[0].paths : context.options) || + []; + const groupedRestrictedPaths = restrictedPaths.reduce( + (memo, importSource) => { + const path = + typeof importSource === "string" + ? importSource + : importSource.name; + + if (!memo[path]) { + memo[path] = []; + } + + if (typeof importSource === "string") { + memo[path].push({}); + } else { + memo[path].push({ + message: importSource.message, + importNames: importSource.importNames, + allowImportNames: importSource.allowImportNames, + allowTypeImports: importSource.allowTypeImports, + }); + } + return memo; + }, + Object.create(null), + ); + + // Handle patterns too, either as strings or groups + let restrictedPatterns = + (isPathAndPatternsObject ? options[0].patterns : []) || []; + + // standardize to array of objects if we have an array of strings + if ( + restrictedPatterns.length > 0 && + typeof restrictedPatterns[0] === "string" + ) { + restrictedPatterns = [{ group: restrictedPatterns }]; + } + + // relative paths are supported for this rule + const restrictedPatternGroups = restrictedPatterns.map( + ({ + group, + regex, + message, + caseSensitive, + importNames, + importNamePattern, + allowImportNames, + allowImportNamePattern, + allowTypeImports, + }) => ({ + ...(group + ? { + matcher: ignore({ + allowRelativePaths: true, + ignorecase: !caseSensitive, + }).add(group), + } + : {}), + ...(typeof regex === "string" + ? { + regexMatcher: new RegExp( + regex, + caseSensitive ? "u" : "iu", + ), + } + : {}), + customMessage: message, + importNames, + importNamePattern, + allowImportNames, + allowImportNamePattern, + allowTypeImports, + }), + ); + + // if no imports are restricted we don't need to check + if ( + Object.keys(restrictedPaths).length === 0 && + restrictedPatternGroups.length === 0 + ) { + return {}; + } + + /** + * Check if the node is a type-only import + * @param {ASTNode} node The node to check + * @returns {boolean} Whether the node is a type-only import + */ + function isTypeOnlyImport(node) { + return ( + node.importKind === "type" || + (node.specifiers?.length > 0 && + node.specifiers.every( + specifier => specifier.importKind === "type", + )) + ); + } + + /** + * Check if a specifier is type-only + * @param {ASTNode} specifier The specifier to check + * @returns {boolean} Whether the specifier is type-only + */ + function isTypeOnlySpecifier(specifier) { + return ( + specifier.importKind === "type" || + specifier.exportKind === "type" + ); + } + + /** + * Check if the node is a type-only export + * @param {ASTNode} node The node to check + * @returns {boolean} Whether the node is a type-only export + */ + function isTypeOnlyExport(node) { + return ( + node.exportKind === "type" || + (node.specifiers?.length > 0 && + node.specifiers.every( + specifier => specifier.exportKind === "type", + )) + ); + } + + /** + * Report a restricted path. + * @param {string} importSource path of the import + * @param {Map} importNames Map of import names that are being imported + * @param {node} node representing the restricted path reference + * @returns {void} + * @private + */ + function checkRestrictedPathAndReport(importSource, importNames, node) { + if (!Object.hasOwn(groupedRestrictedPaths, importSource)) { + return; + } + + groupedRestrictedPaths[importSource].forEach( + restrictedPathEntry => { + const customMessage = restrictedPathEntry.message; + const restrictedImportNames = + restrictedPathEntry.importNames; + const allowedImportNames = + restrictedPathEntry.allowImportNames; + const allowTypeImports = + restrictedPathEntry.allowTypeImports; + + // Skip if this is a type-only import and it's allowed for this specific entry + if ( + allowTypeImports && + (node.type === "ImportDeclaration" || + node.type === "TSImportEqualsDeclaration") && + isTypeOnlyImport(node) + ) { + return; + } + + // Skip if this is a type-only export and it's allowed for this specific entry + if ( + allowTypeImports && + (node.type === "ExportNamedDeclaration" || + node.type === "ExportAllDeclaration") && + isTypeOnlyExport(node) + ) { + return; + } + + if (!restrictedImportNames && !allowedImportNames) { + context.report({ + node, + messageId: customMessage + ? "pathWithCustomMessage" + : "path", + data: { + importSource, + customMessage, + }, + }); + + return; + } + + importNames.forEach((specifiers, importName) => { + if (importName === "*") { + const [specifier] = specifiers; + + if (restrictedImportNames) { + context.report({ + node, + messageId: customMessage + ? "everythingWithCustomMessage" + : "everything", + loc: specifier.loc, + data: { + importSource, + importNames: formatImportNames( + restrictedImportNames, + ), + isOrAre: isOrAre(restrictedImportNames), + customMessage, + }, + }); + } else if (allowedImportNames) { + context.report({ + node, + messageId: customMessage + ? "everythingWithAllowImportNamesAndCustomMessage" + : "everythingWithAllowImportNames", + loc: specifier.loc, + data: { + importSource, + allowedImportNames: + formatImportNames( + allowedImportNames, + ), + isOrAre: isOrAre(allowedImportNames), + customMessage, + }, + }); + } + + return; + } + + if ( + restrictedImportNames && + restrictedImportNames.includes(importName) + ) { + specifiers.forEach(specifier => { + // Skip if this is a type-only import specifier and type imports are allowed + if ( + allowTypeImports && + isTypeOnlySpecifier(specifier.specifier) + ) { + return; + } + + context.report({ + node, + messageId: customMessage + ? "importNameWithCustomMessage" + : "importName", + loc: specifier.loc, + data: { + importSource, + customMessage, + importName, + }, + }); + }); + } + + if ( + allowedImportNames && + !allowedImportNames.includes(importName) + ) { + specifiers.forEach(specifier => { + // Skip if this is a type-only import specifier and type imports are allowed + if ( + allowTypeImports && + isTypeOnlySpecifier(specifier.specifier) + ) { + return; + } + + context.report({ + node, + loc: specifier.loc, + messageId: customMessage + ? "allowedImportNameWithCustomMessage" + : "allowedImportName", + data: { + importSource, + customMessage, + importName, + allowedImportNames: + formatImportNames( + allowedImportNames, + ), + isOrAre: isOrAre(allowedImportNames), + }, + }); + }); + } + }); + }, + ); + } + + /** + * Report a restricted path specifically for patterns. + * @param {node} node representing the restricted path reference + * @param {Object} group contains an Ignore instance for paths, the customMessage to show on failure, + * and any restricted import names that have been specified in the config + * @param {Map} importNames Map of import names that are being imported + * @param {string} importSource the import source string + * @returns {void} + * @private + */ + function reportPathForPatterns(node, group, importNames, importSource) { + // Skip if this is a type-only import and it's allowed + if ( + group.allowTypeImports && + (node.type === "ImportDeclaration" || + node.type === "TSImportEqualsDeclaration") && + isTypeOnlyImport(node) + ) { + return; + } + + // Skip if this is a type-only export and it's allowed + if ( + group.allowTypeImports && + (node.type === "ExportNamedDeclaration" || + node.type === "ExportAllDeclaration") && + isTypeOnlyExport(node) + ) { + return; + } + + const customMessage = group.customMessage; + const restrictedImportNames = group.importNames; + const restrictedImportNamePattern = group.importNamePattern + ? new RegExp(group.importNamePattern, "u") + : null; + const allowedImportNames = group.allowImportNames; + const allowedImportNamePattern = group.allowImportNamePattern + ? new RegExp(group.allowImportNamePattern, "u") + : null; + + /** + * If we are not restricting to any specific import names and just the pattern itself, + * report the error and move on + */ + if ( + !restrictedImportNames && + !allowedImportNames && + !restrictedImportNamePattern && + !allowedImportNamePattern + ) { + context.report({ + node, + messageId: customMessage + ? "patternWithCustomMessage" + : "patterns", + data: { + importSource, + customMessage, + }, + }); + return; + } + + importNames.forEach((specifiers, importName) => { + if (importName === "*") { + const [specifier] = specifiers; + + if (restrictedImportNames) { + context.report({ + node, + messageId: customMessage + ? "patternAndEverythingWithCustomMessage" + : "patternAndEverything", + loc: specifier.loc, + data: { + importSource, + importNames: formatImportNames( + restrictedImportNames, + ), + isOrAre: isOrAre(restrictedImportNames), + customMessage, + }, + }); + } else if (allowedImportNames) { + context.report({ + node, + messageId: customMessage + ? "everythingWithAllowImportNamesAndCustomMessage" + : "everythingWithAllowImportNames", + loc: specifier.loc, + data: { + importSource, + allowedImportNames: + formatImportNames(allowedImportNames), + isOrAre: isOrAre(allowedImportNames), + customMessage, + }, + }); + } else if (allowedImportNamePattern) { + context.report({ + node, + messageId: customMessage + ? "everythingWithAllowedImportNamePatternWithCustomMessage" + : "everythingWithAllowedImportNamePattern", + loc: specifier.loc, + data: { + importSource, + allowedImportNamePattern, + customMessage, + }, + }); + } else { + context.report({ + node, + messageId: customMessage + ? "patternAndEverythingWithRegexImportNameAndCustomMessage" + : "patternAndEverythingWithRegexImportName", + loc: specifier.loc, + data: { + importSource, + importNames: restrictedImportNamePattern, + customMessage, + }, + }); + } + + return; + } + + if ( + (restrictedImportNames && + restrictedImportNames.includes(importName)) || + (restrictedImportNamePattern && + restrictedImportNamePattern.test(importName)) + ) { + specifiers.forEach(specifier => { + // Skip if this is a type-only import specifier and type imports are allowed + if ( + group.allowTypeImports && + isTypeOnlySpecifier(specifier.specifier) + ) { + return; + } + + context.report({ + node, + messageId: customMessage + ? "patternAndImportNameWithCustomMessage" + : "patternAndImportName", + loc: specifier.loc, + data: { + importSource, + customMessage, + importName, + }, + }); + }); + } + + if ( + allowedImportNames && + !allowedImportNames.includes(importName) + ) { + specifiers.forEach(specifier => { + // Skip if this is a type-only import specifier and type imports are allowed + if ( + group.allowTypeImports && + isTypeOnlySpecifier(specifier.specifier) + ) { + return; + } + + context.report({ + node, + messageId: customMessage + ? "allowedImportNameWithCustomMessage" + : "allowedImportName", + loc: specifier.loc, + data: { + importSource, + customMessage, + importName, + allowedImportNames: + formatImportNames(allowedImportNames), + isOrAre: isOrAre(allowedImportNames), + }, + }); + }); + } else if ( + allowedImportNamePattern && + !allowedImportNamePattern.test(importName) + ) { + specifiers.forEach(specifier => { + // Skip if this is a type-only import specifier and type imports are allowed + if ( + group.allowTypeImports && + isTypeOnlySpecifier(specifier.specifier) + ) { + return; + } + + context.report({ + node, + messageId: customMessage + ? "allowedImportNamePatternWithCustomMessage" + : "allowedImportNamePattern", + loc: specifier.loc, + data: { + importSource, + customMessage, + importName, + allowedImportNamePattern, + }, + }); + }); + } + }); + } + + /** + * Check if the given importSource is restricted by a pattern. + * @param {string} importSource path of the import + * @param {Object} group contains a Ignore instance for paths, and the customMessage to show if it fails + * @returns {boolean} whether the variable is a restricted pattern or not + * @private + */ + function isRestrictedPattern(importSource, group) { + return group.regexMatcher + ? group.regexMatcher.test(importSource) + : group.matcher.ignores(importSource); + } + + /** + * Checks a node to see if any problems should be reported. + * @param {ASTNode} node The node to check. + * @returns {void} + * @private + */ + function checkNode(node) { + const importSource = node.source.value.trim(); + const importNames = new Map(); + + if (node.type === "ExportAllDeclaration") { + const starToken = sourceCode.getFirstToken(node, 1); + + importNames.set("*", [{ loc: starToken.loc }]); + } else if (node.specifiers) { + for (const specifier of node.specifiers) { + let name; + const specifierData = { loc: specifier.loc, specifier }; + + if (specifier.type === "ImportDefaultSpecifier") { + name = "default"; + } else if (specifier.type === "ImportNamespaceSpecifier") { + name = "*"; + } else if (specifier.imported) { + name = astUtils.getModuleExportName(specifier.imported); + } else if (specifier.local) { + name = astUtils.getModuleExportName(specifier.local); + } + + if (typeof name === "string") { + if (importNames.has(name)) { + importNames.get(name).push(specifierData); + } else { + importNames.set(name, [specifierData]); + } + } + } + } + + checkRestrictedPathAndReport(importSource, importNames, node); + restrictedPatternGroups.forEach(group => { + if (isRestrictedPattern(importSource, group)) { + reportPathForPatterns( + node, + group, + importNames, + importSource, + ); + } + }); + } + + return { + ImportDeclaration: checkNode, + ExportNamedDeclaration(node) { + if (node.source) { + checkNode(node); + } + }, + ExportAllDeclaration: checkNode, + // Add support for TypeScript import equals declarations + TSImportEqualsDeclaration(node) { + if (node.moduleReference.type === "TSExternalModuleReference") { + const importSource = node.moduleReference.expression.value; + const importNames = new Map(); + + // Use existing logic with the actual node + checkRestrictedPathAndReport( + importSource, + importNames, + node, + ); + restrictedPatternGroups.forEach(group => { + if (isRestrictedPattern(importSource, group)) { + reportPathForPatterns( + node, + group, + importNames, + importSource, + ); + } + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-modules.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-modules.js new file mode 100644 index 00000000..c09cb7d9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-modules.js @@ -0,0 +1,249 @@ +/** + * @fileoverview Restrict usage of specified node modules. + * @author Christian Schulz + * @deprecated in ESLint v7.0.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const ignore = require("ignore"); + +const arrayOfStrings = { + type: "array", + items: { type: "string" }, + uniqueItems: true, +}; + +const arrayOfStringsOrObjects = { + type: "array", + items: { + anyOf: [ + { type: "string" }, + { + type: "object", + properties: { + name: { type: "string" }, + message: { + type: "string", + minLength: 1, + }, + }, + additionalProperties: false, + required: ["name"], + }, + ], + }, + uniqueItems: true, +}; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-restricted-require", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-restricted-require.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow specified modules when loaded by `require`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-modules", + }, + + schema: { + anyOf: [ + arrayOfStringsOrObjects, + { + type: "array", + items: { + type: "object", + properties: { + paths: arrayOfStringsOrObjects, + patterns: arrayOfStrings, + }, + additionalProperties: false, + }, + additionalItems: false, + }, + ], + }, + + messages: { + defaultMessage: "'{{name}}' module is restricted from being used.", + customMessage: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{name}}' module is restricted from being used. {{customMessage}}", + patternMessage: + "'{{name}}' module is restricted from being used by a pattern.", + }, + }, + + create(context) { + const options = Array.isArray(context.options) ? context.options : []; + const isPathAndPatternsObject = + typeof options[0] === "object" && + (Object.hasOwn(options[0], "paths") || + Object.hasOwn(options[0], "patterns")); + + const restrictedPaths = + (isPathAndPatternsObject ? options[0].paths : context.options) || + []; + const restrictedPatterns = + (isPathAndPatternsObject ? options[0].patterns : []) || []; + + const restrictedPathMessages = restrictedPaths.reduce( + (memo, importName) => { + if (typeof importName === "string") { + memo[importName] = null; + } else { + memo[importName.name] = importName.message; + } + return memo; + }, + {}, + ); + + // if no imports are restricted we don't need to check + if ( + Object.keys(restrictedPaths).length === 0 && + restrictedPatterns.length === 0 + ) { + return {}; + } + + // relative paths are supported for this rule + const ig = ignore({ allowRelativePaths: true }).add(restrictedPatterns); + + /** + * Function to check if a node is a string literal. + * @param {ASTNode} node The node to check. + * @returns {boolean} If the node is a string literal. + */ + function isStringLiteral(node) { + return ( + node && + node.type === "Literal" && + typeof node.value === "string" + ); + } + + /** + * Function to check if a node is a require call. + * @param {ASTNode} node The node to check. + * @returns {boolean} If the node is a require call. + */ + function isRequireCall(node) { + return ( + node.callee.type === "Identifier" && + node.callee.name === "require" + ); + } + + /** + * Extract string from Literal or TemplateLiteral node + * @param {ASTNode} node The node to extract from + * @returns {string|null} Extracted string or null if node doesn't represent a string + */ + function getFirstArgumentString(node) { + if (isStringLiteral(node)) { + return node.value.trim(); + } + + if (astUtils.isStaticTemplateLiteral(node)) { + return node.quasis[0].value.cooked.trim(); + } + + return null; + } + + /** + * Report a restricted path. + * @param {node} node representing the restricted path reference + * @param {string} name restricted path + * @returns {void} + * @private + */ + function reportPath(node, name) { + const customMessage = restrictedPathMessages[name]; + const messageId = customMessage + ? "customMessage" + : "defaultMessage"; + + context.report({ + node, + messageId, + data: { + name, + customMessage, + }, + }); + } + + /** + * Check if the given name is a restricted path name + * @param {string} name name of a variable + * @returns {boolean} whether the variable is a restricted path or not + * @private + */ + function isRestrictedPath(name) { + return Object.hasOwn(restrictedPathMessages, name); + } + + return { + CallExpression(node) { + if (isRequireCall(node)) { + // node has arguments + if (node.arguments.length) { + const name = getFirstArgumentString(node.arguments[0]); + + // if first argument is a string literal or a static string template literal + if (name) { + // check if argument value is in restricted modules array + if (isRestrictedPath(name)) { + reportPath(node, name); + } + + if ( + restrictedPatterns.length > 0 && + ig.ignores(name) + ) { + context.report({ + node, + messageId: "patternMessage", + data: { name }, + }); + } + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-properties.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-properties.js new file mode 100644 index 00000000..8a671e0e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-properties.js @@ -0,0 +1,235 @@ +/** + * @fileoverview Rule to disallow certain object properties + * @author Will Klein & Eli White + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow certain properties on certain objects", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-properties", + }, + + schema: { + type: "array", + items: { + type: "object", + properties: { + object: { + type: "string", + }, + property: { + type: "string", + }, + allowObjects: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + allowProperties: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + message: { + type: "string", + }, + }, + anyOf: [ + { + required: ["object"], + }, + { + required: ["property"], + }, + ], + not: { + anyOf: [ + { required: ["allowObjects", "object"] }, + { required: ["allowProperties", "property"] }, + ], + }, + additionalProperties: false, + }, + uniqueItems: true, + }, + + defaultOptions: [], + + messages: { + restrictedObjectProperty: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{objectName}}.{{propertyName}}' is restricted from being used.{{allowedPropertiesMessage}}{{message}}", + restrictedProperty: + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + "'{{propertyName}}' is restricted from being used.{{allowedObjectsMessage}}{{message}}", + }, + }, + + create(context) { + const restrictedCalls = context.options; + + if (restrictedCalls.length === 0) { + return {}; + } + + const restrictedProperties = new Map(); + const globallyRestrictedObjects = new Map(); + const globallyRestrictedProperties = new Map(); + + restrictedCalls.forEach(option => { + const objectName = option.object; + const propertyName = option.property; + + if (typeof objectName === "undefined") { + globallyRestrictedProperties.set(propertyName, { + allowObjects: option.allowObjects, + message: option.message, + }); + } else if (typeof propertyName === "undefined") { + globallyRestrictedObjects.set(objectName, { + allowProperties: option.allowProperties, + message: option.message, + }); + } else { + if (!restrictedProperties.has(objectName)) { + restrictedProperties.set(objectName, new Map()); + } + + restrictedProperties.get(objectName).set(propertyName, { + message: option.message, + }); + } + }); + + /** + * Checks if a name is in the allowed list. + * @param {string} name The name to check + * @param {string[]} [allowedList] The list of allowed names + * @returns {boolean} True if the name is allowed, false otherwise + */ + function isAllowed(name, allowedList) { + if (!allowedList) { + return false; + } + + return allowedList.includes(name); + } + + /** + * Checks to see whether a property access is restricted, and reports it if so. + * @param {ASTNode} node The node to report + * @param {string} objectName The name of the object + * @param {string} propertyName The name of the property + * @returns {undefined} + */ + function checkPropertyAccess(node, objectName, propertyName) { + if (propertyName === null) { + return; + } + const matchedObject = restrictedProperties.get(objectName); + const matchedObjectProperty = matchedObject + ? matchedObject.get(propertyName) + : globallyRestrictedObjects.get(objectName); + const globalMatchedProperty = + globallyRestrictedProperties.get(propertyName); + + if ( + matchedObjectProperty && + !isAllowed(propertyName, matchedObjectProperty.allowProperties) + ) { + const message = matchedObjectProperty.message + ? ` ${matchedObjectProperty.message}` + : ""; + const allowedPropertiesMessage = + matchedObjectProperty.allowProperties + ? ` Only these properties are allowed: ${matchedObjectProperty.allowProperties.join(", ")}.` + : ""; + + context.report({ + node, + messageId: "restrictedObjectProperty", + data: { + objectName, + propertyName, + message, + allowedPropertiesMessage, + }, + }); + } else if ( + globalMatchedProperty && + !isAllowed(objectName, globalMatchedProperty.allowObjects) + ) { + const message = globalMatchedProperty.message + ? ` ${globalMatchedProperty.message}` + : ""; + const allowedObjectsMessage = globalMatchedProperty.allowObjects + ? ` Property '${propertyName}' is only allowed on these objects: ${globalMatchedProperty.allowObjects.join(", ")}.` + : ""; + + context.report({ + node, + messageId: "restrictedProperty", + data: { + propertyName, + message, + allowedObjectsMessage, + }, + }); + } + } + + return { + MemberExpression(node) { + checkPropertyAccess( + node, + node.object && node.object.name, + astUtils.getStaticPropertyName(node), + ); + }, + ObjectPattern(node) { + let objectName = null; + + if (node.parent.type === "VariableDeclarator") { + if ( + node.parent.init && + node.parent.init.type === "Identifier" + ) { + objectName = node.parent.init.name; + } + } else if ( + node.parent.type === "AssignmentExpression" || + node.parent.type === "AssignmentPattern" + ) { + if (node.parent.right.type === "Identifier") { + objectName = node.parent.right.name; + } + } + + node.properties.forEach(property => { + checkPropertyAccess( + node, + objectName, + astUtils.getStaticPropertyName(property), + ); + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-syntax.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-syntax.js new file mode 100644 index 00000000..c9453df9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-restricted-syntax.js @@ -0,0 +1,76 @@ +/** + * @fileoverview Rule to flag use of certain node types + * @author Burak Yigit Kaya + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow specified syntax", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-restricted-syntax", + }, + + schema: { + type: "array", + items: { + oneOf: [ + { + type: "string", + }, + { + type: "object", + properties: { + selector: { type: "string" }, + message: { type: "string" }, + }, + required: ["selector"], + additionalProperties: false, + }, + ], + }, + uniqueItems: true, + minItems: 0, + }, + + defaultOptions: [], + + messages: { + // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period + restrictedSyntax: "{{message}}", + }, + }, + + create(context) { + return context.options.reduce((result, selectorOrObject) => { + const isStringFormat = typeof selectorOrObject === "string"; + const hasCustomMessage = + !isStringFormat && Boolean(selectorOrObject.message); + + const selector = isStringFormat + ? selectorOrObject + : selectorOrObject.selector; + const message = hasCustomMessage + ? selectorOrObject.message + : `Using '${selector}' is not allowed.`; + + return Object.assign(result, { + [selector](node) { + context.report({ + node, + messageId: "restrictedSyntax", + data: { message }, + }); + }, + }); + }, {}); + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-assign.js new file mode 100644 index 00000000..92999ddf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-assign.js @@ -0,0 +1,87 @@ +/** + * @fileoverview Rule to flag when return statement contains assignment + * @author Ilya Volodin + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SENTINEL_TYPE = + /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: ["except-parens"], + + docs: { + description: "Disallow assignment operators in `return` statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-return-assign", + }, + + schema: [ + { + enum: ["except-parens", "always"], + }, + ], + + messages: { + returnAssignment: "Return statement should not contain assignment.", + arrowAssignment: "Arrow function should not return assignment.", + }, + }, + + create(context) { + const always = context.options[0] !== "except-parens"; + const sourceCode = context.sourceCode; + + return { + AssignmentExpression(node) { + if (!always && astUtils.isParenthesised(sourceCode, node)) { + return; + } + + let currentChild = node; + let parent = currentChild.parent; + + // Find ReturnStatement or ArrowFunctionExpression in ancestors. + while (parent && !SENTINEL_TYPE.test(parent.type)) { + currentChild = parent; + parent = parent.parent; + } + + // Reports. + if (parent && parent.type === "ReturnStatement") { + context.report({ + node: parent, + messageId: "returnAssignment", + }); + } else if ( + parent && + parent.type === "ArrowFunctionExpression" && + parent.body === currentChild + ) { + context.report({ + node: parent, + messageId: "arrowAssignment", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-await.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-await.js new file mode 100644 index 00000000..21627edd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-return-await.js @@ -0,0 +1,162 @@ +/** + * @fileoverview Disallows unnecessary `return await` + * @author Jordan Harband + * @deprecated in ESLint v8.46.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "suggestion", + + docs: { + description: "Disallow unnecessary `return await`", + + recommended: false, + + url: "https://eslint.org/docs/latest/rules/no-return-await", + }, + + fixable: null, + + deprecated: { + message: + "The original assumption of the rule no longer holds true because of engine optimization.", + deprecatedSince: "8.46.0", + availableUntil: null, + replacedBy: [], + }, + + schema: [], + + messages: { + removeAwait: "Remove redundant `await`.", + redundantUseOfAwait: "Redundant use of `await` on a return value.", + }, + }, + + create(context) { + /** + * Reports a found unnecessary `await` expression. + * @param {ASTNode} node The node representing the `await` expression to report + * @returns {void} + */ + function reportUnnecessaryAwait(node) { + context.report({ + node: context.sourceCode.getFirstToken(node), + loc: node.loc, + messageId: "redundantUseOfAwait", + suggest: [ + { + messageId: "removeAwait", + fix(fixer) { + const sourceCode = context.sourceCode; + const [awaitToken, tokenAfterAwait] = + sourceCode.getFirstTokens(node, 2); + + const areAwaitAndAwaitedExpressionOnTheSameLine = + awaitToken.loc.start.line === + tokenAfterAwait.loc.start.line; + + if (!areAwaitAndAwaitedExpressionOnTheSameLine) { + return null; + } + + const [startOfAwait, endOfAwait] = awaitToken.range; + + const characterAfterAwait = + sourceCode.text[endOfAwait]; + const trimLength = + characterAfterAwait === " " ? 1 : 0; + + const range = [ + startOfAwait, + endOfAwait + trimLength, + ]; + + return fixer.removeRange(range); + }, + }, + ], + }); + } + + /** + * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting + * this function. For example, a statement in a `try` block will always have an error handler. A statement in + * a `catch` block will only have an error handler if there is also a `finally` block. + * @param {ASTNode} node A node representing a location where an could be thrown + * @returns {boolean} `true` if a thrown error will be caught/handled in this function + */ + function hasErrorHandler(node) { + let ancestor = node; + + while ( + !astUtils.isFunction(ancestor) && + ancestor.type !== "Program" + ) { + if ( + ancestor.parent.type === "TryStatement" && + (ancestor === ancestor.parent.block || + (ancestor === ancestor.parent.handler && + ancestor.parent.finalizer)) + ) { + return true; + } + ancestor = ancestor.parent; + } + return false; + } + + /** + * Checks if a node is placed in tail call position. Once `return` arguments (or arrow function expressions) can be a complex expression, + * an `await` expression could or could not be unnecessary by the definition of this rule. So we're looking for `await` expressions that are in tail position. + * @param {ASTNode} node A node representing the `await` expression to check + * @returns {boolean} The checking result + */ + function isInTailCallPosition(node) { + if (node.parent.type === "ArrowFunctionExpression") { + return true; + } + if (node.parent.type === "ReturnStatement") { + return !hasErrorHandler(node.parent); + } + if ( + node.parent.type === "ConditionalExpression" && + (node === node.parent.consequent || + node === node.parent.alternate) + ) { + return isInTailCallPosition(node.parent); + } + if ( + node.parent.type === "LogicalExpression" && + node === node.parent.right + ) { + return isInTailCallPosition(node.parent); + } + if ( + node.parent.type === "SequenceExpression" && + node === node.parent.expressions.at(-1) + ) { + return isInTailCallPosition(node.parent); + } + return false; + } + + return { + AwaitExpression(node) { + if (isInTailCallPosition(node) && !hasErrorHandler(node)) { + reportUnnecessaryAwait(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-script-url.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-script-url.js new file mode 100644 index 00000000..632935dc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-script-url.js @@ -0,0 +1,66 @@ +/** + * @fileoverview Rule to disallow `javascript:` URLs + * @author Ilya Volodin + */ +/* eslint no-script-url: 0 -- Code is checking to report such URLs */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `javascript:` URLs", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-script-url", + }, + + schema: [], + + messages: { + unexpectedScriptURL: "Script URL is a form of eval.", + }, + }, + + create(context) { + /** + * Check whether a node's static value starts with `javascript:` or not. + * And report an error for unexpected script URL. + * @param {ASTNode} node node to check + * @returns {void} + */ + function check(node) { + const value = astUtils.getStaticStringValue(node); + + if ( + typeof value === "string" && + value.toLowerCase().indexOf("javascript:") === 0 + ) { + context.report({ node, messageId: "unexpectedScriptURL" }); + } + } + return { + Literal(node) { + if (node.value && typeof node.value === "string") { + check(node); + } + }, + TemplateLiteral(node) { + if (!( + node.parent && + node.parent.type === "TaggedTemplateExpression" + )) { + check(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-assign.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-assign.js new file mode 100644 index 00000000..c1831bb0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-assign.js @@ -0,0 +1,186 @@ +/** + * @fileoverview Rule to disallow assignments where both sides are exactly the same + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SPACES = /\s+/gu; + +/** + * Traverses 2 Pattern nodes in parallel, then reports self-assignments. + * @param {ASTNode|null} left A left node to traverse. This is a Pattern or + * a Property. + * @param {ASTNode|null} right A right node to traverse. This is a Pattern or + * a Property. + * @param {boolean} props The flag to check member expressions as well. + * @param {Function} report A callback function to report. + * @returns {void} + */ +function eachSelfAssignment(left, right, props, report) { + if (!left || !right) { + // do nothing + } else if ( + left.type === "Identifier" && + right.type === "Identifier" && + left.name === right.name + ) { + report(right); + } else if ( + left.type === "ArrayPattern" && + right.type === "ArrayExpression" + ) { + const end = Math.min(left.elements.length, right.elements.length); + + for (let i = 0; i < end; ++i) { + const leftElement = left.elements[i]; + const rightElement = right.elements[i]; + + // Avoid cases such as [...a] = [...a, 1] + if ( + leftElement && + leftElement.type === "RestElement" && + i < right.elements.length - 1 + ) { + break; + } + + eachSelfAssignment(leftElement, rightElement, props, report); + + // After a spread element, those indices are unknown. + if (rightElement && rightElement.type === "SpreadElement") { + break; + } + } + } else if (left.type === "RestElement" && right.type === "SpreadElement") { + eachSelfAssignment(left.argument, right.argument, props, report); + } else if ( + left.type === "ObjectPattern" && + right.type === "ObjectExpression" && + right.properties.length >= 1 + ) { + /* + * Gets the index of the last spread property. + * It's possible to overwrite properties followed by it. + */ + let startJ = 0; + + for (let i = right.properties.length - 1; i >= 0; --i) { + const propType = right.properties[i].type; + + if ( + propType === "SpreadElement" || + propType === "ExperimentalSpreadProperty" + ) { + startJ = i + 1; + break; + } + } + + for (let i = 0; i < left.properties.length; ++i) { + for (let j = startJ; j < right.properties.length; ++j) { + eachSelfAssignment( + left.properties[i], + right.properties[j], + props, + report, + ); + } + } + } else if ( + left.type === "Property" && + right.type === "Property" && + right.kind === "init" && + !right.method + ) { + const leftName = astUtils.getStaticPropertyName(left); + + if ( + leftName !== null && + leftName === astUtils.getStaticPropertyName(right) + ) { + eachSelfAssignment(left.value, right.value, props, report); + } + } else if ( + props && + astUtils.skipChainExpression(left).type === "MemberExpression" && + astUtils.skipChainExpression(right).type === "MemberExpression" && + astUtils.isSameReference(left, right) + ) { + report(right); + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [{ props: true }], + + docs: { + description: + "Disallow assignments where both sides are exactly the same", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-self-assign", + }, + + schema: [ + { + type: "object", + properties: { + props: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + selfAssignment: "'{{name}}' is assigned to itself.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ props }] = context.options; + + /** + * Reports a given node as self assignments. + * @param {ASTNode} node A node to report. This is an Identifier node. + * @returns {void} + */ + function report(node) { + context.report({ + node, + messageId: "selfAssignment", + data: { + name: sourceCode.getText(node).replace(SPACES, ""), + }, + }); + } + + return { + AssignmentExpression(node) { + if (["=", "&&=", "||=", "??="].includes(node.operator)) { + eachSelfAssignment(node.left, node.right, props, report); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-compare.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-compare.js new file mode 100644 index 00000000..ee05d3a6 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-self-compare.js @@ -0,0 +1,77 @@ +/** + * @fileoverview Rule to flag comparison where left part is the same as the right + * part. + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow comparisons where both sides are exactly the same", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-self-compare", + }, + + schema: [], + + messages: { + comparingToSelf: "Comparing to itself is potentially pointless.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Determines whether two nodes are composed of the same tokens. + * @param {ASTNode} nodeA The first node + * @param {ASTNode} nodeB The second node + * @returns {boolean} true if the nodes have identical token representations + */ + function hasSameTokens(nodeA, nodeB) { + const tokensA = sourceCode.getTokens(nodeA); + const tokensB = sourceCode.getTokens(nodeB); + + return ( + tokensA.length === tokensB.length && + tokensA.every( + (token, index) => + token.type === tokensB[index].type && + token.value === tokensB[index].value, + ) + ); + } + + return { + BinaryExpression(node) { + const operators = new Set([ + "===", + "==", + "!==", + "!=", + ">", + "<", + ">=", + "<=", + ]); + + if ( + operators.has(node.operator) && + hasSameTokens(node.left, node.right) + ) { + context.report({ node, messageId: "comparingToSelf" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sequences.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sequences.js new file mode 100644 index 00000000..96a8ba4e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sequences.js @@ -0,0 +1,158 @@ +/** + * @fileoverview Rule to flag use of comma operator + * @author Brandon Mills + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow comma operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-sequences", + }, + + schema: [ + { + type: "object", + properties: { + allowInParentheses: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + allowInParentheses: true, + }, + ], + + messages: { + unexpectedCommaExpression: "Unexpected use of comma operator.", + }, + }, + + create(context) { + const [{ allowInParentheses }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Parts of the grammar that are required to have parens. + */ + const parenthesized = { + DoWhileStatement: "test", + IfStatement: "test", + SwitchStatement: "discriminant", + WhileStatement: "test", + WithStatement: "object", + ArrowFunctionExpression: "body", + + /* + * Omitting CallExpression - commas are parsed as argument separators + * Omitting NewExpression - commas are parsed as argument separators + * Omitting ForInStatement - parts aren't individually parenthesised + * Omitting ForStatement - parts aren't individually parenthesised + */ + }; + + /** + * Determines whether a node is required by the grammar to be wrapped in + * parens, e.g. the test of an if statement. + * @param {ASTNode} node The AST node + * @returns {boolean} True if parens around node belong to parent node. + */ + function requiresExtraParens(node) { + return ( + node.parent && + parenthesized[node.parent.type] && + node === node.parent[parenthesized[node.parent.type]] + ); + } + + /** + * Check if a node is wrapped in parens. + * @param {ASTNode} node The AST node + * @returns {boolean} True if the node has a paren on each side. + */ + function isParenthesised(node) { + return astUtils.isParenthesised(sourceCode, node); + } + + /** + * Check if a node is wrapped in two levels of parens. + * @param {ASTNode} node The AST node + * @returns {boolean} True if two parens surround the node on each side. + */ + function isParenthesisedTwice(node) { + const previousToken = sourceCode.getTokenBefore(node, 1), + nextToken = sourceCode.getTokenAfter(node, 1); + + return ( + isParenthesised(node) && + previousToken && + nextToken && + astUtils.isOpeningParenToken(previousToken) && + previousToken.range[1] <= node.range[0] && + astUtils.isClosingParenToken(nextToken) && + nextToken.range[0] >= node.range[1] + ); + } + + return { + SequenceExpression(node) { + // Always allow sequences in for statement update + if ( + node.parent.type === "ForStatement" && + (node === node.parent.init || node === node.parent.update) + ) { + return; + } + + // Wrapping a sequence in extra parens indicates intent + if (allowInParentheses) { + if (requiresExtraParens(node)) { + if (isParenthesisedTwice(node)) { + return; + } + } else { + if (isParenthesised(node)) { + return; + } + } + } + + const firstCommaToken = sourceCode.getTokenAfter( + node.expressions[0], + astUtils.isCommaToken, + ); + + context.report({ + node, + loc: firstCommaToken.loc, + messageId: "unexpectedCommaExpression", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-setter-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-setter-return.js new file mode 100644 index 00000000..c71c4d18 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-setter-return.js @@ -0,0 +1,136 @@ +/** + * @fileoverview Rule to disallow returning values from setters + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the given function node is used as a setter function. + * @param {ASTNode} node The node to check. + * @param {SourceCode} sourceCode Source code to which the node belongs. + * @returns {boolean} `true` if the node is a setter. + */ +function isSetter(node, sourceCode) { + const parent = node.parent; + + if ( + (parent.type === "Property" || parent.type === "MethodDefinition") && + parent.kind === "set" && + parent.value === node + ) { + // Setter in an object literal or in a class + return true; + } + + if ( + parent.type === "Property" && + parent.value === node && + astUtils.getStaticPropertyName(parent) === "set" && + parent.parent.type === "ObjectExpression" && + astUtils.isPropertyDescriptor(parent.parent, sourceCode) + ) { + // Setter in a property descriptor + return true; + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow returning values from setters", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-setter-return", + }, + + schema: [], + + messages: { + returnsValue: "Setter cannot return a value.", + }, + }, + + create(context) { + let funcInfo = null; + const sourceCode = context.sourceCode; + + /** + * Creates and pushes to the stack a function info object for the given function node. + * @param {ASTNode} node The function node. + * @returns {void} + */ + function enterFunction(node) { + funcInfo = { + upper: funcInfo, + isSetter: isSetter(node, sourceCode), + }; + } + + /** + * Pops the current function info object from the stack. + * @returns {void} + */ + function exitFunction() { + funcInfo = funcInfo.upper; + } + + /** + * Reports the given node. + * @param {ASTNode} node Node to report. + * @returns {void} + */ + function report(node) { + context.report({ node, messageId: "returnsValue" }); + } + + return { + /* + * Function declarations cannot be setters, but we still have to track them in the `funcInfo` stack to avoid + * false positives, because a ReturnStatement node can belong to a function declaration inside a setter. + * + * Note: A previously declared function can be referenced and actually used as a setter in a property descriptor, + * but that's out of scope for this rule. + */ + FunctionDeclaration: enterFunction, + FunctionExpression: enterFunction, + ArrowFunctionExpression(node) { + enterFunction(node); + + if (funcInfo.isSetter && node.expression) { + // { set: foo => bar } property descriptor. Report implicit return 'bar' as the equivalent for a return statement. + report(node.body); + } + }, + + "FunctionDeclaration:exit": exitFunction, + "FunctionExpression:exit": exitFunction, + "ArrowFunctionExpression:exit": exitFunction, + + ReturnStatement(node) { + // Global returns (e.g., at the top level of a Node module) don't have `funcInfo`. + if (funcInfo && funcInfo.isSetter && node.argument) { + report(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow-restricted-names.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow-restricted-names.js new file mode 100644 index 00000000..4436c342 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow-restricted-names.js @@ -0,0 +1,113 @@ +/** + * @fileoverview Disallow shadowing of globalThis, NaN, undefined, and Infinity (ES2020 section 18.1) + * @author Michael Ficarra + */ +"use strict"; + +/** + * Determines if a variable safely shadows undefined. + * This is the case when a variable named `undefined` is never assigned to a value (i.e. it always shares the same value + * as the global). + * @param {eslintScope.Variable} variable The variable to check + * @returns {boolean} true if this variable safely shadows `undefined` + */ +function safelyShadowsUndefined(variable) { + return ( + variable.name === "undefined" && + variable.references.every(ref => !ref.isWrite()) && + variable.defs.every( + def => + def.node.type === "VariableDeclarator" && + def.node.init === null, + ) + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + reportGlobalThis: true, + }, + ], + + docs: { + description: "Disallow identifiers from shadowing restricted names", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-shadow-restricted-names", + }, + + schema: [ + { + type: "object", + properties: { + reportGlobalThis: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + shadowingRestrictedName: "Shadowing of global property '{{name}}'.", + }, + }, + + create(context) { + const [{ reportGlobalThis }] = context.options; + + const RESTRICTED = new Set([ + "undefined", + "NaN", + "Infinity", + "arguments", + "eval", + ]); + + if (reportGlobalThis) { + RESTRICTED.add("globalThis"); + } + + const sourceCode = context.sourceCode; + + // Track reported nodes to avoid duplicate reports. For example, on class declarations. + const reportedNodes = new Set(); + + return { + "VariableDeclaration, :function, CatchClause, ImportDeclaration, ClassDeclaration, ClassExpression"( + node, + ) { + for (const variable of sourceCode.getDeclaredVariables(node)) { + if ( + variable.defs.length > 0 && + RESTRICTED.has(variable.name) && + !safelyShadowsUndefined(variable) + ) { + for (const def of variable.defs) { + const nodeToReport = def.name; + + if (!reportedNodes.has(nodeToReport)) { + reportedNodes.add(nodeToReport); + context.report({ + node: nodeToReport, + messageId: "shadowingRestrictedName", + data: { + name: variable.name, + }, + }); + } + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow.js new file mode 100644 index 00000000..0c55ca9e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-shadow.js @@ -0,0 +1,688 @@ +/** + * @fileoverview Rule to flag on declaring variables already declared in the outer scope + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const FUNC_EXPR_NODE_TYPES = new Set([ + "ArrowFunctionExpression", + "FunctionExpression", +]); +const CALL_EXPR_NODE_TYPE = new Set(["CallExpression"]); +const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u; +const SENTINEL_TYPE = + /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u; + +// TS-specific node types +const TYPES_HOISTED_NODES = new Set([ + "TSInterfaceDeclaration", + "TSTypeAliasDeclaration", +]); + +// TS-specific function variable def types +const ALLOWED_FUNCTION_VARIABLE_DEF_TYPES = new Set([ + "TSCallSignatureDeclaration", + "TSFunctionType", + "TSMethodSignature", + "TSEmptyBodyFunctionExpression", + "TSDeclareFunction", + "TSConstructSignatureDeclaration", + "TSConstructorType", +]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allow: [], + builtinGlobals: false, + hoist: "functions", + ignoreOnInitialization: false, + ignoreTypeValueShadow: true, + ignoreFunctionTypeParameterNameValueShadow: true, + }, + ], + + docs: { + description: + "Disallow variable declarations from shadowing variables declared in the outer scope", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-shadow", + }, + + schema: [ + { + type: "object", + properties: { + builtinGlobals: { type: "boolean" }, + hoist: { + enum: [ + "all", + "functions", + "never", + "types", + "functions-and-types", + ], + }, + allow: { + type: "array", + items: { + type: "string", + }, + }, + ignoreOnInitialization: { type: "boolean" }, + ignoreTypeValueShadow: { type: "boolean" }, + ignoreFunctionTypeParameterNameValueShadow: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + noShadow: + "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.", + noShadowGlobal: "'{{name}}' is already a global variable.", + }, + }, + + create(context) { + const [ + { + builtinGlobals, + hoist, + allow, + ignoreOnInitialization, + ignoreTypeValueShadow, + ignoreFunctionTypeParameterNameValueShadow, + }, + ] = context.options; + const sourceCode = context.sourceCode; + + /** + * Check if a scope is a TypeScript module augmenting the global namespace. + * @param {Scope} scope The scope to check + * @returns {boolean} Whether the scope is a global augmentation + */ + function isGlobalAugmentation(scope) { + return ( + scope.block.kind === "global" || + (!!scope.upper && isGlobalAugmentation(scope.upper)) + ); + } + + /** + * Check if variable is a `this` parameter. + * @param {Object} variable The variable to check + * @returns {boolean} Whether the variable is a this parameter + */ + function isThisParam(variable) { + return variable.name === "this"; + } + + /** + * Checks if type and value shadows each other + * @param {Object} variable The variable to check + * @param {Object} shadowedVariable The shadowed variable + * @returns {boolean} Whether it's a type/value shadow case to ignore + */ + function isTypeValueShadow(variable, shadowedVariable) { + if (ignoreTypeValueShadow !== true) { + return false; + } + + if (!("isValueVariable" in variable)) { + return false; + } + + const firstDefinition = shadowedVariable.defs[0]; + + // Check if shadowedVariable is a type import + const isTypeImport = + firstDefinition && + firstDefinition.parent?.type === "ImportDeclaration" && + (firstDefinition.parent.importKind === "type" || + firstDefinition.parent.specifiers.some( + s => s.importKind === "type", + )); + + const isShadowedValue = + !firstDefinition || + (isTypeImport ? false : shadowedVariable.isValueVariable); + + return variable.isValueVariable !== isShadowedValue; + } + + /** + * Checks if it's a function type parameter shadow + * @param {Object} variable The variable to check + * @returns {boolean} Whether it's a function type parameter shadow case to ignore + */ + function isFunctionTypeParameterNameValueShadow(variable) { + if (ignoreFunctionTypeParameterNameValueShadow !== true) { + return false; + } + + return variable.defs.some(def => + ALLOWED_FUNCTION_VARIABLE_DEF_TYPES.has(def.node.type), + ); + } + + /** + * Checks if the variable is a generic of a static method + * @param {Object} variable The variable to check + * @returns {boolean} Whether the variable is a generic of a static method + */ + function isTypeParameterOfStaticMethod(variable) { + const typeParameter = variable.identifiers[0].parent; + const typeParameterDecl = typeParameter.parent; + if (typeParameterDecl.type !== "TSTypeParameterDeclaration") { + return false; + } + const functionExpr = typeParameterDecl.parent; + const methodDefinition = functionExpr.parent; + return methodDefinition.static; + } + + /** + * Checks for static method generic shadowing class generic + * @param {Object} variable The variable to check + * @returns {boolean} Whether it's a static method generic shadowing class generic + */ + function isGenericOfAStaticMethodShadow(variable) { + return isTypeParameterOfStaticMethod(variable); + } + + /** + * Checks whether or not a given location is inside of the range of a given node. + * @param {ASTNode} node An node to check. + * @param {number} location A location to check. + * @returns {boolean} `true` if the location is inside of the range of the node. + */ + function isInRange(node, location) { + return ( + node && node.range[0] <= location && location <= node.range[1] + ); + } + + /** + * Searches from the current node through its ancestry to find a matching node. + * @param {ASTNode} node a node to get. + * @param {(node: ASTNode) => boolean} match a callback that checks whether or not the node verifies its condition or not. + * @returns {ASTNode|null} the matching node. + */ + function findSelfOrAncestor(node, match) { + let currentNode = node; + + while (currentNode && !match(currentNode)) { + currentNode = currentNode.parent; + } + return currentNode; + } + + /** + * Finds function's outer scope. + * @param {Scope} scope Function's own scope. + * @returns {Scope} Function's outer scope. + */ + function getOuterScope(scope) { + const upper = scope.upper; + + if (upper && upper.type === "function-expression-name") { + return upper.upper; + } + return upper; + } + + /** + * Checks if a variable and a shadowedVariable have the same init pattern ancestor. + * @param {Object} variable a variable to check. + * @param {Object} shadowedVariable a shadowedVariable to check. + * @returns {boolean} Whether or not the variable and the shadowedVariable have the same init pattern ancestor. + */ + function isInitPatternNode(variable, shadowedVariable) { + const outerDef = shadowedVariable.defs[0]; + + if (!outerDef) { + return false; + } + + const { variableScope } = variable.scope; + + if (!( + FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) && + getOuterScope(variableScope) === shadowedVariable.scope + )) { + return false; + } + + const fun = variableScope.block; + const { parent } = fun; + + const callExpression = findSelfOrAncestor(parent, node => + CALL_EXPR_NODE_TYPE.has(node.type), + ); + + if (!callExpression) { + return false; + } + + let node = outerDef.name; + const location = callExpression.range[1]; + + while (node) { + if (node.type === "VariableDeclarator") { + if (isInRange(node.init, location)) { + return true; + } + if ( + FOR_IN_OF_TYPE.test(node.parent.parent.type) && + isInRange(node.parent.parent.right, location) + ) { + return true; + } + break; + } else if (node.type === "AssignmentPattern") { + if (isInRange(node.right, location)) { + return true; + } + } else if (SENTINEL_TYPE.test(node.type)) { + break; + } + + node = node.parent; + } + + return false; + } + + /** + * Check if variable name is allowed. + * @param {ASTNode} variable The variable to check. + * @returns {boolean} Whether or not the variable name is allowed. + */ + function isAllowed(variable) { + return allow.includes(variable.name); + } + + /** + * Checks if a variable of the class name in the class scope of ClassDeclaration. + * + * ClassDeclaration creates two variables of its name into its outer scope and its class scope. + * So we should ignore the variable in the class scope. + * @param {Object} variable The variable to check. + * @returns {boolean} Whether or not the variable of the class name in the class scope of ClassDeclaration. + */ + function isDuplicatedClassNameVariable(variable) { + const block = variable.scope.block; + + return ( + block.type === "ClassDeclaration" && + block.id === variable.identifiers[0] + ); + } + + /** + * Finds the uppermost expression node that can evaluate to the given one. + * + * Examples: + * If given `a` in `a || foo`, it returns the `a || foo` node. + * If given `a` in `foo ? a : bar`, it returns the `foo ? a : bar` node. + * If given `a` in `foo ? bar : (baz && a)`, it returns the `foo ? bar : (baz && a)` node. + * If given `a` in `a ? foo : bar`, it returns the `a` node. + * If given `a` in `foo(a)`, it returns the `a` node. + * @param {ASTNode} expression The expression node to unwrap. + * @returns {ASTNode} The uppermost ancestor that can evaluate to the given node + * or the given node if there is no such ancestor. + */ + function unwrapExpression(expression) { + const { parent } = expression; + + const shouldUnwrap = + parent.type === "LogicalExpression" || + (parent.type === "ConditionalExpression" && + parent.test !== expression); + + return shouldUnwrap ? unwrapExpression(parent) : expression; + } + + /** + * Checks if inner variable is the name of a function or class + * that is assigned to outer variable as its initializer. + * + * To avoid reporting at declarations such as: + * var a = function a() {}; + * var A = class A {}; + * var a = foo || function a() {}; + * var a = foo ? function a() {} : bar; + * var { a = function a() {} } = foo; + * + * But it should report at declarations such as: + * var a = function(a) {}; + * var a = function() { function a() {} }; + * var a = wrap(function a() {}); + * @param {Object} innerVariable The inner variable to check. + * @param {Object} outerVariable The outer variable. + * @returns {boolean} Whether or not inner variable is the name of a + * function or class that is assigned to outer variable as its initializer. + */ + function isFunctionNameInitializerException( + innerVariable, + outerVariable, + ) { + const outerDef = outerVariable.defs[0]; + const innerDef = innerVariable.defs[0]; + + if (!outerDef || !innerDef) { + return false; + } + + if (!( + (innerDef.type === "FunctionName" && + innerDef.node.type === "FunctionExpression") || + (innerDef.type === "ClassName" && + innerDef.node.type === "ClassExpression") + )) { + return false; + } + + const outerIdentifier = outerDef.name; + let initializerNode; + + if (outerIdentifier.parent.type === "VariableDeclarator") { + initializerNode = outerIdentifier.parent.init; + } else if (outerIdentifier.parent.type === "AssignmentPattern") { + initializerNode = outerIdentifier.parent.right; + } + + if (!initializerNode) { + return false; + } + + const nodeToCheck = innerDef.node; // FunctionExpression or ClassExpression node + + // Exit early if the node to check isn't inside the initializer + if (!( + initializerNode.range[0] <= nodeToCheck.range[0] && + nodeToCheck.range[1] <= initializerNode.range[1] + )) { + return false; + } + + return initializerNode === unwrapExpression(nodeToCheck); + } + + /** + * Get a range of a variable's identifier node. + * @param {Object} variable The variable to get. + * @returns {Array|undefined} The range of the variable's identifier node. + */ + function getNameRange(variable) { + const def = variable.defs[0]; + + return def && def.name.range; + } + + /** + * Get declared line and column of a variable. + * @param {Variable} variable The variable to get. + * @returns {Object} The declared line and column of the variable. + */ + function getDeclaredLocation(variable) { + const identifier = variable.identifiers[0]; + let obj; + + if (identifier) { + obj = { + global: false, + line: identifier.loc.start.line, + column: identifier.loc.start.column + 1, + }; + } else { + obj = { + global: true, + }; + } + return obj; + } + + /** + * Checks if a variable is in TDZ of scopeVar. + * @param {Object} variable The variable to check. + * @param {Object} scopeVar The variable of TDZ. + * @returns {boolean} Whether or not the variable is in TDZ of scopeVar. + */ + function isInTdz(variable, scopeVar) { + const outerDef = scopeVar.defs[0]; + const inner = getNameRange(variable); + const outer = getNameRange(scopeVar); + + if (!outer || inner[1] >= outer[0]) { + return false; + } + + if (hoist === "types") { + return !TYPES_HOISTED_NODES.has(outerDef.node.type); + } + + if (hoist === "functions-and-types") { + return ( + outerDef.node.type !== "FunctionDeclaration" && + !TYPES_HOISTED_NODES.has(outerDef.node.type) + ); + } + + return ( + inner && + outer && + inner[1] < outer[0] && + // Excepts FunctionDeclaration if is {"hoist":"function"}. + (hoist !== "functions" || + !outerDef || + outerDef.node.type !== "FunctionDeclaration") + ); + } + + /** + * Checks if the initialization of a variable has the declare modifier in a + * definition file. + * @param {Object} variable The variable to check + * @returns {boolean} Whether the variable is declared in a definition file + */ + function isDeclareInDTSFile(variable) { + const fileName = context.filename; + if ( + !fileName.endsWith(".d.ts") && + !fileName.endsWith(".d.cts") && + !fileName.endsWith(".d.mts") + ) { + return false; + } + return variable.defs.some( + def => + (def.type === "Variable" && def.parent.declare) || + (def.type === "ClassName" && def.node.declare) || + (def.type === "TSEnumName" && def.node.declare) || + (def.type === "TSModuleName" && def.node.declare), + ); + } + + /** + * Checks if a variable is a duplicate of an enum name in the enum scope + * @param {Object} variable The variable to check + * @returns {boolean} Whether it's a duplicate enum name variable + */ + function isDuplicatedEnumNameVariable(variable) { + const block = variable.scope.block; + + return ( + block.type === "TSEnumDeclaration" && + block.id === variable.identifiers[0] + ); + } + + /** + * Check if this is an external module declaration merging with a type import + * @param {Scope} scope Current scope + * @param {Object} variable Current variable + * @param {Object} shadowedVariable Shadowed variable + * @returns {boolean} Whether it's an external declaration merging + */ + function isExternalDeclarationMerging( + scope, + variable, + shadowedVariable, + ) { + const firstDefinition = shadowedVariable.defs[0]; + + if (!firstDefinition || !firstDefinition.parent) { + return false; + } + + // Check if the shadowed variable is a type import + const isTypeImport = + firstDefinition.parent.type === "ImportDeclaration" && + (firstDefinition.parent.importKind === "type" || + firstDefinition.parent.specifiers?.some( + s => + s.type === "ImportSpecifier" && + s.importKind === "type" && + s.local.name === shadowedVariable.name, + )); + + if (!isTypeImport) { + return false; + } + + // Check if the current variable is within a module declaration + const moduleDecl = findSelfOrAncestor( + variable.identifiers[0]?.parent, + node => node.type === "TSModuleDeclaration", + ); + + if (!moduleDecl) { + return false; + } + + /* + * Module declaration merging should only happen within the same module + * Check if the module name matches the import source + */ + const importSource = firstDefinition.parent.source.value; + const moduleName = + moduleDecl.id.type === "Literal" + ? moduleDecl.id.value + : moduleDecl.id.name; + + return importSource === moduleName; + } + + /** + * Checks the current context for shadowed variables. + * @param {Scope} scope The scope to check for shadowed variables. + * @returns {void} + */ + function checkForShadows(scope) { + // ignore global augmentation + if (isGlobalAugmentation(scope)) { + return; + } + + const variables = scope.variables; + + for (let i = 0; i < variables.length; ++i) { + const variable = variables[i]; + + // Skips "arguments" or variables of a class name in the class scope of ClassDeclaration. + if ( + variable.identifiers.length === 0 || + isDuplicatedClassNameVariable(variable) || + isDuplicatedEnumNameVariable(variable) || + isAllowed(variable) || + isDeclareInDTSFile(variable) || + isThisParam(variable) + ) { + continue; + } + + // Gets shadowed variable. + const shadowed = astUtils.getVariableByName( + scope.upper, + variable.name, + ); + + if ( + shadowed && + (shadowed.identifiers.length > 0 || + (builtinGlobals && "writeable" in shadowed)) && + !isFunctionNameInitializerException(variable, shadowed) && + !( + ignoreOnInitialization && + isInitPatternNode(variable, shadowed) + ) && + !(hoist !== "all" && isInTdz(variable, shadowed)) && + !isTypeValueShadow(variable, shadowed) && + !isFunctionTypeParameterNameValueShadow(variable) && + !isGenericOfAStaticMethodShadow(variable, shadowed) && + !isExternalDeclarationMerging(scope, variable, shadowed) + ) { + const location = getDeclaredLocation(shadowed); + const messageId = location.global + ? "noShadowGlobal" + : "noShadow"; + const data = { name: variable.name }; + + if (!location.global) { + data.shadowedLine = location.line; + data.shadowedColumn = location.column; + } + context.report({ + node: variable.identifiers[0], + messageId, + data, + }); + } + } + } + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + const stack = globalScope.childScopes.slice(); + + while (stack.length) { + const scope = stack.pop(); + + stack.push(...scope.childScopes); + checkForShadows(scope); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-spaced-func.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-spaced-func.js new file mode 100644 index 00000000..7d8cad60 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-spaced-func.js @@ -0,0 +1,105 @@ +/** + * @fileoverview Rule to check that spaced function application + * @author Matt DuVall + * @deprecated in ESLint v3.3.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + docs: { + description: + "Disallow spacing between function identifiers and their applications (deprecated)", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-spaced-func", + }, + + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules", + deprecatedSince: "3.3.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "function-call-spacing", + url: "https://eslint.style/rules/function-call-spacing", + }, + }, + ], + }, + + fixable: "whitespace", + schema: [], + + messages: { + noSpacedFunction: + "Unexpected space between function name and paren.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Check if open space is present in a function name + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function detectOpenSpaces(node) { + const lastCalleeToken = sourceCode.getLastToken(node.callee); + let prevToken = lastCalleeToken, + parenToken = sourceCode.getTokenAfter(lastCalleeToken); + + // advances to an open parenthesis. + while ( + parenToken && + parenToken.range[1] < node.range[1] && + parenToken.value !== "(" + ) { + prevToken = parenToken; + parenToken = sourceCode.getTokenAfter(parenToken); + } + + // look for a space between the callee and the open paren + if ( + parenToken && + parenToken.range[1] < node.range[1] && + sourceCode.isSpaceBetween(prevToken, parenToken) + ) { + context.report({ + node, + loc: lastCalleeToken.loc.start, + messageId: "noSpacedFunction", + fix(fixer) { + return fixer.removeRange([ + prevToken.range[1], + parenToken.range[0], + ]); + }, + }); + } + } + + return { + CallExpression: detectOpenSpaces, + NewExpression: detectOpenSpaces, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sparse-arrays.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sparse-arrays.js new file mode 100644 index 00000000..f805ecef --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sparse-arrays.js @@ -0,0 +1,68 @@ +/** + * @fileoverview Disallow sparse arrays + * @author Nicholas C. Zakas + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow sparse arrays", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-sparse-arrays", + }, + + schema: [], + + messages: { + unexpectedSparseArray: "Unexpected comma in middle of array.", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ArrayExpression(node) { + if (!node.elements.includes(null)) { + return; + } + + const { sourceCode } = context; + let commaToken; + + for (const [index, element] of node.elements.entries()) { + if (index === node.elements.length - 1 && element) { + return; + } + + commaToken = sourceCode.getTokenAfter( + element ?? commaToken ?? sourceCode.getFirstToken(node), + astUtils.isCommaToken, + ); + + if (element) { + continue; + } + + context.report({ + node, + loc: commaToken.loc, + messageId: "unexpectedSparseArray", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sync.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sync.js new file mode 100644 index 00000000..50b5860e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-sync.js @@ -0,0 +1,81 @@ +/** + * @fileoverview Rule to check for properties whose identifier ends with the string Sync + * @author Matt DuVall + * @deprecated in ESLint v7.0.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Node.js rules were moved out of ESLint core.", + url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules", + deprecatedSince: "7.0.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "eslint-plugin-n now maintains deprecated Node.js-related rules.", + plugin: { + name: "eslint-plugin-n", + url: "https://github.com/eslint-community/eslint-plugin-n", + }, + rule: { + name: "no-sync", + url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-sync.md", + }, + }, + ], + }, + + type: "suggestion", + + docs: { + description: "Disallow synchronous methods", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-sync", + }, + + schema: [ + { + type: "object", + properties: { + allowAtRootLevel: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + noSync: "Unexpected sync method: '{{propertyName}}'.", + }, + }, + + create(context) { + const selector = + context.options[0] && context.options[0].allowAtRootLevel + ? ":function MemberExpression[property.name=/.*Sync$/]" + : "MemberExpression[property.name=/.*Sync$/]"; + + return { + [selector](node) { + context.report({ + node, + messageId: "noSync", + data: { + propertyName: node.property.name, + }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-tabs.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-tabs.js new file mode 100644 index 00000000..f35f4da0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-tabs.js @@ -0,0 +1,110 @@ +/** + * @fileoverview Rule to check for tabs inside a file + * @author Gyandeep Singh + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const tabRegex = /\t+/gu; +const anyNonWhitespaceRegex = /\S/u; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-tabs", + url: "https://eslint.style/rules/no-tabs", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow all tabs", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-tabs", + }, + schema: [ + { + type: "object", + properties: { + allowIndentationTabs: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedTab: "Unexpected tab character.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const allowIndentationTabs = + context.options && + context.options[0] && + context.options[0].allowIndentationTabs; + + return { + Program(node) { + sourceCode.getLines().forEach((line, index) => { + let match; + + while ((match = tabRegex.exec(line)) !== null) { + if ( + allowIndentationTabs && + !anyNonWhitespaceRegex.test( + line.slice(0, match.index), + ) + ) { + continue; + } + + context.report({ + node, + loc: { + start: { + line: index + 1, + column: match.index, + }, + end: { + line: index + 1, + column: match.index + match[0].length, + }, + }, + messageId: "unexpectedTab", + }); + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-template-curly-in-string.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-template-curly-in-string.js new file mode 100644 index 00000000..901e1aea --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-template-curly-in-string.js @@ -0,0 +1,45 @@ +/** + * @fileoverview Warn when using template string syntax in regular strings + * @author Jeroen Engels + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow template literal placeholder syntax in regular strings", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-template-curly-in-string", + }, + + schema: [], + + messages: { + unexpectedTemplateExpression: + "Unexpected template string expression.", + }, + }, + + create(context) { + const regex = /\$\{[^}]+\}/u; + + return { + Literal(node) { + if (typeof node.value === "string" && regex.test(node.value)) { + context.report({ + node, + messageId: "unexpectedTemplateExpression", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ternary.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ternary.js new file mode 100644 index 00000000..f58136d5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-ternary.js @@ -0,0 +1,38 @@ +/** + * @fileoverview Rule to flag use of ternary operators. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow ternary operators", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-ternary", + }, + + schema: [], + + messages: { + noTernaryOperator: "Ternary operator used.", + }, + }, + + create(context) { + return { + ConditionalExpression(node) { + context.report({ node, messageId: "noTernaryOperator" }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-this-before-super.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-this-before-super.js new file mode 100644 index 00000000..27ba94a2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-this-before-super.js @@ -0,0 +1,363 @@ +/** + * @fileoverview A rule to disallow using `this`/`super` before `super()`. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given node is a constructor. + * @param {ASTNode} node A node to check. This node type is one of + * `Program`, `FunctionDeclaration`, `FunctionExpression`, and + * `ArrowFunctionExpression`. + * @returns {boolean} `true` if the node is a constructor. + */ +function isConstructorFunction(node) { + return ( + node.type === "FunctionExpression" && + node.parent.type === "MethodDefinition" && + node.parent.kind === "constructor" + ); +} + +/* + * Information for each code path segment. + * - superCalled: The flag which shows `super()` called in all code paths. + * - invalidNodes: The array of invalid ThisExpression and Super nodes. + */ +/** + * + */ +class SegmentInfo { + /** + * Indicates whether `super()` is called in all code paths. + * @type {boolean} + */ + superCalled = false; + + /** + * The array of invalid ThisExpression and Super nodes. + * @type {ASTNode[]} + */ + invalidNodes = []; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow `this`/`super` before calling `super()` in constructors", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-this-before-super", + }, + + schema: [], + + messages: { + noBeforeSuper: "'{{kind}}' is not allowed before 'super()'.", + }, + }, + + create(context) { + /* + * Information for each constructor. + * - upper: Information of the upper constructor. + * - hasExtends: A flag which shows whether the owner class has a valid + * `extends` part. + * - scope: The scope of the owner class. + * - codePath: The code path of this constructor. + */ + let funcInfo = null; + + /** @type {Record} */ + let segInfoMap = Object.create(null); + + /** + * Gets whether or not `super()` is called in a given code path segment. + * @param {CodePathSegment} segment A code path segment to get. + * @returns {boolean} `true` if `super()` is called. + */ + function isCalled(segment) { + return !segment.reachable || segInfoMap[segment.id]?.superCalled; + } + + /** + * Checks whether or not this is in a constructor. + * @returns {boolean} `true` if this is in a constructor. + */ + function isInConstructorOfDerivedClass() { + return Boolean( + funcInfo && funcInfo.isConstructor && funcInfo.hasExtends, + ); + } + + /** + * Determines if every segment in a set has been called. + * @param {Set} segments The segments to search. + * @returns {boolean} True if every segment has been called; false otherwise. + */ + function isEverySegmentCalled(segments) { + for (const segment of segments) { + if (!isCalled(segment)) { + return false; + } + } + + return true; + } + + /** + * Checks whether or not this is before `super()` is called. + * @returns {boolean} `true` if this is before `super()` is called. + */ + function isBeforeCallOfSuper() { + return ( + isInConstructorOfDerivedClass() && + !isEverySegmentCalled(funcInfo.currentSegments) + ); + } + + /** + * Sets a given node as invalid. + * @param {ASTNode} node A node to set as invalid. This is one of + * a ThisExpression and a Super. + * @returns {void} + */ + function setInvalid(node) { + const segments = funcInfo.currentSegments; + + for (const segment of segments) { + if (segment.reachable) { + segInfoMap[segment.id].invalidNodes.push(node); + } + } + } + + /** + * Sets the current segment as `super` was called. + * @returns {void} + */ + function setSuperCalled() { + const segments = funcInfo.currentSegments; + + for (const segment of segments) { + if (segment.reachable) { + segInfoMap[segment.id].superCalled = true; + } + } + } + + return { + /** + * Adds information of a constructor into the stack. + * @param {CodePath} codePath A code path which was started. + * @param {ASTNode} node The current node. + * @returns {void} + */ + onCodePathStart(codePath, node) { + if (isConstructorFunction(node)) { + // Class > ClassBody > MethodDefinition > FunctionExpression + const classNode = node.parent.parent.parent; + + funcInfo = { + upper: funcInfo, + isConstructor: true, + hasExtends: Boolean( + classNode.superClass && + !astUtils.isNullOrUndefined(classNode.superClass), + ), + codePath, + currentSegments: new Set(), + }; + } else { + funcInfo = { + upper: funcInfo, + isConstructor: false, + hasExtends: false, + codePath, + currentSegments: new Set(), + }; + } + }, + + /** + * Removes the top of stack item. + * + * And this traverses all segments of this code path then reports every + * invalid node. + * @param {CodePath} codePath A code path which was ended. + * @returns {void} + */ + onCodePathEnd(codePath) { + const isDerivedClass = funcInfo.hasExtends; + + funcInfo = funcInfo.upper; + if (!isDerivedClass) { + return; + } + + /** + * A collection of nodes to avoid duplicate reports. + * @type {Set} + */ + const reported = new Set(); + + codePath.traverseSegments((segment, controller) => { + const info = segInfoMap[segment.id]; + const invalidNodes = info.invalidNodes.filter( + /* + * Avoid duplicate reports. + * When there is a `finally`, invalidNodes may contain already reported node. + */ + node => !reported.has(node), + ); + + for (const invalidNode of invalidNodes) { + reported.add(invalidNode); + + context.report({ + messageId: "noBeforeSuper", + node: invalidNode, + data: { + kind: + invalidNode.type === "Super" + ? "super" + : "this", + }, + }); + } + + if (info.superCalled) { + controller.skip(); + } + }); + }, + + /** + * Initialize information of a given code path segment. + * @param {CodePathSegment} segment A code path segment to initialize. + * @returns {void} + */ + onCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + + if (!isInConstructorOfDerivedClass()) { + return; + } + + // Initialize info. + segInfoMap[segment.id] = { + superCalled: + segment.prevSegments.length > 0 && + segment.prevSegments.every(isCalled), + invalidNodes: [], + }; + }, + + onUnreachableCodePathSegmentStart(segment) { + funcInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + funcInfo.currentSegments.delete(segment); + }, + + /** + * Update information of the code path segment when a code path was + * looped. + * @param {CodePathSegment} fromSegment The code path segment of the + * end of a loop. + * @param {CodePathSegment} toSegment A code path segment of the head + * of a loop. + * @returns {void} + */ + onCodePathSegmentLoop(fromSegment, toSegment) { + if (!isInConstructorOfDerivedClass()) { + return; + } + + // Update information inside of the loop. + funcInfo.codePath.traverseSegments( + { first: toSegment, last: fromSegment }, + (segment, controller) => { + const info = + segInfoMap[segment.id] ?? new SegmentInfo(); + + if (info.superCalled) { + controller.skip(); + } else if ( + segment.prevSegments.length > 0 && + segment.prevSegments.every(isCalled) + ) { + info.superCalled = true; + } + + segInfoMap[segment.id] = info; + }, + ); + }, + + /** + * Reports if this is before `super()`. + * @param {ASTNode} node A target node. + * @returns {void} + */ + ThisExpression(node) { + if (isBeforeCallOfSuper()) { + setInvalid(node); + } + }, + + /** + * Reports if this is before `super()`. + * @param {ASTNode} node A target node. + * @returns {void} + */ + Super(node) { + if (!astUtils.isCallee(node) && isBeforeCallOfSuper()) { + setInvalid(node); + } + }, + + /** + * Marks `super()` called. + * @param {ASTNode} node A target node. + * @returns {void} + */ + "CallExpression:exit"(node) { + if (node.callee.type === "Super" && isBeforeCallOfSuper()) { + setSuperCalled(); + } + }, + + /** + * Resets state. + * @returns {void} + */ + "Program:exit"() { + segInfoMap = Object.create(null); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-throw-literal.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-throw-literal.js new file mode 100644 index 00000000..89348a1e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-throw-literal.js @@ -0,0 +1,51 @@ +/** + * @fileoverview Rule to restrict what can be thrown as an exception. + * @author Dieter Oberkofler + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow throwing literals as exceptions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-throw-literal", + }, + + schema: [], + + messages: { + object: "Expected an error object to be thrown.", + undef: "Do not throw undefined.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + ThrowStatement(node) { + if (!astUtils.couldBeError(node.argument)) { + context.report({ node, messageId: "object" }); + } else if (node.argument.type === "Identifier") { + if ( + node.argument.name === "undefined" && + sourceCode.isGlobalReference(node.argument) + ) { + context.report({ node, messageId: "undef" }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-trailing-spaces.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-trailing-spaces.js new file mode 100644 index 00000000..14c66db4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-trailing-spaces.js @@ -0,0 +1,227 @@ +/** + * @fileoverview Disallow trailing spaces at the end of lines. + * @author Nodeca Team + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @import { SourceLocation, SourceRange } from "@eslint/core"; + */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-trailing-spaces", + url: "https://eslint.style/rules/no-trailing-spaces", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow trailing whitespace at the end of lines", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-trailing-spaces", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + skipBlankLines: { + type: "boolean", + default: false, + }, + ignoreComments: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + trailingSpace: "Trailing spaces not allowed.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const BLANK_CLASS = + "[ \t\u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u3000]", + SKIP_BLANK = `^${BLANK_CLASS}*$`, + NONBLANK = `${BLANK_CLASS}+$`; + + const options = context.options[0] || {}, + skipBlankLines = options.skipBlankLines || false, + ignoreComments = options.ignoreComments || false; + + /** + * Report the error message + * @param {ASTNode} node node to report + * @param {SourceLocation} location range information + * @param {SourceRange} fixRange Range based on the whole program + * @returns {void} + */ + function report(node, location, fixRange) { + /* + * Passing node is a bit dirty, because message data will contain big + * text in `source`. But... who cares :) ? + * One more kludge will not make worse the bloody wizardry of this + * plugin. + */ + context.report({ + node, + loc: location, + messageId: "trailingSpace", + fix(fixer) { + return fixer.removeRange(fixRange); + }, + }); + } + + /** + * Given a list of comment nodes, return the line numbers for those comments. + * @param {Array} comments An array of comment nodes. + * @returns {number[]} An array of line numbers containing comments. + */ + function getCommentLineNumbers(comments) { + const lines = new Set(); + + comments.forEach(comment => { + const endLine = + comment.type === "Block" + ? comment.loc.end.line - 1 + : comment.loc.end.line; + + for (let i = comment.loc.start.line; i <= endLine; i++) { + lines.add(i); + } + }); + + return lines; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: function checkTrailingSpaces(node) { + /* + * Let's hack. Since Espree does not return whitespace nodes, + * fetch the source code and do matching via regexps. + */ + + const re = new RegExp(NONBLANK, "u"), + skipMatch = new RegExp(SKIP_BLANK, "u"), + lines = sourceCode.lines, + linebreaks = sourceCode + .getText() + .match(astUtils.createGlobalLinebreakMatcher()), + comments = sourceCode.getAllComments(), + commentLineNumbers = getCommentLineNumbers(comments); + + let totalLength = 0; + + for (let i = 0, ii = lines.length; i < ii; i++) { + const lineNumber = i + 1; + + /* + * Always add linebreak length to line length to accommodate for line break (\n or \r\n) + * Because during the fix time they also reserve one spot in the array. + * Usually linebreak length is 2 for \r\n (CRLF) and 1 for \n (LF) + */ + const linebreakLength = + linebreaks && linebreaks[i] ? linebreaks[i].length : 1; + const lineLength = lines[i].length + linebreakLength; + + const matches = re.exec(lines[i]); + + if (matches) { + const location = { + start: { + line: lineNumber, + column: matches.index, + }, + end: { + line: lineNumber, + column: lineLength - linebreakLength, + }, + }; + + const rangeStart = totalLength + location.start.column; + const rangeEnd = totalLength + location.end.column; + const containingNode = + sourceCode.getNodeByRangeIndex(rangeStart); + + if ( + containingNode && + containingNode.type === "TemplateElement" && + rangeStart > containingNode.parent.range[0] && + rangeEnd < containingNode.parent.range[1] + ) { + totalLength += lineLength; + continue; + } + + /* + * If the line has only whitespace, and skipBlankLines + * is true, don't report it + */ + if (skipBlankLines && skipMatch.test(lines[i])) { + totalLength += lineLength; + continue; + } + + const fixRange = [rangeStart, rangeEnd]; + + if ( + !ignoreComments || + !commentLineNumbers.has(lineNumber) + ) { + report(node, location, fixRange); + } + } + + totalLength += lineLength; + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unassigned-vars.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unassigned-vars.js new file mode 100644 index 00000000..24053b3f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unassigned-vars.js @@ -0,0 +1,79 @@ +/** + * @fileoverview Rule to flag variables that are never assigned + * @author Jacob Bandes-Storch + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow `let` or `var` variables that are read but never assigned", + dialects: ["JavaScript", "TypeScript"], + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unassigned-vars", + }, + + schema: [], + messages: { + unassigned: + "'{{name}}' is always 'undefined' because it's never assigned.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + let insideDeclareModule = false; + + return { + "TSModuleDeclaration[declare=true]"() { + insideDeclareModule = true; + }, + "TSModuleDeclaration[declare=true]:exit"() { + insideDeclareModule = false; + }, + VariableDeclarator(node) { + /** @type {import('estree').VariableDeclaration} */ + const declaration = node.parent; + const shouldSkip = + node.init || + node.id.type !== "Identifier" || + declaration.kind === "const" || + declaration.declare || + insideDeclareModule; + if (shouldSkip) { + return; + } + const [variable] = sourceCode.getDeclaredVariables(node); + if (!variable) { + return; + } + let hasRead = false; + for (const reference of variable.references) { + if (reference.isWrite()) { + return; + } + if (reference.isRead()) { + hasRead = true; + } + } + if (!hasRead) { + // Variables that are never read should be flagged by no-unused-vars instead + return; + } + context.report({ + node, + messageId: "unassigned", + data: { name: node.id.name }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef-init.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef-init.js new file mode 100644 index 00000000..77a12004 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef-init.js @@ -0,0 +1,101 @@ +/** + * @fileoverview Rule to flag when initializing to undefined + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow initializing variables to `undefined`", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-undef-init", + }, + + schema: [], + fixable: "code", + + messages: { + unnecessaryUndefinedInit: + "It's not necessary to initialize '{{name}}' to undefined.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + VariableDeclarator(node) { + const name = sourceCode.getText(node.id), + init = node.init && node.init.name, + scope = sourceCode.getScope(node), + undefinedVar = astUtils.getVariableByName( + scope, + "undefined", + ), + shadowed = undefinedVar && undefinedVar.defs.length > 0, + lastToken = sourceCode.getLastToken(node); + + if ( + init === "undefined" && + !CONSTANT_BINDINGS.has(node.parent.kind) && + !shadowed + ) { + context.report({ + node, + messageId: "unnecessaryUndefinedInit", + data: { name }, + fix(fixer) { + if (node.parent.kind === "var") { + return null; + } + + if ( + node.id.type === "ArrayPattern" || + node.id.type === "ObjectPattern" + ) { + // Don't fix destructuring assignment to `undefined`. + return null; + } + + if ( + sourceCode.commentsExistBetween( + node.id, + lastToken, + ) + ) { + return null; + } + + return fixer.removeRange([ + node.id.range[1], + node.range[1], + ]); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef.js new file mode 100644 index 00000000..fbda8773 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undef.js @@ -0,0 +1,84 @@ +/** + * @fileoverview Rule to flag references to undeclared variables. + * @author Mark Macdonald + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks if the given node is the argument of a typeof operator. + * @param {ASTNode} node The AST node being checked. + * @returns {boolean} Whether or not the node is the argument of a typeof operator. + */ +function hasTypeOfOperator(node) { + const parent = node.parent; + + return parent.type === "UnaryExpression" && parent.operator === "typeof"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + typeof: false, + }, + ], + + docs: { + description: + "Disallow the use of undeclared variables unless mentioned in `/*global */` comments", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-undef", + }, + + schema: [ + { + type: "object", + properties: { + typeof: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + messages: { + undef: "'{{name}}' is not defined.", + }, + }, + + create(context) { + const [{ typeof: considerTypeOf }] = context.options; + const sourceCode = context.sourceCode; + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + globalScope.through.forEach(ref => { + const identifier = ref.identifier; + + if (!considerTypeOf && hasTypeOfOperator(identifier)) { + return; + } + + context.report({ + node: identifier, + messageId: "undef", + data: identifier, + }); + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undefined.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undefined.js new file mode 100644 index 00000000..e728e199 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-undefined.js @@ -0,0 +1,91 @@ +/** + * @fileoverview Rule to flag references to the undefined variable. + * @author Michael Ficarra + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow the use of `undefined` as an identifier", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-undefined", + }, + + schema: [], + + messages: { + unexpectedUndefined: "Unexpected use of undefined.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Report an invalid "undefined" identifier node. + * @param {ASTNode} node The node to report. + * @returns {void} + */ + function report(node) { + context.report({ + node, + messageId: "unexpectedUndefined", + }); + } + + /** + * Checks the given scope for references to `undefined` and reports + * all references found. + * @param {Scope} scope The scope to check. + * @returns {void} + */ + function checkScope(scope) { + const undefinedVar = scope.set.get("undefined"); + + if (!undefinedVar) { + return; + } + + const references = undefinedVar.references; + + const defs = undefinedVar.defs; + + // Report non-initializing references (those are covered in defs below) + references + .filter(ref => !ref.init) + .forEach(ref => report(ref.identifier)); + + defs.forEach(def => report(def.name)); + } + + return { + "Program:exit"(node) { + const globalScope = sourceCode.getScope(node); + + const stack = [globalScope]; + + while (stack.length) { + const scope = stack.pop(); + + stack.push(...scope.childScopes); + checkScope(scope); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-underscore-dangle.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-underscore-dangle.js new file mode 100644 index 00000000..24b72370 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-underscore-dangle.js @@ -0,0 +1,383 @@ +/** + * @fileoverview Rule to flag dangling underscores in variable declarations. + * @author Matt DuVall + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allow: [], + allowAfterSuper: false, + allowAfterThis: false, + allowAfterThisConstructor: false, + allowFunctionParams: true, + allowInArrayDestructuring: true, + allowInObjectDestructuring: true, + enforceInClassFields: false, + enforceInMethodNames: false, + }, + ], + + docs: { + description: "Disallow dangling underscores in identifiers", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-underscore-dangle", + }, + + schema: [ + { + type: "object", + properties: { + allow: { + type: "array", + items: { + type: "string", + }, + }, + allowAfterThis: { + type: "boolean", + }, + allowAfterSuper: { + type: "boolean", + }, + allowAfterThisConstructor: { + type: "boolean", + }, + enforceInMethodNames: { + type: "boolean", + }, + allowFunctionParams: { + type: "boolean", + }, + enforceInClassFields: { + type: "boolean", + }, + allowInArrayDestructuring: { + type: "boolean", + }, + allowInObjectDestructuring: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedUnderscore: + "Unexpected dangling '_' in '{{identifier}}'.", + }, + }, + + create(context) { + const [ + { + allow, + allowAfterSuper, + allowAfterThis, + allowAfterThisConstructor, + allowFunctionParams, + allowInArrayDestructuring, + allowInObjectDestructuring, + enforceInClassFields, + enforceInMethodNames, + }, + ] = context.options; + const sourceCode = context.sourceCode; + + //------------------------------------------------------------------------- + // Helpers + //------------------------------------------------------------------------- + + /** + * Check if identifier is present inside the allowed option + * @param {string} identifier name of the node + * @returns {boolean} true if its is present + * @private + */ + function isAllowed(identifier) { + return allow.includes(identifier); + } + + /** + * Check if identifier has a dangling underscore + * @param {string} identifier name of the node + * @returns {boolean} true if its is present + * @private + */ + function hasDanglingUnderscore(identifier) { + const len = identifier.length; + + return ( + identifier !== "_" && + (identifier[0] === "_" || identifier[len - 1] === "_") + ); + } + + /** + * Check if identifier is a special case member expression + * @param {string} identifier name of the node + * @returns {boolean} true if its is a special case + * @private + */ + function isSpecialCaseIdentifierForMemberExpression(identifier) { + return identifier === "__proto__"; + } + + /** + * Check if identifier is a special case variable expression + * @param {string} identifier name of the node + * @returns {boolean} true if its is a special case + * @private + */ + function isSpecialCaseIdentifierInVariableExpression(identifier) { + // Checks for the underscore library usage here + return identifier === "_"; + } + + /** + * Check if a node is a member reference of this.constructor + * @param {ASTNode} node node to evaluate + * @returns {boolean} true if it is a reference on this.constructor + * @private + */ + function isThisConstructorReference(node) { + return ( + node.object.type === "MemberExpression" && + node.object.property.name === "constructor" && + node.object.object.type === "ThisExpression" + ); + } + + /** + * Check if function parameter has a dangling underscore. + * @param {ASTNode} node function node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInFunctionParameters(node) { + if (!allowFunctionParams) { + node.params.forEach(param => { + const { type } = param; + let nodeToCheck; + + if (type === "RestElement") { + nodeToCheck = param.argument; + } else if (type === "AssignmentPattern") { + nodeToCheck = param.left; + } else { + nodeToCheck = param; + } + + if (nodeToCheck.type === "Identifier") { + const identifier = nodeToCheck.name; + + if ( + hasDanglingUnderscore(identifier) && + !isAllowed(identifier) + ) { + context.report({ + node: param, + messageId: "unexpectedUnderscore", + data: { + identifier, + }, + }); + } + } + }); + } + } + + /** + * Check if function has a dangling underscore + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInFunction(node) { + if (node.type === "FunctionDeclaration" && node.id) { + const identifier = node.id.name; + + if ( + typeof identifier !== "undefined" && + hasDanglingUnderscore(identifier) && + !isAllowed(identifier) + ) { + context.report({ + node, + messageId: "unexpectedUnderscore", + data: { + identifier, + }, + }); + } + } + checkForDanglingUnderscoreInFunctionParameters(node); + } + + /** + * Check if variable expression has a dangling underscore + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInVariableExpression(node) { + sourceCode.getDeclaredVariables(node).forEach(variable => { + const definition = variable.defs.find(def => def.node === node); + const identifierNode = definition.name; + const identifier = identifierNode.name; + let parent = identifierNode.parent; + + while ( + ![ + "VariableDeclarator", + "ArrayPattern", + "ObjectPattern", + ].includes(parent.type) + ) { + parent = parent.parent; + } + + if ( + hasDanglingUnderscore(identifier) && + !isSpecialCaseIdentifierInVariableExpression(identifier) && + !isAllowed(identifier) && + !( + allowInArrayDestructuring && + parent.type === "ArrayPattern" + ) && + !( + allowInObjectDestructuring && + parent.type === "ObjectPattern" + ) + ) { + context.report({ + node, + messageId: "unexpectedUnderscore", + data: { + identifier, + }, + }); + } + }); + } + + /** + * Check if member expression has a dangling underscore + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInMemberExpression(node) { + const identifier = node.property.name, + isMemberOfThis = node.object.type === "ThisExpression", + isMemberOfSuper = node.object.type === "Super", + isMemberOfThisConstructor = isThisConstructorReference(node); + + if ( + typeof identifier !== "undefined" && + hasDanglingUnderscore(identifier) && + !(isMemberOfThis && allowAfterThis) && + !(isMemberOfSuper && allowAfterSuper) && + !(isMemberOfThisConstructor && allowAfterThisConstructor) && + !isSpecialCaseIdentifierForMemberExpression(identifier) && + !isAllowed(identifier) + ) { + context.report({ + node, + messageId: "unexpectedUnderscore", + data: { + identifier, + }, + }); + } + } + + /** + * Check if method declaration or method property has a dangling underscore + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInMethod(node) { + const identifier = node.key.name; + const isMethod = + node.type === "MethodDefinition" || + (node.type === "Property" && node.method); + + if ( + typeof identifier !== "undefined" && + enforceInMethodNames && + isMethod && + hasDanglingUnderscore(identifier) && + !isAllowed(identifier) + ) { + context.report({ + node, + messageId: "unexpectedUnderscore", + data: { + identifier: + node.key.type === "PrivateIdentifier" + ? `#${identifier}` + : identifier, + }, + }); + } + } + + /** + * Check if a class field has a dangling underscore + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkForDanglingUnderscoreInClassField(node) { + const identifier = node.key.name; + + if ( + typeof identifier !== "undefined" && + hasDanglingUnderscore(identifier) && + enforceInClassFields && + !isAllowed(identifier) + ) { + context.report({ + node, + messageId: "unexpectedUnderscore", + data: { + identifier: + node.key.type === "PrivateIdentifier" + ? `#${identifier}` + : identifier, + }, + }); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + FunctionDeclaration: checkForDanglingUnderscoreInFunction, + VariableDeclarator: checkForDanglingUnderscoreInVariableExpression, + MemberExpression: checkForDanglingUnderscoreInMemberExpression, + MethodDefinition: checkForDanglingUnderscoreInMethod, + PropertyDefinition: checkForDanglingUnderscoreInClassField, + Property: checkForDanglingUnderscoreInMethod, + FunctionExpression: checkForDanglingUnderscoreInFunction, + ArrowFunctionExpression: checkForDanglingUnderscoreInFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unexpected-multiline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unexpected-multiline.js new file mode 100644 index 00000000..fe8e5051 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unexpected-multiline.js @@ -0,0 +1,130 @@ +/** + * @fileoverview Rule to spot scenarios where a newline looks like it is ending a statement, but is not. + * @author Glen Mailer + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow confusing multiline expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unexpected-multiline", + }, + + schema: [], + messages: { + function: + "Unexpected newline between function and ( of function call.", + property: + "Unexpected newline between object and [ of property access.", + taggedTemplate: + "Unexpected newline between template tag and template literal.", + division: + "Unexpected newline between numerator and division operator.", + }, + }, + + create(context) { + const REGEX_FLAG_MATCHER = /^[dgimsuvy]+$/u; + + const sourceCode = context.sourceCode; + + /** + * Check to see if there is a newline between the node and the following open bracket + * line's expression + * @param {ASTNode} node The node to check. + * @param {string} messageId The error messageId to use. + * @returns {void} + * @private + */ + function checkForBreakAfter(node, messageId) { + const openParen = sourceCode.getTokenAfter( + node, + astUtils.isNotClosingParenToken, + ); + const nodeExpressionEnd = sourceCode.getTokenBefore(openParen); + + if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) { + context.report({ + node, + loc: openParen.loc, + messageId, + }); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + MemberExpression(node) { + if (!node.computed || node.optional) { + return; + } + checkForBreakAfter(node.object, "property"); + }, + + TaggedTemplateExpression(node) { + const { quasi } = node; + + // handles common tags, parenthesized tags, and typescript's generic type arguments + const tokenBefore = sourceCode.getTokenBefore(quasi); + + if (tokenBefore.loc.end.line !== quasi.loc.start.line) { + context.report({ + node, + loc: { + start: quasi.loc.start, + end: { + line: quasi.loc.start.line, + column: quasi.loc.start.column + 1, + }, + }, + messageId: "taggedTemplate", + }); + } + }, + + CallExpression(node) { + if (node.arguments.length === 0 || node.optional) { + return; + } + checkForBreakAfter(node.callee, "function"); + }, + + "BinaryExpression[operator='/'] > BinaryExpression[operator='/'].left"( + node, + ) { + const secondSlash = sourceCode.getTokenAfter( + node, + token => token.value === "/", + ); + const tokenAfterOperator = + sourceCode.getTokenAfter(secondSlash); + + if ( + tokenAfterOperator.type === "Identifier" && + REGEX_FLAG_MATCHER.test(tokenAfterOperator.value) && + secondSlash.range[1] === tokenAfterOperator.range[0] + ) { + checkForBreakAfter(node.left, "division"); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unmodified-loop-condition.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unmodified-loop-condition.js new file mode 100644 index 00000000..a7e84e8d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unmodified-loop-condition.js @@ -0,0 +1,394 @@ +/** + * @fileoverview Rule to disallow use of unmodified expressions in loop conditions + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Traverser = require("../shared/traverser"), + astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SENTINEL_PATTERN = + /(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u; +const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property. +const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u; +const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u; + +/** + * @typedef {Object} LoopConditionInfo + * @property {Reference} reference - The reference. + * @property {ASTNode} group - BinaryExpression or ConditionalExpression nodes + * that the reference is belonging to. + * @property {Function} isInLoop - The predicate which checks a given reference + * is in this loop. + * @property {boolean} modified - The flag that the reference is modified in + * this loop. + */ + +/** + * Checks whether or not a given reference is a write reference. + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is a write reference. + */ +function isWriteReference(reference) { + if (reference.init) { + const def = reference.resolved && reference.resolved.defs[0]; + + if (!def || def.type !== "Variable" || def.parent.kind !== "var") { + return false; + } + } + return reference.isWrite(); +} + +/** + * Checks whether or not a given loop condition info does not have the modified + * flag. + * @param {LoopConditionInfo} condition A loop condition info to check. + * @returns {boolean} `true` if the loop condition info is "unmodified". + */ +function isUnmodified(condition) { + return !condition.modified; +} + +/** + * Checks whether or not a given loop condition info does not have the modified + * flag and does not have the group this condition belongs to. + * @param {LoopConditionInfo} condition A loop condition info to check. + * @returns {boolean} `true` if the loop condition info is "unmodified". + */ +function isUnmodifiedAndNotBelongToGroup(condition) { + return !(condition.modified || condition.group); +} + +/** + * Checks whether or not a given reference is inside of a given node. + * @param {ASTNode} node A node to check. + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is inside of the node. + */ +function isInRange(node, reference) { + const or = node.range; + const ir = reference.identifier.range; + + return or[0] <= ir[0] && ir[1] <= or[1]; +} + +/** + * Checks whether or not a given reference is inside of a loop node's condition. + * @param {ASTNode} node A node to check. + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is inside of the loop node's + * condition. + */ +const isInLoop = { + WhileStatement: isInRange, + DoWhileStatement: isInRange, + ForStatement(node, reference) { + return ( + isInRange(node, reference) && + !(node.init && isInRange(node.init, reference)) + ); + }, +}; + +/** + * Gets the function which encloses a given reference. + * This supports only FunctionDeclaration. + * @param {Reference} reference A reference to get. + * @returns {ASTNode|null} The function node or null. + */ +function getEncloseFunctionDeclaration(reference) { + let node = reference.identifier; + + while (node) { + if (node.type === "FunctionDeclaration") { + return node.id ? node : null; + } + + node = node.parent; + } + + return null; +} + +/** + * Checks whether a given modifier is in a loop. + * + * Besides checking for the condition being in the loop, this also checks + * whether the function that this modifier is belonging to is called + * in the loop. + * @param {LoopConditionInfo} condition The condition to check. + * @param {Reference} modifier The modifier to check. + * @returns {boolean} `true` if the modifier is in a loop. + */ +function hasModifierInLoop(condition, modifier) { + if (condition.isInLoop(modifier)) { + return true; + } + + const funcNode = getEncloseFunctionDeclaration(modifier); + + if (!funcNode) { + return false; + } + + const funcVar = astUtils.getVariableByName( + modifier.from.upper, + funcNode.id.name, + ); + + return Boolean(funcVar && funcVar.references.some(condition.isInLoop)); +} + +/** + * Updates the "modified" flags of given loop conditions with given modifiers. + * @param {LoopConditionInfo[]} conditions The loop conditions to be updated. + * @param {Reference[]} modifiers The references to update. + * @returns {void} + */ +function updateModifiedFlag(conditions, modifiers) { + for (let i = 0; i < conditions.length; ++i) { + const condition = conditions[i]; + + for (let j = 0; !condition.modified && j < modifiers.length; ++j) { + const modifier = modifiers[j]; + + condition.modified = hasModifierInLoop(condition, modifier); + } + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow unmodified loop conditions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-unmodified-loop-condition", + }, + + schema: [ + { + type: "object", + properties: { + checkConditionalExpressions: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [{ checkConditionalExpressions: false }], + + messages: { + loopConditionNotModified: + "'{{name}}' is not modified in this loop.", + }, + }, + + create(context) { + const [{ checkConditionalExpressions }] = context.options; + const sourceCode = context.sourceCode; + let groupMap = null; + + /** + * Reports a given condition info. + * @param {LoopConditionInfo} condition A loop condition info to report. + * @returns {void} + */ + function report(condition) { + const node = condition.reference.identifier; + + context.report({ + node, + messageId: "loopConditionNotModified", + data: node, + }); + } + + /** + * Registers given conditions to the group the condition belongs to. + * @param {LoopConditionInfo[]} conditions A loop condition info to + * register. + * @returns {void} + */ + function registerConditionsToGroup(conditions) { + for (let i = 0; i < conditions.length; ++i) { + const condition = conditions[i]; + + if (condition.group) { + let group = groupMap.get(condition.group); + + if (!group) { + group = []; + groupMap.set(condition.group, group); + } + group.push(condition); + } + } + } + + /** + * Reports references which are inside of unmodified groups. + * @param {LoopConditionInfo[]} conditions A loop condition info to report. + * @returns {void} + */ + function checkConditionsInGroup(conditions) { + if (conditions.every(isUnmodified)) { + conditions.forEach(report); + } + } + + /** + * Checks whether or not a given group node has any dynamic elements. + * @param {ASTNode} root A node to check. + * This node is one of BinaryExpression or ConditionalExpression. + * @returns {boolean} `true` if the node is dynamic. + */ + function hasDynamicExpressions(root) { + let retv = false; + + Traverser.traverse(root, { + visitorKeys: sourceCode.visitorKeys, + enter(node) { + if (DYNAMIC_PATTERN.test(node.type)) { + retv = true; + this.break(); + } else if (SKIP_PATTERN.test(node.type)) { + this.skip(); + } + }, + }); + + return retv; + } + + /** + * Creates the loop condition information from a given reference. + * @param {Reference} reference A reference to create. + * @returns {LoopConditionInfo|null} Created loop condition info, or null. + */ + function toLoopCondition(reference) { + if (reference.init) { + return null; + } + + let group = null; + let child = reference.identifier; + let node = child.parent; + + while (node) { + if (SENTINEL_PATTERN.test(node.type)) { + if (LOOP_PATTERN.test(node.type) && node.test === child) { + // This reference is inside of a loop condition. + return { + reference, + group, + isInLoop: isInLoop[node.type].bind(null, node), + modified: false, + }; + } + + // This reference is outside of a loop condition. + break; + } + + /* + * If it's inside of a group, OK if any reference in that group is + * modified. So stores the group this reference belongs to. + */ + if ( + node.type === "BinaryExpression" || + (!checkConditionalExpressions && + node.type === "ConditionalExpression") + ) { + // If this expression is dynamic, no need to check. + if (hasDynamicExpressions(node)) { + break; + } else { + group = node; + } + } + + child = node; + node = node.parent; + } + + return null; + } + + /** + * Finds unmodified references which are inside of a loop condition. + * Then reports the references which are outside of groups. + * @param {Variable} variable A variable to report. + * @returns {void} + */ + function checkReferences(variable) { + // Gets references that exist in loop conditions. + const conditions = variable.references + .map(toLoopCondition) + .filter(Boolean); + + if (conditions.length === 0) { + return; + } + + // Registers the conditions to belonging groups. + registerConditionsToGroup(conditions); + + // Check the conditions are modified. + const modifiers = variable.references.filter(isWriteReference); + + if (modifiers.length > 0) { + updateModifiedFlag(conditions, modifiers); + } + + /* + * Reports the conditions which are not belonging to groups. + * Others will be reported after all variables are done. + */ + conditions.filter(isUnmodifiedAndNotBelongToGroup).forEach(report); + } + + return { + "Program:exit"(node) { + const queue = [sourceCode.getScope(node)]; + + groupMap = new Map(); + + let scope; + + while ((scope = queue.pop())) { + queue.push(...scope.childScopes); + scope.variables.forEach(checkReferences); + } + + groupMap.forEach(checkConditionsInGroup); + groupMap = null; + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unneeded-ternary.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unneeded-ternary.js new file mode 100644 index 00000000..24e65b67 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unneeded-ternary.js @@ -0,0 +1,232 @@ +/** + * @fileoverview Rule to flag no-unneeded-ternary + * @author Gyandeep Singh + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +// Operators that always result in a boolean value +const BOOLEAN_OPERATORS = new Set([ + "==", + "===", + "!=", + "!==", + ">", + ">=", + "<", + "<=", + "in", + "instanceof", +]); +const OPERATOR_INVERSES = { + "==": "!=", + "!=": "==", + "===": "!==", + "!==": "===", + + // Operators like < and >= are not true inverses, since both will return false with NaN. +}; +const OR_PRECEDENCE = astUtils.getPrecedence({ + type: "LogicalExpression", + operator: "||", +}); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{ defaultAssignment: true }], + + docs: { + description: + "Disallow ternary operators when simpler alternatives exist", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-unneeded-ternary", + }, + + schema: [ + { + type: "object", + properties: { + defaultAssignment: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + unnecessaryConditionalExpression: + "Unnecessary use of boolean literals in conditional expression.", + unnecessaryConditionalAssignment: + "Unnecessary use of conditional expression for default assignment.", + }, + }, + + create(context) { + const [{ defaultAssignment }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Test if the node is a boolean literal + * @param {ASTNode} node The node to report. + * @returns {boolean} True if the its a boolean literal + * @private + */ + function isBooleanLiteral(node) { + return node.type === "Literal" && typeof node.value === "boolean"; + } + + /** + * Creates an expression that represents the boolean inverse of the expression represented by the original node + * @param {ASTNode} node A node representing an expression + * @returns {string} A string representing an inverted expression + */ + function invertExpression(node) { + if ( + node.type === "BinaryExpression" && + Object.hasOwn(OPERATOR_INVERSES, node.operator) + ) { + const operatorToken = sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + const text = sourceCode.getText(); + + return ( + text.slice(node.range[0], operatorToken.range[0]) + + OPERATOR_INVERSES[node.operator] + + text.slice(operatorToken.range[1], node.range[1]) + ); + } + + if ( + astUtils.getPrecedence(node) < + astUtils.getPrecedence({ type: "UnaryExpression" }) + ) { + return `!(${astUtils.getParenthesisedText(sourceCode, node)})`; + } + return `!${astUtils.getParenthesisedText(sourceCode, node)}`; + } + + /** + * Tests if a given node always evaluates to a boolean value + * @param {ASTNode} node An expression node + * @returns {boolean} True if it is determined that the node will always evaluate to a boolean value + */ + function isBooleanExpression(node) { + return ( + (node.type === "BinaryExpression" && + BOOLEAN_OPERATORS.has(node.operator)) || + (node.type === "UnaryExpression" && node.operator === "!") + ); + } + + /** + * Test if the node matches the pattern id ? id : expression + * @param {ASTNode} node The ConditionalExpression to check. + * @returns {boolean} True if the pattern is matched, and false otherwise + * @private + */ + function matchesDefaultAssignment(node) { + return ( + node.test.type === "Identifier" && + node.consequent.type === "Identifier" && + node.test.name === node.consequent.name + ); + } + + return { + ConditionalExpression(node) { + if ( + isBooleanLiteral(node.alternate) && + isBooleanLiteral(node.consequent) + ) { + context.report({ + node, + messageId: "unnecessaryConditionalExpression", + fix(fixer) { + if ( + node.consequent.value === node.alternate.value + ) { + // Replace `foo ? true : true` with just `true`, but don't replace `foo() ? true : true` + return node.test.type === "Identifier" + ? fixer.replaceText( + node, + node.consequent.value.toString(), + ) + : null; + } + if (node.alternate.value) { + // Replace `foo() ? false : true` with `!(foo())` + return fixer.replaceText( + node, + invertExpression(node.test), + ); + } + + // Replace `foo ? true : false` with `foo` if `foo` is guaranteed to be a boolean, or `!!foo` otherwise. + + return fixer.replaceText( + node, + isBooleanExpression(node.test) + ? astUtils.getParenthesisedText( + sourceCode, + node.test, + ) + : `!${invertExpression(node.test)}`, + ); + }, + }); + } else if ( + !defaultAssignment && + matchesDefaultAssignment(node) + ) { + context.report({ + node, + messageId: "unnecessaryConditionalAssignment", + fix(fixer) { + const shouldParenthesizeAlternate = + (astUtils.getPrecedence(node.alternate) < + OR_PRECEDENCE || + astUtils.isCoalesceExpression( + node.alternate, + )) && + !astUtils.isParenthesised( + sourceCode, + node.alternate, + ); + const alternateText = shouldParenthesizeAlternate + ? `(${sourceCode.getText(node.alternate)})` + : astUtils.getParenthesisedText( + sourceCode, + node.alternate, + ); + const testText = astUtils.getParenthesisedText( + sourceCode, + node.test, + ); + + return fixer.replaceText( + node, + `${testText} || ${alternateText}`, + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable-loop.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable-loop.js new file mode 100644 index 00000000..4d9819d2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable-loop.js @@ -0,0 +1,181 @@ +/** + * @fileoverview Rule to disallow loops with a body that allows only one iteration + * @author Milos Djermanovic + */ + +"use strict"; + +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const allLoopTypes = [ + "WhileStatement", + "DoWhileStatement", + "ForStatement", + "ForInStatement", + "ForOfStatement", +]; + +/** + * Determines whether the given node is the first node in the code path to which a loop statement + * 'loops' for the next iteration. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a looping target. + */ +function isLoopingTarget(node) { + const parent = node.parent; + + if (parent) { + switch (parent.type) { + case "WhileStatement": + return node === parent.test; + case "DoWhileStatement": + return node === parent.body; + case "ForStatement": + return node === (parent.update || parent.test || parent.body); + case "ForInStatement": + case "ForOfStatement": + return node === parent.left; + + // no default + } + } + + return false; +} + +/** + * Creates an array with elements from the first given array that are not included in the second given array. + * @param {Array} arrA The array to compare from. + * @param {Array} arrB The array to compare against. + * @returns {Array} a new array that represents `arrA \ arrB`. + */ +function getDifference(arrA, arrB) { + return arrA.filter(a => !arrB.includes(a)); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [{ ignore: [] }], + + docs: { + description: + "Disallow loops with a body that allows only one iteration", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-unreachable-loop", + }, + + schema: [ + { + type: "object", + properties: { + ignore: { + type: "array", + items: { + enum: allLoopTypes, + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + invalid: "Invalid loop. Its body allows only one iteration.", + }, + }, + + create(context) { + const [{ ignore: ignoredLoopTypes }] = context.options; + const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes); + const loopSelector = loopTypesToCheck.join(","); + + if (!loopSelector) { + return {}; + } + + const loopsByTargetSegments = new Map(); + const loopsToReport = new Set(); + const codePathSegments = []; + let currentCodePathSegments = new Set(); + + return { + onCodePathStart() { + codePathSegments.push(currentCodePathSegments); + currentCodePathSegments = new Set(); + }, + + onCodePathEnd() { + currentCodePathSegments = codePathSegments.pop(); + }, + + onUnreachableCodePathSegmentStart(segment) { + currentCodePathSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + onCodePathSegmentStart(segment, node) { + currentCodePathSegments.add(segment); + + if (isLoopingTarget(node)) { + const loop = node.parent; + + loopsByTargetSegments.set(segment, loop); + } + }, + + onCodePathSegmentLoop(_, toSegment, node) { + const loop = loopsByTargetSegments.get(toSegment); + + /** + * The second iteration is reachable, meaning that the loop is valid by the logic of this rule, + * only if there is at least one loop event with the appropriate target (which has been already + * determined in the `loopsByTargetSegments` map), raised from either: + * + * - the end of the loop's body (in which case `node === loop`) + * - a `continue` statement + * + * This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes. + */ + if (node === loop || node.type === "ContinueStatement") { + // Removes loop if it exists in the set. Otherwise, `Set#delete` has no effect and doesn't throw. + loopsToReport.delete(loop); + } + }, + + [loopSelector](node) { + /** + * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise. + * For unreachable segments, the code path analysis does not raise events required for this implementation. + */ + if (isAnySegmentReachable(currentCodePathSegments)) { + loopsToReport.add(node); + } + }, + + "Program:exit"() { + loopsToReport.forEach(node => + context.report({ node, messageId: "invalid" }), + ); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable.js new file mode 100644 index 00000000..5675fcfc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unreachable.js @@ -0,0 +1,290 @@ +/** + * @fileoverview Checks for unreachable code due to return, throws, break, and continue. + * @author Joel Feenstra + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * @typedef {Object} ConstructorInfo + * @property {ConstructorInfo | null} upper Info about the constructor that encloses this constructor. + * @property {boolean} hasSuperCall The flag about having `super()` expressions. + */ + +/** + * Checks whether or not a given variable declarator has the initializer. + * @param {ASTNode} node A VariableDeclarator node to check. + * @returns {boolean} `true` if the node has the initializer. + */ +function isInitialized(node) { + return Boolean(node.init); +} + +/** + * The class to distinguish consecutive unreachable statements. + */ +class ConsecutiveRange { + constructor(sourceCode) { + this.sourceCode = sourceCode; + this.startNode = null; + this.endNode = null; + } + + /** + * The location object of this range. + * @type {Object} + */ + get location() { + return { + start: this.startNode.loc.start, + end: this.endNode.loc.end, + }; + } + + /** + * `true` if this range is empty. + * @type {boolean} + */ + get isEmpty() { + return !(this.startNode && this.endNode); + } + + /** + * Checks whether the given node is inside of this range. + * @param {ASTNode|Token} node The node to check. + * @returns {boolean} `true` if the node is inside of this range. + */ + contains(node) { + return ( + node.range[0] >= this.startNode.range[0] && + node.range[1] <= this.endNode.range[1] + ); + } + + /** + * Checks whether the given node is consecutive to this range. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is consecutive to this range. + */ + isConsecutive(node) { + return this.contains(this.sourceCode.getTokenBefore(node)); + } + + /** + * Merges the given node to this range. + * @param {ASTNode} node The node to merge. + * @returns {void} + */ + merge(node) { + this.endNode = node; + } + + /** + * Resets this range by the given node or null. + * @param {ASTNode|null} node The node to reset, or null. + * @returns {void} + */ + reset(node) { + this.startNode = this.endNode = node; + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unreachable", + }, + + schema: [], + + messages: { + unreachableCode: "Unreachable code.", + }, + }, + + create(context) { + /** @type {ConstructorInfo | null} */ + let constructorInfo = null; + + /** @type {ConsecutiveRange} */ + const range = new ConsecutiveRange(context.sourceCode); + + /** @type {Array>} */ + const codePathSegments = []; + + /** @type {Set} */ + let currentCodePathSegments = new Set(); + + /** + * Reports a given node if it's unreachable. + * @param {ASTNode} node A statement node to report. + * @returns {void} + */ + function reportIfUnreachable(node) { + let nextNode = null; + + if ( + node && + (node.type === "PropertyDefinition" || + !isAnySegmentReachable(currentCodePathSegments)) + ) { + // Store this statement to distinguish consecutive statements. + if (range.isEmpty) { + range.reset(node); + return; + } + + // Skip if this statement is inside of the current range. + if (range.contains(node)) { + return; + } + + // Merge if this statement is consecutive to the current range. + if (range.isConsecutive(node)) { + range.merge(node); + return; + } + + nextNode = node; + } + + /* + * Report the current range since this statement is reachable or is + * not consecutive to the current range. + */ + if (!range.isEmpty) { + context.report({ + messageId: "unreachableCode", + loc: range.location, + node: range.startNode, + }); + } + + // Update the current range. + range.reset(nextNode); + } + + return { + // Manages the current code path. + onCodePathStart() { + codePathSegments.push(currentCodePathSegments); + currentCodePathSegments = new Set(); + }, + + onCodePathEnd() { + currentCodePathSegments = codePathSegments.pop(); + }, + + onUnreachableCodePathSegmentStart(segment) { + currentCodePathSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + currentCodePathSegments.delete(segment); + }, + + onCodePathSegmentStart(segment) { + currentCodePathSegments.add(segment); + }, + + // Registers for all statement nodes (excludes FunctionDeclaration and ImportDeclaration). + BlockStatement: reportIfUnreachable, + BreakStatement: reportIfUnreachable, + ClassDeclaration: reportIfUnreachable, + ContinueStatement: reportIfUnreachable, + DebuggerStatement: reportIfUnreachable, + DoWhileStatement: reportIfUnreachable, + ExpressionStatement: reportIfUnreachable, + ForInStatement: reportIfUnreachable, + ForOfStatement: reportIfUnreachable, + ForStatement: reportIfUnreachable, + IfStatement: reportIfUnreachable, + LabeledStatement: reportIfUnreachable, + ReturnStatement: reportIfUnreachable, + SwitchStatement: reportIfUnreachable, + ThrowStatement: reportIfUnreachable, + TryStatement: reportIfUnreachable, + + VariableDeclaration(node) { + if ( + node.kind !== "var" || + node.declarations.some(isInitialized) + ) { + reportIfUnreachable(node); + } + }, + + WhileStatement: reportIfUnreachable, + WithStatement: reportIfUnreachable, + ExportNamedDeclaration: reportIfUnreachable, + ExportDefaultDeclaration: reportIfUnreachable, + ExportAllDeclaration: reportIfUnreachable, + + "Program:exit"() { + reportIfUnreachable(); + }, + + /* + * Instance fields defined in a subclass are never created if the constructor of the subclass + * doesn't call `super()`, so their definitions are unreachable code. + */ + "MethodDefinition[kind='constructor']"() { + constructorInfo = { + upper: constructorInfo, + hasSuperCall: false, + }; + }, + "MethodDefinition[kind='constructor']:exit"(node) { + const { hasSuperCall } = constructorInfo; + + constructorInfo = constructorInfo.upper; + + // skip typescript constructors without the body + if (!node.value.body) { + return; + } + + const classDefinition = node.parent.parent; + + if (classDefinition.superClass && !hasSuperCall) { + for (const element of classDefinition.body.body) { + if ( + element.type === "PropertyDefinition" && + !element.static + ) { + reportIfUnreachable(element); + } + } + } + }, + "CallExpression > Super.callee"() { + if (constructorInfo) { + constructorInfo.hasSuperCall = true; + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-finally.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-finally.js new file mode 100644 index 00000000..999e2052 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-finally.js @@ -0,0 +1,119 @@ +/** + * @fileoverview Rule to flag unsafe statements in finally block + * @author Onur Temizkan + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SENTINEL_NODE_TYPE_RETURN_THROW = + /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/u; +const SENTINEL_NODE_TYPE_BREAK = + /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/u; +const SENTINEL_NODE_TYPE_CONTINUE = + /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/u; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow control flow statements in `finally` blocks", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unsafe-finally", + }, + + schema: [], + + messages: { + unsafeUsage: "Unsafe usage of {{nodeType}}.", + }, + }, + create(context) { + /** + * Checks if the node is the finalizer of a TryStatement + * @param {ASTNode} node node to check. + * @returns {boolean} - true if the node is the finalizer of a TryStatement + */ + function isFinallyBlock(node) { + return ( + node.parent.type === "TryStatement" && + node.parent.finalizer === node + ); + } + + /** + * Climbs up the tree if the node is not a sentinel node + * @param {ASTNode} node node to check. + * @param {string} label label of the break or continue statement + * @returns {boolean} - return whether the node is a finally block or a sentinel node + */ + function isInFinallyBlock(node, label) { + let labelInside = false; + let sentinelNodeType; + + if (node.type === "BreakStatement" && !node.label) { + sentinelNodeType = SENTINEL_NODE_TYPE_BREAK; + } else if (node.type === "ContinueStatement" && !node.label) { + sentinelNodeType = SENTINEL_NODE_TYPE_CONTINUE; + } else { + sentinelNodeType = SENTINEL_NODE_TYPE_RETURN_THROW; + } + + for ( + let currentNode = node; + currentNode && !sentinelNodeType.test(currentNode.type); + currentNode = currentNode.parent + ) { + if ( + currentNode.parent.label && + label && + currentNode.parent.label.name === label.name + ) { + labelInside = true; + } + if (isFinallyBlock(currentNode)) { + if (label && labelInside) { + return false; + } + return true; + } + } + return false; + } + + /** + * Checks whether the possibly-unsafe statement is inside a finally block. + * @param {ASTNode} node node to check. + * @returns {void} + */ + function check(node) { + if (isInFinallyBlock(node, node.label)) { + context.report({ + messageId: "unsafeUsage", + data: { + nodeType: node.type, + }, + node, + line: node.loc.line, + column: node.loc.column, + }); + } + } + + return { + ReturnStatement: check, + ThrowStatement: check, + BreakStatement: check, + ContinueStatement: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-negation.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-negation.js new file mode 100644 index 00000000..17e02710 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-negation.js @@ -0,0 +1,152 @@ +/** + * @fileoverview Rule to disallow negating the left operand of relational operators + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether the given operator is `in` or `instanceof` + * @param {string} op The operator type to check. + * @returns {boolean} `true` if the operator is `in` or `instanceof` + */ +function isInOrInstanceOfOperator(op) { + return op === "in" || op === "instanceof"; +} + +/** + * Checks whether the given operator is an ordering relational operator or not. + * @param {string} op The operator type to check. + * @returns {boolean} `true` if the operator is an ordering relational operator. + */ +function isOrderingRelationalOperator(op) { + return op === "<" || op === ">" || op === ">=" || op === "<="; +} + +/** + * Checks whether the given node is a logical negation expression or not. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a logical negation expression. + */ +function isNegation(node) { + return node.type === "UnaryExpression" && node.operator === "!"; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + enforceForOrderingRelations: false, + }, + ], + + docs: { + description: + "Disallow negating the left operand of relational operators", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unsafe-negation", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + enforceForOrderingRelations: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: null, + + messages: { + unexpected: + "Unexpected negating the left operand of '{{operator}}' operator.", + suggestNegatedExpression: + "Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.", + suggestParenthesisedNegation: + "Wrap negation in '()' to make the intention explicit. This preserves the current behavior.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ enforceForOrderingRelations }] = context.options; + + return { + BinaryExpression(node) { + const operator = node.operator; + const orderingRelationRuleApplies = + enforceForOrderingRelations && + isOrderingRelationalOperator(operator); + + if ( + (isInOrInstanceOfOperator(operator) || + orderingRelationRuleApplies) && + isNegation(node.left) && + !astUtils.isParenthesised(sourceCode, node.left) + ) { + context.report({ + node, + loc: node.left.loc, + messageId: "unexpected", + data: { operator }, + suggest: [ + { + messageId: "suggestNegatedExpression", + data: { operator }, + fix(fixer) { + const negationToken = + sourceCode.getFirstToken(node.left); + const fixRange = [ + negationToken.range[1], + node.range[1], + ]; + const text = sourceCode.text.slice( + fixRange[0], + fixRange[1], + ); + + return fixer.replaceTextRange( + fixRange, + `(${text})`, + ); + }, + }, + { + messageId: "suggestParenthesisedNegation", + fix(fixer) { + return fixer.replaceText( + node.left, + `(${sourceCode.getText(node.left)})`, + ); + }, + }, + ], + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js new file mode 100644 index 00000000..95875b7e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unsafe-optional-chaining.js @@ -0,0 +1,221 @@ +/** + * @fileoverview Rule to disallow unsafe optional chaining + * @author Yeon JuAn + */ + +"use strict"; + +const UNSAFE_ARITHMETIC_OPERATORS = new Set(["+", "-", "/", "*", "%", "**"]); +const UNSAFE_ASSIGNMENT_OPERATORS = new Set([ + "+=", + "-=", + "/=", + "*=", + "%=", + "**=", +]); +const UNSAFE_RELATIONAL_OPERATORS = new Set(["in", "instanceof"]); + +/** + * Checks whether a node is a destructuring pattern or not + * @param {ASTNode} node node to check + * @returns {boolean} `true` if a node is a destructuring pattern, otherwise `false` + */ +function isDestructuringPattern(node) { + return node.type === "ObjectPattern" || node.type === "ArrayPattern"; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + disallowArithmeticOperators: false, + }, + ], + + docs: { + description: + "Disallow use of optional chaining in contexts where the `undefined` value is not allowed", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining", + }, + schema: [ + { + type: "object", + properties: { + disallowArithmeticOperators: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + fixable: null, + messages: { + unsafeOptionalChain: + "Unsafe usage of optional chaining. If it short-circuits with 'undefined' the evaluation will throw TypeError.", + unsafeArithmetic: + "Unsafe arithmetic operation on optional chaining. It can result in NaN.", + }, + }, + + create(context) { + const [{ disallowArithmeticOperators }] = context.options; + + /** + * Reports unsafe usage of optional chaining + * @param {ASTNode} node node to report + * @returns {void} + */ + function reportUnsafeUsage(node) { + context.report({ + messageId: "unsafeOptionalChain", + node, + }); + } + + /** + * Reports unsafe arithmetic operation on optional chaining + * @param {ASTNode} node node to report + * @returns {void} + */ + function reportUnsafeArithmetic(node) { + context.report({ + messageId: "unsafeArithmetic", + node, + }); + } + + /** + * Checks and reports if a node can short-circuit with `undefined` by optional chaining. + * @param {ASTNode} [node] node to check + * @param {Function} reportFunc report function + * @returns {void} + */ + function checkUndefinedShortCircuit(node, reportFunc) { + if (!node) { + return; + } + switch (node.type) { + case "LogicalExpression": + if (node.operator === "||" || node.operator === "??") { + checkUndefinedShortCircuit(node.right, reportFunc); + } else if (node.operator === "&&") { + checkUndefinedShortCircuit(node.left, reportFunc); + checkUndefinedShortCircuit(node.right, reportFunc); + } + break; + case "SequenceExpression": + checkUndefinedShortCircuit( + node.expressions.at(-1), + reportFunc, + ); + break; + case "ConditionalExpression": + checkUndefinedShortCircuit(node.consequent, reportFunc); + checkUndefinedShortCircuit(node.alternate, reportFunc); + break; + case "AwaitExpression": + checkUndefinedShortCircuit(node.argument, reportFunc); + break; + case "ChainExpression": + reportFunc(node); + break; + default: + break; + } + } + + /** + * Checks unsafe usage of optional chaining + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkUnsafeUsage(node) { + checkUndefinedShortCircuit(node, reportUnsafeUsage); + } + + /** + * Checks unsafe arithmetic operations on optional chaining + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkUnsafeArithmetic(node) { + checkUndefinedShortCircuit(node, reportUnsafeArithmetic); + } + + return { + "AssignmentExpression, AssignmentPattern"(node) { + if (isDestructuringPattern(node.left)) { + checkUnsafeUsage(node.right); + } + }, + "ClassDeclaration, ClassExpression"(node) { + checkUnsafeUsage(node.superClass); + }, + CallExpression(node) { + if (!node.optional) { + checkUnsafeUsage(node.callee); + } + }, + NewExpression(node) { + checkUnsafeUsage(node.callee); + }, + VariableDeclarator(node) { + if (isDestructuringPattern(node.id)) { + checkUnsafeUsage(node.init); + } + }, + MemberExpression(node) { + if (!node.optional) { + checkUnsafeUsage(node.object); + } + }, + TaggedTemplateExpression(node) { + checkUnsafeUsage(node.tag); + }, + ForOfStatement(node) { + checkUnsafeUsage(node.right); + }, + SpreadElement(node) { + if (node.parent && node.parent.type !== "ObjectExpression") { + checkUnsafeUsage(node.argument); + } + }, + BinaryExpression(node) { + if (UNSAFE_RELATIONAL_OPERATORS.has(node.operator)) { + checkUnsafeUsage(node.right); + } + if ( + disallowArithmeticOperators && + UNSAFE_ARITHMETIC_OPERATORS.has(node.operator) + ) { + checkUnsafeArithmetic(node.right); + checkUnsafeArithmetic(node.left); + } + }, + WithStatement(node) { + checkUnsafeUsage(node.object); + }, + UnaryExpression(node) { + if ( + disallowArithmeticOperators && + UNSAFE_ARITHMETIC_OPERATORS.has(node.operator) + ) { + checkUnsafeArithmetic(node.argument); + } + }, + AssignmentExpression(node) { + if ( + disallowArithmeticOperators && + UNSAFE_ASSIGNMENT_OPERATORS.has(node.operator) + ) { + checkUnsafeArithmetic(node.right); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-expressions.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-expressions.js new file mode 100644 index 00000000..26fe2b94 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-expressions.js @@ -0,0 +1,226 @@ +/** + * @fileoverview Flag expressions in statement position that do not side effect + * @author Michael Ficarra + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** + * Returns `true`. + * @returns {boolean} `true`. + */ +function alwaysTrue() { + return true; +} + +/** + * Returns `false`. + * @returns {boolean} `false`. + */ +function alwaysFalse() { + return false; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unused expressions", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-unused-expressions", + }, + + schema: [ + { + type: "object", + properties: { + allowShortCircuit: { + type: "boolean", + }, + allowTernary: { + type: "boolean", + }, + allowTaggedTemplates: { + type: "boolean", + }, + enforceForJSX: { + type: "boolean", + }, + ignoreDirectives: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + allowShortCircuit: false, + allowTernary: false, + allowTaggedTemplates: false, + enforceForJSX: false, + ignoreDirectives: false, + }, + ], + + messages: { + unusedExpression: + "Expected an assignment or function call and instead saw an expression.", + }, + }, + + create(context) { + const [ + { + allowShortCircuit, + allowTernary, + allowTaggedTemplates, + enforceForJSX, + ignoreDirectives, + }, + ] = context.options; + + /** + * Has AST suggesting a directive. + * @param {ASTNode} node any node + * @returns {boolean} whether the given node structurally represents a directive + */ + function looksLikeDirective(node) { + return ( + node.type === "ExpressionStatement" && + node.expression.type === "Literal" && + typeof node.expression.value === "string" + ); + } + + /** + * Gets the leading sequence of members in a list that pass the predicate. + * @param {Function} predicate ([a] -> Boolean) the function used to make the determination + * @param {a[]} list the input list + * @returns {a[]} the leading sequence of members in the given list that pass the given predicate + */ + function takeWhile(predicate, list) { + for (let i = 0; i < list.length; ++i) { + if (!predicate(list[i])) { + return list.slice(0, i); + } + } + return list.slice(); + } + + /** + * Gets leading directives nodes in a Node body. + * @param {ASTNode} node a Program or BlockStatement node + * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body + */ + function directives(node) { + return takeWhile(looksLikeDirective, node.body); + } + + /** + * Detect if a Node is a directive. + * @param {ASTNode} node any node + * @returns {boolean} whether the given node is considered a directive in its current position + */ + function isDirective(node) { + /** + * https://tc39.es/ecma262/#directive-prologue + * + * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue. + * Class static blocks do not have directive prologue. + */ + return ( + astUtils.isTopLevelExpressionStatement(node) && + directives(node.parent).includes(node) + ); + } + + /** + * The member functions return `true` if the type has no side-effects. + * Unknown nodes are handled as `false`, then this rule ignores those. + */ + const Checker = Object.assign(Object.create(null), { + isDisallowed(node) { + return (Checker[node.type] || alwaysFalse)(node); + }, + + ArrayExpression: alwaysTrue, + ArrowFunctionExpression: alwaysTrue, + BinaryExpression: alwaysTrue, + ChainExpression(node) { + return Checker.isDisallowed(node.expression); + }, + ClassExpression: alwaysTrue, + ConditionalExpression(node) { + if (allowTernary) { + return ( + Checker.isDisallowed(node.consequent) || + Checker.isDisallowed(node.alternate) + ); + } + return true; + }, + FunctionExpression: alwaysTrue, + Identifier: alwaysTrue, + JSXElement() { + return enforceForJSX; + }, + JSXFragment() { + return enforceForJSX; + }, + Literal: alwaysTrue, + LogicalExpression(node) { + if (allowShortCircuit) { + return Checker.isDisallowed(node.right); + } + return true; + }, + MemberExpression: alwaysTrue, + MetaProperty: alwaysTrue, + ObjectExpression: alwaysTrue, + SequenceExpression: alwaysTrue, + TaggedTemplateExpression() { + return !allowTaggedTemplates; + }, + TemplateLiteral: alwaysTrue, + ThisExpression: alwaysTrue, + UnaryExpression(node) { + return node.operator !== "void" && node.operator !== "delete"; + }, + // TypeScript-specific node types + TSAsExpression(node) { + return Checker.isDisallowed(node.expression); + }, + TSTypeAssertion(node) { + return Checker.isDisallowed(node.expression); + }, + TSNonNullExpression(node) { + return Checker.isDisallowed(node.expression); + }, + TSInstantiationExpression(node) { + return Checker.isDisallowed(node.expression); + }, + }); + + return { + ExpressionStatement(node) { + if ( + Checker.isDisallowed(node.expression) && + !astUtils.isDirective(node) && + !(ignoreDirectives && isDirective(node)) + ) { + context.report({ node, messageId: "unusedExpression" }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-labels.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-labels.js new file mode 100644 index 00000000..f1c1cf31 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-labels.js @@ -0,0 +1,177 @@ +/** + * @fileoverview Rule to disallow unused labels. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unused labels", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unused-labels", + }, + + schema: [], + + fixable: "code", + + messages: { + unused: "'{{name}}:' is defined but never used.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + let scopeInfo = null; + + /** + * Adds a scope info to the stack. + * @param {ASTNode} node A node to add. This is a LabeledStatement. + * @returns {void} + */ + function enterLabeledScope(node) { + scopeInfo = { + label: node.label.name, + used: false, + upper: scopeInfo, + }; + } + + /** + * Checks if a `LabeledStatement` node is fixable. + * For a node to be fixable, there must be no comments between the label and the body. + * Furthermore, is must be possible to remove the label without turning the body statement into a + * directive after other fixes are applied. + * @param {ASTNode} node The node to evaluate. + * @returns {boolean} Whether or not the node is fixable. + */ + function isFixable(node) { + /* + * Only perform a fix if there are no comments between the label and the body. This will be the case + * when there is exactly one token/comment (the ":") between the label and the body. + */ + if ( + sourceCode.getTokenAfter(node.label, { + includeComments: true, + }) !== + sourceCode.getTokenBefore(node.body, { includeComments: true }) + ) { + return false; + } + + // Looking for the node's deepest ancestor which is not a `LabeledStatement`. + let ancestor = node.parent; + + while (ancestor.type === "LabeledStatement") { + ancestor = ancestor.parent; + } + + if ( + ancestor.type === "Program" || + (ancestor.type === "BlockStatement" && + astUtils.isFunction(ancestor.parent)) + ) { + const { body } = node; + + if ( + body.type === "ExpressionStatement" && + ((body.expression.type === "Literal" && + typeof body.expression.value === "string") || + astUtils.isStaticTemplateLiteral(body.expression)) + ) { + return false; // potential directive + } + } + + /* + * Do not fix if removing the label would create an ASI hazard. + * e.g. `foo()\nLABEL: [1].forEach(x => x)` → `foo()\n[1].forEach(x => x)` + * would be parsed as `foo()[1].forEach(x => x)`. + */ + const SAFE_TOKENS_BEFORE = /^[:;{]$/u; + const UNSAFE_FIRST_CHARS = /^[([\-+/`]/u; + const tokenBefore = sourceCode.getTokenBefore(node); + const firstBodyToken = sourceCode.getFirstToken(node.body); + + if ( + tokenBefore && + !SAFE_TOKENS_BEFORE.test(tokenBefore.value) && + UNSAFE_FIRST_CHARS.test(firstBodyToken.value) + ) { + return false; + } + + return true; + } + + /** + * Removes the top of the stack. + * At the same time, this reports the label if it's never used. + * @param {ASTNode} node A node to report. This is a LabeledStatement. + * @returns {void} + */ + function exitLabeledScope(node) { + if (!scopeInfo.used) { + context.report({ + node: node.label, + messageId: "unused", + data: node.label, + fix: isFixable(node) + ? fixer => + fixer.removeRange([ + node.range[0], + node.body.range[0], + ]) + : null, + }); + } + + scopeInfo = scopeInfo.upper; + } + + /** + * Marks the label of a given node as used. + * @param {ASTNode} node A node to mark. This is a BreakStatement or + * ContinueStatement. + * @returns {void} + */ + function markAsUsed(node) { + if (!node.label) { + return; + } + + const label = node.label.name; + let info = scopeInfo; + + while (info) { + if (info.label === label) { + info.used = true; + break; + } + info = info.upper; + } + } + + return { + LabeledStatement: enterLabeledScope, + "LabeledStatement:exit": exitLabeledScope, + BreakStatement: markAsUsed, + ContinueStatement: markAsUsed, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-private-class-members.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-private-class-members.js new file mode 100644 index 00000000..3fd4e1d2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-private-class-members.js @@ -0,0 +1,419 @@ +/** + * @fileoverview Rule to flag declared but unused private class members + * @author Tim van der Lippe + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + hasSuggestions: true, + + docs: { + description: "Disallow unused private class members", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members", + }, + + schema: [], + + messages: { + unusedPrivateClassMember: + "'{{classMemberName}}' is defined but never used.", + removeUnusedPrivateClassMember: + "Remove unused private class member '{{classMemberName}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const trackedClasses = []; + + /** + * Gets the start index of the line that contains a given token or node. + * @param {ASTNode|Token|Comment} nodeOrToken The token or node to check + * @returns {number} The line start index + */ + function getLineStartIndex(nodeOrToken) { + return nodeOrToken.range[0] - nodeOrToken.loc.start.column; + } + + /** + * Checks whether a token or node starts on its own line, preceded only by whitespace. + * @param {ASTNode|Token|Comment} nodeOrToken The token or node to check + * @returns {boolean} Whether the token or node starts on its own line + */ + function startsOnOwnLine(nodeOrToken) { + return ( + sourceCode.getTokenBefore(nodeOrToken, { + includeComments: true, + }).loc.end.line !== nodeOrToken.loc.start.line + ); + } + + /** + * Gets leading comments that are directly attached to a class member. + * @param {ASTNode} classMemberNode The class member node + * @returns {Comment[]} Leading comments to remove with the member + */ + function getLeadingComments(classMemberNode) { + const commentsBefore = + sourceCode.getCommentsBefore(classMemberNode); + const lastNonLeadingCommentIndex = commentsBefore.findLastIndex( + (comment, index, self) => { + const next = + index < self.length - 1 + ? self[index + 1] + : classMemberNode; + + return ( + !startsOnOwnLine(comment) || + next.loc.start.line - comment.loc.end.line > 1 + ); + }, + ); + + return commentsBefore.slice(lastNonLeadingCommentIndex + 1); + } + + /** + * Checks whether a class member shares its line with another token. + * @param {ASTNode} classMemberNode The class member node + * @returns {boolean} Whether the member shares its line with another token + */ + function sharesLineWithAnotherToken(classMemberNode) { + const previousToken = sourceCode.getTokenBefore(classMemberNode); + const nextToken = sourceCode.getTokenAfter(classMemberNode); + + return ( + previousToken.loc.end.line === classMemberNode.loc.start.line || + nextToken.loc.start.line === classMemberNode.loc.end.line + ); + } + + /** + * Gets trailing comments that are directly attached to a class member. + * Same-line trailing comments are preserved when another token shares + * the line, because the comment might describe the remaining code rather + * than the unused member alone. + * @param {ASTNode} classMemberNode The class member node + * @returns {Comment[]} Trailing comments to remove with the member + */ + function getTrailingComments(classMemberNode) { + if (sharesLineWithAnotherToken(classMemberNode)) { + return []; + } + + return sourceCode + .getCommentsAfter(classMemberNode) + .filter( + comment => + comment.loc.start.line === classMemberNode.loc.end.line, + ); + } + + /** + * Gets the token after which a semicolon should be inserted when removing a class member. + * @param {ASTNode} classMemberNode The member that would be removed + * @returns {Token|null} The token after which a semicolon should be inserted, or null if no semicolon is needed + */ + function getSemicolonInsertionToken(classMemberNode) { + const nextToken = sourceCode.getTokenAfter(classMemberNode); + + if ( + astUtils.canContinueExpressionInClassBody(nextToken) && + astUtils.needsPrecedingSemicolon(sourceCode, classMemberNode) + ) { + return sourceCode.getTokenBefore(classMemberNode); + } + + return null; + } + + /** + * Gets the replacement range for removing an unused class member. + * @param {ASTNode} classMemberNode The member that would be removed + * @returns {number[]} The text range to remove + */ + function getMemberRemovalRange(classMemberNode) { + const leadingComments = getLeadingComments(classMemberNode); + const trailingComments = getTrailingComments(classMemberNode); + const shouldRemoveLeadingComments = + leadingComments.length > 0 && + !sharesLineWithAnotherToken(classMemberNode); + const lastItemToRemove = + trailingComments.length > 0 + ? trailingComments.at(-1) + : classMemberNode; + + const previousToken = sourceCode.getTokenBefore(classMemberNode); + const nextToken = sourceCode.getTokenAfter(lastItemToRemove, { + includeComments: true, + }); + const nextTokenStartsOnNewLine = + nextToken.loc.start.line > lastItemToRemove.loc.end.line; + const shouldRemoveOwnLine = + !shouldRemoveLeadingComments && + startsOnOwnLine(classMemberNode) && + nextTokenStartsOnNewLine; + let start = classMemberNode.range[0]; + let end = lastItemToRemove.range[1]; + + if (shouldRemoveLeadingComments) { + start = nextTokenStartsOnNewLine + ? getLineStartIndex(leadingComments[0]) + : leadingComments[0].range[0]; + end = nextTokenStartsOnNewLine + ? getLineStartIndex(nextToken) + : nextToken.range[0]; + } else if (shouldRemoveOwnLine) { + start = getLineStartIndex(classMemberNode); + end = getLineStartIndex(nextToken); + } else if ( + previousToken.loc.end.line === classMemberNode.loc.start.line + ) { + start = previousToken.range[1]; + } else if ( + nextToken.loc.start.line === lastItemToRemove.loc.end.line + ) { + end = nextToken.range[0]; + } + + return [start, end]; + } + + /** + * Check whether the current node is in a write only assignment. + * @param {ASTNode} privateIdentifierNode Node referring to a private identifier + * @returns {boolean} Whether the node is in a write only assignment + * @private + */ + function isWriteOnlyAssignment(privateIdentifierNode) { + const parentStatement = privateIdentifierNode.parent.parent; + const isAssignmentExpression = + parentStatement.type === "AssignmentExpression"; + + if ( + !isAssignmentExpression && + parentStatement.type !== "ForInStatement" && + parentStatement.type !== "ForOfStatement" && + parentStatement.type !== "AssignmentPattern" + ) { + return false; + } + + // It is a write-only usage, since we still allow usages on the right for reads + if (parentStatement.left !== privateIdentifierNode.parent) { + return false; + } + + // For any other operator (such as '+=') we still consider it a read operation + if (isAssignmentExpression && parentStatement.operator !== "=") { + /* + * However, if the read operation is "discarded" in an empty statement, then + * we consider it write only. + */ + return parentStatement.parent.type === "ExpressionStatement"; + } + + return true; + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + // Collect all declared members up front and assume they are all unused + ClassBody(classBodyNode) { + const privateMembers = new Map(); + + trackedClasses.unshift(privateMembers); + for (const bodyMember of classBodyNode.body) { + if ( + bodyMember.type === "PropertyDefinition" || + bodyMember.type === "MethodDefinition" + ) { + if (bodyMember.key.type === "PrivateIdentifier") { + privateMembers.set(bodyMember.key.name, { + declaredNode: bodyMember, + hasReference: false, + isAccessor: + bodyMember.type === "MethodDefinition" && + (bodyMember.kind === "set" || + bodyMember.kind === "get"), + }); + } + } + } + }, + + /* + * Process all usages of the private identifier and remove a member from + * `declaredAndUnusedPrivateMembers` if we deem it used. + */ + PrivateIdentifier(privateIdentifierNode) { + const classBody = trackedClasses.find(classProperties => + classProperties.has(privateIdentifierNode.name), + ); + + // Can't happen, as it is a parser to have a missing class body, but let's code defensively here. + if (!classBody) { + return; + } + + // In case any other usage was already detected, we can short circuit the logic here. + const memberDefinition = classBody.get( + privateIdentifierNode.name, + ); + + if (memberDefinition.isUsed) { + return; + } + + // The definition of the class member itself + if ( + privateIdentifierNode.parent.type === + "PropertyDefinition" || + privateIdentifierNode.parent.type === "MethodDefinition" + ) { + return; + } + + memberDefinition.hasReference = true; + + /* + * Any usage of an accessor is considered a read, as the getter/setter can have + * side-effects in its definition. + */ + if (memberDefinition.isAccessor) { + memberDefinition.isUsed = true; + return; + } + + // Any assignments to this member, except for assignments that also read + if (isWriteOnlyAssignment(privateIdentifierNode)) { + return; + } + + const wrappingExpressionType = + privateIdentifierNode.parent.parent.type; + const parentOfWrappingExpressionType = + privateIdentifierNode.parent.parent.parent.type; + + // A statement which only increments (`this.#x++;`) + if ( + wrappingExpressionType === "UpdateExpression" && + parentOfWrappingExpressionType === "ExpressionStatement" + ) { + return; + } + + /* + * ({ x: this.#usedInDestructuring } = bar); + * + * But should treat the following as a read: + * ({ [this.#x]: a } = foo); + */ + if ( + wrappingExpressionType === "Property" && + parentOfWrappingExpressionType === "ObjectPattern" && + privateIdentifierNode.parent.parent.value === + privateIdentifierNode.parent + ) { + return; + } + + // [...this.#unusedInRestPattern] = bar; + if (wrappingExpressionType === "RestElement") { + return; + } + + // [this.#unusedInAssignmentPattern] = bar; + if (wrappingExpressionType === "ArrayPattern") { + return; + } + + /* + * We can't delete the memberDefinition, as we need to keep track of which member we are marking as used. + * In the case of nested classes, we only mark the first member we encounter as used. If you were to delete + * the member, then any subsequent usage could incorrectly mark the member of an encapsulating parent class + * as used, which is incorrect. + */ + memberDefinition.isUsed = true; + }, + + /* + * Post-process the class members and report any remaining members. + * Since private members can only be accessed in the current class context, + * we can safely assume that all usages are within the current class body. + */ + "ClassBody:exit"() { + const unusedPrivateMembers = trackedClasses.shift(); + + for (const [ + classMemberName, + { declaredNode, hasReference, isUsed }, + ] of unusedPrivateMembers.entries()) { + if (isUsed) { + continue; + } + + context.report({ + node: declaredNode, + loc: declaredNode.key.loc, + messageId: "unusedPrivateClassMember", + data: { + classMemberName: `#${classMemberName}`, + }, + suggest: [ + { + messageId: "removeUnusedPrivateClassMember", + data: { + classMemberName: `#${classMemberName}`, + }, + *fix(fixer) { + if (hasReference) { + return; + } + + const removalRange = + getMemberRemovalRange(declaredNode); + const semicolonInsertionToken = + getSemicolonInsertionToken( + declaredNode, + ); + const removalFix = fixer.replaceTextRange( + removalRange, + "", + ); + + yield removalFix; + + if (semicolonInsertionToken) { + yield fixer.insertTextAfter( + semicolonInsertionToken, + ";", + ); + } + }, + }, + ], + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-vars.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-vars.js new file mode 100644 index 00000000..005e8d04 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-unused-vars.js @@ -0,0 +1,1850 @@ +/** + * @fileoverview Rule to flag declared but unused variables + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * A simple name for the types of variables that this rule supports + * @typedef {'array-destructure'|'catch-clause'|'parameter'|'variable'} VariableType + */ + +/** + * Bag of data used for formatting the `unusedVar` lint message. + * @typedef {Object} UnusedVarMessageData + * @property {string} varName The name of the unused var. + * @property {'defined'|'assigned a value'} action Description of the vars state. + * @property {string} additional Any additional info to be appended at the end. + */ + +/** + * Bag of data used for formatting the `usedIgnoredVar` lint message. + * @typedef {Object} UsedIgnoredVarMessageData + * @property {string} varName The name of the unused var. + * @property {string} additional Any additional info to be appended at the end. + */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const DEFAULT_OPTIONS = { + vars: "all", + args: "after-used", + ignoreRestSiblings: false, + caughtErrors: "all", + ignoreClassWithStaticInitBlock: false, + ignoreUsingDeclarations: false, + reportUsedIgnorePattern: false, +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: "Disallow unused variables", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-unused-vars", + }, + + hasSuggestions: true, + + schema: [ + { + oneOf: [ + { + enum: ["all", "local"], + }, + { + type: "object", + properties: { + vars: { + enum: ["all", "local"], + }, + varsIgnorePattern: { + type: "string", + }, + args: { + enum: ["all", "after-used", "none"], + }, + ignoreRestSiblings: { + type: "boolean", + }, + argsIgnorePattern: { + type: "string", + }, + caughtErrors: { + enum: ["all", "none"], + }, + caughtErrorsIgnorePattern: { + type: "string", + }, + destructuredArrayIgnorePattern: { + type: "string", + }, + ignoreClassWithStaticInitBlock: { + type: "boolean", + }, + ignoreUsingDeclarations: { + type: "boolean", + }, + reportUsedIgnorePattern: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [DEFAULT_OPTIONS], + + messages: { + unusedVar: + "'{{varName}}' is {{action}} but never used{{additional}}.", + usedIgnoredVar: + "'{{varName}}' is marked as ignored but is used{{additional}}.", + removeVar: "Remove unused variable '{{varName}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const REST_PROPERTY_TYPE = + /^(?:RestElement|(?:Experimental)?RestProperty)$/u; + + let config; + + const firstOption = context.options[0]; + + if (typeof firstOption === "string") { + config = { + ...DEFAULT_OPTIONS, + vars: firstOption, + }; + } else { + config = { + ...firstOption, + }; + + if (firstOption.varsIgnorePattern) { + config.varsIgnorePattern = new RegExp( + firstOption.varsIgnorePattern, + "u", + ); + } + + if (firstOption.argsIgnorePattern) { + config.argsIgnorePattern = new RegExp( + firstOption.argsIgnorePattern, + "u", + ); + } + + if (firstOption.caughtErrorsIgnorePattern) { + config.caughtErrorsIgnorePattern = new RegExp( + firstOption.caughtErrorsIgnorePattern, + "u", + ); + } + + if (firstOption.destructuredArrayIgnorePattern) { + config.destructuredArrayIgnorePattern = new RegExp( + firstOption.destructuredArrayIgnorePattern, + "u", + ); + } + } + + /** + * Determines what variable type a def is. + * @param {Object} def the declaration to check + * @returns {VariableType} a simple name for the types of variables that this rule supports + */ + function defToVariableType(def) { + /* + * This `destructuredArrayIgnorePattern` error report works differently from the catch + * clause and parameter error reports. _Both_ the `varsIgnorePattern` and the + * `destructuredArrayIgnorePattern` will be checked for array destructuring. However, + * for the purposes of the report, the currently defined behavior is to only inform the + * user of the `destructuredArrayIgnorePattern` if it's present (regardless of the fact + * that the `varsIgnorePattern` would also apply). If it's not present, the user will be + * informed of the `varsIgnorePattern`, assuming that's present. + */ + if ( + config.destructuredArrayIgnorePattern && + def.name.parent.type === "ArrayPattern" + ) { + return "array-destructure"; + } + + switch (def.type) { + case "CatchClause": + return "catch-clause"; + case "Parameter": + return "parameter"; + + default: + return "variable"; + } + } + + /** + * Gets a given variable's description and configured ignore pattern + * based on the provided variableType + * @param {VariableType} variableType a simple name for the types of variables that this rule supports + * @throws {Error} (Unreachable) + * @returns {[string | undefined, string | undefined]} the given variable's description and + * ignore pattern + */ + function getVariableDescription(variableType) { + let pattern; + let variableDescription; + + switch (variableType) { + case "array-destructure": + pattern = config.destructuredArrayIgnorePattern; + variableDescription = "elements of array destructuring"; + break; + + case "catch-clause": + pattern = config.caughtErrorsIgnorePattern; + variableDescription = "caught errors"; + break; + + case "parameter": + pattern = config.argsIgnorePattern; + variableDescription = "args"; + break; + + case "variable": + pattern = config.varsIgnorePattern; + variableDescription = "vars"; + break; + + default: + throw new Error( + `Unexpected variable type: ${variableType}`, + ); + } + + if (pattern) { + pattern = pattern.toString(); + } + + return [variableDescription, pattern]; + } + + /** + * Generates the message data about the variable being defined and unused, + * including the ignore pattern if configured. + * @param {Variable} unusedVar eslint-scope variable object. + * @returns {UnusedVarMessageData} The message data to be used with this unused variable. + */ + function getDefinedMessageData(unusedVar) { + const def = unusedVar.defs && unusedVar.defs[0]; + let additionalMessageData = ""; + + if (def) { + const [variableDescription, pattern] = getVariableDescription( + defToVariableType(def), + ); + + if (pattern && variableDescription) { + additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`; + } + } + + return { + varName: unusedVar.name, + action: "defined", + additional: additionalMessageData, + }; + } + + /** + * Generate the warning message about the variable being + * assigned and unused, including the ignore pattern if configured. + * @param {Variable} unusedVar eslint-scope variable object. + * @returns {UnusedVarMessageData} The message data to be used with this unused variable. + */ + function getAssignedMessageData(unusedVar) { + const def = unusedVar.defs && unusedVar.defs[0]; + let additionalMessageData = ""; + + if (def) { + const [variableDescription, pattern] = getVariableDescription( + defToVariableType(def), + ); + + if (pattern && variableDescription) { + additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`; + } + } + + return { + varName: unusedVar.name, + action: "assigned a value", + additional: additionalMessageData, + }; + } + + /** + * Generate the warning message about a variable being used even though + * it is marked as being ignored. + * @param {Variable} variable eslint-scope variable object + * @param {VariableType} variableType a simple name for the types of variables that this rule supports + * @returns {UsedIgnoredVarMessageData} The message data to be used with + * this used ignored variable. + */ + function getUsedIgnoredMessageData(variable, variableType) { + const [variableDescription, pattern] = + getVariableDescription(variableType); + + let additionalMessageData = ""; + + if (pattern && variableDescription) { + additionalMessageData = `. Used ${variableDescription} must not match ${pattern}`; + } + + return { + varName: variable.name, + additional: additionalMessageData, + }; + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const STATEMENT_TYPE = /(?:Statement|Declaration)$/u; + + /** + * Determines if a given variable is being exported from a module. + * @param {Variable} variable eslint-scope variable object. + * @returns {boolean} True if the variable is exported, false if not. + * @private + */ + function isExported(variable) { + const definition = variable.defs[0]; + + if (definition) { + let node = definition.node; + + if (node.type === "VariableDeclarator") { + node = node.parent; + } else if (definition.type === "Parameter") { + return false; + } + + return node.parent.type.indexOf("Export") === 0; + } + return false; + } + + /** + * Determines if a given variable uses the explicit resource management protocol. + * @param {Variable} variable eslint-scope variable object. + * @returns {boolean} True if the variable is declared with "using" or "await using" + * @private + */ + function usesExplicitResourceManagement(variable) { + const [definition] = variable.defs; + + return ( + definition?.type === "Variable" && + (definition.parent.kind === "using" || + definition.parent.kind === "await using") + ); + } + + /** + * Checks whether a node is a sibling of the rest property or not. + * @param {ASTNode} node a node to check + * @returns {boolean} True if the node is a sibling of the rest property, otherwise false. + */ + function hasRestSibling(node) { + return ( + node.type === "Property" && + node.parent.type === "ObjectPattern" && + REST_PROPERTY_TYPE.test(node.parent.properties.at(-1).type) + ); + } + + /** + * Determines if a variable has a sibling rest property + * @param {Variable} variable eslint-scope variable object. + * @returns {boolean} True if the variable has a sibling rest property, false if not. + * @private + */ + function hasRestSpreadSibling(variable) { + if (config.ignoreRestSiblings) { + const hasRestSiblingDefinition = variable.defs.some(def => + hasRestSibling(def.name.parent), + ); + const hasRestSiblingReference = variable.references.some(ref => + hasRestSibling(ref.identifier.parent), + ); + + return hasRestSiblingDefinition || hasRestSiblingReference; + } + + return false; + } + + /** + * Determines if a reference is a read operation. + * @param {Reference} ref An eslint-scope Reference + * @returns {boolean} whether the given reference represents a read operation + * @private + */ + function isReadRef(ref) { + return ref.isRead(); + } + + /** + * Determine if an identifier is referencing an enclosing function name. + * @param {Reference} ref The reference to check. + * @param {ASTNode[]} nodes The candidate function nodes. + * @returns {boolean} True if it's a self-reference, false if not. + * @private + */ + function isSelfReference(ref, nodes) { + let scope = ref.from; + + while (scope) { + if (nodes.includes(scope.block)) { + return true; + } + + scope = scope.upper; + } + + return false; + } + + /** + * Gets a list of function definitions for a specified variable. + * @param {Variable} variable eslint-scope variable object. + * @returns {ASTNode[]} Function nodes. + * @private + */ + function getFunctionDefinitions(variable) { + const functionDefinitions = []; + + variable.defs.forEach(def => { + const { type, node } = def; + + // FunctionDeclarations + if (type === "FunctionName") { + functionDefinitions.push(node); + } + + // FunctionExpressions + if ( + type === "Variable" && + node.init && + (node.init.type === "FunctionExpression" || + node.init.type === "ArrowFunctionExpression") + ) { + functionDefinitions.push(node.init); + } + }); + return functionDefinitions; + } + + /** + * Checks the position of given nodes. + * @param {ASTNode} inner A node which is expected as inside. + * @param {ASTNode} outer A node which is expected as outside. + * @returns {boolean} `true` if the `inner` node exists in the `outer` node. + * @private + */ + function isInside(inner, outer) { + return ( + inner.range[0] >= outer.range[0] && + inner.range[1] <= outer.range[1] + ); + } + + /** + * Checks whether a given node is unused expression or not. + * @param {ASTNode} node The node itself + * @returns {boolean} The node is an unused expression. + * @private + */ + function isUnusedExpression(node) { + const parent = node.parent; + + if (parent.type === "ExpressionStatement") { + return true; + } + + if (parent.type === "SequenceExpression") { + const isLastExpression = parent.expressions.at(-1) === node; + + if (!isLastExpression) { + return true; + } + return isUnusedExpression(parent); + } + + return false; + } + + /** + * If a given reference is left-hand side of an assignment, this gets + * the right-hand side node of the assignment. + * + * In the following cases, this returns null. + * + * - The reference is not the LHS of an assignment expression. + * - The reference is inside of a loop. + * - The reference is inside of a function scope which is different from + * the declaration. + * @param {Reference} ref A reference to check. + * @param {ASTNode} prevRhsNode The previous RHS node. + * @returns {ASTNode|null} The RHS node or null. + * @private + */ + function getRhsNode(ref, prevRhsNode) { + const id = ref.identifier; + const parent = id.parent; + const refScope = ref.from.variableScope; + const varScope = ref.resolved.scope.variableScope; + const canBeUsedLater = + refScope !== varScope || astUtils.isInLoop(id); + + /* + * Inherits the previous node if this reference is in the node. + * This is for `a = a + a`-like code. + */ + if (prevRhsNode && isInside(id, prevRhsNode)) { + return prevRhsNode; + } + + if ( + parent.type === "AssignmentExpression" && + isUnusedExpression(parent) && + id === parent.left && + !canBeUsedLater + ) { + return parent.right; + } + return null; + } + + /** + * Checks whether a given function node is stored to somewhere or not. + * If the function node is stored, the function can be used later. + * @param {ASTNode} funcNode A function node to check. + * @param {ASTNode} rhsNode The RHS node of the previous assignment. + * @returns {boolean} `true` if under the following conditions: + * - the funcNode is assigned to a variable. + * - the funcNode is bound as an argument of a function call. + * - the function is bound to a property and the object satisfies above conditions. + * @private + */ + function isStorableFunction(funcNode, rhsNode) { + let node = funcNode; + let parent = funcNode.parent; + + while (parent && isInside(parent, rhsNode)) { + switch (parent.type) { + case "SequenceExpression": + if (parent.expressions.at(-1) !== node) { + return false; + } + break; + + case "CallExpression": + case "NewExpression": + return parent.callee !== node; + + case "AssignmentExpression": + case "TaggedTemplateExpression": + case "YieldExpression": + return true; + + default: + if (STATEMENT_TYPE.test(parent.type)) { + /* + * If it encountered statements, this is a complex pattern. + * Since analyzing complex patterns is hard, this returns `true` to avoid false positive. + */ + return true; + } + } + + node = parent; + parent = parent.parent; + } + + return false; + } + + /** + * Checks whether a given Identifier node exists inside of a function node which can be used later. + * + * "can be used later" means: + * - the function is assigned to a variable. + * - the function is bound to a property and the object can be used later. + * - the function is bound as an argument of a function call. + * + * If a reference exists in a function which can be used later, the reference is read when the function is called. + * @param {ASTNode} id An Identifier node to check. + * @param {ASTNode} rhsNode The RHS node of the previous assignment. + * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later. + * @private + */ + function isInsideOfStorableFunction(id, rhsNode) { + const funcNode = astUtils.getUpperFunction(id); + + return ( + funcNode && + isInside(funcNode, rhsNode) && + isStorableFunction(funcNode, rhsNode) + ); + } + + /** + * Checks whether a given reference is a read to update itself or not. + * @param {Reference} ref A reference to check. + * @param {ASTNode} rhsNode The RHS node of the previous assignment. + * @returns {boolean} The reference is a read to update itself. + * @private + */ + function isReadForItself(ref, rhsNode) { + const id = ref.identifier; + const parent = id.parent; + + return ( + ref.isRead() && + // self update. e.g. `a += 1`, `a++` + ((parent.type === "AssignmentExpression" && + parent.left === id && + isUnusedExpression(parent) && + !astUtils.isLogicalAssignmentOperator(parent.operator)) || + (parent.type === "UpdateExpression" && + isUnusedExpression(parent)) || + // in RHS of an assignment for itself. e.g. `a = a + 1` + (rhsNode && + isInside(id, rhsNode) && + !isInsideOfStorableFunction(id, rhsNode))) + ); + } + + /** + * Determine if an identifier is used either in for-in or for-of loops. + * @param {Reference} ref The reference to check. + * @returns {boolean} whether reference is used in the for-in loops + * @private + */ + function isForInOfRef(ref) { + let target = ref.identifier.parent; + + // "for (var ...) { return; }" + if (target.type === "VariableDeclarator") { + target = target.parent.parent; + } + + if ( + target.type !== "ForInStatement" && + target.type !== "ForOfStatement" + ) { + return false; + } + + // "for (...) { return; }" + if (target.body.type === "BlockStatement") { + target = target.body.body[0]; + + // "for (...) return;" + } else { + target = target.body; + } + + // For empty loop body + if (!target) { + return false; + } + + return target.type === "ReturnStatement"; + } + + /** + * Determines if the variable is used. + * @param {Variable} variable The variable to check. + * @returns {boolean} True if the variable is used + * @private + */ + function isUsedVariable(variable) { + if (variable.eslintUsed) { + return true; + } + + const functionNodes = getFunctionDefinitions(variable); + const isFunctionDefinition = functionNodes.length > 0; + + let rhsNode = null; + + return variable.references.some(ref => { + if (isForInOfRef(ref)) { + return true; + } + + const forItself = isReadForItself(ref, rhsNode); + + rhsNode = getRhsNode(ref, rhsNode); + + return ( + isReadRef(ref) && + !forItself && + !( + isFunctionDefinition && + isSelfReference(ref, functionNodes) + ) + ); + }); + } + + /** + * Checks whether the given variable is after the last used parameter. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable is defined after the last + * used parameter. + */ + function isAfterLastUsedArg(variable) { + const def = variable.defs[0]; + const params = sourceCode.getDeclaredVariables(def.node); + const posteriorParams = params.slice(params.indexOf(variable) + 1); + + // If any used parameters occur after this parameter, do not report. + return !posteriorParams.some( + v => v.references.length > 0 || v.eslintUsed, + ); + } + + /** + * Gets an array of variables without read references. + * @param {Scope} scope an eslint-scope Scope object. + * @param {Variable[]} unusedVars an array that saving result. + * @returns {Variable[]} unused variables of the scope and descendant scopes. + * @private + */ + function collectUnusedVariables(scope, unusedVars) { + const variables = scope.variables; + const childScopes = scope.childScopes; + let i, l; + + if (scope.type !== "global" || config.vars === "all") { + for (i = 0, l = variables.length; i < l; ++i) { + const variable = variables[i]; + + // skip a variable of class itself name in the class scope + if ( + scope.type === "class" && + scope.block.id === variable.identifiers[0] + ) { + continue; + } + + // skip function expression names + if (scope.functionExpressionScope) { + continue; + } + + // skip variables marked with markVariableAsUsed() + if ( + !config.reportUsedIgnorePattern && + variable.eslintUsed + ) { + continue; + } + + // skip implicit "arguments" variable + if ( + scope.type === "function" && + variable.name === "arguments" && + variable.identifiers.length === 0 + ) { + continue; + } + + // explicit global variables don't have definitions. + const def = variable.defs[0]; + + if (def) { + const type = def.type; + const refUsedInArrayPatterns = variable.references.some( + ref => + ref.identifier.parent.type === "ArrayPattern", + ); + + // skip elements of array destructuring patterns + if ( + (def.name.parent.type === "ArrayPattern" || + refUsedInArrayPatterns) && + config.destructuredArrayIgnorePattern && + config.destructuredArrayIgnorePattern.test( + def.name.name, + ) + ) { + if ( + config.reportUsedIgnorePattern && + isUsedVariable(variable) + ) { + context.report({ + node: def.name, + messageId: "usedIgnoredVar", + data: getUsedIgnoredMessageData( + variable, + "array-destructure", + ), + }); + } + + continue; + } + + if (type === "ClassName") { + const hasStaticBlock = def.node.body.body.some( + node => node.type === "StaticBlock", + ); + + if ( + config.ignoreClassWithStaticInitBlock && + hasStaticBlock + ) { + continue; + } + } + + // skip catch variables + if (type === "CatchClause") { + if (config.caughtErrors === "none") { + continue; + } + + // skip ignored parameters + if ( + config.caughtErrorsIgnorePattern && + config.caughtErrorsIgnorePattern.test( + def.name.name, + ) + ) { + if ( + config.reportUsedIgnorePattern && + isUsedVariable(variable) + ) { + context.report({ + node: def.name, + messageId: "usedIgnoredVar", + data: getUsedIgnoredMessageData( + variable, + "catch-clause", + ), + }); + } + + continue; + } + } else if (type === "Parameter") { + // skip any setter argument + if ( + (def.node.parent.type === "Property" || + def.node.parent.type === + "MethodDefinition") && + def.node.parent.kind === "set" + ) { + continue; + } + + // if "args" option is "none", skip any parameter + if (config.args === "none") { + continue; + } + + // skip ignored parameters + if ( + config.argsIgnorePattern && + config.argsIgnorePattern.test(def.name.name) + ) { + if ( + config.reportUsedIgnorePattern && + isUsedVariable(variable) + ) { + context.report({ + node: def.name, + messageId: "usedIgnoredVar", + data: getUsedIgnoredMessageData( + variable, + "parameter", + ), + }); + } + + continue; + } + + // if "args" option is "after-used", skip used variables + if ( + config.args === "after-used" && + astUtils.isFunction(def.name.parent) && + !isAfterLastUsedArg(variable) + ) { + continue; + } + } else { + // skip ignored variables + if ( + config.varsIgnorePattern && + config.varsIgnorePattern.test(def.name.name) + ) { + if ( + config.reportUsedIgnorePattern && + isUsedVariable(variable) + ) { + context.report({ + node: def.name, + messageId: "usedIgnoredVar", + data: getUsedIgnoredMessageData( + variable, + "variable", + ), + }); + } + + continue; + } + } + } + + if ( + !isUsedVariable(variable) && + !isExported(variable) && + !( + config.ignoreUsingDeclarations && + usesExplicitResourceManagement(variable) + ) && + !hasRestSpreadSibling(variable) + ) { + unusedVars.push(variable); + } + } + } + + for (i = 0, l = childScopes.length; i < l; ++i) { + collectUnusedVariables(childScopes[i], unusedVars); + } + + return unusedVars; + } + + /** + * fixes unused variables + * @param {Object} fixer fixer object + * @param {Object} unusedVar unused variable to fix + * @returns {Object} fixer object + */ + function handleFixes(fixer, unusedVar) { + const id = unusedVar.identifiers[0]; + const parent = id.parent; + const parentType = parent.type; + const tokenBefore = sourceCode.getTokenBefore(id); + const tokenAfter = sourceCode.getTokenAfter(id); + const isFunction = astUtils.isFunction; + const isLoop = astUtils.isLoop; + const allWriteReferences = unusedVar.references.filter(ref => + ref.isWrite(), + ); + + /** + * get range from token before of a given node + * @param {ASTNode} node node of identifier + * @param {number} skips number of token to skip + * @returns {number} start range of token before the identifier + */ + function getPreviousTokenStart(node, skips) { + return sourceCode.getTokenBefore(node, skips).range[0]; + } + + /** + * get range to token after of a given node + * @param {ASTNode} node node of identifier + * @param {number} skips number of token to skip + * @returns {number} end range of token after the identifier + */ + function getNextTokenEnd(node, skips) { + return sourceCode.getTokenAfter(node, skips).range[1]; + } + + /** + * get the value of token before of a given node + * @param {ASTNode} node node of identifier + * @returns {string} value of token before the identifier + */ + function getTokenBeforeValue(node) { + return sourceCode.getTokenBefore(node).value; + } + + /** + * get the value of token after of a given node + * @param {ASTNode} node node of identifier + * @returns {string} value of token after the identifier + */ + function getTokenAfterValue(node) { + return sourceCode.getTokenAfter(node).value; + } + + /** + * Check if an array has a single element with null as other element. + * @param {ASTNode} node ArrayPattern node + * @returns {boolean} true if array has single element with other null elements + */ + function hasSingleElement(node) { + return node.elements.filter(e => e !== null).length === 1; + } + + /** + * check whether import specifier has an import of particular type + * @param {ASTNode} node ImportDeclaration node + * @param {string} type type of import to check + * @returns {boolean} true if import specifier has import of specified type + */ + function hasImportOfCertainType(node, type) { + return node.specifiers.some(e => e.type === type); + } + + /** + * Check whether a closing brace token belongs to a block-level + * construct (safe for ASI) rather than an expression (unsafe). + * + * Block-level `}` (e.g., if/for/while/function declaration body) + * always triggers ASI, so it's safe to have adjacent tokens. + * + * Expression-level `}` (e.g., object literal, function expression, + * arrow function body) does NOT trigger ASI, so adjacent tokens + * could merge and change the parse. + * @param {Token} token The token to check + * @returns {boolean} true if the token is `}` from a block construct + */ + function isClosingBraceOfBlock(token) { + if (!astUtils.isClosingBraceToken(token)) { + return false; + } + + const node = sourceCode.getNodeByRangeIndex(token.range[0]); + + switch (node.type) { + case "BlockStatement": + /* + * Safe only if the block belongs to a statement construct, + * not an expression (FunctionExpression, ArrowFunctionExpression) + */ + return ( + node.parent.type !== "FunctionExpression" && + node.parent.type !== "ArrowFunctionExpression" + ); + + case "ClassBody": + return node.parent.type === "ClassDeclaration"; + + case "SwitchStatement": + return true; + + default: + return false; + } + } + + /** + * Check whether declaration is safe to remove or not + * @param {ASTNode} nextToken next token of unused variable + * @param {ASTNode} prevToken previous token of unused variable + * @returns {boolean} true if declaration is not safe to remove + */ + function isDeclarationNotSafeToRemove(nextToken, prevToken) { + return ( + nextToken.type === "String" || + (prevToken && + !astUtils.isSemicolonToken(prevToken) && + !astUtils.isOpeningBraceToken(prevToken) && + !isClosingBraceOfBlock(prevToken)) + ); + } + + /** + * give fixes for unused variables in function parameters + * @param {ASTNode} node node to check + * @returns {Object} fixer object + */ + function fixFunctionParameters(node) { + const parentNode = node.parent; + + if (isFunction(parentNode)) { + // remove unused function parameter if there is only a single parameter + if (parentNode.params.length === 1) { + return fixer.removeRange(node.range); + } + + // remove first unused function parameter when there are multiple parameters + if ( + getTokenBeforeValue(node) === "(" && + getTokenAfterValue(node) === "," + ) { + return fixer.removeRange([ + node.range[0], + getNextTokenEnd(node), + ]); + } + + // remove unused function parameters except first one when there are multiple parameters + return fixer.removeRange([ + getPreviousTokenStart(node), + node.range[1], + ]); + } + + return null; + } + + /** + * fix unused variable declarations and function parameters + * @param {ASTNode} node parent node to identifier + * @returns {Object} fixer object + */ + function fixVariables(node) { + const parentNode = node.parent; + + // remove unused declared variables such as var a = b; or var a = b, c; + if (parentNode.type === "VariableDeclarator") { + // skip variable in for (const [ foo ] of bar); + if (isLoop(parentNode.parent.parent)) { + return null; + } + + /* + * remove unused declared variable with single declaration such as 'var a = b;' + * remove complete declaration when there is an unused variable in 'const { a } = foo;', same for arrays. + */ + if (parentNode.parent.declarations.length === 1) { + // if next token is a string it could become a directive if node is removed -> no suggestion. + const nextToken = sourceCode.getTokenAfter( + parentNode.parent, + ); + + // if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion. + const prevToken = sourceCode.getTokenBefore( + parentNode.parent, + ); + + if ( + nextToken && + isDeclarationNotSafeToRemove(nextToken, prevToken) + ) { + return null; + } + + return fixer.removeRange(parentNode.parent.range); + } + + /* + * remove unused declared variable with multiple declaration except first one such as 'var a = b, c = d;' + * fix 'let bar = "hello", { a } = foo;' to 'let bar = "hello";' if 'a' is unused, same for arrays. + */ + if (getTokenBeforeValue(parentNode) === ",") { + // If this is the last declarator, removing it may create an ASI hazard + if ( + parentNode === parentNode.parent.declarations.at(-1) + ) { + const lastTokenOfDecl = sourceCode.getLastToken( + parentNode.parent, + ); + + // If the declaration has a trailing semicolon, the removal is safe + if (!astUtils.isSemicolonToken(lastTokenOfDecl)) { + const nextToken = sourceCode.getTokenAfter( + parentNode.parent, + ); + const lastRemainingToken = + sourceCode.getTokenBefore(parentNode, { + skip: 1, + }); + + if ( + nextToken && + isDeclarationNotSafeToRemove( + nextToken, + lastRemainingToken, + ) + ) { + return null; + } + } + } + + return fixer.removeRange([ + getPreviousTokenStart(parentNode), + parentNode.range[1], + ]); + } + + /* + * remove first unused declared variable when there are multiple declarations + * fix 'let { a } = foo, bar = "hello";' to 'let bar = "hello";' if 'a' is unused, same for arrays. + */ + return fixer.removeRange([ + parentNode.range[0], + getNextTokenEnd(parentNode), + ]); + } + + // fixes [{a: {k}}], [{a: [k]}] + if (getTokenBeforeValue(node) === ":") { + if (parentNode.parent.type === "ObjectPattern") { + // eslint-disable-next-line no-use-before-define -- due to interdependency of functions + return fixObjectWithValueSeparator(node); + } + } + + // fix unused function parameters + return fixFunctionParameters(node); + } + + /** + * fix nested object like { a: { b } } + * @param {ASTNode} node parent node to check + * @returns {Object} fixer object + */ + function fixNestedObjectVariable(node) { + const parentNode = node.parent; + + // fix for { a: { b: { c: { d } } } } + if ( + parentNode.parent.parent.parent.type === "ObjectPattern" && + parentNode.parent.properties.length === 1 + ) { + return fixNestedObjectVariable(parentNode.parent); + } + + // fix for { a: { b } } + if (parentNode.parent.type === "ObjectPattern") { + // fix for unused variables in destructured object with single property in variable declaration and function parameter + if (parentNode.parent.properties.length === 1) { + return fixVariables(parentNode.parent); + } + + // fix for first unused property when there are multiple properties such as '{ a: { b }, c }' + if (getTokenBeforeValue(parentNode) === "{") { + return fixer.removeRange([ + parentNode.range[0], + getNextTokenEnd(parentNode), + ]); + } + + // fix for unused property except first one when there are multiple properties such as '{ k, a: { b } }' + return fixer.removeRange([ + getPreviousTokenStart(parentNode), + parentNode.range[1], + ]); + } + + return null; + } + + /** + * fix unused variables in array and nested array + * @param {ASTNode} node parent node to check + * @returns {Object} fixer object + */ + function fixNestedArrayVariable(node) { + const parentNode = node.parent; + + // fix for nested arrays [[ a ]] + if ( + parentNode.parent.type === "ArrayPattern" && + hasSingleElement(parentNode) + ) { + return fixNestedArrayVariable(parentNode); + } + + if (hasSingleElement(parentNode)) { + // fixes { a: [{ b }] } or { a: [[ b ]] } + if (getTokenBeforeValue(parentNode) === ":") { + return fixVariables(parentNode); + } + + // fixes [a, ...[[ b ]]] or [a, ...[{ b }]] + if (parentNode.parent.type === "RestElement") { + // eslint-disable-next-line no-use-before-define -- due to interdependency of functions + return fixRestInPattern(parentNode.parent); + } + + // fix unused variables in destructured array in variable declaration or function parameter + return fixVariables(parentNode); + } + + // remove last unused array element + if ( + getTokenBeforeValue(node) === "," && + getTokenAfterValue(node) === "]" + ) { + return fixer.removeRange([ + getPreviousTokenStart(node), + node.range[1], + ]); + } + + // remove unused array element + return fixer.removeRange(node.range); + } + + /** + * fix cases like {a: {k}} or {a: [k]} + * @param {ASTNode} node parent node to check + * @returns {Object} fixer object + */ + function fixObjectWithValueSeparator(node) { + const parentNode = node.parent.parent; + + // fix cases like [{a : { b }}] or [{a : [ b ]}] + if ( + parentNode.parent.type === "ArrayPattern" && + parentNode.properties.length === 1 + ) { + return fixNestedArrayVariable(parentNode); + } + + // fix cases like {a: {k}} or {a: [k]} + return fixNestedObjectVariable(node); + } + + /** + * fix ...[[a]] or ...[{a}] like patterns + * @param {ASTNode} node parent node to check + * @returns {Object} fixer object + */ + function fixRestInPattern(node) { + const parentNode = node.parent; + + // fix ...[[a]] or ...[{a}] in function parameters + if (isFunction(parentNode)) { + if (parentNode.params.length === 1) { + return fixer.removeRange(node.range); + } + + return fixer.removeRange([ + getPreviousTokenStart(node), + node.range[1], + ]); + } + + // fix rest in nested array pattern like [[a, ...[b]]] + if (parentNode.type === "ArrayPattern") { + // fix [[...[b]]] + if (hasSingleElement(parentNode)) { + if (parentNode.parent.type === "ArrayPattern") { + return fixNestedArrayVariable(parentNode); + } + + // fix 'const [...[b]] = foo; and function foo([...[b]]) {} + return fixVariables(parentNode); + } + + // fix [[a, ...[b]]] + return fixer.removeRange([ + getPreviousTokenStart(node), + node.range[1], + ]); + } + + return null; + } + + // skip fix when variable has references that would be left behind + if ( + allWriteReferences.some( + ref => ref.identifier.range[0] !== id.range[0], + ) + ) { + return null; + } + + // remove declared variables such as var a; or var a, b; + if (parentType === "VariableDeclarator") { + if (parent.parent.declarations.length === 1) { + // prevent fix of variable in forOf and forIn loops. + if ( + isLoop(parent.parent.parent) && + parent.parent.parent.body !== parent.parent + ) { + return null; + } + + // removes only variable not semicolon in 'if (foo()) var bar;' or in 'loops' or in 'with' statement. + if ( + parent.parent.parent.type === "IfStatement" || + isLoop(parent.parent.parent) || + (parent.parent.parent.type === "WithStatement" && + parent.parent.parent.body === parent.parent) + ) { + return fixer.replaceText(parent.parent, ";"); + } + + // if next token is a string it could become a directive if node is removed -> no suggestion. + const nextToken = sourceCode.getTokenAfter(parent.parent); + + // if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion. + const prevToken = sourceCode.getTokenBefore(parent.parent); + + if ( + nextToken && + isDeclarationNotSafeToRemove(nextToken, prevToken) + ) { + return null; + } + + // remove unused declared variable with single declaration like 'var a = b;' + return fixer.removeRange(parent.parent.range); + } + + // remove unused declared variable with multiple declaration except first one like 'var a = b, c = d;' + if (tokenBefore.value === ",") { + // If this is the last declarator, removing it may create an ASI hazard + if (parent === parent.parent.declarations.at(-1)) { + const lastTokenOfDecl = sourceCode.getLastToken( + parent.parent, + ); + + // If the declaration has a trailing semicolon, the removal is safe + if (!astUtils.isSemicolonToken(lastTokenOfDecl)) { + const nextToken = sourceCode.getTokenAfter( + parent.parent, + ); + const lastRemainingToken = + sourceCode.getTokenBefore(parent, { skip: 1 }); + + if ( + nextToken && + isDeclarationNotSafeToRemove( + nextToken, + lastRemainingToken, + ) + ) { + return null; + } + } + } + + return fixer.removeRange([ + tokenBefore.range[0], + parent.range[1], + ]); + } + + // remove first unused declared variable when there are multiple declarations + return fixer.removeRange([ + parent.range[0], + getNextTokenEnd(parent), + ]); + } + + // remove variables in object patterns + if (parent.parent.type === "ObjectPattern") { + if (parent.parent.properties.length === 1) { + // fix [a, ...{b}] + if (parent.parent.parent.type === "RestElement") { + return fixRestInPattern(parent.parent.parent); + } + + // fix [{ a }] + if (parent.parent.parent.type === "ArrayPattern") { + return fixNestedArrayVariable(parent.parent); + } + + /* + * var {a} = foo; + * function a({a}) {} + * fix const { a: { b } } = foo; + */ + return fixVariables(parent.parent); + } + + // fix const { a:b } = foo; + if (tokenBefore.value === ":") { + // remove first unused variable in const { a:b } = foo; + if ( + getTokenBeforeValue(parent) === "{" && + getTokenAfterValue(parent) === "," + ) { + return fixer.removeRange([ + parent.range[0], + getNextTokenEnd(parent), + ]); + } + + // remove unused variables in const { a: b, c: d } = foo; except first one + return fixer.removeRange([ + getPreviousTokenStart(parent), + id.range[1], + ]); + } + } + + // remove unused variables inside an array + if (parentType === "ArrayPattern") { + if (hasSingleElement(parent)) { + // fix [a, ...[b]] + if (parent.parent.type === "RestElement") { + return fixRestInPattern(parent.parent); + } + + // fix [ [a] ] + if (parent.parent.type === "ArrayPattern") { + return fixNestedArrayVariable(parent); + } + + /* + * fix var [a] = foo; + * fix function foo([a]) {} + * fix const { a: [b] } = foo; + */ + return fixVariables(parent); + } + + // if "a" is unused in [a, b ,c] fixes to [, b, c] + if (tokenBefore.value === "," && tokenAfter.value === ",") { + return fixer.removeRange(id.range); + } + } + + // remove unused rest elements + if (parentType === "RestElement") { + // fix [a, ...rest] + if (parent.parent.type === "ArrayPattern") { + if (hasSingleElement(parent.parent)) { + // fix [[...rest]] when there is only rest element + if (parent.parent.parent.type === "ArrayPattern") { + return fixNestedArrayVariable(parent.parent); + } + + // fix 'const [...rest] = foo;' and 'function foo([...rest]) {}' + return fixVariables(parent.parent); + } + + // fix [a, ...rest] + return fixer.removeRange([ + getPreviousTokenStart(id, 1), + id.range[1], + ]); + } + + // fix { a, ...rest} + if (parent.parent.type === "ObjectPattern") { + // fix 'const {...rest} = foo;' and 'function foo({...rest}) {}' + if (parent.parent.properties.length === 1) { + return fixVariables(parent.parent); + } + + // fix { a, ...rest} when there are multiple properties + return fixer.removeRange([ + getPreviousTokenStart(id, 1), + id.range[1], + ]); + } + + // fix function foo(...rest) {} + if (isFunction(parent.parent)) { + // remove unused rest in function parameter if there is only single parameter + if (parent.parent.params.length === 1) { + return fixer.removeRange(parent.range); + } + + // remove unused rest in function parameter if there multiple parameter + return fixer.removeRange([ + getPreviousTokenStart(parent), + parent.range[1], + ]); + } + } + + if (parentType === "AssignmentPattern") { + // fix [a = aDefault] + if (parent.parent.type === "ArrayPattern") { + return fixNestedArrayVariable(parent); + } + + // fix {a = aDefault} + if (parent.parent.parent.type === "ObjectPattern") { + if (parent.parent.parent.properties.length === 1) { + // fixes [{a = aDefault}] + if ( + parent.parent.parent.parent.type === "ArrayPattern" + ) { + return fixNestedArrayVariable(parent.parent.parent); + } + + // fix 'const {a = aDefault} = foo;' and 'function foo({a = aDefault}) {}' + return fixVariables(parent.parent.parent); + } + + // fix unused 'a' in {a = aDefault} if it is the first property + if ( + getTokenBeforeValue(parent.parent) === "{" && + getTokenAfterValue(parent.parent) === "," + ) { + return fixer.removeRange([ + parent.parent.range[0], + getNextTokenEnd(parent.parent), + ]); + } + + // fix unused 'b' in {a, b = aDefault} if it is not the first property + return fixer.removeRange([ + getPreviousTokenStart(parent.parent), + parent.parent.range[1], + ]); + } + + // fix unused assignment patterns in function parameters + if (isFunction(parent.parent)) { + return fixFunctionParameters(parent); + } + } + + // remove unused functions and classes + if ( + (parentType === "FunctionDeclaration" && parent.id === id) || + parentType === "ClassDeclaration" + ) { + const nextToken = sourceCode.getTokenAfter(parent); + const prevToken = sourceCode.getTokenBefore(parent); + + if ( + nextToken && + isDeclarationNotSafeToRemove(nextToken, prevToken) + ) { + return null; + } + + return fixer.removeRange(parent.range); + } + + // remove unused default import + if (parentType === "ImportDefaultSpecifier") { + // remove unused default import when there are not other imports + if ( + !hasImportOfCertainType(parent.parent, "ImportSpecifier") && + !hasImportOfCertainType( + parent.parent, + "ImportNamespaceSpecifier", + ) + ) { + return fixer.removeRange([ + parent.range[0], + parent.parent.source.range[0], + ]); + } + + // remove unused default import when there are other imports also + return fixer.removeRange([id.range[0], tokenAfter.range[1]]); + } + + if (parentType === "ImportSpecifier") { + // remove unused imports when there is a single import + if ( + parent.parent.specifiers.filter( + e => e.type === "ImportSpecifier", + ).length === 1 + ) { + // remove unused import when there is no default import + if ( + !hasImportOfCertainType( + parent.parent, + "ImportDefaultSpecifier", + ) + ) { + return fixer.removeRange(parent.parent.range); + } + + // fixes "import foo from 'module';" to "import 'module';" + return fixer.removeRange([ + getPreviousTokenStart(parent, 1), + tokenAfter.range[1], + ]); + } + + if (getTokenBeforeValue(parent) === "{") { + return fixer.removeRange([ + parent.range[0], + getNextTokenEnd(parent), + ]); + } + + return fixer.removeRange([ + getPreviousTokenStart(parent), + parent.range[1], + ]); + } + + if (parentType === "ImportNamespaceSpecifier") { + if ( + hasImportOfCertainType( + parent.parent, + "ImportDefaultSpecifier", + ) + ) { + return fixer.removeRange([ + getPreviousTokenStart(parent), + parent.range[1], + ]); + } + + // fixes "import * as foo from 'module';" to "import 'module';" + return fixer.removeRange([ + parent.range[0], + parent.parent.source.range[0], + ]); + } + + // skip error in catch(error) variable + if (parentType === "CatchClause") { + return null; + } + + // remove unused variable that is in a sequence [a,b] fixes to [a] + if (tokenBefore?.value === ",") { + return fixer.removeRange([tokenBefore.range[0], id.range[1]]); + } + + // remove unused variable that is in a sequence inside function arguments and object pattern + if (tokenAfter.value === ",") { + // fix function foo(a, b) {} + if (tokenBefore.value === "(") { + return fixer.removeRange([ + id.range[0], + tokenAfter.range[1], + ]); + } + + // fix const {a, b} = foo; + if (tokenBefore.value === "{") { + return fixer.removeRange([ + id.range[0], + tokenAfter.range[1], + ]); + } + } + + if ( + parentType === "ArrowFunctionExpression" && + parent.params.length === 1 && + tokenAfter?.value !== ")" + ) { + return fixer.replaceText(id, "()"); + } + + return fixer.removeRange(id.range); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + "Program:exit"(programNode) { + const unusedVars = collectUnusedVariables( + sourceCode.getScope(programNode), + [], + ); + + for (let i = 0, l = unusedVars.length; i < l; ++i) { + const unusedVar = unusedVars[i]; + + // Report the first declaration. + if (unusedVar.defs.length > 0) { + // report last write reference, https://github.com/eslint/eslint/issues/14324 + const writeReferences = unusedVar.references.filter( + ref => + ref.isWrite() && + ref.from.variableScope === + unusedVar.scope.variableScope, + ); + + let referenceToReport; + + if (writeReferences.length > 0) { + referenceToReport = writeReferences.at(-1); + } + + context.report({ + node: referenceToReport + ? referenceToReport.identifier + : unusedVar.identifiers[0], + messageId: "unusedVar", + data: unusedVar.references.some(ref => + ref.isWrite(), + ) + ? getAssignedMessageData(unusedVar) + : getDefinedMessageData(unusedVar), + suggest: [ + { + messageId: "removeVar", + data: { + varName: unusedVar.name, + }, + fix(fixer) { + return handleFixes(fixer, unusedVar); + }, + }, + ], + }); + + // If there are no regular declaration, report the first `/*globals*/` comment directive. + } else if (unusedVar.eslintExplicitGlobalComments) { + const directiveComment = + unusedVar.eslintExplicitGlobalComments[0]; + + context.report({ + node: programNode, + loc: astUtils.getNameLocationInGlobalDirectiveComment( + sourceCode, + directiveComment, + unusedVar.name, + ), + messageId: "unusedVar", + data: getDefinedMessageData(unusedVar), + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-use-before-define.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-use-before-define.js new file mode 100644 index 00000000..19f36c4b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-use-before-define.js @@ -0,0 +1,452 @@ +/** + * @fileoverview Rule to flag use of variables before they are defined + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const SENTINEL_TYPE = + /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u; +const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u; + +/** + * Parses a given value as options. + * @param {any} options A value to parse. + * @returns {Object} The parsed options. + */ +function parseOptions(options) { + if (typeof options === "object" && options !== null) { + return options; + } + + const functions = typeof options === "string" ? options !== "nofunc" : true; + + return { + functions, + classes: true, + variables: true, + allowNamedExports: false, + enums: true, + typedefs: true, + ignoreTypeReferences: true, + }; +} + +/** + * Checks whether or not a given location is inside of the range of a given node. + * @param {ASTNode} node An node to check. + * @param {number} location A location to check. + * @returns {boolean} `true` if the location is inside of the range of the node. + */ +function isInRange(node, location) { + return node && node.range[0] <= location && location <= node.range[1]; +} + +/** + * Checks whether or not a given location is inside of the range of a class static initializer. + * Static initializers are static blocks and initializers of static fields. + * @param {ASTNode} node `ClassBody` node to check static initializers. + * @param {number} location A location to check. + * @returns {boolean} `true` if the location is inside of a class static initializer. + */ +function isInClassStaticInitializerRange(node, location) { + return node.body.some( + classMember => + (classMember.type === "StaticBlock" && + isInRange(classMember, location)) || + (classMember.type === "PropertyDefinition" && + classMember.static && + classMember.value && + isInRange(classMember.value, location)), + ); +} + +/** + * Checks whether a given scope is the scope of a class static initializer. + * Static initializers are static blocks and initializers of static fields. + * @param {Scope} scope A scope to check. + * @returns {boolean} `true` if the scope is a class static initializer scope. + */ +function isClassStaticInitializerScope(scope) { + if (scope.type === "class-static-block") { + return true; + } + + if (scope.type === "class-field-initializer") { + // `scope.block` is PropertyDefinition#value node + const propertyDefinition = scope.block.parent; + + return propertyDefinition.static; + } + + return false; +} + +/** + * Checks whether a given reference is evaluated in an execution context + * that isn't the one where the variable it refers to is defined. + * Execution contexts are: + * - top-level + * - functions + * - class field initializers (implicit functions) + * - class static blocks (implicit functions) + * Static class field initializers and class static blocks are automatically run during the class definition evaluation, + * and therefore we'll consider them as a part of the parent execution context. + * Example: + * + * const x = 1; + * + * x; // returns `false` + * () => x; // returns `true` + * + * class C { + * field = x; // returns `true` + * static field = x; // returns `false` + * + * method() { + * x; // returns `true` + * } + * + * static method() { + * x; // returns `true` + * } + * + * static { + * x; // returns `false` + * } + * } + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is from a separate execution context. + */ +function isFromSeparateExecutionContext(reference) { + const variable = reference.resolved; + let scope = reference.from; + + // Scope#variableScope represents execution context + while (variable.scope.variableScope !== scope.variableScope) { + if (isClassStaticInitializerScope(scope.variableScope)) { + scope = scope.variableScope.upper; + } else { + return true; + } + } + + return false; +} + +/** + * Checks whether or not a given reference is evaluated during the initialization of its variable. + * + * This returns `true` in the following cases: + * + * var a = a + * var [a = a] = list + * var {a = a} = obj + * for (var a in a) {} + * for (var a of a) {} + * var C = class { [C]; }; + * var C = class { static foo = C; }; + * var C = class { static { foo = C; } }; + * class C extends C {} + * class C extends (class { static foo = C; }) {} + * class C { [C]; } + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is evaluated during the initialization. + */ +function isEvaluatedDuringInitialization(reference) { + if (isFromSeparateExecutionContext(reference)) { + /* + * Even if the reference appears in the initializer, it isn't evaluated during the initialization. + * For example, `const x = () => x;` is valid. + */ + return false; + } + + const location = reference.identifier.range[1]; + const definition = reference.resolved.defs[0]; + + if (definition.type === "ClassName") { + // `ClassDeclaration` or `ClassExpression` + const classDefinition = definition.node; + + return ( + isInRange(classDefinition, location) && + /* + * Class binding is initialized before running static initializers. + * For example, `class C { static foo = C; static { bar = C; } }` is valid. + */ + !isInClassStaticInitializerRange(classDefinition.body, location) + ); + } + + let node = definition.name.parent; + + while (node) { + if (node.type === "VariableDeclarator") { + if (isInRange(node.init, location)) { + return true; + } + if ( + FOR_IN_OF_TYPE.test(node.parent.parent.type) && + isInRange(node.parent.parent.right, location) + ) { + return true; + } + break; + } else if (node.type === "AssignmentPattern") { + if (isInRange(node.right, location)) { + return true; + } + } else if (SENTINEL_TYPE.test(node.type)) { + break; + } + + node = node.parent; + } + + return false; +} + +/** + * check whether the reference contains a type query. + * @param {ASTNode} node Identifier node to check. + * @returns {boolean} true if reference contains type query. + */ +function referenceContainsTypeQuery(node) { + switch (node.type) { + case "TSTypeQuery": + return true; + + case "TSQualifiedName": + case "Identifier": + return referenceContainsTypeQuery(node.parent); + + default: + // if we find a different node, there's no chance that we're in a TSTypeQuery + return false; + } +} + +/** + * Decorators are transpiled such that the decorator is placed after the class declaration + * So it is considered safe + * @param {Variable} variable The variable to check. + * @param {Reference} reference The reference to check. + * @returns {boolean} `true` if the reference is in a class decorator. + */ +function isClassRefInClassDecorator(variable, reference) { + if (variable.defs[0].type !== "ClassName") { + return false; + } + + if ( + !variable.defs[0].node.decorators || + variable.defs[0].node.decorators.length === 0 + ) { + return false; + } + + for (const deco of variable.defs[0].node.decorators) { + if ( + reference.identifier.range[0] >= deco.range[0] && + reference.identifier.range[1] <= deco.range[1] + ) { + return true; + } + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow the use of variables before they are defined", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-use-before-define", + }, + + schema: [ + { + oneOf: [ + { + enum: ["nofunc"], + }, + { + type: "object", + properties: { + functions: { type: "boolean" }, + classes: { type: "boolean" }, + variables: { type: "boolean" }, + allowNamedExports: { type: "boolean" }, + enums: { type: "boolean" }, + typedefs: { type: "boolean" }, + ignoreTypeReferences: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: [ + { + classes: true, + functions: true, + variables: true, + allowNamedExports: false, + enums: true, + typedefs: true, + ignoreTypeReferences: true, + }, + ], + + messages: { + usedBeforeDefined: "'{{name}}' was used before it was defined.", + }, + }, + + create(context) { + const options = parseOptions(context.options[0]); + const sourceCode = context.sourceCode; + + /** + * Determines whether a given reference should be checked. + * + * Returns `false` if the reference is: + * - initialization's (e.g., `let a = 1`). + * - referring to an undefined variable (i.e., if it's an unresolved reference). + * - referring to a variable that is defined, but not in the given source code + * (e.g., global environment variable or `arguments` in functions). + * - allowed by options. + * @param {Reference} reference The reference + * @returns {boolean} `true` if the reference should be checked + */ + function shouldCheck(reference) { + if (reference.init) { + return false; + } + + const { identifier } = reference; + + if ( + options.allowNamedExports && + identifier.parent.type === "ExportSpecifier" && + identifier.parent.local === identifier + ) { + return false; + } + + const variable = reference.resolved; + + if (!variable || variable.defs.length === 0) { + return false; + } + + const definitionType = variable.defs[0].type; + + if (!options.functions && definitionType === "FunctionName") { + return false; + } + + if ( + ((!options.variables && definitionType === "Variable") || + (!options.classes && definitionType === "ClassName")) && + // don't skip checking the reference if it's in the same execution context, because of TDZ + isFromSeparateExecutionContext(reference) + ) { + return false; + } + + if (!options.enums && definitionType === "TSEnumName") { + return false; + } + + if (!options.typedefs && definitionType === "Type") { + return false; + } + + if ( + options.ignoreTypeReferences && + (referenceContainsTypeQuery(identifier) || + identifier.parent.type === "TSTypeReference") + ) { + return false; + } + + // skip nested namespace aliases as variable references + if (identifier.parent.type === "TSQualifiedName") { + let currentNode = identifier.parent; + + while (currentNode.type === "TSQualifiedName") { + currentNode = currentNode.left; + } + + if (currentNode === identifier) { + return true; + } + + return false; + } + + if (isClassRefInClassDecorator(variable, reference)) { + return false; + } + + return true; + } + + /** + * Finds and validates all references in a given scope and its child scopes. + * @param {Scope} scope The scope object. + * @returns {void} + */ + function checkReferencesInScope(scope) { + scope.references.filter(shouldCheck).forEach(reference => { + const variable = reference.resolved; + const definitionIdentifier = variable.defs[0].name; + + if ( + reference.identifier.range[1] < + definitionIdentifier.range[1] || + (isEvaluatedDuringInitialization(reference) && + reference.identifier.parent.type !== "TSTypeReference") + ) { + context.report({ + node: reference.identifier, + messageId: "usedBeforeDefined", + data: reference.identifier, + }); + } + }); + + scope.childScopes.forEach(checkReferencesInScope); + } + + return { + Program(node) { + checkReferencesInScope(sourceCode.getScope(node)); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-assignment.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-assignment.js new file mode 100644 index 00000000..d5cca1e4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-assignment.js @@ -0,0 +1,658 @@ +/** + * @fileoverview A rule to disallow unnecessary assignments`. + * @author Yosuke Ota + */ + +"use strict"; + +const { findVariable } = require("@eslint-community/eslint-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("estree").Node} ASTNode */ +/** @typedef {import("estree").Pattern} Pattern */ +/** @typedef {import("estree").Identifier} Identifier */ +/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */ +/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */ +/** @typedef {import("estree").UpdateExpression} UpdateExpression */ +/** @typedef {import("estree").Expression} Expression */ +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("../linter/code-path-analysis/code-path")} CodePath */ +/** @typedef {import("../linter/code-path-analysis/code-path-segment")} CodePathSegment */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Extract identifier from the given pattern node used on the left-hand side of the assignment. + * @param {Pattern} pattern The pattern node to extract identifier + * @returns {Iterable} The extracted identifier + */ +function* extractIdentifiersFromPattern(pattern) { + switch (pattern.type) { + case "Identifier": + yield pattern; + return; + case "ObjectPattern": + for (const property of pattern.properties) { + yield* extractIdentifiersFromPattern( + property.type === "Property" ? property.value : property, + ); + } + return; + case "ArrayPattern": + for (const element of pattern.elements) { + if (!element) { + continue; + } + yield* extractIdentifiersFromPattern(element); + } + return; + case "RestElement": + yield* extractIdentifiersFromPattern(pattern.argument); + return; + case "AssignmentPattern": + yield* extractIdentifiersFromPattern(pattern.left); + + // no default + } +} + +/** + * Checks whether the given identifier node is evaluated after the assignment identifier. + * @param {AssignmentInfo} assignment The assignment info. + * @param {Identifier} identifier The identifier to check. + * @returns {boolean} `true` if the given identifier node is evaluated after the assignment identifier. + */ +function isIdentifierEvaluatedAfterAssignment(assignment, identifier) { + if (identifier.range[0] < assignment.identifier.range[1]) { + return false; + } + if ( + assignment.expression && + assignment.expression.range[0] <= identifier.range[0] && + identifier.range[1] <= assignment.expression.range[1] + ) { + /* + * The identifier node is in an expression that is evaluated before the assignment. + * e.g. x = id; + * ^^ identifier to check + * ^ assignment identifier + */ + return false; + } + + /* + * e.g. + * x = 42; id; + * ^^ identifier to check + * ^ assignment identifier + * let { x, y = id } = obj; + * ^^ identifier to check + * ^ assignment identifier + */ + return true; +} + +/** + * Checks whether the given identifier node is used between the assigned identifier and the equal sign. + * + * e.g. let { x, y = x } = obj; + * ^ identifier to check + * ^ assigned identifier + * @param {AssignmentInfo} assignment The assignment info. + * @param {Identifier} identifier The identifier to check. + * @returns {boolean} `true` if the given identifier node is used between the assigned identifier and the equal sign. + */ +function isIdentifierUsedBetweenAssignedAndEqualSign(assignment, identifier) { + if (!assignment.expression) { + return false; + } + return ( + assignment.identifier.range[1] <= identifier.range[0] && + identifier.range[1] <= assignment.expression.range[0] + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow variable assignments when the value is not used", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-useless-assignment", + }, + + schema: [], + + messages: { + unnecessaryAssignment: + "The value assigned to '{{name}}' is not used in subsequent statements.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * @typedef {Object} ScopeStack + * @property {CodePath} codePath The code path of this scope stack. + * @property {Scope} scope The scope of this scope stack. + * @property {ScopeStack} upper The upper scope stack. + * @property {Record} segments The map of ScopeStackSegmentInfo. + * @property {Set} currentSegments The current CodePathSegments. + * @property {Map} assignments The map of list of AssignmentInfo for each variable. + * @property {Array} tryStatementBlocks The array of TryStatement block nodes in this scope stack. + */ + /** + * @typedef {Object} ScopeStackSegmentInfo + * @property {CodePathSegment} segment The code path segment. + * @property {Identifier|null} first The first identifier that appears within the segment. + * @property {Identifier|null} last The last identifier that appears within the segment. + * `first` and `last` are used to determine whether an identifier exists within the segment position range. + * Since it is used as a range of segments, we should originally hold all nodes, not just identifiers, + * but since the only nodes to be judged are identifiers, it is sufficient to have a range of identifiers. + */ + /** + * @typedef {Object} AssignmentInfo + * @property {Variable} variable The variable that is assigned. + * @property {Identifier} identifier The identifier that is assigned. + * @property {VariableDeclarator|AssignmentExpression|UpdateExpression} node The node where the variable was updated. + * @property {Expression|null} expression The expression that is evaluated before the assignment. + * @property {CodePathSegment[]} segments The code path segments where the assignment was made. + */ + + /** @type {ScopeStack} */ + let scopeStack = null; + + /** @type {Set} */ + const codePathStartScopes = new Set(); + + /** + * Gets the scope of code path start from given scope + * @param {Scope} scope The initial scope + * @returns {Scope} The scope of code path start + * @throws {Error} Unexpected error + */ + function getCodePathStartScope(scope) { + let target = scope; + + while (target) { + if (codePathStartScopes.has(target)) { + return target; + } + target = target.upper; + } + + // Should be unreachable + return null; + } + + /** + * Verify the given scope stack. + * @param {ScopeStack} target The scope stack to verify. + * @returns {void} + */ + function verify(target) { + /** + * Checks whether the given identifier is used in the segment. + * @param {CodePathSegment} segment The code path segment. + * @param {Identifier} identifier The identifier to check. + * @returns {boolean} `true` if the identifier is used in the segment. + */ + function isIdentifierUsedInSegment(segment, identifier) { + const segmentInfo = target.segments[segment.id]; + + return ( + segmentInfo.first && + segmentInfo.last && + segmentInfo.first.range[0] <= identifier.range[0] && + identifier.range[1] <= segmentInfo.last.range[1] + ); + } + + /** + * Verifies whether the given assignment info is an used assignment. + * Report if it is an unused assignment. + * @param {AssignmentInfo} targetAssignment The assignment info to verify. + * @param {AssignmentInfo[]} allAssignments The list of all assignment info for variables. + * @returns {void} + */ + function verifyAssignmentIsUsed(targetAssignment, allAssignments) { + // Skip assignment if it is in a try block. + const isAssignmentInTryBlock = target.tryStatementBlocks.some( + tryBlock => + tryBlock.range[0] <= + targetAssignment.identifier.range[0] && + targetAssignment.identifier.range[1] <= + tryBlock.range[1], + ); + + if (isAssignmentInTryBlock) { + return; + } + + /** + * @typedef {Object} SubsequentSegmentData + * @property {CodePathSegment} segment The code path segment + * @property {AssignmentInfo} [assignment] The first occurrence of the assignment within the segment. + * There is no need to check if the variable is used after this assignment, + * as the value it was assigned will be used. + */ + + /** + * Information used in `getSubsequentSegments()`. + * To avoid unnecessary iterations, cache information that has already been iterated over, + * and if additional iterations are needed, start iterating from the retained position. + */ + const subsequentSegmentData = { + /** + * Cache of subsequent segment information list that have already been iterated. + * @type {SubsequentSegmentData[]} + */ + results: [], + + /** + * Subsequent segments that have already been iterated on. Used to avoid infinite loops. + * @type {Set} + */ + subsequentSegments: new Set(), + + /** + * Unexplored code path segment. + * If additional iterations are needed, consume this information and iterate. + * @type {CodePathSegment[]} + */ + queueSegments: targetAssignment.segments.flatMap( + segment => segment.nextSegments, + ), + }; + + /** + * Gets the subsequent segments from the segment of + * the assignment currently being validated (targetAssignment). + * @returns {Iterable} the subsequent segments + */ + function* getSubsequentSegments() { + yield* subsequentSegmentData.results; + + while (subsequentSegmentData.queueSegments.length > 0) { + const nextSegment = + subsequentSegmentData.queueSegments.shift(); + + if ( + subsequentSegmentData.subsequentSegments.has( + nextSegment, + ) + ) { + continue; + } + subsequentSegmentData.subsequentSegments.add( + nextSegment, + ); + + const assignmentInSegment = allAssignments.find( + otherAssignment => + otherAssignment.segments.includes( + nextSegment, + ) && + !isIdentifierUsedBetweenAssignedAndEqualSign( + otherAssignment, + targetAssignment.identifier, + ), + ); + + if (!assignmentInSegment) { + /* + * Stores the next segment to explore. + * If `assignmentInSegment` exists, + * we are guarding it because we don't need to explore the next segment. + */ + subsequentSegmentData.queueSegments.push( + ...nextSegment.nextSegments, + ); + } + + /** @type {SubsequentSegmentData} */ + const result = { + segment: nextSegment, + assignment: assignmentInSegment, + }; + + subsequentSegmentData.results.push(result); + yield result; + } + } + + if ( + targetAssignment.variable.references.some(ref => { + const type = ref.identifier.type; + return ( + type !== "Identifier" && type !== "JSXIdentifier" + ); + }) + ) { + /** + * Skip checking for a variable that has at least one non-identifier reference. + * It's generated by plugins and cannot be handled reliably in the core rule. + */ + return; + } + + const readReferences = + targetAssignment.variable.references.filter(reference => + reference.isRead(), + ); + + if (!readReferences.length) { + /* + * It is not just an unnecessary assignment, but an unnecessary (unused) variable + * and thus should not be reported by this rule because it is reported by `no-unused-vars`. + */ + return; + } + + /** + * Other assignment on the current segment and after current assignment. + */ + const otherAssignmentAfterTargetAssignment = + allAssignments.find(assignment => { + if ( + assignment === targetAssignment || + (assignment.segments.length && + assignment.segments.every( + segment => + !targetAssignment.segments.includes( + segment, + ), + )) + ) { + return false; + } + if ( + isIdentifierEvaluatedAfterAssignment( + targetAssignment, + assignment.identifier, + ) + ) { + return true; + } + if ( + assignment.expression && + assignment.expression.range[0] <= + targetAssignment.identifier.range[0] && + targetAssignment.identifier.range[1] <= + assignment.expression.range[1] + ) { + /* + * The target assignment is in an expression that is evaluated before the assignment. + * e.g. x=(x=1); + * ^^^ targetAssignment + * ^^^^^^^ assignment + */ + return true; + } + + return false; + }); + + for (const reference of readReferences) { + /* + * If the scope of the reference is outside the current code path scope, + * we cannot track whether this assignment is not used. + * For example, it can also be called asynchronously. + */ + if ( + target.scope !== getCodePathStartScope(reference.from) + ) { + return; + } + + // Checks if it is used in the same segment as the target assignment. + if ( + isIdentifierEvaluatedAfterAssignment( + targetAssignment, + reference.identifier, + ) && + (isIdentifierUsedBetweenAssignedAndEqualSign( + targetAssignment, + reference.identifier, + ) || + targetAssignment.segments.some(segment => + isIdentifierUsedInSegment( + segment, + reference.identifier, + ), + )) + ) { + if ( + otherAssignmentAfterTargetAssignment && + isIdentifierEvaluatedAfterAssignment( + otherAssignmentAfterTargetAssignment, + reference.identifier, + ) + ) { + // There was another assignment before the reference. Therefore, it has not been used yet. + continue; + } + + // Uses in statements after the written identifier. + return; + } + + if (otherAssignmentAfterTargetAssignment) { + /* + * The assignment was followed by another assignment in the same segment. + * Therefore, there is no need to check the next segment. + */ + continue; + } + + // Check subsequent segments. + for (const subsequentSegment of getSubsequentSegments()) { + if ( + isIdentifierUsedInSegment( + subsequentSegment.segment, + reference.identifier, + ) + ) { + if ( + subsequentSegment.assignment && + isIdentifierEvaluatedAfterAssignment( + subsequentSegment.assignment, + reference.identifier, + ) + ) { + // There was another assignment before the reference. Therefore, it has not been used yet. + continue; + } + + // It is used + return; + } + } + } + context.report({ + node: targetAssignment.identifier, + messageId: "unnecessaryAssignment", + data: { name: targetAssignment.identifier.name }, + }); + } + + // Verify that each assignment in the code path is used. + for (const assignments of target.assignments.values()) { + assignments.sort( + (a, b) => a.identifier.range[0] - b.identifier.range[0], + ); + for (const assignment of assignments) { + verifyAssignmentIsUsed(assignment, assignments); + } + } + } + + return { + onCodePathStart(codePath, node) { + const scope = sourceCode.getScope(node); + + scopeStack = { + upper: scopeStack, + codePath, + scope, + segments: Object.create(null), + currentSegments: new Set(), + assignments: new Map(), + tryStatementBlocks: [], + }; + codePathStartScopes.add(scopeStack.scope); + }, + onCodePathEnd() { + verify(scopeStack); + + scopeStack = scopeStack.upper; + }, + onCodePathSegmentStart(segment) { + const segmentInfo = { segment, first: null, last: null }; + + scopeStack.segments[segment.id] = segmentInfo; + scopeStack.currentSegments.add(segment); + }, + onCodePathSegmentEnd(segment) { + scopeStack.currentSegments.delete(segment); + }, + TryStatement(node) { + scopeStack.tryStatementBlocks.push(node.block); + }, + "Identifier, JSXIdentifier"(node) { + for (const segment of scopeStack.currentSegments) { + const segmentInfo = scopeStack.segments[segment.id]; + + if (!segmentInfo.first) { + segmentInfo.first = node; + } + segmentInfo.last = node; + } + }, + "VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression:exit"( + node, + ) { + if (scopeStack.currentSegments.size === 0) { + // Ignore unreachable segments + return; + } + + const assignments = scopeStack.assignments; + + let pattern; + let expression = null; + + if (node.type === "VariableDeclarator") { + pattern = node.id; + expression = node.init; + } else if (node.type === "AssignmentExpression") { + pattern = node.left; + expression = node.right; + } else { + // UpdateExpression + pattern = node.argument; + } + + for (const identifier of extractIdentifiersFromPattern( + pattern, + )) { + const scope = sourceCode.getScope(identifier); + + /** @type {Variable} */ + const variable = findVariable(scope, identifier); + + if (!variable) { + continue; + } + + // We don't know where global variables are used. + if ( + variable.scope.type === "global" && + variable.defs.length === 0 + ) { + continue; + } + + /* + * If the scope of the variable is outside the current code path scope, + * we cannot track whether this assignment is not used. + */ + if ( + scopeStack.scope !== + getCodePathStartScope(variable.scope) + ) { + continue; + } + + // Variables marked by `markVariableAsUsed()` or + // exported by "exported" block comment. + if (variable.eslintUsed) { + continue; + } + + // Variables exported by ESM export syntax + if (variable.scope.type === "module") { + if ( + variable.defs.some( + def => + (def.type === "Variable" && + def.parent.parent.type === + "ExportNamedDeclaration") || + (def.type === "FunctionName" && + (def.node.parent.type === + "ExportNamedDeclaration" || + def.node.parent.type === + "ExportDefaultDeclaration")) || + (def.type === "ClassName" && + (def.node.parent.type === + "ExportNamedDeclaration" || + def.node.parent.type === + "ExportDefaultDeclaration")), + ) + ) { + continue; + } + if ( + variable.references.some( + reference => + reference.identifier.parent.type === + "ExportSpecifier", + ) + ) { + // It have `export { ... }` reference. + continue; + } + } + + let list = assignments.get(variable); + + if (!list) { + list = []; + assignments.set(variable, list); + } + list.push({ + variable, + identifier, + node, + expression, + segments: [...scopeStack.currentSegments], + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-backreference.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-backreference.js new file mode 100644 index 00000000..73cce577 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-backreference.js @@ -0,0 +1,263 @@ +/** + * @fileoverview Rule to disallow useless backreferences in regular expressions + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + CALL, + CONSTRUCT, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils"); +const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const parser = new RegExpParser(); + +/** + * Finds the path from the given `regexpp` AST node to the root node. + * @param {regexpp.Node} node Node. + * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node. + */ +function getPathToRoot(node) { + const path = []; + let current = node; + + do { + path.push(current); + current = current.parent; + } while (current); + + return path; +} + +/** + * Determines whether the given `regexpp` AST node is a lookaround node. + * @param {regexpp.Node} node Node. + * @returns {boolean} `true` if it is a lookaround node. + */ +function isLookaround(node) { + return ( + node.type === "Assertion" && + (node.kind === "lookahead" || node.kind === "lookbehind") + ); +} + +/** + * Determines whether the given `regexpp` AST node is a negative lookaround node. + * @param {regexpp.Node} node Node. + * @returns {boolean} `true` if it is a negative lookaround node. + */ +function isNegativeLookaround(node) { + return isLookaround(node) && node.negate; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + docs: { + description: + "Disallow useless backreferences in regular expressions", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-useless-backreference", + }, + + schema: [], + + messages: { + nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.", + forward: + "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.", + backward: + "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.", + disjunctive: + "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.", + intoNegativeLookaround: + "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Checks and reports useless backreferences in the given regular expression. + * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call. + * @param {string} pattern Regular expression pattern. + * @param {string} flags Regular expression flags. + * @returns {void} + */ + function checkRegex(node, pattern, flags) { + let regExpAST; + + try { + regExpAST = parser.parsePattern(pattern, 0, pattern.length, { + unicode: flags.includes("u"), + unicodeSets: flags.includes("v"), + }); + } catch { + // Ignore regular expressions with syntax errors + return; + } + + visitRegExpAST(regExpAST, { + onBackreferenceEnter(bref) { + const groups = [bref.resolved].flat(), + brefPath = getPathToRoot(bref); + + const problems = groups.map(group => { + const groupPath = getPathToRoot(group); + + if (brefPath.includes(group)) { + // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match. + return { + messageId: "nested", + group, + }; + } + + // Start from the root to find the lowest common ancestor. + let i = brefPath.length - 1, + j = groupPath.length - 1; + + do { + i--; + j--; + } while (brefPath[i] === groupPath[j]); + + const indexOfLowestCommonAncestor = j + 1, + groupCut = groupPath.slice( + 0, + indexOfLowestCommonAncestor, + ), + commonPath = groupPath.slice( + indexOfLowestCommonAncestor, + ), + lowestCommonLookaround = + commonPath.find(isLookaround), + isMatchingBackward = + lowestCommonLookaround && + lowestCommonLookaround.kind === "lookbehind"; + + if (groupCut.at(-1).type === "Alternative") { + // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive. + return { + messageId: "disjunctive", + group, + }; + } + if (!isMatchingBackward && bref.end <= group.start) { + // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match. + return { + messageId: "forward", + group, + }; + } + if (isMatchingBackward && group.end <= bref.start) { + // the opposite of the previous when the regex is matching backward in a lookbehind context. + return { + messageId: "backward", + group, + }; + } + if (groupCut.some(isNegativeLookaround)) { + // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match. + return { + messageId: "intoNegativeLookaround", + group, + }; + } + + return null; + }); + + if ( + problems.length === 0 || + problems.some(problem => !problem) + ) { + // If there are no problems or no problems with any group then do not report it. + return; + } + + let problemsToReport; + + // Gets problems that appear in the same disjunction. + const problemsInSameDisjunction = problems.filter( + problem => problem.messageId !== "disjunctive", + ); + + if (problemsInSameDisjunction.length) { + // Only report problems that appear in the same disjunction. + problemsToReport = problemsInSameDisjunction; + } else { + // If all groups appear in different disjunctions, report it. + problemsToReport = problems; + } + + const [{ messageId, group }, ...other] = problemsToReport; + let otherGroups = ""; + + if (other.length === 1) { + otherGroups = " and another group"; + } else if (other.length > 1) { + otherGroups = ` and other ${other.length} groups`; + } + context.report({ + node, + messageId, + data: { + bref: bref.raw, + group: group.raw, + otherGroups, + }, + }); + }, + }); + } + + return { + "Literal[regex]"(node) { + const { pattern, flags } = node.regex; + + checkRegex(node, pattern, flags); + }, + Program(node) { + const scope = sourceCode.getScope(node), + tracker = new ReferenceTracker(scope), + traceMap = { + RegExp: { + [CALL]: true, + [CONSTRUCT]: true, + }, + }; + + for (const { node: refNode } of tracker.iterateGlobalReferences( + traceMap, + )) { + const [patternNode, flagsNode] = refNode.arguments, + pattern = getStringIfConstant(patternNode, scope), + flags = getStringIfConstant(flagsNode, scope); + + if (typeof pattern === "string") { + checkRegex(refNode, pattern, flags || ""); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-call.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-call.js new file mode 100644 index 00000000..2a04ad29 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-call.js @@ -0,0 +1,95 @@ +/** + * @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`. + * @author Toru Nagashima + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a node is a `.call()`/`.apply()`. + * @param {ASTNode} node A CallExpression node to check. + * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`. + */ +function isCallOrNonVariadicApply(node) { + const callee = astUtils.skipChainExpression(node.callee); + + return ( + callee.type === "MemberExpression" && + callee.property.type === "Identifier" && + callee.computed === false && + ((callee.property.name === "call" && node.arguments.length >= 1) || + (callee.property.name === "apply" && + node.arguments.length === 2 && + node.arguments[1].type === "ArrayExpression")) + ); +} + +/** + * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`. + * @param {ASTNode|null} expectedThis The node that is the owner of the applied function. + * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`. + * @param {SourceCode} sourceCode The ESLint source code object. + * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`. + */ +function isValidThisArg(expectedThis, thisArg, sourceCode) { + if (!expectedThis) { + return astUtils.isNullOrUndefined(thisArg); + } + return astUtils.equalTokens(expectedThis, thisArg, sourceCode); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow unnecessary calls to `.call()` and `.apply()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-useless-call", + }, + + schema: [], + + messages: { + unnecessaryCall: "Unnecessary '.{{name}}()'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + CallExpression(node) { + if (!isCallOrNonVariadicApply(node)) { + return; + } + + const callee = astUtils.skipChainExpression(node.callee); + const applied = astUtils.skipChainExpression(callee.object); + const expectedThis = + applied.type === "MemberExpression" ? applied.object : null; + const thisArg = node.arguments[0]; + + if (isValidThisArg(expectedThis, thisArg, sourceCode)) { + context.report({ + node, + messageId: "unnecessaryCall", + data: { name: callee.property.name }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-catch.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-catch.js new file mode 100644 index 00000000..e3df3093 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-catch.js @@ -0,0 +1,57 @@ +/** + * @fileoverview Reports useless `catch` clauses that just rethrow their error. + * @author Teddy Katz + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unnecessary `catch` clauses", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-useless-catch", + }, + + schema: [], + + messages: { + unnecessaryCatchClause: "Unnecessary catch clause.", + unnecessaryCatch: "Unnecessary try/catch wrapper.", + }, + }, + + create(context) { + return { + CatchClause(node) { + if ( + node.param && + node.param.type === "Identifier" && + node.body.body.length && + node.body.body[0].type === "ThrowStatement" && + node.body.body[0].argument.type === "Identifier" && + node.body.body[0].argument.name === node.param.name + ) { + if (node.parent.finalizer) { + context.report({ + node, + messageId: "unnecessaryCatchClause", + }); + } else { + context.report({ + node: node.parent, + messageId: "unnecessaryCatch", + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-computed-key.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-computed-key.js new file mode 100644 index 00000000..3c61c767 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-computed-key.js @@ -0,0 +1,204 @@ +/** + * @fileoverview Rule to disallow unnecessary computed property keys in object literals + * @author Burak Yigit Kaya + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the computed key syntax is unnecessarily used for the given node. + * In particular, it determines whether removing the square brackets and using the content between them + * directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior. + * Valid non-computed keys are only: identifiers, number literals and string literals. + * Only literals can preserve the same behavior, with a few exceptions for specific node types: + * Property + * - { ["__proto__"]: foo } defines a property named "__proto__" + * { "__proto__": foo } defines object's prototype + * PropertyDefinition + * - class C { ["constructor"]; } defines an instance field named "constructor" + * class C { "constructor"; } produces a parsing error + * - class C { static ["constructor"]; } defines a static field named "constructor" + * class C { static "constructor"; } produces a parsing error + * - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script) + * class C { static "prototype"; } produces a parsing error (breaks the whole script) + * MethodDefinition + * - class C { ["constructor"]() {} } defines a prototype method named "constructor" + * class C { "constructor"() {} } defines the constructor + * - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script) + * class C { static "prototype"() {} } produces a parsing error (breaks the whole script) + * @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`. + * @throws {Error} (Unreachable.) + * @returns {void} `true` if the node has useless computed key. + */ +function hasUselessComputedKey(node) { + if (!node.computed) { + return false; + } + + const { key } = node; + + if (key.type !== "Literal") { + return false; + } + + const { value } = key; + + if (typeof value !== "number" && typeof value !== "string") { + return false; + } + + switch (node.type) { + case "Property": + if (node.parent.type === "ObjectExpression") { + return value !== "__proto__"; + } + return true; + + case "PropertyDefinition": + if (node.static) { + return value !== "constructor" && value !== "prototype"; + } + + return value !== "constructor"; + + case "MethodDefinition": + if (node.static) { + return value !== "prototype"; + } + + return value !== "constructor"; + + /* c8 ignore next */ + default: + throw new Error(`Unexpected node type: ${node.type}`); + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + enforceForClassMembers: true, + }, + ], + + docs: { + description: + "Disallow unnecessary computed property keys in objects and classes", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-useless-computed-key", + }, + + schema: [ + { + type: "object", + properties: { + enforceForClassMembers: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + fixable: "code", + + messages: { + unnecessarilyComputedProperty: + "Unnecessarily computed property [{{property}}] found.", + }, + }, + create(context) { + const sourceCode = context.sourceCode; + const [{ enforceForClassMembers }] = context.options; + + /** + * Reports a given node if it violated this rule. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function check(node) { + if (hasUselessComputedKey(node)) { + const { key } = node; + + context.report({ + node, + messageId: "unnecessarilyComputedProperty", + data: { property: sourceCode.getText(key) }, + fix(fixer) { + const leftSquareBracket = sourceCode.getTokenBefore( + key, + astUtils.isOpeningBracketToken, + ); + const rightSquareBracket = sourceCode.getTokenAfter( + key, + astUtils.isClosingBracketToken, + ); + + // If there are comments between the brackets and the property name, don't do a fix. + if ( + sourceCode.commentsExistBetween( + leftSquareBracket, + rightSquareBracket, + ) + ) { + return null; + } + + const tokenBeforeLeftBracket = + sourceCode.getTokenBefore(leftSquareBracket); + + // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} }) + const needsSpaceBeforeKey = + tokenBeforeLeftBracket.range[1] === + leftSquareBracket.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBeforeLeftBracket, + sourceCode.getFirstToken(key), + ); + + const replacementKey = + (needsSpaceBeforeKey ? " " : "") + key.raw; + + return fixer.replaceTextRange( + [ + leftSquareBracket.range[0], + rightSquareBracket.range[1], + ], + replacementKey, + ); + }, + }); + } + } + + /** + * A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`. + * @returns {void} + * @private + */ + function noop() {} + + return { + Property: check, + MethodDefinition: enforceForClassMembers ? check : noop, + PropertyDefinition: enforceForClassMembers ? check : noop, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-concat.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-concat.js new file mode 100644 index 00000000..a4846e01 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-concat.js @@ -0,0 +1,121 @@ +/** + * @fileoverview disallow unnecessary concatenation of template strings + * @author Henry Zhu + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given node is a concatenation. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is a concatenation. + */ +function isConcatenation(node) { + return node.type === "BinaryExpression" && node.operator === "+"; +} + +/** + * Checks if the given token is a `+` token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a `+` token. + */ +function isConcatOperatorToken(token) { + return token.value === "+" && token.type === "Punctuator"; +} + +/** + * Gets the right most node on the left side of a BinaryExpression with + operator. + * @param {ASTNode} node A BinaryExpression node to check. + * @returns {ASTNode} node + */ +function getLeft(node) { + let left = node.left; + + while (isConcatenation(left)) { + left = left.right; + } + return left; +} + +/** + * Gets the left most node on the right side of a BinaryExpression with + operator. + * @param {ASTNode} node A BinaryExpression node to check. + * @returns {ASTNode} node + */ +function getRight(node) { + let right = node.right; + + while (isConcatenation(right)) { + right = right.left; + } + return right; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow unnecessary concatenation of literals or template literals", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-useless-concat", + }, + + schema: [], + + messages: { + unexpectedConcat: "Unexpected string concatenation of literals.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + BinaryExpression(node) { + // check if not concatenation + if (node.operator !== "+") { + return; + } + + // account for the `foo + "a" + "b"` case + const left = getLeft(node); + const right = getRight(node); + + if ( + astUtils.isStringLiteral(left) && + astUtils.isStringLiteral(right) && + astUtils.isTokenOnSameLine(left, right) + ) { + const operatorToken = sourceCode.getFirstTokenBetween( + left, + right, + isConcatOperatorToken, + ); + + context.report({ + node, + loc: operatorToken.loc, + messageId: "unexpectedConcat", + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-constructor.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-constructor.js new file mode 100644 index 00000000..d81cb6c2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-constructor.js @@ -0,0 +1,262 @@ +/** + * @fileoverview Rule to flag the use of redundant constructors in classes. + * @author Alberto Rodríguez + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether any of a method's parameters have a decorator or are a parameter property. + * @param {ASTNode} node A method definition node. + * @returns {boolean} `true` if any parameter had a decorator or is a parameter property. + */ +function hasDecoratorsOrParameterProperty(node) { + return node.value.params.some( + param => + param.decorators?.length || param.type === "TSParameterProperty", + ); +} + +/** + * Checks whether a node's accessibility makes it not useless. + * @param {ASTNode} node A method definition node. + * @returns {boolean} `true` if the node has a useful accessibility. + */ +function hasUsefulAccessibility(node) { + switch (node.accessibility) { + case "protected": + case "private": + return true; + case "public": + return !!node.parent.parent.superClass; + default: + return false; + } +} + +/** + * Checks whether a given array of statements is a single call of `super`. + * @param {ASTNode[]} body An array of statements to check. + * @returns {boolean} `true` if the body is a single call of `super`. + */ +function isSingleSuperCall(body) { + return ( + body.length === 1 && + body[0].type === "ExpressionStatement" && + body[0].expression.type === "CallExpression" && + body[0].expression.callee.type === "Super" + ); +} + +/** + * Checks whether a given node is a pattern which doesn't have any side effects. + * Default parameters and Destructuring parameters can have side effects. + * @param {ASTNode} node A pattern node. + * @returns {boolean} `true` if the node doesn't have any side effects. + */ +function isSimple(node) { + return node.type === "Identifier" || node.type === "RestElement"; +} + +/** + * Checks whether a given array of expressions is `...arguments` or not. + * `super(...arguments)` passes all arguments through. + * @param {ASTNode[]} superArgs An array of expressions to check. + * @returns {boolean} `true` if the superArgs is `...arguments`. + */ +function isSpreadArguments(superArgs) { + return ( + superArgs.length === 1 && + superArgs[0].type === "SpreadElement" && + superArgs[0].argument.type === "Identifier" && + superArgs[0].argument.name === "arguments" + ); +} + +/** + * Checks whether given 2 nodes are identifiers which have the same name or not. + * @param {ASTNode} ctorParam A node to check. + * @param {ASTNode} superArg A node to check. + * @returns {boolean} `true` if the nodes are identifiers which have the same + * name. + */ +function isValidIdentifierPair(ctorParam, superArg) { + return ( + ctorParam.type === "Identifier" && + superArg.type === "Identifier" && + ctorParam.name === superArg.name + ); +} + +/** + * Checks whether given 2 nodes are a rest/spread pair which has the same values. + * @param {ASTNode} ctorParam A node to check. + * @param {ASTNode} superArg A node to check. + * @returns {boolean} `true` if the nodes are a rest/spread pair which has the + * same values. + */ +function isValidRestSpreadPair(ctorParam, superArg) { + return ( + ctorParam.type === "RestElement" && + superArg.type === "SpreadElement" && + isValidIdentifierPair(ctorParam.argument, superArg.argument) + ); +} + +/** + * Checks whether given 2 nodes have the same value or not. + * @param {ASTNode} ctorParam A node to check. + * @param {ASTNode} superArg A node to check. + * @returns {boolean} `true` if the nodes have the same value or not. + */ +function isValidPair(ctorParam, superArg) { + return ( + isValidIdentifierPair(ctorParam, superArg) || + isValidRestSpreadPair(ctorParam, superArg) + ); +} + +/** + * Checks whether the parameters of a constructor and the arguments of `super()` + * have the same values or not. + * @param {ASTNode} ctorParams The parameters of a constructor to check. + * @param {ASTNode} superArgs The arguments of `super()` to check. + * @returns {boolean} `true` if those have the same values. + */ +function isPassingThrough(ctorParams, superArgs) { + if (ctorParams.length !== superArgs.length) { + return false; + } + + for (let i = 0; i < ctorParams.length; ++i) { + if (!isValidPair(ctorParams[i], superArgs[i])) { + return false; + } + } + + return true; +} + +/** + * Checks whether the constructor body is a redundant super call. + * @param {Array} body constructor body content. + * @param {Array} ctorParams The params to check against super call. + * @returns {boolean} true if the constructor body is redundant + */ +function isRedundantSuperCall(body, ctorParams) { + return ( + isSingleSuperCall(body) && + ctorParams.every(isSimple) && + (isSpreadArguments(body[0].expression.arguments) || + isPassingThrough(ctorParams, body[0].expression.arguments)) + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow unnecessary constructors", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-useless-constructor", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + noUselessConstructor: "Useless constructor.", + removeConstructor: "Remove the constructor.", + }, + }, + + create(context) { + const { sourceCode } = context; + + /** + * Checks whether a node is a redundant constructor + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkForConstructor(node) { + if ( + node.kind !== "constructor" || + node.value.type !== "FunctionExpression" || + hasDecoratorsOrParameterProperty(node) || + hasUsefulAccessibility(node) + ) { + return; + } + + /* + * Prevent crashing on parsers which do not require class constructor + * to have a body, e.g. typescript and flow + */ + if (!node.value.body) { + return; + } + + const body = node.value.body.body; + const ctorParams = node.value.params; + const superClass = node.parent.parent.superClass; + const parenToken = sourceCode.getFirstToken( + node, + astUtils.isOpeningParenToken, + ); + const loc = { + start: node.loc.start, + end: sourceCode.getTokenBefore(parenToken).loc.end, + }; + + if ( + superClass + ? isRedundantSuperCall(body, ctorParams) + : body.length === 0 + ) { + context.report({ + loc, + messageId: "noUselessConstructor", + suggest: [ + { + messageId: "removeConstructor", + *fix(fixer) { + const nextToken = + sourceCode.getTokenAfter(node); + const addSemiColon = + astUtils.canContinueExpressionInClassBody( + nextToken, + ) && + astUtils.needsPrecedingSemicolon( + sourceCode, + node, + ); + + yield fixer.replaceText( + node, + addSemiColon ? ";" : "", + ); + }, + }, + ], + }); + } + } + + return { + MethodDefinition: checkForConstructor, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-escape.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-escape.js new file mode 100644 index 00000000..4a48e318 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-escape.js @@ -0,0 +1,406 @@ +/** + * @fileoverview Look for useless escapes in strings and regexes + * @author Onur Temizkan + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); +const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp"); + +/** + * @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass + * @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass + */ +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** + * Returns the union of two sets. + * @param {Set} setA The first set + * @param {Set} setB The second set + * @returns {Set} The union of the two sets + */ +function union(setA, setB) { + return new Set( + (function* () { + yield* setA; + yield* setB; + })(), + ); +} + +const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS); +const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]"); +const REGEX_NON_CHARCLASS_ESCAPES = union( + REGEX_GENERAL_ESCAPES, + new Set("^/.$*+?[{}|()Bk"), +); + +/* + * Set of characters that require escaping in character classes in `unicodeSets` mode. + * ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter + */ +const REGEX_CLASSSET_CHARACTER_ESCAPES = union( + REGEX_GENERAL_ESCAPES, + new Set("q/[{}|()-"), +); + +/* + * A single character set of ClassSetReservedDoublePunctuator. + * && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator + */ +const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set( + "!#$%&*+,.:;<=>?@^`~", +); + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowRegexCharacters: [], + }, + ], + + docs: { + description: "Disallow unnecessary escape characters", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-useless-escape", + }, + + hasSuggestions: true, + + messages: { + unnecessaryEscape: "Unnecessary escape character: \\{{character}}.", + removeEscape: + "Remove the `\\`. This maintains the current functionality.", + removeEscapeDoNotKeepSemantics: + "Remove the `\\` if it was inserted by mistake.", + escapeBackslash: + "Replace the `\\` with `\\\\` to include the actual backslash character.", + }, + + schema: [ + { + type: "object", + properties: { + allowRegexCharacters: { + type: "array", + items: { + type: "string", + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ allowRegexCharacters }] = context.options; + const parser = new RegExpParser(); + + /** + * Reports a node + * @param {ASTNode} node The node to report + * @param {number} startOffset The backslash's offset from the start of the node + * @param {string} character The uselessly escaped character (not including the backslash) + * @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off. + * @returns {void} + */ + function report( + node, + startOffset, + character, + disableEscapeBackslashSuggest, + ) { + const rangeStart = node.range[0] + startOffset; + const range = [rangeStart, rangeStart + 1]; + const start = sourceCode.getLocFromIndex(rangeStart); + + context.report({ + node, + loc: { + start, + end: { line: start.line, column: start.column + 1 }, + }, + messageId: "unnecessaryEscape", + data: { character }, + suggest: [ + { + // Removing unnecessary `\` characters in a directive is not guaranteed to maintain functionality. + messageId: astUtils.isDirective(node.parent) + ? "removeEscapeDoNotKeepSemantics" + : "removeEscape", + fix(fixer) { + return fixer.removeRange(range); + }, + }, + ...(disableEscapeBackslashSuggest + ? [] + : [ + { + messageId: "escapeBackslash", + fix(fixer) { + return fixer.insertTextBeforeRange( + range, + "\\", + ); + }, + }, + ]), + ], + }); + } + + /** + * Checks if the escape character in given string slice is unnecessary. + * @private + * @param {ASTNode} node node to validate. + * @param {string} match string slice to validate. + * @returns {void} + */ + function validateString(node, match) { + const isTemplateElement = node.type === "TemplateElement"; + const escapedChar = match[0][1]; + let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar); + let isQuoteEscape; + + if (isTemplateElement) { + isQuoteEscape = escapedChar === "`"; + + if (escapedChar === "$") { + // Warn if `\$` is not followed by `{` + isUnnecessaryEscape = match.input[match.index + 2] !== "{"; + } else if (escapedChar === "{") { + /* + * Warn if `\{` is not preceded by `$`. If preceded by `$`, escaping + * is necessary and the rule should not warn. If preceded by `/$`, the rule + * will warn for the `/$` instead, as it is the first unnecessarily escaped character. + */ + isUnnecessaryEscape = match.input[match.index - 1] !== "$"; + } + } else { + isQuoteEscape = escapedChar === node.raw[0]; + } + + if (isUnnecessaryEscape && !isQuoteEscape) { + report(node, match.index, match[0].slice(1)); + } + } + + /** + * Checks if the escape character in given regexp is unnecessary. + * @private + * @param {ASTNode} node node to validate. + * @returns {void} + */ + function validateRegExp(node) { + const { pattern, flags } = node.regex; + let patternNode; + const unicode = flags.includes("u"); + const unicodeSets = flags.includes("v"); + + try { + patternNode = parser.parsePattern(pattern, 0, pattern.length, { + unicode, + unicodeSets, + }); + } catch { + // Ignore regular expressions with syntax errors + return; + } + + /** @type {(CharacterClass | ExpressionCharacterClass)[]} */ + const characterClassStack = []; + + visitRegExpAST(patternNode, { + onCharacterClassEnter: characterClassNode => + characterClassStack.unshift(characterClassNode), + onCharacterClassLeave: () => characterClassStack.shift(), + onExpressionCharacterClassEnter: characterClassNode => + characterClassStack.unshift(characterClassNode), + onExpressionCharacterClassLeave: () => + characterClassStack.shift(), + onCharacterEnter(characterNode) { + if (!characterNode.raw.startsWith("\\")) { + // It's not an escaped character. + return; + } + + const escapedChar = characterNode.raw.slice(1); + + if ( + escapedChar !== + String.fromCodePoint(characterNode.value) || + allowRegexCharacters.includes(escapedChar) + ) { + // It's a valid escape. + return; + } + let allowedEscapes; + + if (characterClassStack.length) { + allowedEscapes = unicodeSets + ? REGEX_CLASSSET_CHARACTER_ESCAPES + : REGEX_GENERAL_ESCAPES; + } else { + allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES; + } + if (allowedEscapes.has(escapedChar)) { + return; + } + + const reportedIndex = characterNode.start + 1; + let disableEscapeBackslashSuggest = false; + + if (characterClassStack.length) { + const characterClassNode = characterClassStack[0]; + + if (escapedChar === "^") { + /* + * The '^' character is also a special case; it must always be escaped outside of character classes, but + * it only needs to be escaped in character classes if it's at the beginning of the character class. To + * account for this, consider it to be a valid escape character outside of character classes, and filter + * out '^' characters that appear at the start of a character class. + */ + if ( + characterClassNode.start + 1 === + characterNode.start + ) { + return; + } + } + if (!unicodeSets) { + if (escapedChar === "-") { + /* + * The '-' character is a special case, because it's only valid to escape it if it's in a character + * class, and is not at either edge of the character class. To account for this, don't consider '-' + * characters to be valid in general, and filter out '-' characters that appear in the middle of a + * character class. + */ + if ( + characterClassNode.start + 1 !== + characterNode.start && + characterNode.end !== + characterClassNode.end - 1 + ) { + return; + } + } + } else { + // unicodeSets mode + if ( + REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has( + escapedChar, + ) + ) { + // Escaping is valid if it is a ClassSetReservedDoublePunctuator. + if ( + pattern[characterNode.end] === escapedChar + ) { + return; + } + if ( + pattern[characterNode.start - 1] === + escapedChar + ) { + if (escapedChar !== "^") { + return; + } + + // If the previous character is a `negate` caret(`^`), escape to caret is unnecessary. + + if (!characterClassNode.negate) { + return; + } + const negateCaretIndex = + characterClassNode.start + 1; + + if ( + negateCaretIndex < + characterNode.start - 1 + ) { + return; + } + } + } + + if ( + characterNode.parent.type === + "ClassIntersection" || + characterNode.parent.type === "ClassSubtraction" + ) { + disableEscapeBackslashSuggest = true; + } + } + } + + report( + node, + reportedIndex, + escapedChar, + disableEscapeBackslashSuggest, + ); + }, + }); + } + + /** + * Checks if a node has an escape. + * @param {ASTNode} node node to check. + * @returns {void} + */ + function check(node) { + const isTemplateElement = node.type === "TemplateElement"; + + if ( + isTemplateElement && + node.parent && + node.parent.parent && + node.parent.parent.type === "TaggedTemplateExpression" && + node.parent === node.parent.parent.quasi + ) { + // Don't report tagged template literals, because the backslash character is accessible to the tag function. + return; + } + + if (typeof node.value === "string" || isTemplateElement) { + /* + * JSXAttribute doesn't have any escape sequence: https://react.github.io/jsx/. + * In addition, backticks are not supported by JSX yet: https://github.com/react/jsx/issues/25. + */ + if ( + node.parent.type === "JSXAttribute" || + node.parent.type === "JSXElement" || + node.parent.type === "JSXFragment" + ) { + return; + } + + const value = isTemplateElement + ? sourceCode.getText(node) + : node.raw; + const pattern = /\\\D/gu; + let match; + + while ((match = pattern.exec(value))) { + validateString(node, match); + } + } else if (node.regex) { + validateRegExp(node); + } + } + + return { + Literal: check, + TemplateElement: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-rename.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-rename.js new file mode 100644 index 00000000..13c76861 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-rename.js @@ -0,0 +1,202 @@ +/** + * @fileoverview Disallow renaming import, export, and destructured assignments to the same name. + * @author Kai Cataldo + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + ignoreDestructuring: false, + ignoreImport: false, + ignoreExport: false, + }, + ], + + docs: { + description: + "Disallow renaming import, export, and destructured assignments to the same name", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-useless-rename", + }, + + fixable: "code", + + schema: [ + { + type: "object", + properties: { + ignoreDestructuring: { type: "boolean" }, + ignoreImport: { type: "boolean" }, + ignoreExport: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + + messages: { + unnecessarilyRenamed: "{{type}} {{name}} unnecessarily renamed.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ ignoreDestructuring, ignoreImport, ignoreExport }] = + context.options; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports error for unnecessarily renamed assignments + * @param {ASTNode} node node to report + * @param {ASTNode} initial node with initial name value + * @param {string} type the type of the offending node + * @returns {void} + */ + function reportError(node, initial, type) { + const name = + initial.type === "Identifier" ? initial.name : initial.value; + + return context.report({ + node, + messageId: "unnecessarilyRenamed", + data: { + name, + type, + }, + fix(fixer) { + const replacementNode = + node.type === "Property" ? node.value : node.local; + + if ( + sourceCode.getCommentsInside(node).length > + sourceCode.getCommentsInside(replacementNode).length + ) { + return null; + } + + // Don't autofix code such as `({foo: (foo) = a} = obj);`, parens are not allowed in shorthand properties. + if ( + replacementNode.type === "AssignmentPattern" && + astUtils.isParenthesised( + sourceCode, + replacementNode.left, + ) + ) { + return null; + } + + return fixer.replaceText( + node, + sourceCode.getText(replacementNode), + ); + }, + }); + } + + /** + * Checks whether a destructured assignment is unnecessarily renamed + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkDestructured(node) { + if (ignoreDestructuring) { + return; + } + + for (const property of node.properties) { + /** + * Properties using shorthand syntax and rest elements can not be renamed. + * If the property is computed, we have no idea if a rename is useless or not. + */ + if ( + property.type !== "Property" || + property.shorthand || + property.computed + ) { + continue; + } + + const key = + (property.key.type === "Identifier" && property.key.name) || + (property.key.type === "Literal" && property.key.value); + const renamedKey = + property.value.type === "AssignmentPattern" + ? property.value.left.name + : property.value.name; + + if (key === renamedKey) { + reportError( + property, + property.key, + "Destructuring assignment", + ); + } + } + } + + /** + * Checks whether an import is unnecessarily renamed + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkImport(node) { + if (ignoreImport) { + return; + } + + if ( + node.imported.range[0] !== node.local.range[0] && + astUtils.getModuleExportName(node.imported) === node.local.name + ) { + reportError(node, node.imported, "Import"); + } + } + + /** + * Checks whether an export is unnecessarily renamed + * @param {ASTNode} node node to check + * @returns {void} + */ + function checkExport(node) { + if (ignoreExport) { + return; + } + + if ( + node.local.range[0] !== node.exported.range[0] && + astUtils.getModuleExportName(node.local) === + astUtils.getModuleExportName(node.exported) + ) { + reportError(node, node.local, "Export"); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + ObjectPattern: checkDestructured, + ImportSpecifier: checkImport, + ExportSpecifier: checkExport, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-return.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-return.js new file mode 100644 index 00000000..a2f0380d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-useless-return.js @@ -0,0 +1,387 @@ +/** + * @fileoverview Disallow redundant return statements + * @author Teddy Katz + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"), + FixTracker = require("./utils/fix-tracker"); +const { isAnySegmentReachable } = require("./utils/code-path-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Removes the given element from the array. + * @param {Array} array The source array to remove. + * @param {any} element The target item to remove. + * @returns {void} + */ +function remove(array, element) { + const index = array.indexOf(element); + + if (index !== -1) { + array.splice(index, 1); + } +} + +/** + * Checks whether it can remove the given return statement or not. + * @param {ASTNode} node The return statement node to check. + * @returns {boolean} `true` if the node is removable. + */ +function isRemovable(node) { + return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type); +} + +/** + * Checks whether the given return statement is in a `finally` block or not. + * @param {ASTNode} node The return statement node to check. + * @returns {boolean} `true` if the node is in a `finally` block. + */ +function isInFinally(node) { + for ( + let currentNode = node; + currentNode && currentNode.parent && !astUtils.isFunction(currentNode); + currentNode = currentNode.parent + ) { + if ( + currentNode.parent.type === "TryStatement" && + currentNode.parent.finalizer === currentNode + ) { + return true; + } + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow redundant return statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-useless-return", + }, + + fixable: "code", + schema: [], + + messages: { + unnecessaryReturn: "Unnecessary return statement.", + }, + }, + + create(context) { + const segmentInfoMap = new WeakMap(); + const sourceCode = context.sourceCode; + let scopeInfo = null; + + /** + * Checks whether the given segment is terminated by a return statement or not. + * @param {CodePathSegment} segment The segment to check. + * @returns {boolean} `true` if the segment is terminated by a return statement, or if it's still a part of unreachable. + */ + function isReturned(segment) { + const info = segmentInfoMap.get(segment); + + return !info || info.returned; + } + + /** + * Collects useless return statements from the given previous segments. + * + * A previous segment may be an unreachable segment. + * In that case, the information object of the unreachable segment is not + * initialized because `onCodePathSegmentStart` event is not notified for + * unreachable segments. + * This goes to the previous segments of the unreachable segment recursively + * if the unreachable segment was generated by a return statement. Otherwise, + * this ignores the unreachable segment. + * + * This behavior would simulate code paths for the case that the return + * statement does not exist. + * @param {ASTNode[]} uselessReturns The collected return statements. + * @param {CodePathSegment[]} prevSegments The previous segments to traverse. + * @param {WeakSet} [providedTraversedSegments] A set of segments that have already been traversed in this call + * @returns {ASTNode[]} `uselessReturns`. + */ + function getUselessReturns( + uselessReturns, + prevSegments, + providedTraversedSegments, + ) { + const traversedSegments = + providedTraversedSegments || new WeakSet(); + + for (const segment of prevSegments) { + if (!segment.reachable) { + if (!traversedSegments.has(segment)) { + traversedSegments.add(segment); + getUselessReturns( + uselessReturns, + segment.allPrevSegments.filter(isReturned), + traversedSegments, + ); + } + continue; + } + + if (segmentInfoMap.has(segment)) { + uselessReturns.push( + ...segmentInfoMap.get(segment).uselessReturns, + ); + } + } + + return uselessReturns; + } + + /** + * Removes the return statements on the given segment from the useless return + * statement list. + * + * This segment may be an unreachable segment. + * In that case, the information object of the unreachable segment is not + * initialized because `onCodePathSegmentStart` event is not notified for + * unreachable segments. + * This goes to the previous segments of the unreachable segment recursively + * if the unreachable segment was generated by a return statement. Otherwise, + * this ignores the unreachable segment. + * + * This behavior would simulate code paths for the case that the return + * statement does not exist. + * @param {CodePathSegment} segment The segment to get return statements. + * @param {Set} usedUnreachableSegments A set of segments that have already been traversed in this call. + * @returns {void} + */ + function markReturnStatementsOnSegmentAsUsed( + segment, + usedUnreachableSegments, + ) { + if (!segment.reachable) { + usedUnreachableSegments.add(segment); + segment.allPrevSegments + .filter(isReturned) + .filter( + prevSegment => + !usedUnreachableSegments.has(prevSegment), + ) + .forEach(prevSegment => + markReturnStatementsOnSegmentAsUsed( + prevSegment, + usedUnreachableSegments, + ), + ); + return; + } + + const info = segmentInfoMap.get(segment); + + if (!info) { + return; + } + + info.uselessReturns = info.uselessReturns.filter(node => { + if ( + scopeInfo.traversedTryBlockStatements && + scopeInfo.traversedTryBlockStatements.length > 0 + ) { + const returnInitialRange = node.range[0]; + const returnFinalRange = node.range[1]; + + const areBlocksInRange = + scopeInfo.traversedTryBlockStatements.some( + tryBlockStatement => { + const blockInitialRange = + tryBlockStatement.range[0]; + const blockFinalRange = + tryBlockStatement.range[1]; + + return ( + returnInitialRange >= blockInitialRange && + returnFinalRange <= blockFinalRange + ); + }, + ); + + if (areBlocksInRange) { + return true; + } + } + + remove(scopeInfo.uselessReturns, node); + return false; + }); + } + + /** + * Removes the return statements on the current segments from the useless + * return statement list. + * + * This function will be called at every statement except FunctionDeclaration, + * BlockStatement, and BreakStatement. + * + * - FunctionDeclarations are always executed whether it's returned or not. + * - BlockStatements do nothing. + * - BreakStatements go the next merely. + * @returns {void} + */ + function markReturnStatementsOnCurrentSegmentsAsUsed() { + scopeInfo.currentSegments.forEach(segment => + markReturnStatementsOnSegmentAsUsed(segment, new Set()), + ); + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + // Makes and pushes a new scope information. + onCodePathStart(codePath) { + scopeInfo = { + upper: scopeInfo, + uselessReturns: [], + traversedTryBlockStatements: [], + codePath, + currentSegments: new Set(), + }; + }, + + // Reports useless return statements if exist. + onCodePathEnd() { + for (const node of scopeInfo.uselessReturns) { + context.report({ + node, + loc: node.loc, + messageId: "unnecessaryReturn", + fix(fixer) { + if ( + isRemovable(node) && + !sourceCode.getCommentsInside(node).length + ) { + /* + * Extend the replacement range to include the + * entire function to avoid conflicting with + * no-else-return. + * https://github.com/eslint/eslint/issues/8026 + */ + return new FixTracker(fixer, sourceCode) + .retainEnclosingFunction(node) + .remove(node); + } + return null; + }, + }); + } + + scopeInfo = scopeInfo.upper; + }, + + /* + * Initializes segments. + * NOTE: This event is notified for only reachable segments. + */ + onCodePathSegmentStart(segment) { + scopeInfo.currentSegments.add(segment); + + const info = { + uselessReturns: getUselessReturns( + [], + segment.allPrevSegments, + ), + returned: false, + }; + + // Stores the info. + segmentInfoMap.set(segment, info); + }, + + onUnreachableCodePathSegmentStart(segment) { + scopeInfo.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + scopeInfo.currentSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + scopeInfo.currentSegments.delete(segment); + }, + + // Adds ReturnStatement node to check whether it's useless or not. + ReturnStatement(node) { + if (node.argument) { + markReturnStatementsOnCurrentSegmentsAsUsed(); + } + if ( + node.argument || + astUtils.isInLoop(node) || + isInFinally(node) || + // Ignore `return` statements in unreachable places (https://github.com/eslint/eslint/issues/11647). + !isAnySegmentReachable(scopeInfo.currentSegments) + ) { + return; + } + + for (const segment of scopeInfo.currentSegments) { + const info = segmentInfoMap.get(segment); + + if (info) { + info.uselessReturns.push(node); + info.returned = true; + } + } + scopeInfo.uselessReturns.push(node); + }, + + "TryStatement > BlockStatement.block:exit"(node) { + scopeInfo.traversedTryBlockStatements.push(node); + }, + + "TryStatement:exit"() { + scopeInfo.traversedTryBlockStatements.pop(); + }, + + /* + * Registers for all statement nodes except FunctionDeclaration, BlockStatement, BreakStatement. + * Removes return statements of the current segments from the useless return statement list. + */ + ClassDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed, + ContinueStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + DebuggerStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + DoWhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + EmptyStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ExpressionStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ForInStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ForOfStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ForStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + IfStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ImportDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed, + LabeledStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + SwitchStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ThrowStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + TryStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + VariableDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed, + WhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + WithStatement: markReturnStatementsOnCurrentSegmentsAsUsed, + ExportNamedDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed, + ExportDefaultDeclaration: + markReturnStatementsOnCurrentSegmentsAsUsed, + ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-var.js new file mode 100644 index 00000000..05c665ab --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-var.js @@ -0,0 +1,488 @@ +/** + * @fileoverview Rule to check for the usage of var. + * @author Jamund Ferguson + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Check whether a given variable is a global variable or not. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable is a global variable. + */ +function isGlobal(variable) { + return Boolean(variable.scope) && variable.scope.type === "global"; +} + +/** + * Finds the nearest function scope or global scope walking up the scope + * hierarchy. + * @param {Scope} scope The scope to traverse. + * @returns {Scope} a function scope or global scope containing the given + * scope. + */ +function getEnclosingFunctionScope(scope) { + let currentScope = scope; + + while (currentScope.type !== "function" && currentScope.type !== "global") { + currentScope = currentScope.upper; + } + return currentScope; +} + +/** + * Checks whether the given variable has any references from a more specific + * function expression (i.e. a closure). + * @param {Variable} variable A variable to check. + * @returns {boolean} `true` if the variable is used from a closure. + */ +function isReferencedInClosure(variable) { + const enclosingFunctionScope = getEnclosingFunctionScope(variable.scope); + + return variable.references.some( + reference => + getEnclosingFunctionScope(reference.from) !== + enclosingFunctionScope, + ); +} + +/** + * Checks whether the given node is the assignee of a loop. + * @param {ASTNode} node A VariableDeclaration node to check. + * @returns {boolean} `true` if the declaration is assigned as part of loop + * iteration. + */ +function isLoopAssignee(node) { + return ( + (node.parent.type === "ForOfStatement" || + node.parent.type === "ForInStatement") && + node === node.parent.left + ); +} + +/** + * Checks whether the given variable declaration is immediately initialized. + * @param {ASTNode} node A VariableDeclaration node to check. + * @returns {boolean} `true` if the declaration has an initializer. + */ +function isDeclarationInitialized(node) { + return node.declarations.every(declarator => declarator.init !== null); +} + +const SCOPE_NODE_TYPE = + /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u; + +/** + * Gets the scope node which directly contains a given node. + * @param {ASTNode} node A node to get. This is a `VariableDeclaration` or + * an `Identifier`. + * @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`, + * `SwitchStatement`, `ForStatement`, `ForInStatement`, and + * `ForOfStatement`. + */ +function getScopeNode(node) { + for ( + let currentNode = node; + currentNode; + currentNode = currentNode.parent + ) { + if (SCOPE_NODE_TYPE.test(currentNode.type)) { + return currentNode; + } + } + + /* c8 ignore next */ + return null; +} + +/** + * Checks whether a given variable is redeclared or not. + * @param {Variable} variable A variable to check. + * @returns {boolean} `true` if the variable is redeclared. + */ +function isRedeclared(variable) { + return variable.defs.length >= 2; +} + +/** + * Checks whether a given variable is used from outside of the specified scope. + * @param {ASTNode} scopeNode A scope node to check. + * @returns {Function} The predicate function which checks whether a given + * variable is used from outside of the specified scope. + */ +function isUsedFromOutsideOf(scopeNode) { + /** + * Checks whether a given reference is inside of the specified scope or not. + * @param {Reference} reference A reference to check. + * @returns {boolean} `true` if the reference is inside of the specified + * scope. + */ + function isOutsideOfScope(reference) { + const scope = scopeNode.range; + const id = reference.identifier.range; + + return id[0] < scope[0] || id[1] > scope[1]; + } + + return function (variable) { + return variable.references.some(isOutsideOfScope); + }; +} + +/** + * Creates the predicate function which checks whether a variable has their references in TDZ. + * + * The predicate function would return `true`: + * + * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};) + * - if a reference is in the expression of their default value. E.g. (var {a = a} = {};) + * - if a reference is in the expression of their initializer. E.g. (var a = a;) + * @param {ASTNode} node The initializer node of VariableDeclarator. + * @returns {Function} The predicate function. + * @private + */ +function hasReferenceInTDZ(node) { + const initStart = node.range[0]; + const initEnd = node.range[1]; + + return variable => { + const id = variable.defs[0].name; + const idStart = id.range[0]; + const defaultValue = + id.parent.type === "AssignmentPattern" ? id.parent.right : null; + const defaultStart = defaultValue && defaultValue.range[0]; + const defaultEnd = defaultValue && defaultValue.range[1]; + + return variable.references.some(reference => { + const start = reference.identifier.range[0]; + const end = reference.identifier.range[1]; + + return ( + !reference.init && + (start < idStart || + (defaultValue !== null && + start >= defaultStart && + end <= defaultEnd) || + (!astUtils.isFunction(node) && + start >= initStart && + end <= initEnd)) + ); + }); + }; +} + +/** + * Checks whether a given variable has name that is allowed for 'var' declarations, + * but disallowed for `let` declarations. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable has a disallowed name. + */ +function hasNameDisallowedForLetDeclarations(variable) { + return variable.name === "let"; +} + +/** + * Checks whether a given variable has any references before its declaration. + * This is important because var allows hoisting, but let/const do not. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable is referenced before its declaration. + */ +function hasReferenceBeforeDeclaration(variable) { + const declarationStart = variable.defs[0].node.range[0]; + + return variable.references.some(reference => { + const referenceStart = reference.identifier.range[0]; + + /* + * Check if the reference occurs before the declaration. + * We don't need to check scopes because all references to this variable + * are already in variable.references (which only includes references + * that resolve to this specific variable binding). + */ + return !reference.init && referenceStart < declarationStart; + }); +} + +/** + * Checks whether a given variable is referenced inside a hoisted function + * declaration that is called before the variable's declaration. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable is referenced from a hoisted + * function called before its declaration. + */ +function hasUnsafeHoistedFunctionReference(variable) { + const declarationNode = variable.defs[0].node; + const declarationStart = declarationNode.range[0]; + + for (const reference of variable.references) { + if (reference.init) { + continue; + } + + if (reference.identifier.range[0] < declarationStart) { + continue; + } + + let currentScope = reference.from.variableScope; + + while (currentScope !== variable.scope) { + if ( + currentScope.block.type === "FunctionDeclaration" && + currentScope.block.id + ) { + const funcName = currentScope.block.id.name; + const funcVariable = currentScope.upper.set.get(funcName); + + for (const funcRef of funcVariable.references) { + const refId = funcRef.identifier; + + if ( + refId.parent.type === "CallExpression" && + refId.parent.callee === refId && + refId.range[0] < declarationStart + ) { + return true; + } + } + } + + currentScope = currentScope.upper.variableScope; + } + } + + return false; +} + +/** + * Checks whether a given variable is shadowed by the parameter of an enclosing + * `catch` clause. + * + * Scope analysis does not report this as a redeclaration, because the catch + * parameter and the `var` are distinct variables living in distinct scopes, so + * neither one has more than one definition. + * + * Resolving the name from the scope of the declaration is enough to detect it. + * A simple catch parameter is the only binding a `var` is allowed to shadow: + * any other block-scoped declaration of the same name makes the `var` itself a + * syntax error, and a function parameter shares its variable with the `var`, so + * that case is reported by `isRedeclared` instead. + * @param {ASTNode} node A `VariableDeclaration` node to check. + * @param {SourceCode} sourceCode The source code object. + * @returns {Function} The predicate function which checks whether a given + * variable is shadowed by a `catch` clause parameter. + */ +function isShadowedByCatchParameter(node, sourceCode) { + return variable => + astUtils.getVariableByName(sourceCode.getScope(node), variable.name) !== + variable; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require `let` or `const` instead of `var`", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-var", + }, + + schema: [], + fixable: "code", + + messages: { + unexpectedVar: "Unexpected var, use let or const instead.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Checks whether the variables which are defined by the given declarator node have their references in TDZ. + * @param {ASTNode} declarator The VariableDeclarator node to check. + * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ. + */ + function hasSelfReferenceInTDZ(declarator) { + if (!declarator.init) { + return false; + } + const variables = sourceCode.getDeclaredVariables(declarator); + + return variables.some(hasReferenceInTDZ(declarator.init)); + } + + /** + * Checks whether it can fix a given variable declaration or not. + * It cannot fix if the following cases: + * + * - A variable is a global variable. + * - A variable is declared on a SwitchCase node. + * - A variable is redeclared. + * - A variable is used from outside the scope. + * - A variable is used from a closure within a loop. + * - A variable might be used before it is assigned within a loop. + * - A variable might be used in TDZ. + * - A variable is referenced before its declaration. + * - A variable is declared in statement position (e.g. a single-line `IfStatement`) + * - A variable has name that is disallowed for `let` declarations. + * - A variable is shadowed by a `catch` clause parameter. + * + * ## A variable is declared on a SwitchCase node. + * + * If this rule modifies 'var' declarations on a SwitchCase node, it + * would generate the warnings of 'no-case-declarations' rule. And the + * 'eslint:recommended' preset includes 'no-case-declarations' rule, so + * this rule doesn't modify those declarations. + * + * ## A variable is redeclared. + * + * The language spec disallows redeclarations of `let` declarations. + * Those variables would cause syntax errors. + * + * ## A variable is used from outside the scope. + * + * The language spec disallows accesses from outside of the scope for + * `let` declarations. Those variables would cause reference errors. + * + * ## A variable is used from a closure within a loop. + * + * A `var` declaration within a loop shares the same variable instance + * across all loop iterations, while a `let` declaration creates a new + * instance for each iteration. This means if a variable in a loop is + * referenced by any closure, changing it from `var` to `let` would + * change the behavior in a way that is generally unsafe. + * + * ## A variable might be used before it is assigned within a loop. + * + * Within a loop, a `let` declaration without an initializer will be + * initialized to null, while a `var` declaration will retain its value + * from the previous iteration, so it is only safe to change `var` to + * `let` if we can statically determine that the variable is always + * assigned a value before its first access in the loop body. To keep + * the implementation simple, we only convert `var` to `let` within + * loops when the variable is a loop assignee or the declaration has an + * initializer. + * + * ## A variable is shadowed by a `catch` clause parameter. + * + * A `var` declaration may reuse the name of a simple catch clause + * parameter, but the equivalent `let` declaration may not. Directly + * inside the catch block, `let` would be a syntax error. In a nested + * block, `let` is valid but changes behavior: the `var` assigns to the + * catch parameter, while the `let` introduces a separate binding and + * leaves the catch parameter untouched. + * @param {ASTNode} node A variable declaration node to check. + * @returns {boolean} `true` if it can fix the node. + */ + function canFix(node) { + const variables = sourceCode.getDeclaredVariables(node); + const scopeNode = getScopeNode(node); + const parentStatementList = new Set([ + ...astUtils.STATEMENT_LIST_PARENTS, + "TSModuleBlock", + ]); + + if ( + node.parent.type === "SwitchCase" || + node.declarations.some(hasSelfReferenceInTDZ) || + variables.some(isGlobal) || + variables.some(isRedeclared) || + variables.some(isUsedFromOutsideOf(scopeNode)) || + variables.some(hasNameDisallowedForLetDeclarations) || + variables.some(hasReferenceBeforeDeclaration) || + variables.some(hasUnsafeHoistedFunctionReference) || + variables.some(isShadowedByCatchParameter(node, sourceCode)) + ) { + return false; + } + + if (astUtils.isInLoop(node)) { + if (variables.some(isReferencedInClosure)) { + return false; + } + if (!isLoopAssignee(node) && !isDeclarationInitialized(node)) { + return false; + } + } + + if ( + !isLoopAssignee(node) && + !( + node.parent.type === "ForStatement" && + node.parent.init === node + ) && + !parentStatementList.has(node.parent.type) + ) { + // If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed. + return false; + } + + return true; + } + + /** + * Reports a given variable declaration node. + * @param {ASTNode} node A variable declaration node to report. + * @returns {void} + */ + function report(node) { + context.report({ + node, + messageId: "unexpectedVar", + + fix(fixer) { + const varToken = sourceCode.getFirstToken(node, { + filter: t => t.value === "var", + }); + + return canFix(node) + ? fixer.replaceText(varToken, "let") + : null; + }, + }); + } + + return { + "VariableDeclaration:exit"(node) { + if (node.kind !== "var") { + return; + } + + if ( + node.parent.type === "TSModuleBlock" && + node.parent.parent.type === "TSModuleDeclaration" && + node.parent.parent.global + ) { + return; + } + + report(node); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-void.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-void.js new file mode 100644 index 00000000..7e99fd3c --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-void.js @@ -0,0 +1,69 @@ +/** + * @fileoverview Rule to disallow use of void operator. + * @author Mike Sidorov + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowAsStatement: false, + }, + ], + + docs: { + description: "Disallow `void` operators", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-void", + }, + + messages: { + noVoid: "Expected 'undefined' and instead saw 'void'.", + }, + + schema: [ + { + type: "object", + properties: { + allowAsStatement: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + + create(context) { + const [{ allowAsStatement }] = context.options; + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + 'UnaryExpression[operator="void"]'(node) { + if ( + allowAsStatement && + node.parent && + node.parent.type === "ExpressionStatement" + ) { + return; + } + context.report({ + node, + messageId: "noVoid", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-warning-comments.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-warning-comments.js new file mode 100644 index 00000000..8f1a7c36 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-warning-comments.js @@ -0,0 +1,209 @@ +/** + * @fileoverview Rule that warns about used warning comments + * @author Alexander Schmidt + */ + +"use strict"; + +const escapeRegExp = require("escape-string-regexp"); +const astUtils = require("./utils/ast-utils"); + +const CHAR_LIMIT = 40; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + location: "start", + terms: ["todo", "fixme", "xxx"], + }, + ], + + docs: { + description: "Disallow specified warning terms in comments", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/no-warning-comments", + }, + + schema: [ + { + type: "object", + properties: { + terms: { + type: "array", + items: { + type: "string", + }, + }, + location: { + enum: ["start", "anywhere"], + }, + decoration: { + type: "array", + items: { + type: "string", + pattern: "^\\S$", + }, + minItems: 1, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedComment: + "Unexpected '{{matchedTerm}}' comment: '{{comment}}'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ decoration, location, terms: warningTerms }] = context.options; + const escapedDecoration = escapeRegExp( + decoration ? decoration.join("") : "", + ); + const selfConfigRegEx = /\bno-warning-comments\b/u; + + /** + * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified + * location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not + * require word boundaries on that side. + * @param {string} term A term to convert to a RegExp + * @returns {RegExp} The term converted to a RegExp + */ + function convertToRegExp(term) { + const escaped = escapeRegExp(term); + + /* + * When matching at the start, ignore leading whitespace, and + * there's no need to worry about word boundaries. + * + * These expressions for the prefix and suffix are designed as follows: + * ^ handles any terms at the beginning of a comment. + * e.g. terms ["TODO"] matches `//TODO something` + * $ handles any terms at the end of a comment + * e.g. terms ["TODO"] matches `// something TODO` + * \b handles terms preceded/followed by word boundary + * e.g. terms: ["!FIX", "FIX!"] matches `// FIX!something` or `// something!FIX` + * terms: ["FIX"] matches `// FIX!` or `// !FIX`, but not `// fixed or affix` + * + * For location start: + * [\s]* handles optional leading spaces + * e.g. terms ["TODO"] matches `// TODO something` + * [\s\*]* (where "\*" is the escaped string of decoration) + * handles optional leading spaces or decoration characters (for "start" location only) + * e.g. terms ["TODO"] matches `/**** TODO something ... ` + */ + const wordBoundary = "\\b"; + + let prefix = ""; + + if (location === "start") { + prefix = `^[\\s${escapedDecoration}]*`; + } else if (/^\w/u.test(term)) { + prefix = wordBoundary; + } + + const suffix = /\w$/u.test(term) ? wordBoundary : ""; + const flags = "iu"; // Case-insensitive with Unicode case folding. + + /* + * For location "start", the typical regex is: + * /^[\s]*ESCAPED_TERM\b/iu. + * Or if decoration characters are specified (e.g. "*"), then any of + * those characters may appear in any order at the start: + * /^[\s\*]*ESCAPED_TERM\b/iu. + * + * For location "anywhere" the typical regex is + * /\bESCAPED_TERM\b/iu + * + * If it starts or ends with non-word character, the prefix and suffix are empty, respectively. + */ + return new RegExp(`${prefix}${escaped}${suffix}`, flags); + } + + const warningRegExps = warningTerms.map(convertToRegExp); + + /** + * Checks the specified comment for matches of the configured warning terms and returns the matches. + * @param {string} comment The comment which is checked. + * @returns {Array} All matched warning terms for this comment. + */ + function commentContainsWarningTerm(comment) { + const matches = []; + + warningRegExps.forEach((regex, index) => { + if (regex.test(comment)) { + matches.push(warningTerms[index]); + } + }); + + return matches; + } + + /** + * Checks the specified node for matching warning comments and reports them. + * @param {ASTNode} node The AST node being checked. + * @returns {void} undefined. + */ + function checkComment(node) { + const comment = node.value; + + if ( + astUtils.isDirectiveComment(node) && + selfConfigRegEx.test(comment) + ) { + return; + } + + const matches = commentContainsWarningTerm(comment); + + matches.forEach(matchedTerm => { + let commentToDisplay = ""; + let truncated = false; + + for (const c of comment.trim().split(/\s+/u)) { + const tmp = commentToDisplay + ? `${commentToDisplay} ${c}` + : c; + + if (tmp.length <= CHAR_LIMIT) { + commentToDisplay = tmp; + } else { + truncated = true; + break; + } + } + + context.report({ + node, + messageId: "unexpectedComment", + data: { + matchedTerm, + comment: `${commentToDisplay}${truncated ? "..." : ""}`, + }, + }); + }); + } + + return { + Program() { + const comments = sourceCode.getAllComments(); + + comments + .filter(token => token.type !== "Shebang") + .forEach(checkComment); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-whitespace-before-property.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-whitespace-before-property.js new file mode 100644 index 00000000..137d8fcf --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-whitespace-before-property.js @@ -0,0 +1,150 @@ +/** + * @fileoverview Rule to disallow whitespace before properties + * @author Kai Cataldo + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "no-whitespace-before-property", + url: "https://eslint.style/rules/no-whitespace-before-property", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Disallow whitespace before properties", + recommended: false, + url: "https://eslint.org/docs/latest/rules/no-whitespace-before-property", + }, + + fixable: "whitespace", + schema: [], + + messages: { + unexpectedWhitespace: + "Unexpected whitespace before property {{propName}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports whitespace before property token + * @param {ASTNode} node the node to report in the event of an error + * @param {Token} leftToken the left token + * @param {Token} rightToken the right token + * @returns {void} + * @private + */ + function reportError(node, leftToken, rightToken) { + context.report({ + node, + messageId: "unexpectedWhitespace", + data: { + propName: sourceCode.getText(node.property), + }, + fix(fixer) { + let replacementText = ""; + + if ( + !node.computed && + !node.optional && + astUtils.isDecimalInteger(node.object) + ) { + /* + * If the object is a number literal, fixing it to something like 5.toString() would cause a SyntaxError. + * Don't fix this case. + */ + return null; + } + + // Don't fix if comments exist. + if ( + sourceCode.commentsExistBetween(leftToken, rightToken) + ) { + return null; + } + + if (node.optional) { + replacementText = "?."; + } else if (!node.computed) { + replacementText = "."; + } + + return fixer.replaceTextRange( + [leftToken.range[1], rightToken.range[0]], + replacementText, + ); + }, + }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + MemberExpression(node) { + let rightToken; + let leftToken; + + if (!astUtils.isTokenOnSameLine(node.object, node.property)) { + return; + } + + if (node.computed) { + rightToken = sourceCode.getTokenBefore( + node.property, + astUtils.isOpeningBracketToken, + ); + leftToken = sourceCode.getTokenBefore( + rightToken, + node.optional ? 1 : 0, + ); + } else { + rightToken = sourceCode.getFirstToken(node.property); + leftToken = sourceCode.getTokenBefore(rightToken, 1); + } + + if (sourceCode.isSpaceBetween(leftToken, rightToken)) { + reportError(node, leftToken, rightToken); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-with.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-with.js new file mode 100644 index 00000000..f0461180 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/no-with.js @@ -0,0 +1,43 @@ +/** + * @fileoverview Rule to flag use of with statement + * @author Nicholas C. Zakas + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Disallow `with` statements", + recommended: true, + url: "https://eslint.org/docs/latest/rules/no-with", + }, + + schema: [], + + messages: { + unexpectedWith: "Unexpected use of 'with' statement.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + WithStatement(node) { + context.report({ + node, + loc: sourceCode.getFirstToken(node).loc, + messageId: "unexpectedWith", + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/nonblock-statement-body-position.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/nonblock-statement-body-position.js new file mode 100644 index 00000000..dbfd1063 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/nonblock-statement-body-position.js @@ -0,0 +1,164 @@ +/** + * @fileoverview enforce the location of single-line statements + * @author Teddy Katz + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const POSITION_SCHEMA = { enum: ["beside", "below", "any"] }; + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "nonblock-statement-body-position", + url: "https://eslint.style/rules/nonblock-statement-body-position", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce the location of single-line statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/nonblock-statement-body-position", + }, + + fixable: "whitespace", + + schema: [ + POSITION_SCHEMA, + { + properties: { + overrides: { + properties: { + if: POSITION_SCHEMA, + else: POSITION_SCHEMA, + while: POSITION_SCHEMA, + do: POSITION_SCHEMA, + for: POSITION_SCHEMA, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + expectNoLinebreak: "Expected no linebreak before this statement.", + expectLinebreak: "Expected a linebreak before this statement.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Gets the applicable preference for a particular keyword + * @param {string} keywordName The name of a keyword, e.g. 'if' + * @returns {string} The applicable option for the keyword, e.g. 'beside' + */ + function getOption(keywordName) { + return ( + (context.options[1] && + context.options[1].overrides && + context.options[1].overrides[keywordName]) || + context.options[0] || + "beside" + ); + } + + /** + * Validates the location of a single-line statement + * @param {ASTNode} node The single-line statement + * @param {string} keywordName The applicable keyword name for the single-line statement + * @returns {void} + */ + function validateStatement(node, keywordName) { + const option = getOption(keywordName); + + if (node.type === "BlockStatement" || option === "any") { + return; + } + + const tokenBefore = sourceCode.getTokenBefore(node); + + if ( + tokenBefore.loc.end.line === node.loc.start.line && + option === "below" + ) { + context.report({ + node, + messageId: "expectLinebreak", + fix: fixer => fixer.insertTextBefore(node, "\n"), + }); + } else if ( + tokenBefore.loc.end.line !== node.loc.start.line && + option === "beside" + ) { + context.report({ + node, + messageId: "expectNoLinebreak", + fix(fixer) { + if ( + sourceCode + .getText() + .slice(tokenBefore.range[1], node.range[0]) + .trim() + ) { + return null; + } + return fixer.replaceTextRange( + [tokenBefore.range[1], node.range[0]], + " ", + ); + }, + }); + } + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + IfStatement(node) { + validateStatement(node.consequent, "if"); + + // Check the `else` node, but don't check 'else if' statements. + if (node.alternate && node.alternate.type !== "IfStatement") { + validateStatement(node.alternate, "else"); + } + }, + WhileStatement: node => validateStatement(node.body, "while"), + DoWhileStatement: node => validateStatement(node.body, "do"), + ForStatement: node => validateStatement(node.body, "for"), + ForInStatement: node => validateStatement(node.body, "for"), + ForOfStatement: node => validateStatement(node.body, "for"), + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-newline.js new file mode 100644 index 00000000..e0b860b3 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-newline.js @@ -0,0 +1,383 @@ +/** + * @fileoverview Rule to require or disallow line breaks inside braces. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +// Schema objects. +const OPTION_VALUE = { + oneOf: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + multiline: { + type: "boolean", + }, + minProperties: { + type: "integer", + minimum: 0, + }, + consistent: { + type: "boolean", + }, + }, + additionalProperties: false, + minProperties: 1, + }, + ], +}; + +/** + * Normalizes a given option value. + * @param {string|Object|undefined} value An option value to parse. + * @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object. + */ +function normalizeOptionValue(value) { + let multiline = false; + let minProperties = Number.POSITIVE_INFINITY; + let consistent = false; + + if (value) { + if (value === "always") { + minProperties = 0; + } else if (value === "never") { + minProperties = Number.POSITIVE_INFINITY; + } else { + multiline = Boolean(value.multiline); + minProperties = value.minProperties || Number.POSITIVE_INFINITY; + consistent = Boolean(value.consistent); + } + } else { + consistent = true; + } + + return { multiline, minProperties, consistent }; +} + +/** + * Checks if a value is an object. + * @param {any} value The value to check + * @returns {boolean} `true` if the value is an object, otherwise `false` + */ +function isObject(value) { + return typeof value === "object" && value !== null; +} + +/** + * Checks if an option is a node-specific option + * @param {any} option The option to check + * @returns {boolean} `true` if the option is node-specific, otherwise `false` + */ +function isNodeSpecificOption(option) { + return isObject(option) || typeof option === "string"; +} + +/** + * Normalizes a given option value. + * @param {string|Object|undefined} options An option value to parse. + * @returns {{ + * ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean}, + * ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean}, + * ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean}, + * ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean} + * }} Normalized option object. + */ +function normalizeOptions(options) { + if ( + isObject(options) && + Object.values(options).some(isNodeSpecificOption) + ) { + return { + ObjectExpression: normalizeOptionValue(options.ObjectExpression), + ObjectPattern: normalizeOptionValue(options.ObjectPattern), + ImportDeclaration: normalizeOptionValue(options.ImportDeclaration), + ExportNamedDeclaration: normalizeOptionValue( + options.ExportDeclaration, + ), + }; + } + + const value = normalizeOptionValue(options); + + return { + ObjectExpression: value, + ObjectPattern: value, + ImportDeclaration: value, + ExportNamedDeclaration: value, + }; +} + +/** + * Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration + * node needs to be checked for missing line breaks + * @param {ASTNode} node Node under inspection + * @param {Object} options option specific to node type + * @param {Token} first First object property + * @param {Token} last Last object property + * @returns {boolean} `true` if node needs to be checked for missing line breaks + */ +function areLineBreaksRequired(node, options, first, last) { + let objectProperties; + + if (node.type === "ObjectExpression" || node.type === "ObjectPattern") { + objectProperties = node.properties; + } else { + // is ImportDeclaration or ExportNamedDeclaration + objectProperties = node.specifiers.filter( + s => s.type === "ImportSpecifier" || s.type === "ExportSpecifier", + ); + } + + return ( + objectProperties.length >= options.minProperties || + (options.multiline && + objectProperties.length > 0 && + first.loc.start.line !== last.loc.end.line) + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "object-curly-newline", + url: "https://eslint.style/rules/object-curly-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent line breaks after opening and before closing braces", + recommended: false, + url: "https://eslint.org/docs/latest/rules/object-curly-newline", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + OPTION_VALUE, + { + type: "object", + properties: { + ObjectExpression: OPTION_VALUE, + ObjectPattern: OPTION_VALUE, + ImportDeclaration: OPTION_VALUE, + ExportDeclaration: OPTION_VALUE, + }, + additionalProperties: false, + minProperties: 1, + }, + ], + }, + ], + + messages: { + unexpectedLinebreakBeforeClosingBrace: + "Unexpected line break before this closing brace.", + unexpectedLinebreakAfterOpeningBrace: + "Unexpected line break after this opening brace.", + expectedLinebreakBeforeClosingBrace: + "Expected a line break before this closing brace.", + expectedLinebreakAfterOpeningBrace: + "Expected a line break after this opening brace.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const normalizedOptions = normalizeOptions(context.options[0]); + + /** + * Reports a given node if it violated this rule. + * @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node. + * @returns {void} + */ + function check(node) { + const options = normalizedOptions[node.type]; + + if ( + (node.type === "ImportDeclaration" && + !node.specifiers.some( + specifier => specifier.type === "ImportSpecifier", + )) || + (node.type === "ExportNamedDeclaration" && + !node.specifiers.some( + specifier => specifier.type === "ExportSpecifier", + )) + ) { + return; + } + + const openBrace = sourceCode.getFirstToken( + node, + token => token.value === "{", + ); + + let closeBrace; + + if (node.typeAnnotation) { + closeBrace = sourceCode.getTokenBefore(node.typeAnnotation); + } else { + closeBrace = sourceCode.getLastToken( + node, + token => token.value === "}", + ); + } + + let first = sourceCode.getTokenAfter(openBrace, { + includeComments: true, + }); + let last = sourceCode.getTokenBefore(closeBrace, { + includeComments: true, + }); + + const needsLineBreaks = areLineBreaksRequired( + node, + options, + first, + last, + ); + + const hasCommentsFirstToken = astUtils.isCommentToken(first); + const hasCommentsLastToken = astUtils.isCommentToken(last); + + /* + * Use tokens or comments to check multiline or not. + * But use only tokens to check whether line breaks are needed. + * This allows: + * var obj = { // eslint-disable-line foo + * a: 1 + * } + */ + first = sourceCode.getTokenAfter(openBrace); + last = sourceCode.getTokenBefore(closeBrace); + + if (needsLineBreaks) { + if (astUtils.isTokenOnSameLine(openBrace, first)) { + context.report({ + messageId: "expectedLinebreakAfterOpeningBrace", + node, + loc: openBrace.loc, + fix(fixer) { + if (hasCommentsFirstToken) { + return null; + } + + return fixer.insertTextAfter(openBrace, "\n"); + }, + }); + } + if (astUtils.isTokenOnSameLine(last, closeBrace)) { + context.report({ + messageId: "expectedLinebreakBeforeClosingBrace", + node, + loc: closeBrace.loc, + fix(fixer) { + if (hasCommentsLastToken) { + return null; + } + + return fixer.insertTextBefore(closeBrace, "\n"); + }, + }); + } + } else { + const consistent = options.consistent; + const hasLineBreakBetweenOpenBraceAndFirst = + !astUtils.isTokenOnSameLine(openBrace, first); + const hasLineBreakBetweenCloseBraceAndLast = + !astUtils.isTokenOnSameLine(last, closeBrace); + + if ( + (!consistent && hasLineBreakBetweenOpenBraceAndFirst) || + (consistent && + hasLineBreakBetweenOpenBraceAndFirst && + !hasLineBreakBetweenCloseBraceAndLast) + ) { + context.report({ + messageId: "unexpectedLinebreakAfterOpeningBrace", + node, + loc: openBrace.loc, + fix(fixer) { + if (hasCommentsFirstToken) { + return null; + } + + return fixer.removeRange([ + openBrace.range[1], + first.range[0], + ]); + }, + }); + } + if ( + (!consistent && hasLineBreakBetweenCloseBraceAndLast) || + (consistent && + !hasLineBreakBetweenOpenBraceAndFirst && + hasLineBreakBetweenCloseBraceAndLast) + ) { + context.report({ + messageId: "unexpectedLinebreakBeforeClosingBrace", + node, + loc: closeBrace.loc, + fix(fixer) { + if (hasCommentsLastToken) { + return null; + } + + return fixer.removeRange([ + last.range[1], + closeBrace.range[0], + ]); + }, + }); + } + } + } + + return { + ObjectExpression: check, + ObjectPattern: check, + ImportDeclaration: check, + ExportNamedDeclaration: check, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-spacing.js new file mode 100644 index 00000000..acbc8dde --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-curly-spacing.js @@ -0,0 +1,369 @@ +/** + * @fileoverview Disallows or enforces spaces inside of object literals. + * @author Jamund Ferguson + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "object-curly-spacing", + url: "https://eslint.style/rules/object-curly-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing inside braces", + recommended: false, + url: "https://eslint.org/docs/latest/rules/object-curly-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + arraysInObjects: { + type: "boolean", + }, + objectsInObjects: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + requireSpaceBefore: "A space is required before '{{token}}'.", + requireSpaceAfter: "A space is required after '{{token}}'.", + unexpectedSpaceBefore: + "There should be no space before '{{token}}'.", + unexpectedSpaceAfter: "There should be no space after '{{token}}'.", + }, + }, + + create(context) { + const spaced = context.options[0] === "always", + sourceCode = context.sourceCode; + + /** + * Determines whether an option is set, relative to the spacing option. + * If spaced is "always", then check whether option is set to false. + * If spaced is "never", then check whether option is set to true. + * @param {Object} option The option to exclude. + * @returns {boolean} Whether or not the property is excluded. + */ + function isOptionSet(option) { + return context.options[1] + ? context.options[1][option] === !spaced + : false; + } + + const options = { + spaced, + arraysInObjectsException: isOptionSet("arraysInObjects"), + objectsInObjectsException: isOptionSet("objectsInObjects"), + }; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports that there shouldn't be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoBeginningSpace(node, token) { + const nextToken = context.sourceCode.getTokenAfter(token, { + includeComments: true, + }); + + context.report({ + node, + loc: { start: token.loc.end, end: nextToken.loc.start }, + messageId: "unexpectedSpaceAfter", + data: { + token: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + token.range[1], + nextToken.range[0], + ]); + }, + }); + } + + /** + * Reports that there shouldn't be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportNoEndingSpace(node, token) { + const previousToken = context.sourceCode.getTokenBefore(token, { + includeComments: true, + }); + + context.report({ + node, + loc: { start: previousToken.loc.end, end: token.loc.start }, + messageId: "unexpectedSpaceBefore", + data: { + token: token.value, + }, + fix(fixer) { + return fixer.removeRange([ + previousToken.range[1], + token.range[0], + ]); + }, + }); + } + + /** + * Reports that there should be a space after the first token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredBeginningSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "requireSpaceAfter", + data: { + token: token.value, + }, + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + + /** + * Reports that there should be a space before the last token + * @param {ASTNode} node The node to report in the event of an error. + * @param {Token} token The token to use for the report. + * @returns {void} + */ + function reportRequiredEndingSpace(node, token) { + context.report({ + node, + loc: token.loc, + messageId: "requireSpaceBefore", + data: { + token: token.value, + }, + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + + /** + * Determines if spacing in curly braces is valid. + * @param {ASTNode} node The AST node to check. + * @param {Token} first The first token to check (should be the opening brace) + * @param {Token} second The second token to check (should be first after the opening brace) + * @param {Token} penultimate The penultimate token to check (should be last before closing brace) + * @param {Token} last The last token to check (should be closing brace) + * @returns {void} + */ + function validateBraceSpacing(node, first, second, penultimate, last) { + if (astUtils.isTokenOnSameLine(first, second)) { + const firstSpaced = sourceCode.isSpaceBetween(first, second); + + if (options.spaced && !firstSpaced) { + reportRequiredBeginningSpace(node, first); + } + if (!options.spaced && firstSpaced && second.type !== "Line") { + reportNoBeginningSpace(node, first); + } + } + + if (astUtils.isTokenOnSameLine(penultimate, last)) { + const shouldCheckPenultimate = + (options.arraysInObjectsException && + astUtils.isClosingBracketToken(penultimate)) || + (options.objectsInObjectsException && + astUtils.isClosingBraceToken(penultimate)); + const penultimateType = + shouldCheckPenultimate && + sourceCode.getNodeByRangeIndex(penultimate.range[0]).type; + + const closingCurlyBraceMustBeSpaced = + (options.arraysInObjectsException && + penultimateType === "ArrayExpression") || + (options.objectsInObjectsException && + (penultimateType === "ObjectExpression" || + penultimateType === "ObjectPattern")) + ? !options.spaced + : options.spaced; + + const lastSpaced = sourceCode.isSpaceBetween(penultimate, last); + + if (closingCurlyBraceMustBeSpaced && !lastSpaced) { + reportRequiredEndingSpace(node, last); + } + if (!closingCurlyBraceMustBeSpaced && lastSpaced) { + reportNoEndingSpace(node, last); + } + } + } + + /** + * Gets '}' token of an object node. + * + * Because the last token of object patterns might be a type annotation, + * this traverses tokens preceded by the last property, then returns the + * first '}' token. + * @param {ASTNode} node The node to get. This node is an + * ObjectExpression or an ObjectPattern. And this node has one or + * more properties. + * @returns {Token} '}' token. + */ + function getClosingBraceOfObject(node) { + const lastProperty = node.properties.at(-1); + + return sourceCode.getTokenAfter( + lastProperty, + astUtils.isClosingBraceToken, + ); + } + + /** + * Reports a given object node if spacing in curly braces is invalid. + * @param {ASTNode} node An ObjectExpression or ObjectPattern node to check. + * @returns {void} + */ + function checkForObject(node) { + if (node.properties.length === 0) { + return; + } + + const first = sourceCode.getFirstToken(node), + last = getClosingBraceOfObject(node), + second = sourceCode.getTokenAfter(first, { + includeComments: true, + }), + penultimate = sourceCode.getTokenBefore(last, { + includeComments: true, + }); + + validateBraceSpacing(node, first, second, penultimate, last); + } + + /** + * Reports a given import node if spacing in curly braces is invalid. + * @param {ASTNode} node An ImportDeclaration node to check. + * @returns {void} + */ + function checkForImport(node) { + if (node.specifiers.length === 0) { + return; + } + + let firstSpecifier = node.specifiers[0]; + const lastSpecifier = node.specifiers.at(-1); + + if (lastSpecifier.type !== "ImportSpecifier") { + return; + } + if (firstSpecifier.type !== "ImportSpecifier") { + firstSpecifier = node.specifiers[1]; + } + + const first = sourceCode.getTokenBefore(firstSpecifier), + last = sourceCode.getTokenAfter( + lastSpecifier, + astUtils.isNotCommaToken, + ), + second = sourceCode.getTokenAfter(first, { + includeComments: true, + }), + penultimate = sourceCode.getTokenBefore(last, { + includeComments: true, + }); + + validateBraceSpacing(node, first, second, penultimate, last); + } + + /** + * Reports a given export node if spacing in curly braces is invalid. + * @param {ASTNode} node An ExportNamedDeclaration node to check. + * @returns {void} + */ + function checkForExport(node) { + if (node.specifiers.length === 0) { + return; + } + + const firstSpecifier = node.specifiers[0], + lastSpecifier = node.specifiers.at(-1), + first = sourceCode.getTokenBefore(firstSpecifier), + last = sourceCode.getTokenAfter( + lastSpecifier, + astUtils.isNotCommaToken, + ), + second = sourceCode.getTokenAfter(first, { + includeComments: true, + }), + penultimate = sourceCode.getTokenBefore(last, { + includeComments: true, + }); + + validateBraceSpacing(node, first, second, penultimate, last); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + // var {x} = y; + ObjectPattern: checkForObject, + + // var y = {x: 'y'} + ObjectExpression: checkForObject, + + // import {y} from 'x'; + ImportDeclaration: checkForImport, + + // export {name} from 'yo'; + ExportNamedDeclaration: checkForExport, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-property-newline.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-property-newline.js new file mode 100644 index 00000000..6921e048 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-property-newline.js @@ -0,0 +1,151 @@ +/** + * @fileoverview Rule to enforce placing object properties on separate lines. + * @author Vitor Balocco + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "object-property-newline", + url: "https://eslint.style/rules/object-property-newline", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce placing object properties on separate lines", + recommended: false, + url: "https://eslint.org/docs/latest/rules/object-property-newline", + }, + + schema: [ + { + type: "object", + properties: { + allowAllPropertiesOnSameLine: { + type: "boolean", + default: false, + }, + allowMultiplePropertiesPerLine: { + // Deprecated + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + fixable: "whitespace", + + messages: { + propertiesOnNewlineAll: + "Object properties must go on a new line if they aren't all on the same line.", + propertiesOnNewline: "Object properties must go on a new line.", + }, + }, + + create(context) { + const allowSameLine = + context.options[0] && + (context.options[0].allowAllPropertiesOnSameLine || + context.options[0] + .allowMultiplePropertiesPerLine); /* Deprecated */ + const messageId = allowSameLine + ? "propertiesOnNewlineAll" + : "propertiesOnNewline"; + + const sourceCode = context.sourceCode; + + return { + ObjectExpression(node) { + if (allowSameLine) { + if (node.properties.length > 1) { + const firstTokenOfFirstProperty = + sourceCode.getFirstToken(node.properties[0]); + const lastTokenOfLastProperty = sourceCode.getLastToken( + node.properties.at(-1), + ); + + if ( + firstTokenOfFirstProperty.loc.end.line === + lastTokenOfLastProperty.loc.start.line + ) { + // All keys and values are on the same line + return; + } + } + } + + for (let i = 1; i < node.properties.length; i++) { + const lastTokenOfPreviousProperty = sourceCode.getLastToken( + node.properties[i - 1], + ); + const firstTokenOfCurrentProperty = + sourceCode.getFirstToken(node.properties[i]); + + if ( + lastTokenOfPreviousProperty.loc.end.line === + firstTokenOfCurrentProperty.loc.start.line + ) { + context.report({ + node, + loc: firstTokenOfCurrentProperty.loc, + messageId, + fix(fixer) { + const comma = sourceCode.getTokenBefore( + firstTokenOfCurrentProperty, + ); + const rangeAfterComma = [ + comma.range[1], + firstTokenOfCurrentProperty.range[0], + ]; + + // Don't perform a fix if there are any comments between the comma and the next property. + if ( + sourceCode.text + .slice( + rangeAfterComma[0], + rangeAfterComma[1], + ) + .trim() + ) { + return null; + } + + return fixer.replaceTextRange( + rangeAfterComma, + "\n", + ); + }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-shorthand.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-shorthand.js new file mode 100644 index 00000000..07ab5b86 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/object-shorthand.js @@ -0,0 +1,683 @@ +/** + * @fileoverview Rule to enforce concise object methods and properties. + * @author Jamund Ferguson + */ + +"use strict"; + +const OPTIONS = { + always: "always", + never: "never", + methods: "methods", + properties: "properties", + consistent: "consistent", + consistentAsNeeded: "consistent-as-needed", +}; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ +const astUtils = require("./utils/ast-utils"); +const { containsLetter } = require("./utils/string-utils"); +//-------------------------------------------------------------------------- +// Helpers +//-------------------------------------------------------------------------- +// Skip non-letter characters used as an identifier prefix: '$', '_' and digits. +// https://tc39.es/ecma262/#prod-IdentifierPart +const IDENTIFIER_PREFIX_END_REGEX = /[^_$0-9]/u; +const JSDOC_COMMENT_REGEX = /^\s*\*/u; + +/** + * Determines if the first character of the name is a capital letter. + * @param {string} name The name of the node to evaluate. + * @returns {boolean} True if the first character of the property name is a capital letter, false if not. + * @private + */ +function isConstructor(name) { + const match = IDENTIFIER_PREFIX_END_REGEX.exec(name); + + // Not a constructor if name has no characters apart from '_', '$' and digits e.g. '_', '$$', '_8' + if (!match) { + return false; + } + + const firstChar = match[0]; + + if (!containsLetter(firstChar)) { + return false; + } + + return firstChar === firstChar.toUpperCase(); +} + +/** + * Determines if the property can have a shorthand form. + * @param {ASTNode} property Property AST node + * @returns {boolean} True if the property can have a shorthand form + * @private + */ +function canHaveShorthand(property) { + return ( + property.kind !== "set" && + property.kind !== "get" && + property.type !== "SpreadElement" && + property.type !== "SpreadProperty" && + property.type !== "ExperimentalSpreadProperty" + ); +} + +/** + * Checks whether a node is a string literal. + * @param {ASTNode} node Any AST node. + * @returns {boolean} `true` if it is a string literal. + */ +function isStringLiteral(node) { + return node.type === "Literal" && typeof node.value === "string"; +} + +/** + * Determines whether the key of a property in an object literal is a non-computed `__proto__`. + * `{ __proto__: foo }` and `{ "__proto__": foo }` set the object's prototype, while the concise + * forms `{ __proto__ }` and `{ __proto__() {} }` define an own property named `__proto__`, so + * converting between the two forms changes behavior in either direction. + * Computed keys are excluded because `{ ["__proto__"]: foo }` and `{ ["__proto__"]() {} }` both + * define an own property, which makes that conversion safe. + * @param {ASTNode} property Property AST node + * @returns {boolean} True if the key is a non-computed `__proto__` + * @private + */ +function isProtoKey(property) { + return ( + !property.computed && + astUtils.getStaticPropertyName(property) === "__proto__" + ); +} + +/** + * Determines if the property is a shorthand or not. + * @param {ASTNode} property Property AST node + * @returns {boolean} True if the property is considered shorthand, false if not. + * @private + */ +function isShorthand(property) { + // property.method is true when `{a(){}}`. + return property.shorthand || property.method; +} + +/** + * Determines if the property's key and method or value are named equally. + * @param {ASTNode} property Property AST node + * @returns {boolean} True if the key and value are named equally, false if not. + * @private + */ +function isRedundant(property) { + const value = property.value; + + if (isProtoKey(property)) { + return false; + } + if (value.type === "FunctionExpression") { + return !value.id; // Only anonymous should be shorthand method. + } + if (value.type === "Identifier") { + return astUtils.getStaticPropertyName(property) === value.name; + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require or disallow method and property shorthand syntax for object literals", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/object-shorthand", + }, + + fixable: "code", + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: [ + "always", + "methods", + "properties", + "never", + "consistent", + "consistent-as-needed", + ], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: ["always", "methods", "properties"], + }, + { + type: "object", + properties: { + avoidQuotes: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + { + type: "array", + items: [ + { + enum: ["always", "methods"], + }, + { + type: "object", + properties: { + ignoreConstructors: { + type: "boolean", + }, + methodsIgnorePattern: { + type: "string", + }, + avoidQuotes: { + type: "boolean", + }, + avoidExplicitReturnArrows: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + defaultOptions: ["always"], + + messages: { + expectedAllPropertiesShorthanded: + "Expected shorthand for all properties.", + expectedLiteralMethodLongform: + "Expected longform method syntax for string literal keys.", + expectedPropertyShorthand: "Expected property shorthand.", + expectedPropertyLongform: "Expected longform property syntax.", + expectedMethodShorthand: "Expected method shorthand.", + expectedMethodLongform: "Expected longform method syntax.", + unexpectedMix: + "Unexpected mix of shorthand and non-shorthand properties.", + }, + }, + + create(context) { + const APPLY = context.options[0]; + const APPLY_TO_METHODS = + APPLY === OPTIONS.methods || APPLY === OPTIONS.always; + const APPLY_TO_PROPS = + APPLY === OPTIONS.properties || APPLY === OPTIONS.always; + const APPLY_NEVER = APPLY === OPTIONS.never; + const APPLY_CONSISTENT = APPLY === OPTIONS.consistent; + const APPLY_CONSISTENT_AS_NEEDED = APPLY === OPTIONS.consistentAsNeeded; + + const PARAMS = context.options[1] || {}; + const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors; + const METHODS_IGNORE_PATTERN = PARAMS.methodsIgnorePattern + ? new RegExp(PARAMS.methodsIgnorePattern, "u") + : null; + const AVOID_QUOTES = PARAMS.avoidQuotes; + const AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows; + const sourceCode = context.sourceCode; + + /** + * Ensures that an object's properties are consistently shorthand, or not shorthand at all. + * @param {ASTNode} node Property AST node + * @param {boolean} checkRedundancy Whether to check longform redundancy + * @returns {void} + */ + function checkConsistency(node, checkRedundancy) { + // We are excluding getters/setters and spread properties as they are considered neither longform nor shorthand. + const properties = node.properties.filter(canHaveShorthand); + + // Do we still have properties left after filtering the getters and setters? + if (properties.length > 0) { + const shorthandProperties = properties.filter(isShorthand); + + /* + * If we do not have an equal number of longform properties as + * shorthand properties, we are using the annotations inconsistently + */ + if (shorthandProperties.length !== properties.length) { + // We have at least 1 shorthand property + if (shorthandProperties.length > 0) { + context.report({ node, messageId: "unexpectedMix" }); + } else if (checkRedundancy) { + /* + * If all properties of the object contain a method or value with a name matching it's key, + * all the keys are redundant. + */ + const canAlwaysUseShorthand = + properties.every(isRedundant); + + if (canAlwaysUseShorthand) { + context.report({ + node, + messageId: "expectedAllPropertiesShorthanded", + }); + } + } + } + } + } + + /** + * Fixes a FunctionExpression node by making it into a shorthand property. + * @param {SourceCodeFixer} fixer The fixer object + * @param {ASTNode} node A `Property` node that has a `FunctionExpression` or `ArrowFunctionExpression` as its value + * @returns {Object} A fix for this node + */ + function makeFunctionShorthand(fixer, node) { + const firstKeyToken = node.computed + ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) + : sourceCode.getFirstToken(node.key); + const lastKeyToken = node.computed + ? sourceCode.getFirstTokenBetween( + node.key, + node.value, + astUtils.isClosingBracketToken, + ) + : sourceCode.getLastToken(node.key); + const keyText = sourceCode.text.slice( + firstKeyToken.range[0], + lastKeyToken.range[1], + ); + let keyPrefix = ""; + + // key: /* */ () => {} + if (sourceCode.commentsExistBetween(lastKeyToken, node.value)) { + return null; + } + + if (node.value.async) { + keyPrefix += "async "; + } + if (node.value.generator) { + keyPrefix += "*"; + } + + const fixRange = [firstKeyToken.range[0], node.range[1]]; + const methodPrefix = keyPrefix + keyText; + + if (node.value.type === "FunctionExpression") { + const functionToken = sourceCode + .getTokens(node.value) + .find( + token => + token.type === "Keyword" && + token.value === "function", + ); + const tokenBeforeParams = node.value.generator + ? sourceCode.getTokenAfter(functionToken) + : functionToken; + + return fixer.replaceTextRange( + fixRange, + methodPrefix + + sourceCode.text.slice( + tokenBeforeParams.range[1], + node.value.range[1], + ), + ); + } + + const arrowToken = sourceCode.getTokenBefore( + node.value.body, + astUtils.isArrowToken, + ); + const fnBody = sourceCode.text.slice( + arrowToken.range[1], + node.value.range[1], + ); + + // First token should not be `async` + const firstValueToken = sourceCode.getFirstToken(node.value, { + skip: node.value.async ? 1 : 0, + }); + + const sliceStart = firstValueToken.range[0]; + const sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1]; + const shouldAddParens = + node.value.params.length === 1 && + node.value.params[0].range[0] === sliceStart; + + const oldParamText = sourceCode.text.slice(sliceStart, sliceEnd); + const newParamText = shouldAddParens + ? `(${oldParamText})` + : oldParamText; + + return fixer.replaceTextRange( + fixRange, + methodPrefix + newParamText + fnBody, + ); + } + + /** + * Fixes a FunctionExpression node by making it into a longform property. + * @param {SourceCodeFixer} fixer The fixer object + * @param {ASTNode} node A `Property` node that has a `FunctionExpression` as its value + * @returns {Object} A fix for this node + */ + function makeFunctionLongform(fixer, node) { + const firstKeyToken = node.computed + ? sourceCode.getTokens(node).find(token => token.value === "[") + : sourceCode.getFirstToken(node.key); + const lastKeyToken = node.computed + ? sourceCode + .getTokensBetween(node.key, node.value) + .find(token => token.value === "]") + : sourceCode.getLastToken(node.key); + const keyText = sourceCode.text.slice( + firstKeyToken.range[0], + lastKeyToken.range[1], + ); + let functionHeader = "function"; + + if (node.value.async) { + functionHeader = `async ${functionHeader}`; + } + if (node.value.generator) { + functionHeader = `${functionHeader}*`; + } + + return fixer.replaceTextRange( + [node.range[0], lastKeyToken.range[1]], + `${keyText}: ${functionHeader}`, + ); + } + + /* + * To determine whether a given arrow function has a lexical identifier (`this`, `arguments`, `super`, or `new.target`), + * create a stack of functions that define these identifiers (i.e. all functions except arrow functions) as the AST is + * traversed. Whenever a new function is encountered, create a new entry on the stack (corresponding to a different lexical + * scope of `this`), and whenever a function is exited, pop that entry off the stack. When an arrow function is entered, + * keep a reference to it on the current stack entry, and remove that reference when the arrow function is exited. + * When a lexical identifier is encountered, mark all the arrow functions on the current stack entry by adding them + * to an `arrowsWithLexicalIdentifiers` set. Any arrow function in that set will not be reported by this rule, + * because converting it into a method would change the value of one of the lexical identifiers. + */ + const lexicalScopeStack = []; + const arrowsWithLexicalIdentifiers = new WeakSet(); + const argumentsIdentifiers = new WeakSet(); + + /** + * Enters a function. This creates a new lexical identifier scope, so a new Set of arrow functions is pushed onto the stack. + * Also, this marks all `arguments` identifiers so that they can be detected later. + * @param {ASTNode} node The node representing the function. + * @returns {void} + */ + function enterFunction(node) { + lexicalScopeStack.unshift(new Set()); + sourceCode + .getScope(node) + .variables.filter(variable => variable.name === "arguments") + .forEach(variable => { + variable.references + .map(ref => ref.identifier) + .forEach(identifier => + argumentsIdentifiers.add(identifier), + ); + }); + } + + /** + * Exits a function. This pops the current set of arrow functions off the lexical scope stack. + * @returns {void} + */ + function exitFunction() { + lexicalScopeStack.shift(); + } + + /** + * Marks the current function as having a lexical keyword. This implies that all arrow functions + * in the current lexical scope contain a reference to this lexical keyword. + * @returns {void} + */ + function reportLexicalIdentifier() { + lexicalScopeStack[0].forEach(arrowFunction => + arrowsWithLexicalIdentifiers.add(arrowFunction), + ); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: enterFunction, + FunctionDeclaration: enterFunction, + FunctionExpression: enterFunction, + "Program:exit": exitFunction, + "FunctionDeclaration:exit": exitFunction, + "FunctionExpression:exit": exitFunction, + + ArrowFunctionExpression(node) { + lexicalScopeStack[0].add(node); + }, + "ArrowFunctionExpression:exit"(node) { + lexicalScopeStack[0].delete(node); + }, + + ThisExpression: reportLexicalIdentifier, + Super: reportLexicalIdentifier, + MetaProperty(node) { + if ( + node.meta.name === "new" && + node.property.name === "target" + ) { + reportLexicalIdentifier(); + } + }, + Identifier(node) { + if (argumentsIdentifiers.has(node)) { + reportLexicalIdentifier(); + } + }, + + ObjectExpression(node) { + if (APPLY_CONSISTENT) { + checkConsistency(node, false); + } else if (APPLY_CONSISTENT_AS_NEEDED) { + checkConsistency(node, true); + } + }, + + "Property:exit"(node) { + const isConciseProperty = node.method || node.shorthand; + + // Ignore destructuring assignment + if (node.parent.type === "ObjectPattern") { + return; + } + + // getters and setters are ignored + if (node.kind === "get" || node.kind === "set") { + return; + } + + if (isProtoKey(node)) { + return; + } + + // only computed methods can fail the following checks + if ( + node.computed && + node.value.type !== "FunctionExpression" && + node.value.type !== "ArrowFunctionExpression" + ) { + return; + } + + //-------------------------------------------------------------- + // Checks for property/method shorthand. + if (isConciseProperty) { + if ( + node.method && + (APPLY_NEVER || + (AVOID_QUOTES && isStringLiteral(node.key))) + ) { + const messageId = APPLY_NEVER + ? "expectedMethodLongform" + : "expectedLiteralMethodLongform"; + + // { x() {} } should be written as { x: function() {} } + context.report({ + node, + messageId, + fix: fixer => makeFunctionLongform(fixer, node), + }); + } else if (APPLY_NEVER) { + // { x } should be written as { x: x } + context.report({ + node, + messageId: "expectedPropertyLongform", + fix: fixer => + fixer.insertTextAfter( + node.key, + `: ${node.key.name}`, + ), + }); + } + } else if ( + APPLY_TO_METHODS && + !node.value.id && + (node.value.type === "FunctionExpression" || + node.value.type === "ArrowFunctionExpression") + ) { + const propertyName = astUtils.getStaticPropertyName(node); + if ( + IGNORE_CONSTRUCTORS && + propertyName !== null && + isConstructor(propertyName) + ) { + return; + } + + if (METHODS_IGNORE_PATTERN) { + if ( + propertyName !== null && + METHODS_IGNORE_PATTERN.test(propertyName) + ) { + return; + } + } + + if (AVOID_QUOTES && isStringLiteral(node.key)) { + return; + } + + // {[x]: function(){}} should be written as {[x]() {}} + if ( + node.value.type === "FunctionExpression" || + (node.value.type === "ArrowFunctionExpression" && + node.value.body.type === "BlockStatement" && + AVOID_EXPLICIT_RETURN_ARROWS && + !arrowsWithLexicalIdentifiers.has(node.value)) + ) { + context.report({ + node, + messageId: "expectedMethodShorthand", + fix: fixer => makeFunctionShorthand(fixer, node), + }); + } + } else if ( + node.value.type === "Identifier" && + node.key.name === node.value.name && + APPLY_TO_PROPS + ) { + // Skip if there are JSDoc comments inside the property (e.g., JSDoc type annotations) + const comments = sourceCode.getCommentsInside(node); + if ( + comments.some( + comment => + comment.type === "Block" && + JSDOC_COMMENT_REGEX.test(comment.value) && + comment.value.includes("@type"), + ) + ) { + return; + } + + // {x: x} should be written as {x} + context.report({ + node, + messageId: "expectedPropertyShorthand", + fix(fixer) { + // x: /* */ x + // x: (/* */ x) + if (sourceCode.getCommentsInside(node).length > 0) { + return null; + } + + return fixer.replaceText(node, node.value.name); + }, + }); + } else if ( + node.value.type === "Identifier" && + node.key.type === "Literal" && + node.key.value === node.value.name && + APPLY_TO_PROPS + ) { + if (AVOID_QUOTES) { + return; + } + + const comments = sourceCode.getCommentsInside(node); + if ( + comments.some( + comment => + comment.type === "Block" && + comment.value.startsWith("*") && + comment.value.includes("@type"), + ) + ) { + return; + } + + // {"x": x} should be written as {x} + context.report({ + node, + messageId: "expectedPropertyShorthand", + fix(fixer) { + // "x": /* */ x + // "x": (/* */ x) + if (sourceCode.getCommentsInside(node).length > 0) { + return null; + } + + return fixer.replaceText(node, node.value.name); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var-declaration-per-line.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var-declaration-per-line.js new file mode 100644 index 00000000..3671e272 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var-declaration-per-line.js @@ -0,0 +1,117 @@ +/** + * @fileoverview Rule to check multiple var declarations per line + * @author Alberto Rodríguez + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "one-var-declaration-per-line", + url: "https://eslint.style/rules/one-var-declaration-per-line", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: + "Require or disallow newlines around variable declarations", + recommended: false, + url: "https://eslint.org/docs/latest/rules/one-var-declaration-per-line", + }, + + schema: [ + { + enum: ["always", "initializations"], + }, + ], + + fixable: "whitespace", + + messages: { + expectVarOnNewline: + "Expected variable declaration to be on a new line.", + }, + }, + + create(context) { + const always = context.options[0] === "always"; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Determine if provided keyword is a variant of for specifiers + * @private + * @param {string} keyword keyword to test + * @returns {boolean} True if `keyword` is a variant of for specifier + */ + function isForTypeSpecifier(keyword) { + return ( + keyword === "ForStatement" || + keyword === "ForInStatement" || + keyword === "ForOfStatement" + ); + } + + /** + * Checks newlines around variable declarations. + * @private + * @param {ASTNode} node `VariableDeclaration` node to test + * @returns {void} + */ + function checkForNewLine(node) { + if (isForTypeSpecifier(node.parent.type)) { + return; + } + + const declarations = node.declarations; + let prev; + + declarations.forEach(current => { + if (prev && prev.loc.end.line === current.loc.start.line) { + if (always || prev.init || current.init) { + context.report({ + node, + messageId: "expectVarOnNewline", + loc: current.loc, + fix: fixer => fixer.insertTextBefore(current, "\n"), + }); + } + } + prev = current; + }); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + VariableDeclaration: checkForNewLine, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var.js new file mode 100644 index 00000000..4241afa7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/one-var.js @@ -0,0 +1,719 @@ +/** + * @fileoverview A rule to control the use of single variable declarations. + * @author Ian Christian Myers + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the given node is in a statement list. + * @param {ASTNode} node node to check + * @returns {boolean} `true` if the given node is in a statement list + */ +function isInStatementList(node) { + return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce variables to be declared either together or separately in functions", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/one-var", + }, + + fixable: "code", + + schema: [ + { + oneOf: [ + { + enum: ["always", "never", "consecutive"], + }, + { + type: "object", + properties: { + separateRequires: { + type: "boolean", + }, + var: { + enum: ["always", "never", "consecutive"], + }, + let: { + enum: ["always", "never", "consecutive"], + }, + const: { + enum: ["always", "never", "consecutive"], + }, + using: { + enum: ["always", "never", "consecutive"], + }, + awaitUsing: { + enum: ["always", "never", "consecutive"], + }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + initialized: { + enum: ["always", "never", "consecutive"], + }, + uninitialized: { + enum: ["always", "never", "consecutive"], + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + defaultOptions: ["always"], + + messages: { + combineUninitialized: + "Combine this with the previous '{{type}}' statement with uninitialized variables.", + combineInitialized: + "Combine this with the previous '{{type}}' statement with initialized variables.", + splitUninitialized: + "Split uninitialized '{{type}}' declarations into multiple statements.", + splitInitialized: + "Split initialized '{{type}}' declarations into multiple statements.", + splitRequires: + "Split requires to be separated into a single block.", + combine: "Combine this with the previous '{{type}}' statement.", + split: "Split '{{type}}' declarations into multiple statements.", + }, + }, + + create(context) { + const MODE_ALWAYS = "always"; + const MODE_NEVER = "never"; + const MODE_CONSECUTIVE = "consecutive"; + const mode = context.options[0]; + + const options = {}; + + if (typeof mode === "string") { + // simple options configuration with just a string + options.var = { uninitialized: mode, initialized: mode }; + options.let = { uninitialized: mode, initialized: mode }; + options.const = { uninitialized: mode, initialized: mode }; + options.using = { uninitialized: mode, initialized: mode }; + options.awaitUsing = { uninitialized: mode, initialized: mode }; + } else if (typeof mode === "object") { + // options configuration is an object + options.separateRequires = !!mode.separateRequires; + options.var = { uninitialized: mode.var, initialized: mode.var }; + options.let = { uninitialized: mode.let, initialized: mode.let }; + options.const = { + uninitialized: mode.const, + initialized: mode.const, + }; + options.using = { + uninitialized: mode.using, + initialized: mode.using, + }; + options.awaitUsing = { + uninitialized: mode.awaitUsing, + initialized: mode.awaitUsing, + }; + if (Object.hasOwn(mode, "uninitialized")) { + options.var.uninitialized = mode.uninitialized; + options.let.uninitialized = mode.uninitialized; + options.const.uninitialized = mode.uninitialized; + options.using.uninitialized = mode.uninitialized; + options.awaitUsing.uninitialized = mode.uninitialized; + } + if (Object.hasOwn(mode, "initialized")) { + options.var.initialized = mode.initialized; + options.let.initialized = mode.initialized; + options.const.initialized = mode.initialized; + options.using.initialized = mode.initialized; + options.awaitUsing.initialized = mode.initialized; + } + } + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + const functionStack = []; + const blockStack = []; + + /** + * Increments the blockStack counter. + * @returns {void} + * @private + */ + function startBlock() { + blockStack.push({ + let: { initialized: false, uninitialized: false }, + const: { initialized: false, uninitialized: false }, + using: { initialized: false, uninitialized: false }, + awaitUsing: { initialized: false, uninitialized: false }, + }); + } + + /** + * Increments the functionStack counter. + * @returns {void} + * @private + */ + function startFunction() { + functionStack.push({ initialized: false, uninitialized: false }); + startBlock(); + } + + /** + * Decrements the blockStack counter. + * @returns {void} + * @private + */ + function endBlock() { + blockStack.pop(); + } + + /** + * Decrements the functionStack counter. + * @returns {void} + * @private + */ + function endFunction() { + functionStack.pop(); + endBlock(); + } + + /** + * Check if a variable declaration is a require. + * @param {ASTNode} decl variable declaration Node + * @returns {bool} if decl is a require, return true; else return false. + * @private + */ + function isRequire(decl) { + return ( + decl.init && + decl.init.type === "CallExpression" && + decl.init.callee.name === "require" + ); + } + + /** + * Records whether initialized/uninitialized/required variables are defined in current scope. + * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing" + * @param {ASTNode[]} declarations List of declarations + * @param {Object} currentScope The scope being investigated + * @returns {void} + * @private + */ + function recordTypes(statementType, declarations, currentScope) { + for (let i = 0; i < declarations.length; i++) { + if (declarations[i].init === null) { + if ( + options[statementType] && + options[statementType].uninitialized === MODE_ALWAYS + ) { + currentScope.uninitialized = true; + } + } else { + if ( + options[statementType] && + options[statementType].initialized === MODE_ALWAYS + ) { + if ( + options.separateRequires && + isRequire(declarations[i]) + ) { + currentScope.required = true; + } else { + currentScope.initialized = true; + } + } + } + } + } + + /** + * Determines the current scope (function or block) + * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing" + * @returns {Object} The scope associated with statementType + */ + function getCurrentScope(statementType) { + let currentScope; + + if (statementType === "var") { + currentScope = functionStack.at(-1); + } else if (statementType === "let") { + currentScope = blockStack.at(-1).let; + } else if (statementType === "const") { + currentScope = blockStack.at(-1).const; + } else if (statementType === "using") { + currentScope = blockStack.at(-1).using; + } else if (statementType === "awaitUsing") { + currentScope = blockStack.at(-1).awaitUsing; + } + return currentScope; + } + + /** + * Counts the number of initialized and uninitialized declarations in a list of declarations + * @param {ASTNode[]} declarations List of declarations + * @returns {Object} Counts of 'uninitialized' and 'initialized' declarations + * @private + */ + function countDeclarations(declarations) { + const counts = { uninitialized: 0, initialized: 0 }; + + for (let i = 0; i < declarations.length; i++) { + if (declarations[i].init === null) { + counts.uninitialized++; + } else { + counts.initialized++; + } + } + return counts; + } + + /** + * Determines if there is more than one var statement in the current scope. + * @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing" + * @param {ASTNode[]} declarations List of declarations + * @returns {boolean} Returns true if it is the first var declaration, false if not. + * @private + */ + function hasOnlyOneStatement(statementType, declarations) { + const declarationCounts = countDeclarations(declarations); + const currentOptions = options[statementType] || {}; + const currentScope = getCurrentScope(statementType); + const hasRequires = declarations.some(isRequire); + + if ( + currentOptions.uninitialized === MODE_ALWAYS && + currentOptions.initialized === MODE_ALWAYS + ) { + if (currentScope.uninitialized || currentScope.initialized) { + if (!hasRequires) { + return false; + } + } + } + + if (declarationCounts.uninitialized > 0) { + if ( + currentOptions.uninitialized === MODE_ALWAYS && + currentScope.uninitialized + ) { + return false; + } + } + if (declarationCounts.initialized > 0) { + if ( + currentOptions.initialized === MODE_ALWAYS && + currentScope.initialized + ) { + if (!hasRequires) { + return false; + } + } + } + if (currentScope.required && hasRequires) { + return false; + } + recordTypes(statementType, declarations, currentScope); + return true; + } + + /** + * Fixer to join VariableDeclaration's into a single declaration + * @param {VariableDeclarator[]} declarations The `VariableDeclaration` to join + * @returns {Function} The fixer function + */ + function joinDeclarations(declarations) { + const declaration = declarations[0]; + const body = Array.isArray(declaration.parent.parent.body) + ? declaration.parent.parent.body + : []; + const currentIndex = body.findIndex( + node => node.range[0] === declaration.parent.range[0], + ); + const previousNode = body[currentIndex - 1]; + + return function* joinDeclarationsFixer(fixer) { + const type = sourceCode.getFirstToken(declaration.parent); + const beforeType = sourceCode.getTokenBefore(type); + + if ( + previousNode && + previousNode.kind === declaration.parent.kind + ) { + if (beforeType.value === ";") { + yield fixer.replaceText(beforeType, ","); + } else { + yield fixer.insertTextAfter(beforeType, ","); + } + + if (declaration.parent.kind === "await using") { + const usingToken = sourceCode.getTokenAfter(type); + yield fixer.remove(usingToken); + } + + yield fixer.replaceText(type, ""); + } + }; + } + + /** + * Fixer to split a VariableDeclaration into individual declarations + * @param {VariableDeclaration} declaration The `VariableDeclaration` to split + * @returns {Function|null} The fixer function + */ + function splitDeclarations(declaration) { + const { parent } = declaration; + + // don't autofix code such as: if (foo) var x, y; + if ( + !isInStatementList( + parent.type === "ExportNamedDeclaration" + ? parent + : declaration, + ) + ) { + return null; + } + + return fixer => + declaration.declarations + .map(declarator => { + const tokenAfterDeclarator = + sourceCode.getTokenAfter(declarator); + + if (tokenAfterDeclarator === null) { + return null; + } + + const afterComma = sourceCode.getTokenAfter( + tokenAfterDeclarator, + { includeComments: true }, + ); + + if (tokenAfterDeclarator.value !== ",") { + return null; + } + + const exportPlacement = + declaration.parent.type === "ExportNamedDeclaration" + ? "export " + : ""; + + /* + * `var x,y` + * tokenAfterDeclarator ^^ afterComma + */ + if ( + afterComma.range[0] === + tokenAfterDeclarator.range[1] + ) { + return fixer.replaceText( + tokenAfterDeclarator, + `; ${exportPlacement}${declaration.kind} `, + ); + } + + /* + * `var x, + * tokenAfterDeclarator ^ + * y` + * ^ afterComma + */ + if ( + afterComma.loc.start.line > + tokenAfterDeclarator.loc.end.line || + afterComma.type === "Line" || + afterComma.type === "Block" + ) { + let lastComment = afterComma; + + while ( + lastComment.type === "Line" || + lastComment.type === "Block" + ) { + lastComment = sourceCode.getTokenAfter( + lastComment, + { includeComments: true }, + ); + } + + return fixer.replaceTextRange( + [ + tokenAfterDeclarator.range[0], + lastComment.range[0], + ], + `;${sourceCode.text.slice( + tokenAfterDeclarator.range[1], + lastComment.range[0], + )}${exportPlacement}${declaration.kind} `, + ); + } + + return fixer.replaceText( + tokenAfterDeclarator, + `; ${exportPlacement}${declaration.kind}`, + ); + }) + .filter(x => x); + } + + /** + * Checks a given VariableDeclaration node for errors. + * @param {ASTNode} node The VariableDeclaration node to check + * @returns {void} + * @private + */ + function checkVariableDeclaration(node) { + const parent = node.parent; + const type = node.kind; + const key = type === "await using" ? "awaitUsing" : type; + + if (!options[key]) { + return; + } + + const declarations = node.declarations; + const declarationCounts = countDeclarations(declarations); + const mixedRequires = + declarations.some(isRequire) && !declarations.every(isRequire); + + if (options[key].initialized === MODE_ALWAYS) { + if (options.separateRequires && mixedRequires) { + context.report({ + node, + messageId: "splitRequires", + }); + } + } + + // consecutive + const nodeIndex = + (parent.body && + parent.body.length > 0 && + parent.body.indexOf(node)) || + 0; + + if (nodeIndex > 0) { + const previousNode = parent.body[nodeIndex - 1]; + const isPreviousNodeDeclaration = + previousNode.type === "VariableDeclaration"; + const declarationsWithPrevious = declarations.concat( + previousNode.declarations || [], + ); + + if ( + isPreviousNodeDeclaration && + previousNode.kind === type && + !( + declarationsWithPrevious.some(isRequire) && + !declarationsWithPrevious.every(isRequire) + ) + ) { + const previousDeclCounts = countDeclarations( + previousNode.declarations, + ); + + if ( + options[key].initialized === MODE_CONSECUTIVE && + options[key].uninitialized === MODE_CONSECUTIVE + ) { + context.report({ + node, + messageId: "combine", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } else if ( + options[key].initialized === MODE_CONSECUTIVE && + declarationCounts.initialized > 0 && + previousDeclCounts.initialized > 0 + ) { + context.report({ + node, + messageId: "combineInitialized", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } else if ( + options[key].uninitialized === MODE_CONSECUTIVE && + declarationCounts.uninitialized > 0 && + previousDeclCounts.uninitialized > 0 + ) { + context.report({ + node, + messageId: "combineUninitialized", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } + } + } + + // always + if (!hasOnlyOneStatement(key, declarations)) { + if ( + options[key].initialized === MODE_ALWAYS && + options[key].uninitialized === MODE_ALWAYS + ) { + context.report({ + node, + messageId: "combine", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } else { + if ( + options[key].initialized === MODE_ALWAYS && + declarationCounts.initialized > 0 + ) { + context.report({ + node, + messageId: "combineInitialized", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } + if ( + options[key].uninitialized === MODE_ALWAYS && + declarationCounts.uninitialized > 0 + ) { + if ( + node.parent.left === node && + (node.parent.type === "ForInStatement" || + node.parent.type === "ForOfStatement") + ) { + return; + } + context.report({ + node, + messageId: "combineUninitialized", + data: { + type, + }, + fix: joinDeclarations(declarations), + }); + } + } + } + + // never + if (parent.type !== "ForStatement" || parent.init !== node) { + const totalDeclarations = + declarationCounts.uninitialized + + declarationCounts.initialized; + + if (totalDeclarations > 1) { + if ( + options[key].initialized === MODE_NEVER && + options[key].uninitialized === MODE_NEVER + ) { + // both initialized and uninitialized + context.report({ + node, + messageId: "split", + data: { + type, + }, + fix: splitDeclarations(node), + }); + } else if ( + options[key].initialized === MODE_NEVER && + declarationCounts.initialized > 0 + ) { + // initialized + context.report({ + node, + messageId: "splitInitialized", + data: { + type, + }, + fix: splitDeclarations(node), + }); + } else if ( + options[key].uninitialized === MODE_NEVER && + declarationCounts.uninitialized > 0 + ) { + // uninitialized + context.report({ + node, + messageId: "splitUninitialized", + data: { + type, + }, + fix: splitDeclarations(node), + }); + } + } + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + Program: startFunction, + FunctionDeclaration: startFunction, + FunctionExpression: startFunction, + ArrowFunctionExpression: startFunction, + StaticBlock: startFunction, // StaticBlock creates a new scope for `var` variables + + BlockStatement: startBlock, + ForStatement: startBlock, + ForInStatement: startBlock, + ForOfStatement: startBlock, + SwitchStatement: startBlock, + VariableDeclaration: checkVariableDeclaration, + "ForStatement:exit": endBlock, + "ForOfStatement:exit": endBlock, + "ForInStatement:exit": endBlock, + "SwitchStatement:exit": endBlock, + "BlockStatement:exit": endBlock, + + "Program:exit": endFunction, + "FunctionDeclaration:exit": endFunction, + "FunctionExpression:exit": endFunction, + "ArrowFunctionExpression:exit": endFunction, + "StaticBlock:exit": endFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-assignment.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-assignment.js new file mode 100644 index 00000000..50ae9996 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-assignment.js @@ -0,0 +1,270 @@ +/** + * @fileoverview Rule to replace assignment expressions with operator assignment + * @author Brandon Mills + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether an operator is commutative and has an operator assignment + * shorthand form. + * @param {string} operator Operator to check. + * @returns {boolean} True if the operator is commutative and has a + * shorthand form. + */ +function isCommutativeOperatorWithShorthand(operator) { + return ["*", "&", "^", "|"].includes(operator); +} + +/** + * Checks whether an operator is not commutative and has an operator assignment + * shorthand form. + * @param {string} operator Operator to check. + * @returns {boolean} True if the operator is not commutative and has + * a shorthand form. + */ +function isNonCommutativeOperatorWithShorthand(operator) { + return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].includes(operator); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** + * Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and) + * toString calls regardless of whether assignment shorthand is used) + * @param {ASTNode} node The node on the left side of the expression + * @returns {boolean} `true` if the node can be fixed + */ +function canBeFixed(node) { + return ( + node.type === "Identifier" || + (node.type === "MemberExpression" && + (node.object.type === "Identifier" || + node.object.type === "ThisExpression") && + (!node.computed || node.property.type === "Literal")) + ); +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: ["always"], + + docs: { + description: + "Require or disallow assignment operator shorthand where possible", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/operator-assignment", + }, + + schema: [ + { + enum: ["always", "never"], + }, + ], + + fixable: "code", + messages: { + replaced: + "Assignment (=) can be replaced with operator assignment ({{operator}}).", + unexpected: + "Unexpected operator assignment ({{operator}}) shorthand.", + }, + }, + + create(context) { + const never = context.options[0] === "never"; + const sourceCode = context.sourceCode; + + /** + * Returns the operator token of an AssignmentExpression or BinaryExpression + * @param {ASTNode} node An AssignmentExpression or BinaryExpression node + * @returns {Token} The operator token in the node + */ + function getOperatorToken(node) { + return sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + } + + /** + * Ensures that an assignment uses the shorthand form where possible. + * @param {ASTNode} node An AssignmentExpression node. + * @returns {void} + */ + function verify(node) { + if ( + node.operator !== "=" || + node.right.type !== "BinaryExpression" + ) { + return; + } + + const left = node.left; + const expr = node.right; + const operator = expr.operator; + + if ( + isCommutativeOperatorWithShorthand(operator) || + isNonCommutativeOperatorWithShorthand(operator) + ) { + const replacementOperator = `${operator}=`; + + if (astUtils.isSameReference(left, expr.left, true)) { + context.report({ + node, + messageId: "replaced", + data: { operator: replacementOperator }, + fix(fixer) { + if (canBeFixed(left) && canBeFixed(expr.left)) { + const equalsToken = getOperatorToken(node); + const operatorToken = getOperatorToken(expr); + const leftText = sourceCode + .getText() + .slice(node.range[0], equalsToken.range[0]); + const rightText = sourceCode + .getText() + .slice( + operatorToken.range[1], + node.right.range[1], + ); + + // Check for comments that would be removed. + if ( + sourceCode.commentsExistBetween( + equalsToken, + operatorToken, + ) + ) { + return null; + } + + return fixer.replaceText( + node, + `${leftText}${replacementOperator}${rightText}`, + ); + } + return null; + }, + }); + } else if ( + astUtils.isSameReference(left, expr.right, true) && + isCommutativeOperatorWithShorthand(operator) + ) { + /* + * This case can't be fixed safely. + * If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would + * change the execution order of the valueOf() functions. + */ + context.report({ + node, + messageId: "replaced", + data: { operator: replacementOperator }, + }); + } + } + } + + /** + * Warns if an assignment expression uses operator assignment shorthand. + * @param {ASTNode} node An AssignmentExpression node. + * @returns {void} + */ + function prohibit(node) { + if ( + node.operator !== "=" && + !astUtils.isLogicalAssignmentOperator(node.operator) + ) { + context.report({ + node, + messageId: "unexpected", + data: { operator: node.operator }, + fix(fixer) { + if (canBeFixed(node.left)) { + const firstToken = sourceCode.getFirstToken(node); + const operatorToken = getOperatorToken(node); + const leftText = sourceCode + .getText() + .slice(node.range[0], operatorToken.range[0]); + const newOperator = node.operator.slice(0, -1); + let rightText; + + // Check for comments that would be duplicated. + if ( + sourceCode.commentsExistBetween( + firstToken, + operatorToken, + ) + ) { + return null; + } + + // If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side. + if ( + astUtils.getPrecedence(node.right) <= + astUtils.getPrecedence({ + type: "BinaryExpression", + operator: newOperator, + }) && + !astUtils.isParenthesised( + sourceCode, + node.right, + ) + ) { + rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`; + } else { + const tokenAfterOperator = + sourceCode.getTokenAfter(operatorToken, { + includeComments: true, + }); + let rightTextPrefix = ""; + + if ( + operatorToken.range[1] === + tokenAfterOperator.range[0] && + !astUtils.canTokensBeAdjacent( + { + type: "Punctuator", + value: newOperator, + }, + tokenAfterOperator, + ) + ) { + rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar + } + + rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`; + } + + return fixer.replaceText( + node, + `${leftText}= ${leftText}${newOperator}${rightText}`, + ); + } + return null; + }, + }); + } + } + + return { + AssignmentExpression: !never ? verify : prohibit, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-linebreak.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-linebreak.js new file mode 100644 index 00000000..f0b7d46f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/operator-linebreak.js @@ -0,0 +1,315 @@ +/** + * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before + * @author Benoît Zugmeyer + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "operator-linebreak", + url: "https://eslint.style/rules/operator-linebreak", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent linebreak style for operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/operator-linebreak", + }, + + schema: [ + { + enum: ["after", "before", "none", null], + }, + { + type: "object", + properties: { + overrides: { + type: "object", + additionalProperties: { + enum: ["after", "before", "none", "ignore"], + }, + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + operatorAtBeginning: + "'{{operator}}' should be placed at the beginning of the line.", + operatorAtEnd: + "'{{operator}}' should be placed at the end of the line.", + badLinebreak: "Bad line breaking before and after '{{operator}}'.", + noLinebreak: + "There should be no line break before or after '{{operator}}'.", + }, + }, + + create(context) { + const usedDefaultGlobal = !context.options[0]; + const globalStyle = context.options[0] || "after"; + const options = context.options[1] || {}; + const styleOverrides = options.overrides + ? Object.assign({}, options.overrides) + : {}; + + if (usedDefaultGlobal && !styleOverrides["?"]) { + styleOverrides["?"] = "before"; + } + + if (usedDefaultGlobal && !styleOverrides[":"]) { + styleOverrides[":"] = "before"; + } + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Gets a fixer function to fix rule issues + * @param {Token} operatorToken The operator token of an expression + * @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none' + * @returns {Function} A fixer function + */ + function getFixer(operatorToken, desiredStyle) { + return fixer => { + const tokenBefore = sourceCode.getTokenBefore(operatorToken); + const tokenAfter = sourceCode.getTokenAfter(operatorToken); + const textBefore = sourceCode.text.slice( + tokenBefore.range[1], + operatorToken.range[0], + ); + const textAfter = sourceCode.text.slice( + operatorToken.range[1], + tokenAfter.range[0], + ); + const hasLinebreakBefore = !astUtils.isTokenOnSameLine( + tokenBefore, + operatorToken, + ); + const hasLinebreakAfter = !astUtils.isTokenOnSameLine( + operatorToken, + tokenAfter, + ); + let newTextBefore, newTextAfter; + + if ( + hasLinebreakBefore !== hasLinebreakAfter && + desiredStyle !== "none" + ) { + // If there is a comment before and after the operator, don't do a fix. + if ( + sourceCode.getTokenBefore(operatorToken, { + includeComments: true, + }) !== tokenBefore && + sourceCode.getTokenAfter(operatorToken, { + includeComments: true, + }) !== tokenAfter + ) { + return null; + } + + /* + * If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator. + * foo && + * bar + * would get fixed to + * foo + * && bar + */ + newTextBefore = textAfter; + newTextAfter = textBefore; + } else { + const LINEBREAK_REGEX = + astUtils.createGlobalLinebreakMatcher(); + + // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings. + newTextBefore = + desiredStyle === "before" || textBefore.trim() + ? textBefore + : textBefore.replace(LINEBREAK_REGEX, ""); + newTextAfter = + desiredStyle === "after" || textAfter.trim() + ? textAfter + : textAfter.replace(LINEBREAK_REGEX, ""); + + // If there was no change (due to interfering comments), don't output a fix. + if ( + newTextBefore === textBefore && + newTextAfter === textAfter + ) { + return null; + } + } + + if ( + newTextAfter === "" && + tokenAfter.type === "Punctuator" && + "+-".includes(operatorToken.value) && + tokenAfter.value === operatorToken.value + ) { + // To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-. + newTextAfter += " "; + } + + return fixer.replaceTextRange( + [tokenBefore.range[1], tokenAfter.range[0]], + newTextBefore + operatorToken.value + newTextAfter, + ); + }; + } + + /** + * Checks the operator placement + * @param {ASTNode} node The node to check + * @param {ASTNode} rightSide The node that comes after the operator in `node` + * @param {string} operator The operator + * @private + * @returns {void} + */ + function validateNode(node, rightSide, operator) { + /* + * Find the operator token by searching from the right side, because between the left side and the operator + * there could be additional tokens from type annotations. Search specifically for the token which + * value equals the operator, in order to skip possible opening parentheses before the right side node. + */ + const operatorToken = sourceCode.getTokenBefore( + rightSide, + token => token.value === operator, + ); + const leftToken = sourceCode.getTokenBefore(operatorToken); + const rightToken = sourceCode.getTokenAfter(operatorToken); + const operatorStyleOverride = styleOverrides[operator]; + const style = operatorStyleOverride || globalStyle; + const fix = getFixer(operatorToken, style); + + // if single line + if ( + astUtils.isTokenOnSameLine(leftToken, operatorToken) && + astUtils.isTokenOnSameLine(operatorToken, rightToken) + ) { + // do nothing. + } else if ( + operatorStyleOverride !== "ignore" && + !astUtils.isTokenOnSameLine(leftToken, operatorToken) && + !astUtils.isTokenOnSameLine(operatorToken, rightToken) + ) { + // lone operator + context.report({ + node, + loc: operatorToken.loc, + messageId: "badLinebreak", + data: { + operator, + }, + fix, + }); + } else if ( + style === "before" && + astUtils.isTokenOnSameLine(leftToken, operatorToken) + ) { + context.report({ + node, + loc: operatorToken.loc, + messageId: "operatorAtBeginning", + data: { + operator, + }, + fix, + }); + } else if ( + style === "after" && + astUtils.isTokenOnSameLine(operatorToken, rightToken) + ) { + context.report({ + node, + loc: operatorToken.loc, + messageId: "operatorAtEnd", + data: { + operator, + }, + fix, + }); + } else if (style === "none") { + context.report({ + node, + loc: operatorToken.loc, + messageId: "noLinebreak", + data: { + operator, + }, + fix, + }); + } + } + + /** + * Validates a binary expression using `validateNode` + * @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated + * @returns {void} + */ + function validateBinaryExpression(node) { + validateNode(node, node.right, node.operator); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + BinaryExpression: validateBinaryExpression, + LogicalExpression: validateBinaryExpression, + AssignmentExpression: validateBinaryExpression, + VariableDeclarator(node) { + if (node.init) { + validateNode(node, node.init, "="); + } + }, + PropertyDefinition(node) { + if (node.value) { + validateNode(node, node.value, "="); + } + }, + ConditionalExpression(node) { + validateNode(node, node.consequent, "?"); + validateNode(node, node.alternate, ":"); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padded-blocks.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padded-blocks.js new file mode 100644 index 00000000..2df44f89 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padded-blocks.js @@ -0,0 +1,366 @@ +/** + * @fileoverview A rule to ensure blank lines within blocks. + * @author Mathias Schreck + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "padded-blocks", + url: "https://eslint.style/rules/padded-blocks", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require or disallow padding within blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/padded-blocks", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + blocks: { + enum: ["always", "never"], + }, + switches: { + enum: ["always", "never"], + }, + classes: { + enum: ["always", "never"], + }, + }, + additionalProperties: false, + minProperties: 1, + }, + ], + }, + { + type: "object", + properties: { + allowSingleLineBlocks: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + alwaysPadBlock: "Block must be padded by blank lines.", + neverPadBlock: "Block must not be padded by blank lines.", + }, + }, + + create(context) { + const options = {}; + const typeOptions = context.options[0] || "always"; + const exceptOptions = context.options[1] || {}; + + if (typeof typeOptions === "string") { + const shouldHavePadding = typeOptions === "always"; + + options.blocks = shouldHavePadding; + options.switches = shouldHavePadding; + options.classes = shouldHavePadding; + } else { + if (Object.hasOwn(typeOptions, "blocks")) { + options.blocks = typeOptions.blocks === "always"; + } + if (Object.hasOwn(typeOptions, "switches")) { + options.switches = typeOptions.switches === "always"; + } + if (Object.hasOwn(typeOptions, "classes")) { + options.classes = typeOptions.classes === "always"; + } + } + + if (Object.hasOwn(exceptOptions, "allowSingleLineBlocks")) { + options.allowSingleLineBlocks = + exceptOptions.allowSingleLineBlocks === true; + } + + const sourceCode = context.sourceCode; + + /** + * Gets the open brace token from a given node. + * @param {ASTNode} node A BlockStatement or SwitchStatement node from which to get the open brace. + * @returns {Token} The token of the open brace. + */ + function getOpenBrace(node) { + if (node.type === "SwitchStatement") { + return sourceCode.getTokenBefore(node.cases[0]); + } + + if (node.type === "StaticBlock") { + return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token + } + + // `BlockStatement` or `ClassBody` + return sourceCode.getFirstToken(node); + } + + /** + * Checks if the given parameter is a comment node + * @param {ASTNode|Token} node An AST node or token + * @returns {boolean} True if node is a comment + */ + function isComment(node) { + return node.type === "Line" || node.type === "Block"; + } + + /** + * Checks if there is padding between two tokens + * @param {Token} first The first token + * @param {Token} second The second token + * @returns {boolean} True if there is at least a line between the tokens + */ + function isPaddingBetweenTokens(first, second) { + return second.loc.start.line - first.loc.end.line >= 2; + } + + /** + * Checks if the given token has a blank line after it. + * @param {Token} token The token to check. + * @returns {boolean} Whether or not the token is followed by a blank line. + */ + function getFirstBlockToken(token) { + let prev, + first = token; + + do { + prev = first; + first = sourceCode.getTokenAfter(first, { + includeComments: true, + }); + } while ( + isComment(first) && + first.loc.start.line === prev.loc.end.line + ); + + return first; + } + + /** + * Checks if the given token is preceded by a blank line. + * @param {Token} token The token to check + * @returns {boolean} Whether or not the token is preceded by a blank line + */ + function getLastBlockToken(token) { + let last = token, + next; + + do { + next = last; + last = sourceCode.getTokenBefore(last, { + includeComments: true, + }); + } while ( + isComment(last) && + last.loc.end.line === next.loc.start.line + ); + + return last; + } + + /** + * Checks if a node should be padded, according to the rule config. + * @param {ASTNode} node The AST node to check. + * @throws {Error} (Unreachable) + * @returns {boolean} True if the node should be padded, false otherwise. + */ + function requirePaddingFor(node) { + switch (node.type) { + case "BlockStatement": + case "StaticBlock": + return options.blocks; + case "SwitchStatement": + return options.switches; + case "ClassBody": + return options.classes; + + /* c8 ignore next */ + default: + throw new Error("unreachable"); + } + } + + /** + * Checks the given BlockStatement node to be padded if the block is not empty. + * @param {ASTNode} node The AST node of a BlockStatement. + * @returns {void} undefined. + */ + function checkPadding(node) { + const openBrace = getOpenBrace(node), + firstBlockToken = getFirstBlockToken(openBrace), + tokenBeforeFirst = sourceCode.getTokenBefore(firstBlockToken, { + includeComments: true, + }), + closeBrace = sourceCode.getLastToken(node), + lastBlockToken = getLastBlockToken(closeBrace), + tokenAfterLast = sourceCode.getTokenAfter(lastBlockToken, { + includeComments: true, + }), + blockHasTopPadding = isPaddingBetweenTokens( + tokenBeforeFirst, + firstBlockToken, + ), + blockHasBottomPadding = isPaddingBetweenTokens( + lastBlockToken, + tokenAfterLast, + ); + + if ( + options.allowSingleLineBlocks && + astUtils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast) + ) { + return; + } + + if (requirePaddingFor(node)) { + if (!blockHasTopPadding) { + context.report({ + node, + loc: { + start: tokenBeforeFirst.loc.start, + end: firstBlockToken.loc.start, + }, + fix(fixer) { + return fixer.insertTextAfter( + tokenBeforeFirst, + "\n", + ); + }, + messageId: "alwaysPadBlock", + }); + } + if (!blockHasBottomPadding) { + context.report({ + node, + loc: { + end: tokenAfterLast.loc.start, + start: lastBlockToken.loc.end, + }, + fix(fixer) { + return fixer.insertTextBefore(tokenAfterLast, "\n"); + }, + messageId: "alwaysPadBlock", + }); + } + } else { + if (blockHasTopPadding) { + context.report({ + node, + loc: { + start: tokenBeforeFirst.loc.start, + end: firstBlockToken.loc.start, + }, + fix(fixer) { + return fixer.replaceTextRange( + [ + tokenBeforeFirst.range[1], + firstBlockToken.range[0] - + firstBlockToken.loc.start.column, + ], + "\n", + ); + }, + messageId: "neverPadBlock", + }); + } + + if (blockHasBottomPadding) { + context.report({ + node, + loc: { + end: tokenAfterLast.loc.start, + start: lastBlockToken.loc.end, + }, + messageId: "neverPadBlock", + fix(fixer) { + return fixer.replaceTextRange( + [ + lastBlockToken.range[1], + tokenAfterLast.range[0] - + tokenAfterLast.loc.start.column, + ], + "\n", + ); + }, + }); + } + } + } + + const rule = {}; + + if (Object.hasOwn(options, "switches")) { + rule.SwitchStatement = function (node) { + if (node.cases.length === 0) { + return; + } + checkPadding(node); + }; + } + + if (Object.hasOwn(options, "blocks")) { + rule.BlockStatement = function (node) { + if (node.body.length === 0) { + return; + } + checkPadding(node); + }; + rule.StaticBlock = rule.BlockStatement; + } + + if (Object.hasOwn(options, "classes")) { + rule.ClassBody = function (node) { + if (node.body.length === 0) { + return; + } + checkPadding(node); + }; + } + + return rule; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padding-line-between-statements.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padding-line-between-statements.js new file mode 100644 index 00000000..4287170f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/padding-line-between-statements.js @@ -0,0 +1,612 @@ +/** + * @fileoverview Rule to require or disallow newlines between statements + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const LT = `[${Array.from(astUtils.LINEBREAKS).join("")}]`; +const PADDING_LINE_SEQUENCE = new RegExp( + String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`, + "u", +); +const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u; +const CJS_IMPORT = /^require\(/u; + +/** + * Creates tester which check if a node starts with specific keyword. + * @param {string} keyword The keyword to test. + * @returns {Object} the created tester. + * @private + */ +function newKeywordTester(keyword) { + return { + test: (node, sourceCode) => + sourceCode.getFirstToken(node).value === keyword, + }; +} + +/** + * Creates tester which check if a node starts with specific keyword and spans a single line. + * @param {string} keyword The keyword to test. + * @returns {Object} the created tester. + * @private + */ +function newSinglelineKeywordTester(keyword) { + return { + test: (node, sourceCode) => + node.loc.start.line === node.loc.end.line && + sourceCode.getFirstToken(node).value === keyword, + }; +} + +/** + * Creates tester which check if a node starts with specific keyword and spans multiple lines. + * @param {string} keyword The keyword to test. + * @returns {Object} the created tester. + * @private + */ +function newMultilineKeywordTester(keyword) { + return { + test: (node, sourceCode) => + node.loc.start.line !== node.loc.end.line && + sourceCode.getFirstToken(node).value === keyword, + }; +} + +/** + * Creates tester which check if a node is specific type. + * @param {string} type The node type to test. + * @returns {Object} the created tester. + * @private + */ +function newNodeTypeTester(type) { + return { + test: node => node.type === type, + }; +} + +/** + * Checks the given node is an expression statement of IIFE. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is an expression statement of IIFE. + * @private + */ +function isIIFEStatement(node) { + if (node.type === "ExpressionStatement") { + let call = astUtils.skipChainExpression(node.expression); + + if (call.type === "UnaryExpression") { + call = astUtils.skipChainExpression(call.argument); + } + return ( + call.type === "CallExpression" && astUtils.isFunction(call.callee) + ); + } + return false; +} + +/** + * Checks whether the given node is a block-like statement. + * This checks the last token of the node is the closing brace of a block. + * @param {SourceCode} sourceCode The source code to get tokens. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a block-like statement. + * @private + */ +function isBlockLikeStatement(sourceCode, node) { + // do-while with a block is a block-like statement. + if ( + node.type === "DoWhileStatement" && + node.body.type === "BlockStatement" + ) { + return true; + } + + /* + * IIFE is a block-like statement specially from + * JSCS#disallowPaddingNewLinesAfterBlocks. + */ + if (isIIFEStatement(node)) { + return true; + } + + // Checks the last token is a closing brace of blocks. + const lastToken = sourceCode.getLastToken( + node, + astUtils.isNotSemicolonToken, + ); + const belongingNode = + lastToken && astUtils.isClosingBraceToken(lastToken) + ? sourceCode.getNodeByRangeIndex(lastToken.range[0]) + : null; + + return ( + Boolean(belongingNode) && + (belongingNode.type === "BlockStatement" || + belongingNode.type === "SwitchStatement") + ); +} + +/** + * Gets the actual last token. + * + * If a semicolon is semicolon-less style's semicolon, this ignores it. + * For example: + * + * foo() + * ;[1, 2, 3].forEach(bar) + * @param {SourceCode} sourceCode The source code to get tokens. + * @param {ASTNode} node The node to get. + * @returns {Token} The actual last token. + * @private + */ +function getActualLastToken(sourceCode, node) { + const semiToken = sourceCode.getLastToken(node); + const prevToken = sourceCode.getTokenBefore(semiToken); + const nextToken = sourceCode.getTokenAfter(semiToken); + const isSemicolonLessStyle = Boolean( + prevToken && + nextToken && + prevToken.range[0] >= node.range[0] && + astUtils.isSemicolonToken(semiToken) && + semiToken.loc.start.line !== prevToken.loc.end.line && + semiToken.loc.end.line === nextToken.loc.start.line, + ); + + return isSemicolonLessStyle ? prevToken : semiToken; +} + +/** + * This returns the concatenation of the first 2 captured strings. + * @param {string} _ Unused. Whole matched string. + * @param {string} trailingSpaces The trailing spaces of the first line. + * @param {string} indentSpaces The indentation spaces of the last line. + * @returns {string} The concatenation of trailingSpaces and indentSpaces. + * @private + */ +function replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) { + return trailingSpaces + indentSpaces; +} + +/** + * Check and report statements for `any` configuration. + * It does nothing. + * @returns {void} + * @private + */ +function verifyForAny() {} + +/** + * Check and report statements for `never` configuration. + * This autofix removes blank lines between the given 2 statements. + * However, if comments exist between 2 blank lines, it does not remove those + * blank lines automatically. + * @param {RuleContext} context The rule context to report. + * @param {ASTNode} _ Unused. The previous node to check. + * @param {ASTNode} nextNode The next node to check. + * @param {Array} paddingLines The array of token pairs that blank + * lines exist between the pair. + * @returns {void} + * @private + */ +function verifyForNever(context, _, nextNode, paddingLines) { + if (paddingLines.length === 0) { + return; + } + + context.report({ + node: nextNode, + messageId: "unexpectedBlankLine", + fix(fixer) { + if (paddingLines.length >= 2) { + return null; + } + + const prevToken = paddingLines[0][0]; + const nextToken = paddingLines[0][1]; + const start = prevToken.range[1]; + const end = nextToken.range[0]; + const text = context.sourceCode.text + .slice(start, end) + .replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines); + + return fixer.replaceTextRange([start, end], text); + }, + }); +} + +/** + * Check and report statements for `always` configuration. + * This autofix inserts a blank line between the given 2 statements. + * If the `prevNode` has trailing comments, it inserts a blank line after the + * trailing comments. + * @param {RuleContext} context The rule context to report. + * @param {ASTNode} prevNode The previous node to check. + * @param {ASTNode} nextNode The next node to check. + * @param {Array} paddingLines The array of token pairs that blank + * lines exist between the pair. + * @returns {void} + * @private + */ +function verifyForAlways(context, prevNode, nextNode, paddingLines) { + if (paddingLines.length > 0) { + return; + } + + context.report({ + node: nextNode, + messageId: "expectedBlankLine", + fix(fixer) { + const sourceCode = context.sourceCode; + let prevToken = getActualLastToken(sourceCode, prevNode); + const nextToken = + sourceCode.getFirstTokenBetween(prevToken, nextNode, { + includeComments: true, + + /** + * Skip the trailing comments of the previous node. + * This inserts a blank line after the last trailing comment. + * + * For example: + * + * foo(); // trailing comment. + * // comment. + * bar(); + * + * Get fixed to: + * + * foo(); // trailing comment. + * + * // comment. + * bar(); + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is not a trailing comment. + * @private + */ + filter(token) { + if (astUtils.isTokenOnSameLine(prevToken, token)) { + prevToken = token; + return false; + } + return true; + }, + }) || nextNode; + const insertText = astUtils.isTokenOnSameLine(prevToken, nextToken) + ? "\n\n" + : "\n"; + + return fixer.insertTextAfter(prevToken, insertText); + }, + }); +} + +/** + * Types of blank lines. + * `any`, `never`, and `always` are defined. + * Those have `verify` method to check and report statements. + * @private + */ +const PaddingTypes = { + any: { verify: verifyForAny }, + never: { verify: verifyForNever }, + always: { verify: verifyForAlways }, +}; + +/** + * Types of statements. + * Those have `test` method to check it matches to the given statement. + * @private + */ +const StatementTypes = { + "*": { test: () => true }, + "block-like": { + test: (node, sourceCode) => isBlockLikeStatement(sourceCode, node), + }, + "cjs-export": { + test: (node, sourceCode) => + node.type === "ExpressionStatement" && + node.expression.type === "AssignmentExpression" && + CJS_EXPORT.test(sourceCode.getText(node.expression.left)), + }, + "cjs-import": { + test: (node, sourceCode) => + node.type === "VariableDeclaration" && + node.declarations.length > 0 && + Boolean(node.declarations[0].init) && + CJS_IMPORT.test(sourceCode.getText(node.declarations[0].init)), + }, + directive: { + test: astUtils.isDirective, + }, + expression: { + test: node => + node.type === "ExpressionStatement" && !astUtils.isDirective(node), + }, + iife: { + test: isIIFEStatement, + }, + "multiline-block-like": { + test: (node, sourceCode) => + node.loc.start.line !== node.loc.end.line && + isBlockLikeStatement(sourceCode, node), + }, + "multiline-expression": { + test: node => + node.loc.start.line !== node.loc.end.line && + node.type === "ExpressionStatement" && + !astUtils.isDirective(node), + }, + + "multiline-const": newMultilineKeywordTester("const"), + "multiline-let": newMultilineKeywordTester("let"), + "multiline-var": newMultilineKeywordTester("var"), + "singleline-const": newSinglelineKeywordTester("const"), + "singleline-let": newSinglelineKeywordTester("let"), + "singleline-var": newSinglelineKeywordTester("var"), + + block: newNodeTypeTester("BlockStatement"), + empty: newNodeTypeTester("EmptyStatement"), + function: newNodeTypeTester("FunctionDeclaration"), + + break: newKeywordTester("break"), + case: newKeywordTester("case"), + class: newKeywordTester("class"), + const: newKeywordTester("const"), + continue: newKeywordTester("continue"), + debugger: newKeywordTester("debugger"), + default: newKeywordTester("default"), + do: newKeywordTester("do"), + export: newKeywordTester("export"), + for: newKeywordTester("for"), + if: newKeywordTester("if"), + import: newKeywordTester("import"), + let: newKeywordTester("let"), + return: newKeywordTester("return"), + switch: newKeywordTester("switch"), + throw: newKeywordTester("throw"), + try: newKeywordTester("try"), + var: newKeywordTester("var"), + while: newKeywordTester("while"), + with: newKeywordTester("with"), +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "padding-line-between-statements", + url: "https://eslint.style/rules/padding-line-between-statements", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require or disallow padding lines between statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/padding-line-between-statements", + }, + + fixable: "whitespace", + + schema: { + definitions: { + paddingType: { + enum: Object.keys(PaddingTypes), + }, + statementType: { + anyOf: [ + { enum: Object.keys(StatementTypes) }, + { + type: "array", + items: { enum: Object.keys(StatementTypes) }, + minItems: 1, + uniqueItems: true, + }, + ], + }, + }, + type: "array", + items: { + type: "object", + properties: { + blankLine: { $ref: "#/definitions/paddingType" }, + prev: { $ref: "#/definitions/statementType" }, + next: { $ref: "#/definitions/statementType" }, + }, + additionalProperties: false, + required: ["blankLine", "prev", "next"], + }, + }, + + messages: { + unexpectedBlankLine: "Unexpected blank line before this statement.", + expectedBlankLine: "Expected blank line before this statement.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const configureList = context.options || []; + let scopeInfo = null; + + /** + * Processes to enter to new scope. + * This manages the current previous statement. + * @returns {void} + * @private + */ + function enterScope() { + scopeInfo = { + upper: scopeInfo, + prevNode: null, + }; + } + + /** + * Processes to exit from the current scope. + * @returns {void} + * @private + */ + function exitScope() { + scopeInfo = scopeInfo.upper; + } + + /** + * Checks whether the given node matches the given type. + * @param {ASTNode} node The statement node to check. + * @param {string|string[]} type The statement type to check. + * @returns {boolean} `true` if the statement node matched the type. + * @private + */ + function match(node, type) { + let innerStatementNode = node; + + while (innerStatementNode.type === "LabeledStatement") { + innerStatementNode = innerStatementNode.body; + } + if (Array.isArray(type)) { + return type.some(match.bind(null, innerStatementNode)); + } + return StatementTypes[type].test(innerStatementNode, sourceCode); + } + + /** + * Finds the last matched configure from configureList. + * @param {ASTNode} prevNode The previous statement to match. + * @param {ASTNode} nextNode The current statement to match. + * @returns {Object} The tester of the last matched configure. + * @private + */ + function getPaddingType(prevNode, nextNode) { + for (let i = configureList.length - 1; i >= 0; --i) { + const configure = configureList[i]; + const matched = + match(prevNode, configure.prev) && + match(nextNode, configure.next); + + if (matched) { + return PaddingTypes[configure.blankLine]; + } + } + return PaddingTypes.any; + } + + /** + * Gets padding line sequences between the given 2 statements. + * Comments are separators of the padding line sequences. + * @param {ASTNode} prevNode The previous statement to count. + * @param {ASTNode} nextNode The current statement to count. + * @returns {Array} The array of token pairs. + * @private + */ + function getPaddingLineSequences(prevNode, nextNode) { + const pairs = []; + let prevToken = getActualLastToken(sourceCode, prevNode); + + if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) { + do { + const token = sourceCode.getTokenAfter(prevToken, { + includeComments: true, + }); + + if (token.loc.start.line - prevToken.loc.end.line >= 2) { + pairs.push([prevToken, token]); + } + prevToken = token; + } while (prevToken.range[0] < nextNode.range[0]); + } + + return pairs; + } + + /** + * Verify padding lines between the given node and the previous node. + * @param {ASTNode} node The node to verify. + * @returns {void} + * @private + */ + function verify(node) { + const parentType = node.parent.type; + const validParent = + astUtils.STATEMENT_LIST_PARENTS.has(parentType) || + parentType === "SwitchStatement"; + + if (!validParent) { + return; + } + + // Save this node as the current previous statement. + const prevNode = scopeInfo.prevNode; + + // Verify. + if (prevNode) { + const type = getPaddingType(prevNode, node); + const paddingLines = getPaddingLineSequences(prevNode, node); + + type.verify(context, prevNode, node, paddingLines); + } + + scopeInfo.prevNode = node; + } + + /** + * Verify padding lines between the given node and the previous node. + * Then process to enter to new scope. + * @param {ASTNode} node The node to verify. + * @returns {void} + * @private + */ + function verifyThenEnterScope(node) { + verify(node); + enterScope(); + } + + return { + Program: enterScope, + BlockStatement: enterScope, + SwitchStatement: enterScope, + StaticBlock: enterScope, + "Program:exit": exitScope, + "BlockStatement:exit": exitScope, + "SwitchStatement:exit": exitScope, + "StaticBlock:exit": exitScope, + + ":statement": verify, + + SwitchCase: verifyThenEnterScope, + "SwitchCase:exit": exitScope, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-arrow-callback.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-arrow-callback.js new file mode 100644 index 00000000..df2ea3bb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-arrow-callback.js @@ -0,0 +1,453 @@ +/** + * @fileoverview A rule to suggest using arrow functions as callbacks. + * @author Toru Nagashima + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Variable} Variable */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether or not a given variable is a function name. + * @param {Variable} variable A variable to check. + * @returns {boolean} `true` if the variable is a function name. + */ +function isFunctionName(variable) { + return variable && variable.defs[0].type === "FunctionName"; +} + +/** + * Checks whether or not a given MetaProperty node equals to a given value. + * @param {ASTNode} node A MetaProperty node to check. + * @param {string} metaName The name of `MetaProperty.meta`. + * @param {string} propertyName The name of `MetaProperty.property`. + * @returns {boolean} `true` if the node is the specific value. + */ +function checkMetaProperty(node, metaName, propertyName) { + return node.meta.name === metaName && node.property.name === propertyName; +} + +/** + * Gets the variable object of `arguments` which is defined implicitly. + * @param {Scope} scope A scope to get. + * @returns {Variable} The found variable object. + */ +function getVariableOfArguments(scope) { + const variables = scope.variables; + + for (let i = 0; i < variables.length; ++i) { + const variable = variables[i]; + + if (variable.name === "arguments") { + /* + * If there was a parameter which is named "arguments", the + * implicit "arguments" is not defined. + * So does fast return with null. + */ + return variable.identifiers.length === 0 ? variable : null; + } + } + + /* c8 ignore next */ + return null; +} + +/** + * Checks whether or not a given node is a callback. + * @param {ASTNode} node A node to check. + * @throws {Error} (Unreachable.) + * @returns {Object} + * {boolean} retv.isCallback - `true` if the node is a callback. + * {boolean} retv.isLexicalThis - `true` if the node is with `.bind(this)`. + */ +function getCallbackInfo(node) { + const retv = { isCallback: false, isLexicalThis: false }; + let currentNode = node; + let parent = node.parent; + let bound = false; + + while (currentNode) { + switch (parent.type) { + // Checks parents recursively. + + case "LogicalExpression": + case "ChainExpression": + case "ConditionalExpression": + break; + + // Checks whether the parent node is `.bind(this)` call. + case "MemberExpression": + if ( + parent.object === currentNode && + !parent.property.computed && + parent.property.type === "Identifier" && + parent.property.name === "bind" + ) { + const maybeCallee = + parent.parent.type === "ChainExpression" + ? parent.parent + : parent; + + if (astUtils.isCallee(maybeCallee)) { + if (!bound) { + bound = true; // Use only the first `.bind()` to make `isLexicalThis` value. + retv.isLexicalThis = + maybeCallee.parent.arguments.length === 1 && + maybeCallee.parent.arguments[0].type === + "ThisExpression"; + } + parent = maybeCallee.parent; + } else { + return retv; + } + } else { + return retv; + } + break; + + // Checks whether the node is a callback. + case "CallExpression": + case "NewExpression": + if (parent.callee !== currentNode) { + retv.isCallback = true; + } + return retv; + + default: + return retv; + } + + currentNode = parent; + parent = parent.parent; + } + + /* c8 ignore next */ + throw new Error("unreachable"); +} + +/** + * Checks whether a simple list of parameters contains any duplicates. This does not handle complex + * parameter lists (e.g. with destructuring), since complex parameter lists are a SyntaxError with duplicate + * parameter names anyway. Instead, it always returns `false` for complex parameter lists. + * @param {ASTNode[]} paramsList The list of parameters for a function + * @returns {boolean} `true` if the list of parameters contains any duplicates + */ +function hasDuplicateParams(paramsList) { + return ( + paramsList.every(param => param.type === "Identifier") && + paramsList.length !== new Set(paramsList.map(param => param.name)).size + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { allowNamedFunctions: false, allowUnboundThis: true }, + ], + + docs: { + description: "Require using arrow functions for callbacks", + dialects: ["JavaScript", "TypeScript"], + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/prefer-arrow-callback", + }, + + schema: [ + { + type: "object", + properties: { + allowNamedFunctions: { + type: "boolean", + }, + allowUnboundThis: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + preferArrowCallback: "Unexpected function expression.", + }, + }, + + create(context) { + const [{ allowNamedFunctions, allowUnboundThis }] = context.options; + const sourceCode = context.sourceCode; + + /* + * {Array<{this: boolean, super: boolean, meta: boolean}>} + * - this - A flag which shows there are one or more ThisExpression. + * - super - A flag which shows there are one or more Super. + * - meta - A flag which shows there are one or more MethProperty. + */ + let stack = []; + + /** + * Pushes new function scope with all `false` flags. + * @returns {void} + */ + function enterScope() { + stack.push({ this: false, super: false, meta: false }); + } + + /** + * Pops a function scope from the stack. + * @returns {{this: boolean, super: boolean, meta: boolean}} The information of the last scope. + */ + function exitScope() { + return stack.pop(); + } + + return { + // Reset internal state. + Program() { + stack = []; + }, + + // If there are below, it cannot replace with arrow functions merely. + ThisExpression() { + const info = stack.at(-1); + + if (info) { + info.this = true; + } + }, + + Super() { + const info = stack.at(-1); + + if (info) { + info.super = true; + } + }, + + MetaProperty(node) { + const info = stack.at(-1); + + if (info && checkMetaProperty(node, "new", "target")) { + info.meta = true; + } + }, + + // To skip nested scopes. + FunctionDeclaration: enterScope, + "FunctionDeclaration:exit": exitScope, + + // Main. + FunctionExpression: enterScope, + "FunctionExpression:exit"(node) { + const scopeInfo = exitScope(); + + // Skip named function expressions + if (allowNamedFunctions && node.id && node.id.name) { + return; + } + + // Skip generators. + if (node.generator) { + return; + } + + // Skip recursive functions. + const nameVar = sourceCode.getDeclaredVariables(node)[0]; + + if (isFunctionName(nameVar) && nameVar.references.length > 0) { + return; + } + + // Skip if it's using arguments. + const variable = getVariableOfArguments( + sourceCode.getScope(node), + ); + + if (variable && variable.references.length > 0) { + return; + } + + // Reports if it's a callback which can replace with arrows. + const callbackInfo = getCallbackInfo(node); + + if ( + callbackInfo.isCallback && + (!allowUnboundThis || + !scopeInfo.this || + callbackInfo.isLexicalThis) && + !scopeInfo.super && + !scopeInfo.meta + ) { + context.report({ + node, + messageId: "preferArrowCallback", + *fix(fixer) { + if ( + (!callbackInfo.isLexicalThis && + scopeInfo.this) || + hasDuplicateParams(node.params) + ) { + /* + * If the callback function does not have .bind(this) and contains a reference to `this`, there + * is no way to determine what `this` should be, so don't perform any fixes. + * If the callback function has duplicates in its list of parameters (possible in sloppy mode), + * don't replace it with an arrow function, because this is a SyntaxError with arrow functions. + */ + return; + } + + if ( + node.params.length && + node.params[0].name === "this" + ) { + return; + } + + const functionToken = sourceCode.getFirstToken( + node, + node.async ? 1 : 0, + ); + const leftParenToken = sourceCode.getTokenAfter( + functionToken, + astUtils.isOpeningParenToken, + ); + + if (node.async) { + if ( + functionToken.loc.end.line < + leftParenToken.loc.start.line + ) { + return; + } + } + + // Remove `.bind(this)` if exists. + if (callbackInfo.isLexicalThis) { + const memberNode = node.parent; + + /* + * If `.bind(this)` exists but the parent is not `.bind(this)`, don't remove it automatically. + * E.g. `(foo || function(){}).bind(this)` + */ + if (memberNode.type !== "MemberExpression") { + return; + } + + const callNode = memberNode.parent; + const firstTokenToRemove = + sourceCode.getTokenAfter( + memberNode.object, + astUtils.isNotClosingParenToken, + ); + const lastTokenToRemove = + sourceCode.getLastToken(callNode); + + /* + * If the member expression is parenthesized, don't remove the right paren. + * E.g. `(function(){}.bind)(this)` + * ^^^^^^^^^^^^ + */ + if ( + astUtils.isParenthesised( + sourceCode, + memberNode, + ) + ) { + return; + } + + // If comments exist in the `.bind(this)`, don't remove those. + if ( + sourceCode.commentsExistBetween( + firstTokenToRemove, + lastTokenToRemove, + ) + ) { + return; + } + + yield fixer.removeRange([ + firstTokenToRemove.range[0], + lastTokenToRemove.range[1], + ]); + } + + // Convert the function expression to an arrow function. + const tokenBeforeBody = sourceCode.getTokenBefore( + node.body, + ); + + if ( + sourceCode.commentsExistBetween( + functionToken, + leftParenToken, + ) + ) { + // Remove only extra tokens to keep comments. + yield fixer.remove(functionToken); + if (node.id) { + yield fixer.remove(node.id); + } + } else { + // Remove extra tokens and spaces. + yield fixer.removeRange([ + functionToken.range[0], + leftParenToken.range[0], + ]); + } + yield fixer.insertTextAfter(tokenBeforeBody, " =>"); + + // Get the node that will become the new arrow function. + let replacedNode = callbackInfo.isLexicalThis + ? node.parent.parent + : node; + + if (replacedNode.type === "ChainExpression") { + replacedNode = replacedNode.parent; + } + + /* + * If the replaced node is part of a BinaryExpression, LogicalExpression, or MemberExpression, then + * the arrow function needs to be parenthesized, because `foo || () => {}` is invalid syntax even + * though `foo || function() {}` is valid. + */ + if ( + replacedNode.parent.type !== "CallExpression" && + replacedNode.parent.type !== + "ConditionalExpression" && + !astUtils.isParenthesised( + sourceCode, + replacedNode, + ) && + !astUtils.isParenthesised(sourceCode, node) + ) { + yield fixer.insertTextBefore(replacedNode, "("); + yield fixer.insertTextAfter(replacedNode, ")"); + } + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-const.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-const.js new file mode 100644 index 00000000..57cfb7ee --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-const.js @@ -0,0 +1,554 @@ +/** + * @fileoverview A rule to suggest using of const declaration for variables that are never reassigned after declared. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const FixTracker = require("./utils/fix-tracker"); +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Variable} Variable */ +/** @typedef {import("eslint-scope").Reference} Reference */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const PATTERN_TYPE = + /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u; +const DECLARATION_HOST_TYPE = + /^(?:Program|BlockStatement|StaticBlock|SwitchCase)$/u; +const DESTRUCTURING_HOST_TYPE = + /^(?:VariableDeclarator|AssignmentExpression)$/u; + +/** + * Checks whether a given node is located at `ForStatement.init` or not. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is located at `ForStatement.init`. + */ +function isInitOfForStatement(node) { + return node.parent.type === "ForStatement" && node.parent.init === node; +} + +/** + * Checks whether a given Identifier node becomes a VariableDeclaration or not. + * @param {ASTNode} identifier An Identifier node to check. + * @returns {boolean} `true` if the node can become a VariableDeclaration. + */ +function canBecomeVariableDeclaration(identifier) { + let node = identifier.parent; + + while (PATTERN_TYPE.test(node.type)) { + node = node.parent; + } + + return ( + node.type === "VariableDeclarator" || + (node.type === "AssignmentExpression" && + node.parent.type === "ExpressionStatement" && + DECLARATION_HOST_TYPE.test(node.parent.parent.type)) + ); +} + +/** + * Checks if an property or element is from outer scope or function parameters + * in destructing pattern. + * @param {string} name A variable name to be checked. + * @param {Scope} initScope A scope to start find. + * @returns {boolean} Indicates if the variable is from outer scope or function parameters. + */ +function isOuterVariableInDestructing(name, initScope) { + if ( + initScope.through.some( + ref => ref.resolved && ref.resolved.name === name, + ) + ) { + return true; + } + + const variable = astUtils.getVariableByName(initScope, name); + + if (variable !== null) { + return variable.defs.some(def => def.type === "Parameter"); + } + + return false; +} + +/** + * Gets the VariableDeclarator/AssignmentExpression node that a given reference + * belongs to. + * This is used to detect a mix of reassigned and never reassigned in a + * destructuring. + * @param {Reference} reference A reference to get. + * @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or + * null. + */ +function getDestructuringHost(reference) { + if (!reference.isWrite()) { + return null; + } + let node = reference.identifier.parent; + + while (PATTERN_TYPE.test(node.type)) { + node = node.parent; + } + + if (!DESTRUCTURING_HOST_TYPE.test(node.type)) { + return null; + } + return node; +} + +/** + * Determines if a destructuring assignment node contains + * any MemberExpression nodes. This is used to determine if a + * variable that is only written once using destructuring can be + * safely converted into a const declaration. + * @param {ASTNode} node The ObjectPattern or ArrayPattern node to check. + * @returns {boolean} True if the destructuring pattern contains + * a MemberExpression, false if not. + */ +function hasMemberExpressionAssignment(node) { + switch (node.type) { + case "ObjectPattern": + return node.properties.some(prop => { + if (prop) { + /* + * Spread elements have an argument property while + * others have a value property. Because different + * parsers use different node types for spread elements, + * we just check if there is an argument property. + */ + return hasMemberExpressionAssignment( + prop.argument || prop.value, + ); + } + + return false; + }); + + case "ArrayPattern": + return node.elements.some(element => { + if (element) { + return hasMemberExpressionAssignment(element); + } + + return false; + }); + + case "AssignmentPattern": + return hasMemberExpressionAssignment(node.left); + + case "MemberExpression": + return true; + + // no default + } + + return false; +} + +/** + * Gets an identifier node of a given variable. + * + * If the initialization exists or one or more reading references exist before + * the first assignment, the identifier node is the node of the declaration. + * Otherwise, the identifier node is the node of the first assignment. + * + * If the variable should not change to const, this function returns null. + * - If the variable is reassigned. + * - If the variable is never initialized nor assigned. + * - If the variable is initialized in a different scope from the declaration. + * - If the unique assignment of the variable cannot change to a declaration. + * e.g. `if (a) b = 1` / `return (b = 1)` + * - If the variable is declared in the global scope and `eslintUsed` is `true`. + * `/*exported foo` directive comment makes such variables. This rule does not + * warn such variables because this rule cannot distinguish whether the + * exported variables are reassigned or not. + * @param {Variable} variable A variable to get. + * @param {boolean} ignoreReadBeforeAssign + * The value of `ignoreReadBeforeAssign` option. + * @returns {ASTNode|null} + * An Identifier node if the variable should change to const. + * Otherwise, null. + */ +function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) { + if (variable.eslintUsed && variable.scope.type === "global") { + return null; + } + + // Finds the unique WriteReference. + let writer = null; + let isReadBeforeInit = false; + const references = variable.references; + + for (let i = 0; i < references.length; ++i) { + const reference = references[i]; + + if (reference.isWrite()) { + const isReassigned = + writer !== null && writer.identifier !== reference.identifier; + + if (isReassigned) { + return null; + } + + const destructuringHost = getDestructuringHost(reference); + + if ( + destructuringHost !== null && + destructuringHost.left !== void 0 + ) { + const leftNode = destructuringHost.left; + let hasOuterVariables = false, + hasNonIdentifiers = false; + + if (leftNode.type === "ObjectPattern") { + const properties = leftNode.properties; + + hasOuterVariables = properties + .filter(prop => prop.value) + .map(prop => prop.value.name) + .some(name => + isOuterVariableInDestructing(name, variable.scope), + ); + + hasNonIdentifiers = hasMemberExpressionAssignment(leftNode); + } else if (leftNode.type === "ArrayPattern") { + const elements = leftNode.elements; + + hasOuterVariables = elements + .map(element => element && element.name) + .some(name => + isOuterVariableInDestructing(name, variable.scope), + ); + + hasNonIdentifiers = hasMemberExpressionAssignment(leftNode); + } + + if (hasOuterVariables || hasNonIdentifiers) { + return null; + } + } + + writer = reference; + } else if (reference.isRead() && writer === null) { + if (ignoreReadBeforeAssign) { + return null; + } + isReadBeforeInit = true; + } + } + + /* + * If the assignment is from a different scope, ignore it. + * If the assignment cannot change to a declaration, ignore it. + */ + const shouldBeConst = + writer !== null && + writer.from === variable.scope && + canBecomeVariableDeclaration(writer.identifier); + + if (!shouldBeConst) { + return null; + } + + if (isReadBeforeInit) { + return variable.defs[0].name; + } + + return writer.identifier; +} + +/** + * Groups by the VariableDeclarator/AssignmentExpression node that each + * reference of given variables belongs to. + * This is used to detect a mix of reassigned and never reassigned in a + * destructuring. + * @param {Variable[]} variables Variables to group by destructuring. + * @param {boolean} ignoreReadBeforeAssign + * The value of `ignoreReadBeforeAssign` option. + * @returns {Map} Grouped identifier nodes. + */ +function groupByDestructuring(variables, ignoreReadBeforeAssign) { + const identifierMap = new Map(); + + for (let i = 0; i < variables.length; ++i) { + const variable = variables[i]; + const references = variable.references; + const identifier = getIdentifierIfShouldBeConst( + variable, + ignoreReadBeforeAssign, + ); + let prevId = null; + + for (let j = 0; j < references.length; ++j) { + const reference = references[j]; + const id = reference.identifier; + + /* + * Avoid counting a reference twice or more for default values of + * destructuring. + */ + if (id === prevId) { + continue; + } + prevId = id; + + // Add the identifier node into the destructuring group. + const group = getDestructuringHost(reference); + + if (group) { + if (identifierMap.has(group)) { + identifierMap.get(group).push(identifier); + } else { + identifierMap.set(group, [identifier]); + } + } + } + } + + return identifierMap; +} + +/** + * Finds the nearest parent of node with a given type. + * @param {ASTNode} node The node to search from. + * @param {string} type The type field of the parent node. + * @param {Function} shouldStop A predicate that returns true if the traversal should stop, and false otherwise. + * @returns {ASTNode} The closest ancestor with the specified type; null if no such ancestor exists. + */ +function findUp(node, type, shouldStop) { + if (!node || shouldStop(node)) { + return null; + } + if (node.type === type) { + return node; + } + return findUp(node.parent, type, shouldStop); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + destructuring: "any", + ignoreReadBeforeAssign: false, + }, + ], + + docs: { + description: + "Require `const` declarations for variables that are never reassigned after declared", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-const", + }, + + fixable: "code", + + schema: [ + { + type: "object", + properties: { + destructuring: { enum: ["any", "all"] }, + ignoreReadBeforeAssign: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + messages: { + useConst: "'{{name}}' is never reassigned. Use 'const' instead.", + }, + }, + + create(context) { + const [{ destructuring, ignoreReadBeforeAssign }] = context.options; + const shouldMatchAnyDestructuredVariable = destructuring !== "all"; + const sourceCode = context.sourceCode; + const variables = []; + let reportCount = 0; + let checkedId = null; + let checkedName = ""; + + /** + * Reports given identifier nodes if all of the nodes should be declared + * as const. + * + * The argument 'nodes' is an array of Identifier nodes. + * This node is the result of 'getIdentifierIfShouldBeConst()', so it's + * nullable. In simple declaration or assignment cases, the length of + * the array is 1. In destructuring cases, the length of the array can + * be 2 or more. + * @param {(Reference|null)[]} nodes + * References which are grouped by destructuring to report. + * @returns {void} + */ + function checkGroup(nodes) { + const nodesToReport = nodes.filter(Boolean); + + if ( + nodes.length && + (shouldMatchAnyDestructuredVariable || + nodesToReport.length === nodes.length) + ) { + const varDeclParent = findUp( + nodes[0], + "VariableDeclaration", + parentNode => parentNode.type.endsWith("Statement"), + ); + const isVarDecParentNull = varDeclParent === null; + + if ( + !isVarDecParentNull && + varDeclParent.declarations.length > 0 + ) { + const firstDeclaration = varDeclParent.declarations[0]; + + if (firstDeclaration.init) { + const firstDecParent = firstDeclaration.init.parent; + + /* + * First we check the declaration type and then depending on + * if the type is a "VariableDeclarator" or its an "ObjectPattern" + * we compare the name and id from the first identifier, if the names are different + * we assign the new name, id and reset the count of reportCount and nodeCount in + * order to check each block for the number of reported errors and base our fix + * based on comparing nodes.length and nodesToReport.length. + */ + + if (firstDecParent.type === "VariableDeclarator") { + if (firstDecParent.id.name !== checkedName) { + checkedName = firstDecParent.id.name; + reportCount = 0; + } + + if (firstDecParent.id.type === "ObjectPattern") { + if (firstDecParent.init.name !== checkedName) { + checkedName = firstDecParent.init.name; + reportCount = 0; + } + } + + if (firstDecParent.id !== checkedId) { + checkedId = firstDecParent.id; + reportCount = 0; + } + } + } + } + + let shouldFix = + varDeclParent && + // Don't do a fix unless all variables in the declarations are initialized (or it's in a for-in or for-of loop) + (varDeclParent.parent.type === "ForInStatement" || + varDeclParent.parent.type === "ForOfStatement" || + varDeclParent.declarations.every( + declaration => declaration.init, + )) && + /* + * If options.destructuring is "all", then this warning will not occur unless + * every assignment in the destructuring should be const. In that case, it's safe + * to apply the fix. + */ + nodesToReport.length === nodes.length; + + if ( + !isVarDecParentNull && + varDeclParent.declarations && + varDeclParent.declarations.length !== 1 + ) { + if ( + varDeclParent && + varDeclParent.declarations && + varDeclParent.declarations.length >= 1 + ) { + /* + * Add nodesToReport.length to a count, then comparing the count to the length + * of the declarations in the current block. + */ + + reportCount += nodesToReport.length; + + let totalDeclarationsCount = 0; + + varDeclParent.declarations.forEach(declaration => { + if (declaration.id.type === "ObjectPattern") { + totalDeclarationsCount += + declaration.id.properties.length; + } else if (declaration.id.type === "ArrayPattern") { + totalDeclarationsCount += + declaration.id.elements.length; + } else { + totalDeclarationsCount += 1; + } + }); + + shouldFix = + shouldFix && reportCount === totalDeclarationsCount; + } + } + + nodesToReport.forEach(node => { + context.report({ + node, + messageId: "useConst", + data: node, + fix: shouldFix + ? fixer => { + const letKeywordToken = + sourceCode.getFirstToken( + varDeclParent, + t => t.value === varDeclParent.kind, + ); + + /** + * Extend the replacement range to the whole declaration, + * in order to prevent other fixes in the same pass + * https://github.com/eslint/eslint/issues/13899 + */ + return new FixTracker(fixer, sourceCode) + .retainRange(varDeclParent.range) + .replaceTextRange( + letKeywordToken.range, + "const", + ); + } + : null, + }); + }); + } + } + + return { + "Program:exit"() { + groupByDestructuring(variables, ignoreReadBeforeAssign).forEach( + checkGroup, + ); + }, + + VariableDeclaration(node) { + if (node.kind === "let" && !isInitOfForStatement(node)) { + variables.push(...sourceCode.getDeclaredVariables(node)); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-destructuring.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-destructuring.js new file mode 100644 index 00000000..09d0e5be --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-destructuring.js @@ -0,0 +1,332 @@ +/** + * @fileoverview Prefer destructuring from arrays and objects + * @author Alex LaFroscia + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({ + type: "AssignmentExpression", +}); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require destructuring from arrays and/or objects", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/prefer-destructuring", + }, + + fixable: "code", + + schema: [ + { + /* + * old support {array: Boolean, object: Boolean} + * new support {VariableDeclarator: {}, AssignmentExpression: {}} + */ + oneOf: [ + { + type: "object", + properties: { + VariableDeclarator: { + type: "object", + properties: { + array: { + type: "boolean", + }, + object: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + AssignmentExpression: { + type: "object", + properties: { + array: { + type: "boolean", + }, + object: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + { + type: "object", + properties: { + array: { + type: "boolean", + }, + object: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + { + type: "object", + properties: { + enforceForRenamedProperties: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + preferDestructuring: "Use {{type}} destructuring.", + }, + }, + create(context) { + const enabledTypes = context.options[0]; + const enforceForRenamedProperties = + context.options[1] && + context.options[1].enforceForRenamedProperties; + let normalizedOptions = { + VariableDeclarator: { array: true, object: true }, + AssignmentExpression: { array: true, object: true }, + }; + + if (enabledTypes) { + normalizedOptions = + typeof enabledTypes.array !== "undefined" || + typeof enabledTypes.object !== "undefined" + ? { + VariableDeclarator: enabledTypes, + AssignmentExpression: enabledTypes, + } + : enabledTypes; + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Checks if destructuring type should be checked. + * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator" + * @param {string} destructuringType "array" or "object" + * @returns {boolean} `true` if the destructuring type should be checked for the given node + */ + function shouldCheck(nodeType, destructuringType) { + return ( + normalizedOptions && + normalizedOptions[nodeType] && + normalizedOptions[nodeType][destructuringType] + ); + } + + /** + * Determines if the given node is accessing an array index + * + * This is used to differentiate array index access from object property + * access. + * @param {ASTNode} node the node to evaluate + * @returns {boolean} whether or not the node is an integer + */ + function isArrayIndexAccess(node) { + return Number.isInteger(node.property.value); + } + + /** + * Report that the given node should use destructuring + * @param {ASTNode} reportNode the node to report + * @param {string} type the type of destructuring that should have been done + * @param {Function|null} fix the fix function or null to pass to context.report + * @returns {void} + */ + function report(reportNode, type, fix) { + context.report({ + node: reportNode, + messageId: "preferDestructuring", + data: { type }, + fix, + }); + } + + /** + * Determines if a node should be fixed into object destructuring + * + * The fixer only fixes the simplest case of object destructuring, + * like: `let x = a.x`; + * + * Assignment expression is not fixed. + * Array destructuring is not fixed. + * Renamed property is not fixed. + * @param {ASTNode} node the node to evaluate + * @returns {boolean} whether or not the node should be fixed + */ + function shouldFix(node) { + return ( + node.type === "VariableDeclarator" && + node.id.type === "Identifier" && + node.init.type === "MemberExpression" && + !node.init.computed && + node.init.property.type === "Identifier" && + node.id.name === node.init.property.name + ); + } + + /** + * Fix a node into object destructuring. + * This function only handles the simplest case of object destructuring, + * see {@link shouldFix}. + * @param {SourceCodeFixer} fixer the fixer object + * @param {ASTNode} node the node to be fixed. + * @returns {Object} a fix for the node + */ + function fixIntoObjectDestructuring(fixer, node) { + const rightNode = node.init; + const sourceCode = context.sourceCode; + + // Don't fix if that would remove any comments. Only comments inside `rightNode.object` can be preserved. + if ( + sourceCode.getCommentsInside(node).length > + sourceCode.getCommentsInside(rightNode.object).length + ) { + return null; + } + + let objectText = sourceCode.getText(rightNode.object); + + if ( + astUtils.getPrecedence(rightNode.object) < + PRECEDENCE_OF_ASSIGNMENT_EXPR + ) { + objectText = `(${objectText})`; + } + + return fixer.replaceText( + node, + `{${rightNode.property.name}} = ${objectText}`, + ); + } + + /** + * Check that the `prefer-destructuring` rules are followed based on the + * given left- and right-hand side of the assignment. + * + * Pulled out into a separate method so that VariableDeclarators and + * AssignmentExpressions can share the same verification logic. + * @param {ASTNode} leftNode the left-hand side of the assignment + * @param {ASTNode} rightNode the right-hand side of the assignment + * @param {ASTNode} reportNode the node to report the error on + * @returns {void} + */ + function performCheck(leftNode, rightNode, reportNode) { + if ( + rightNode.type !== "MemberExpression" || + rightNode.object.type === "Super" || + rightNode.property.type === "PrivateIdentifier" + ) { + return; + } + + if (isArrayIndexAccess(rightNode)) { + if (shouldCheck(reportNode.type, "array")) { + report(reportNode, "array", null); + } + return; + } + + const fix = shouldFix(reportNode) + ? fixer => fixIntoObjectDestructuring(fixer, reportNode) + : null; + + if ( + shouldCheck(reportNode.type, "object") && + enforceForRenamedProperties + ) { + report(reportNode, "object", fix); + return; + } + + if (shouldCheck(reportNode.type, "object")) { + const property = rightNode.property; + + if ( + (property.type === "Literal" && + leftNode.name === property.value) || + (property.type === "Identifier" && + leftNode.name === property.name && + !rightNode.computed) + ) { + report(reportNode, "object", fix); + } + } + } + + /** + * Check if a given variable declarator is coming from an property access + * that should be using destructuring instead + * @param {ASTNode} node the variable declarator to check + * @returns {void} + */ + function checkVariableDeclarator(node) { + // Skip if variable is declared without assignment + if (!node.init) { + return; + } + + // Variable declarations using explicit resource management cannot use destructuring (parse error) + if ( + node.parent.kind === "using" || + node.parent.kind === "await using" + ) { + return; + } + + // We only care about member expressions past this point + if (node.init.type !== "MemberExpression") { + return; + } + + performCheck(node.id, node.init, node); + } + + /** + * Run the `prefer-destructuring` check on an AssignmentExpression + * @param {ASTNode} node the AssignmentExpression node + * @returns {void} + */ + function checkAssignmentExpression(node) { + if (node.operator === "=") { + performCheck(node.left, node.right, node); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + VariableDeclarator: checkVariableDeclarator, + AssignmentExpression: checkAssignmentExpression, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-exponentiation-operator.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-exponentiation-operator.js new file mode 100644 index 00000000..82ad61fa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-exponentiation-operator.js @@ -0,0 +1,274 @@ +/** + * @fileoverview Rule to disallow Math.pow in favor of the ** operator + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({ + type: "BinaryExpression", + operator: "**", +}); + +/* + * Characters that can cause continuation without preceding semi + */ +const continuationChars = new Set(["(", "[", "/", "`"]); + +/** + * Determines whether the given node needs parens if used as the base in an exponentiation binary expression. + * @param {ASTNode} base The node to check. + * @returns {boolean} `true` if the node needs to be parenthesised. + */ +function doesBaseNeedParens(base) { + return ( + // '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c + astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR || + // An unary operator cannot be used immediately before an exponentiation expression + base.type === "AwaitExpression" || + base.type === "UnaryExpression" + ); +} + +/** + * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression. + * @param {ASTNode} exponent The node to check. + * @returns {boolean} `true` if the node needs to be parenthesised. + */ +function doesExponentNeedParens(exponent) { + // '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c + return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR; +} + +/** + * Determines whether an exponentiation binary expression at the place of the given node would need parens. + * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression. + * @param {SourceCode} sourceCode A SourceCode object. + * @returns {boolean} `true` if the expression needs to be parenthesised. + */ +function doesExponentiationExpressionNeedParens(node, sourceCode) { + const parent = + node.parent.type === "ChainExpression" + ? node.parent.parent + : node.parent; + + const parentPrecedence = astUtils.getPrecedence(parent); + const needsParens = + parent.type === "ClassDeclaration" || + (parent.type.endsWith("Expression") && + (parentPrecedence === -1 || + parentPrecedence >= PRECEDENCE_OF_EXPONENTIATION_EXPR) && + !( + parent.type === "BinaryExpression" && + parent.operator === "**" && + parent.right === node + ) && + !( + (parent.type === "CallExpression" || + parent.type === "NewExpression") && + parent.arguments.includes(node) + ) && + !( + parent.type === "MemberExpression" && + parent.computed && + parent.property === node + ) && + !(parent.type === "ArrayExpression")); + + return needsParens && !astUtils.isParenthesised(sourceCode, node); +} + +/** + * Optionally parenthesizes given text. + * @param {string} text The text to parenthesize. + * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised. + * @returns {string} parenthesised or unchanged text. + */ +function parenthesizeIfShould(text, shouldParenthesize) { + return shouldParenthesize ? `(${text})` : text; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow the use of `Math.pow` in favor of the `**` operator", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/prefer-exponentiation-operator", + }, + + schema: [], + fixable: "code", + + messages: { + useExponentiation: "Use the '**' operator instead of 'Math.pow'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Reports the given node. + * @param {ASTNode} node 'Math.pow()' node to report. + * @returns {void} + */ + function report(node) { + context.report({ + node, + messageId: "useExponentiation", + fix(fixer) { + if ( + node.arguments.length !== 2 || + node.arguments.some( + arg => arg.type === "SpreadElement", + ) || + sourceCode.getCommentsInside(node).length > 0 + ) { + return null; + } + + const base = node.arguments[0], + exponent = node.arguments[1], + baseText = sourceCode.getText(base), + exponentText = sourceCode.getText(exponent), + shouldParenthesizeBase = doesBaseNeedParens(base), + shouldParenthesizeExponent = + doesExponentNeedParens(exponent), + isStartOfExpressionStatement = + astUtils.isStartOfExpressionStatement(node); + + let shouldParenthesizeAll = + doesExponentiationExpressionNeedParens( + node, + sourceCode, + ); + + /* + * `function`, `class`, or `{` token at the start of an expression statement + * would cause incorrect parsing. + * https://github.com/eslint/eslint/issues/20987 + */ + if ( + !shouldParenthesizeAll && + !shouldParenthesizeBase && + isStartOfExpressionStatement + ) { + const firstTokenOfBase = sourceCode.getFirstToken(base); + + if ( + astUtils.isOpeningBraceToken(firstTokenOfBase) || + (firstTokenOfBase.type === "Keyword" && + (firstTokenOfBase.value === "function" || + firstTokenOfBase.value === "class")) + ) { + shouldParenthesizeAll = true; + } + } + + let prefix = "", + suffix = ""; + + if (!shouldParenthesizeAll) { + if (!shouldParenthesizeBase) { + const firstReplacementToken = + sourceCode.getFirstToken(base), + tokenBefore = sourceCode.getTokenBefore(node); + + if ( + tokenBefore && + tokenBefore.range[1] === node.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBefore, + firstReplacementToken, + ) + ) { + prefix = " "; // a+Math.pow(++b, c) -> a+ ++b**c + } + } + if (!shouldParenthesizeExponent) { + const lastReplacementToken = + sourceCode.getLastToken(exponent), + tokenAfter = sourceCode.getTokenAfter(node); + + if ( + tokenAfter && + node.range[1] === tokenAfter.range[0] && + !astUtils.canTokensBeAdjacent( + lastReplacementToken, + tokenAfter, + ) + ) { + suffix = " "; // Math.pow(a, b)in c -> a**b in c + } + } + } + + const baseReplacement = parenthesizeIfShould( + baseText, + shouldParenthesizeBase, + ), + exponentReplacement = parenthesizeIfShould( + exponentText, + shouldParenthesizeExponent, + ), + replacement = parenthesizeIfShould( + `${baseReplacement}**${exponentReplacement}`, + shouldParenthesizeAll, + ); + + if ( + !prefix && + isStartOfExpressionStatement && + continuationChars.has(replacement[0]) && + astUtils.needsPrecedingSemicolon(sourceCode, node) + ) { + prefix = ";"; + } + + return fixer.replaceText( + node, + `${prefix}${replacement}${suffix}`, + ); + }, + }); + } + + return { + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const trackMap = { + Math: { + pow: { [CALL]: true }, + }, + }; + + for (const { node: refNode } of tracker.iterateGlobalReferences( + trackMap, + )) { + report(refNode); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-named-capture-group.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-named-capture-group.js new file mode 100644 index 00000000..d5c1f460 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-named-capture-group.js @@ -0,0 +1,197 @@ +/** + * @fileoverview Rule to enforce requiring named capture groups in regular expression. + * @author Pig Fang + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + CALL, + CONSTRUCT, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils"); +const regexpp = require("@eslint-community/regexpp"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** @import { SuggestedEdit } from "@eslint/core"; */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const parser = new regexpp.RegExpParser(); + +/** + * Creates fixer suggestions for the regex, if statically determinable. + * @param {number} groupStart Starting index of the regex group. + * @param {string} pattern The regular expression pattern to be checked. + * @param {string} rawText Source text of the regexNode. + * @param {ASTNode} regexNode AST node which contains the regular expression. + * @returns {Array} Fixer suggestions for the regex, if statically determinable. + */ +function suggestIfPossible(groupStart, pattern, rawText, regexNode) { + switch (regexNode.type) { + case "Literal": + if (typeof regexNode.value === "string" && rawText.includes("\\")) { + return null; + } + break; + case "TemplateLiteral": + if ( + regexNode.expressions.length || + rawText.slice(1, -1) !== pattern + ) { + return null; + } + break; + default: + return null; + } + + const start = regexNode.range[0] + groupStart + 2; + + return [ + { + fix(fixer) { + const existingTemps = pattern.match(/temp\d+/gu) || []; + const highestTempCount = existingTemps.reduce( + (previous, next) => + Math.max(previous, Number(next.slice("temp".length))), + 0, + ); + + return fixer.insertTextBeforeRange( + [start, start], + `?`, + ); + }, + messageId: "addGroupName", + }, + { + fix(fixer) { + return fixer.insertTextBeforeRange([start, start], "?:"); + }, + messageId: "addNonCapture", + }, + ]; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce using named capture group in regular expression", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group", + }, + + hasSuggestions: true, + + schema: [], + + messages: { + addGroupName: "Add name to capture group.", + addNonCapture: "Convert group to non-capturing.", + required: + "Capture group '{{group}}' should be converted to a named or non-capturing group.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Function to check regular expression. + * @param {string} pattern The regular expression pattern to be checked. + * @param {ASTNode} node AST node which contains the regular expression or a call/new expression. + * @param {ASTNode} regexNode AST node which contains the regular expression. + * @param {string|null} flags The regular expression flags to be checked. + * @returns {void} + */ + function checkRegex(pattern, node, regexNode, flags) { + let ast; + + try { + ast = parser.parsePattern(pattern, 0, pattern.length, { + unicode: Boolean(flags && flags.includes("u")), + unicodeSets: Boolean(flags && flags.includes("v")), + }); + } catch { + // ignore regex syntax errors + return; + } + + regexpp.visitRegExpAST(ast, { + onCapturingGroupEnter(group) { + if (!group.name) { + const rawText = sourceCode.getText(regexNode); + const suggest = suggestIfPossible( + group.start, + pattern, + rawText, + regexNode, + ); + + context.report({ + node, + messageId: "required", + data: { + group: group.raw, + }, + suggest, + }); + } + }, + }); + } + + return { + Literal(node) { + if (node.regex) { + checkRegex( + node.regex.pattern, + node, + node, + node.regex.flags, + ); + } + }, + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const traceMap = { + RegExp: { + [CALL]: true, + [CONSTRUCT]: true, + }, + }; + + for (const { node: refNode } of tracker.iterateGlobalReferences( + traceMap, + )) { + const regex = getStringIfConstant(refNode.arguments[0]); + const flags = getStringIfConstant(refNode.arguments[1]); + + if (regex) { + checkRegex(regex, refNode, refNode.arguments[0], flags); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-numeric-literals.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-numeric-literals.js new file mode 100644 index 00000000..50aaaf12 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-numeric-literals.js @@ -0,0 +1,165 @@ +/** + * @fileoverview Rule to disallow `parseInt()` in favor of binary, octal, and hexadecimal literals + * @author Annie Zhang, Henry Zhu + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const radixMap = new Map([ + [2, { system: "binary", literalPrefix: "0b" }], + [8, { system: "octal", literalPrefix: "0o" }], + [16, { system: "hexadecimal", literalPrefix: "0x" }], +]); + +/** + * Checks to see if a CallExpression's callee node is `parseInt` or + * `Number.parseInt`. + * @param {ASTNode} calleeNode The callee node to evaluate. + * @param {SourceCode} sourceCode The source code object. + * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`, + * false otherwise. + */ +function isParseInt(calleeNode, sourceCode) { + if (astUtils.isSpecificId(calleeNode, "parseInt")) { + return sourceCode.isGlobalReference(calleeNode); + } + + if (astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")) { + const objectNode = astUtils.skipChainExpression(calleeNode).object; + + return sourceCode.isGlobalReference(objectNode); + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals", + }, + + schema: [], + + messages: { + useLiteral: + "Use {{system}} literals instead of {{functionName}}().", + }, + + fixable: "code", + }, + + create(context) { + const sourceCode = context.sourceCode; + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + "CallExpression[arguments.length=2]"(node) { + const [strNode, radixNode] = node.arguments, + str = astUtils.getStaticStringValue(strNode), + radix = radixNode.value; + + if ( + str !== null && + astUtils.isStringLiteral(strNode) && + radixNode.type === "Literal" && + typeof radix === "number" && + radixMap.has(radix) && + isParseInt(node.callee, sourceCode) + ) { + const { system, literalPrefix } = radixMap.get(radix); + + context.report({ + node, + messageId: "useLiteral", + data: { + system, + functionName: sourceCode.getText(node.callee), + }, + fix(fixer) { + if (sourceCode.getCommentsInside(node).length) { + return null; + } + + const replacement = `${literalPrefix}${str}`; + + if (+replacement !== parseInt(str, radix)) { + /* + * If the newly-produced literal would be invalid, (e.g. 0b1234), + * or it would yield an incorrect parseInt result for some other reason, don't make a fix. + * + * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+` + * per the specification doesn't support numeric separators. Thus, the above condition will be `true` + * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value. + * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also + * doesn't support numeric separators, but it does parse part of the string before the first `_`, + * so the autofix would be invalid: + * + * parseInt("1_1", 2) // === 1 + * 0b1_1 // === 3 + */ + return null; + } + + const tokenBefore = sourceCode.getTokenBefore(node), + tokenAfter = sourceCode.getTokenAfter(node); + let prefix = "", + suffix = ""; + + if ( + tokenBefore && + tokenBefore.range[1] === node.range[0] && + !astUtils.canTokensBeAdjacent( + tokenBefore, + replacement, + ) + ) { + prefix = " "; + } + + if ( + tokenAfter && + node.range[1] === tokenAfter.range[0] && + !astUtils.canTokensBeAdjacent( + replacement, + tokenAfter, + ) + ) { + suffix = " "; + } + + return fixer.replaceText( + node, + `${prefix}${replacement}${suffix}`, + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-has-own.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-has-own.js new file mode 100644 index 00000000..39b4d1f2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-has-own.js @@ -0,0 +1,147 @@ +/** + * @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call() + * @author Nitin Kumar + * @author Gautam Arora + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks if the given node is considered to be an access to a property of `Object.prototype`. + * @param {ASTNode} node `MemberExpression` node to evaluate. + * @returns {boolean} `true` if `node.object` is `Object`, `Object.prototype`, or `{}` (empty 'ObjectExpression' node). + */ +function hasLeftHandObject(node) { + /* + * ({}).hasOwnProperty.call(obj, prop) - `true` + * ({ foo }.hasOwnProperty.call(obj, prop)) - `false`, object literal should be empty + */ + if ( + node.object.type === "ObjectExpression" && + node.object.properties.length === 0 + ) { + return true; + } + + const objectNodeToCheck = + node.object.type === "MemberExpression" && + astUtils.getStaticPropertyName(node.object) === "prototype" + ? node.object.object + : node.object; + + if ( + objectNodeToCheck.type === "Identifier" && + objectNodeToCheck.name === "Object" + ) { + return true; + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + docs: { + description: + "Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-object-has-own", + }, + schema: [], + messages: { + useHasOwn: + "Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'.", + }, + fixable: "code", + }, + create(context) { + const sourceCode = context.sourceCode; + + return { + CallExpression(node) { + if (!( + node.callee.type === "MemberExpression" && + node.callee.object.type === "MemberExpression" + )) { + return; + } + + const calleePropertyName = astUtils.getStaticPropertyName( + node.callee, + ); + const objectPropertyName = astUtils.getStaticPropertyName( + node.callee.object, + ); + const isObject = hasLeftHandObject(node.callee.object); + + // check `Object` scope + const scope = sourceCode.getScope(node); + const variable = astUtils.getVariableByName(scope, "Object"); + + if ( + calleePropertyName === "call" && + objectPropertyName === "hasOwnProperty" && + isObject && + variable && + variable.scope.type === "global" && + variable.defs.length === 0 + ) { + context.report({ + node, + messageId: "useHasOwn", + fix(fixer) { + if ( + sourceCode.getCommentsInside(node.callee) + .length > 0 + ) { + return null; + } + + const tokenJustBeforeNode = + sourceCode.getTokenBefore(node.callee, { + includeComments: true, + }); + + // for https://github.com/eslint/eslint/pull/15346#issuecomment-991417335 + if ( + tokenJustBeforeNode && + tokenJustBeforeNode.range[1] === + node.callee.range[0] && + !astUtils.canTokensBeAdjacent( + tokenJustBeforeNode, + "Object.hasOwn", + ) + ) { + return fixer.replaceText( + node.callee, + " Object.hasOwn", + ); + } + + return fixer.replaceText( + node.callee, + "Object.hasOwn", + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-spread.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-spread.js new file mode 100644 index 00000000..36695015 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-object-spread.js @@ -0,0 +1,371 @@ +/** + * @fileoverview Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead + * @author Sharmila Jesupaul + */ + +"use strict"; + +const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils"); +const { + getStaticPropertyName, + isCommaToken, + isOpeningParenToken, + isClosingParenToken, + isParenthesised, + isStartOfExpressionStatement, + needsPrecedingSemicolon, +} = require("./utils/ast-utils"); + +const ANY_SPACE = /\s/u; + +/** + * Helper that checks if the Object.assign call has array spread + * @param {ASTNode} node The node that the rule warns on + * @returns {boolean} - Returns true if the Object.assign call has array spread + */ +function hasArraySpread(node) { + return node.arguments.some(arg => arg.type === "SpreadElement"); +} + +/** + * Determines whether the given node is an accessor property (getter/setter). + * @param {ASTNode} node Node to check. + * @returns {boolean} `true` if the node is a getter or a setter. + */ +function isAccessorProperty(node) { + return ( + node.type === "Property" && (node.kind === "get" || node.kind === "set") + ); +} + +/** + * Determines whether the given object expression node has accessor properties (getters/setters). + * @param {ASTNode} node `ObjectExpression` node to check. + * @returns {boolean} `true` if the node has at least one getter/setter. + */ +function hasAccessors(node) { + return node.properties.some(isAccessorProperty); +} + +/** + * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters). + * @param {ASTNode} node `CallExpression` node to check. + * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter. + */ +function hasArgumentsWithAccessors(node) { + return node.arguments + .filter(arg => arg.type === "ObjectExpression") + .some(hasAccessors); +} + +/** + * Determines whether the given node is a property with a `__proto__` key. + * Such a property in a source object can't be inlined into the target literal, because + * `__proto__` behaves differently in the two positions, and in opposite directions: + * - A `__proto__:` initializer creates no own property, so `Object.assign` doesn't copy it + * and the prototype is unaffected. Inlined into an object literal, it sets the prototype. + * - Any other form (computed, shorthand, or method) creates an own property, which + * `Object.assign` copies with `[[Set]]`, triggering the `__proto__` setter and changing + * the target's prototype. Inlined into an object literal, it is an ordinary own property. + * @param {ASTNode} node Node to check. + * @returns {boolean} `true` if the node is a property named `__proto__`. + */ +function isProtoProperty(node) { + return ( + node.type === "Property" && getStaticPropertyName(node) === "__proto__" + ); +} + +/** + * Determines whether the given object expression node has a `__proto__` property. + * @param {ASTNode} node `ObjectExpression` node to check. + * @returns {boolean} `true` if the node has at least one `__proto__` property. + */ +function hasProtoProperty(node) { + return node.properties.some(isProtoProperty); +} + +/** + * Determines whether the given call expression node has object expression source arguments (all but the first) with `__proto__` properties. + * The first argument is not checked. It is the target of the assignment, and its properties are + * inlined into the resulting object literal with the same meaning they already had. Properties of + * the other arguments are copied by `Object.assign` with `[[Set]]`, and that is the step the autofix removes. + * @param {ASTNode} node `CallExpression` node to check. + * @returns {boolean} `true` if the node has at least one source argument that is an object expression with a `__proto__` property. + */ +function hasArgumentsWithProtoProperty(node) { + return node.arguments + .slice(1) + .filter(arg => arg.type === "ObjectExpression") + .some(hasProtoProperty); +} + +/** + * Helper that checks if the node needs parentheses to be valid JS. + * The default is to wrap the node in parentheses to avoid parsing errors. + * @param {ASTNode} node The node that the rule warns on + * @param {Object} sourceCode in context sourcecode object + * @returns {boolean} - Returns true if the node needs parentheses + */ +function needsParens(node, sourceCode) { + const parent = node.parent; + + switch (parent.type) { + case "VariableDeclarator": + case "ArrayExpression": + case "ReturnStatement": + case "CallExpression": + case "Property": + return false; + case "AssignmentExpression": + return parent.left === node && !isParenthesised(sourceCode, node); + default: + return !isParenthesised(sourceCode, node); + } +} + +/** + * Determines if an argument needs parentheses. The default is to not add parens. + * @param {ASTNode} node The node to be checked. + * @param {Object} sourceCode in context sourcecode object + * @returns {boolean} True if the node needs parentheses + */ +function argNeedsParens(node, sourceCode) { + switch (node.type) { + case "AssignmentExpression": + case "ArrowFunctionExpression": + case "ConditionalExpression": + return !isParenthesised(sourceCode, node); + default: + return false; + } +} + +/** + * Get the parenthesis tokens of a given ObjectExpression node. + * This includes the braces of the object literal and enclosing parentheses. + * @param {ASTNode} node The node to get. + * @param {Token} leftArgumentListParen The opening paren token of the argument list. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location. + */ +function getParenTokens(node, leftArgumentListParen, sourceCode) { + const parens = [ + sourceCode.getFirstToken(node), + sourceCode.getLastToken(node), + ]; + let leftNext = sourceCode.getTokenBefore(node); + let rightNext = sourceCode.getTokenAfter(node); + + // Note: don't include the parens of the argument list. + while ( + leftNext && + rightNext && + leftNext.range[0] > leftArgumentListParen.range[0] && + isOpeningParenToken(leftNext) && + isClosingParenToken(rightNext) + ) { + parens.push(leftNext, rightNext); + leftNext = sourceCode.getTokenBefore(leftNext); + rightNext = sourceCode.getTokenAfter(rightNext); + } + + return parens.sort((a, b) => a.range[0] - b.range[0]); +} + +/** + * Get the range of a given token and around whitespaces. + * @param {Token} token The token to get range. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {number} The end of the range of the token and around whitespaces. + */ +function getStartWithSpaces(token, sourceCode) { + const text = sourceCode.text; + let start = token.range[0]; + + // If the previous token is a line comment then skip this step to avoid commenting this token out. + { + const prevToken = sourceCode.getTokenBefore(token, { + includeComments: true, + }); + + if (prevToken && prevToken.type === "Line") { + return start; + } + } + + // Detect spaces before the token. + while (ANY_SPACE.test(text[start - 1] || "")) { + start -= 1; + } + + return start; +} + +/** + * Get the range of a given token and around whitespaces. + * @param {Token} token The token to get range. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {number} The start of the range of the token and around whitespaces. + */ +function getEndWithSpaces(token, sourceCode) { + const text = sourceCode.text; + let end = token.range[1]; + + // Detect spaces after the token. + while (ANY_SPACE.test(text[end] || "")) { + end += 1; + } + + return end; +} + +/** + * Autofixes the Object.assign call to use an object spread instead. + * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call + * @param {string} sourceCode sourceCode of the Object.assign call + * @returns {Function} autofixer - replaces the Object.assign with a spread object. + */ +function defineFixer(node, sourceCode) { + return function* (fixer) { + const leftParen = sourceCode.getTokenAfter( + node.callee, + isOpeningParenToken, + ); + const rightParen = sourceCode.getLastToken(node); + + // Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren. + yield fixer.removeRange([node.range[0], leftParen.range[0]]); + + // Replace the parens of argument list to braces. + if (needsParens(node, sourceCode)) { + const prefix = + isStartOfExpressionStatement(node) && + needsPrecedingSemicolon(sourceCode, node) + ? ";({" + : "({"; + + yield fixer.replaceText(leftParen, prefix); + yield fixer.replaceText(rightParen, "})"); + } else { + yield fixer.replaceText(leftParen, "{"); + yield fixer.replaceText(rightParen, "}"); + } + + // Process arguments. + for (const argNode of node.arguments) { + const innerParens = getParenTokens(argNode, leftParen, sourceCode); + const left = innerParens.shift(); + const right = innerParens.pop(); + + if (argNode.type === "ObjectExpression") { + const maybeTrailingComma = sourceCode.getLastToken(argNode, 1); + const maybeArgumentComma = sourceCode.getTokenAfter(right); + + /* + * Make bare this object literal. + * And remove spaces inside of the braces for better formatting. + */ + for (const innerParen of innerParens) { + yield fixer.remove(innerParen); + } + const leftRange = [ + left.range[0], + getEndWithSpaces(left, sourceCode), + ]; + const rightRange = [ + Math.max( + getStartWithSpaces(right, sourceCode), + leftRange[1], + ), // Ensure ranges don't overlap + right.range[1], + ]; + + yield fixer.removeRange(leftRange); + yield fixer.removeRange(rightRange); + + // Remove the comma of this argument if it's duplication. + if ( + (argNode.properties.length === 0 || + isCommaToken(maybeTrailingComma)) && + isCommaToken(maybeArgumentComma) + ) { + yield fixer.remove(maybeArgumentComma); + } + } else { + // Make spread. + if (argNeedsParens(argNode, sourceCode)) { + yield fixer.insertTextBefore(left, "...("); + yield fixer.insertTextAfter(right, ")"); + } else { + yield fixer.insertTextBefore(left, "..."); + } + } + } + }; +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/prefer-object-spread", + }, + + schema: [], + fixable: "code", + + messages: { + useSpreadMessage: + "Use an object spread instead of `Object.assign` eg: `{ ...foo }`.", + useLiteralMessage: + "Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const trackMap = { + Object: { + assign: { [CALL]: true }, + }, + }; + + // Iterate all calls of `Object.assign` (only of the global variable `Object`). + for (const { node: refNode } of tracker.iterateGlobalReferences( + trackMap, + )) { + if ( + refNode.arguments.length >= 1 && + refNode.arguments[0].type === "ObjectExpression" && + !hasArraySpread(refNode) && + !( + refNode.arguments.length > 1 && + (hasArgumentsWithAccessors(refNode) || + hasArgumentsWithProtoProperty(refNode)) + ) + ) { + const messageId = + refNode.arguments.length === 1 + ? "useLiteralMessage" + : "useSpreadMessage"; + const fix = defineFixer(refNode, sourceCode); + + context.report({ node: refNode, messageId, fix }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js new file mode 100644 index 00000000..79cf81f9 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js @@ -0,0 +1,164 @@ +/** + * @fileoverview restrict values that can be used as Promise rejection reasons + * @author Teddy Katz + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowEmptyReject: false, + }, + ], + + docs: { + description: + "Require using Error objects as Promise rejection reasons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors", + }, + + fixable: null, + + schema: [ + { + type: "object", + properties: { + allowEmptyReject: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + + messages: { + rejectAnError: + "Expected the Promise rejection reason to be an Error.", + }, + }, + + create(context) { + const [{ allowEmptyReject }] = context.options; + const sourceCode = context.sourceCode; + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error + * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise + * @returns {void} + */ + function checkRejectCall(callExpression) { + if (!callExpression.arguments.length && allowEmptyReject) { + return; + } + + const rejectionReason = callExpression.arguments[0]; + + if ( + !callExpression.arguments.length || + !astUtils.couldBeError(rejectionReason) || + (rejectionReason.type === "Identifier" && + rejectionReason.name === "undefined" && + sourceCode.isGlobalReference(rejectionReason)) + ) { + context.report({ + node: callExpression, + messageId: "rejectAnError", + }); + } + } + + /** + * Determines whether a function call is a Promise.reject() call + * @param {ASTNode} node A CallExpression node + * @returns {boolean} `true` if the call is a Promise.reject() call + */ + function isPromiseRejectCall(node) { + return ( + astUtils.isSpecificMemberAccess( + node.callee, + "Promise", + "reject", + ) && + sourceCode.isGlobalReference( + astUtils.skipChainExpression(node.callee).object, + ) + ); + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + + return { + // Check `Promise.reject(value)` calls. + CallExpression(node) { + if (isPromiseRejectCall(node)) { + checkRejectCall(node); + } + }, + + /* + * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls. + * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that + * the nodes in the expression already have the `parent` property. + */ + "NewExpression:exit"(node) { + if ( + node.callee.type === "Identifier" && + node.callee.name === "Promise" && + sourceCode.isGlobalReference(node.callee) && + node.arguments.length && + astUtils.isFunction(node.arguments[0]) && + node.arguments[0].params.length > 1 && + node.arguments[0].params[1].type === "Identifier" + ) { + sourceCode + .getDeclaredVariables(node.arguments[0]) + + /* + * Find the first variable that matches the second parameter's name. + * If the first parameter has the same name as the second parameter, then the variable will actually + * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten + * by the second parameter. It's not possible for an expression with the variable to be evaluated before + * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or + * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for + * this case. + */ + .find( + variable => + variable.name === + node.arguments[0].params[1].name, + ) + + // Get the references to that variable. + .references // Only check the references that read the parameter's value. + .filter(ref => ref.isRead()) + + // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`. + .filter( + ref => + ref.identifier.parent.type === + "CallExpression" && + ref.identifier === ref.identifier.parent.callee, + ) + + // Check the argument of the function call to determine whether it's an Error. + .forEach(ref => checkRejectCall(ref.identifier.parent)); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-reflect.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-reflect.js new file mode 100644 index 00000000..4eae98af --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-reflect.js @@ -0,0 +1,150 @@ +/** + * @fileoverview Rule to suggest using "Reflect" api over Function/Object methods + * @author Keith Cirkel + * @deprecated in ESLint v3.9.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require `Reflect` methods where applicable", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-reflect", + }, + + deprecated: { + message: "The original intention of this rule was misguided.", + deprecatedSince: "3.9.0", + availableUntil: null, + replacedBy: [], + }, + + schema: [ + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + enum: [ + "apply", + "call", + "delete", + "defineProperty", + "getOwnPropertyDescriptor", + "getPrototypeOf", + "setPrototypeOf", + "isExtensible", + "getOwnPropertyNames", + "preventExtensions", + ], + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + preferReflect: + "Avoid using {{existing}}, instead use {{substitute}}.", + }, + }, + + create(context) { + const existingNames = { + apply: "Function.prototype.apply", + call: "Function.prototype.call", + defineProperty: "Object.defineProperty", + getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor", + getPrototypeOf: "Object.getPrototypeOf", + setPrototypeOf: "Object.setPrototypeOf", + isExtensible: "Object.isExtensible", + getOwnPropertyNames: "Object.getOwnPropertyNames", + preventExtensions: "Object.preventExtensions", + }; + + const reflectSubstitutes = { + apply: "Reflect.apply", + call: "Reflect.apply", + defineProperty: "Reflect.defineProperty", + getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor", + getPrototypeOf: "Reflect.getPrototypeOf", + setPrototypeOf: "Reflect.setPrototypeOf", + isExtensible: "Reflect.isExtensible", + getOwnPropertyNames: "Reflect.getOwnPropertyNames", + preventExtensions: "Reflect.preventExtensions", + }; + + const exceptions = (context.options[0] || {}).exceptions || []; + + /** + * Reports the Reflect violation based on the `existing` and `substitute` + * @param {Object} node The node that violates the rule. + * @param {string} existing The existing method name that has been used. + * @param {string} substitute The Reflect substitute that should be used. + * @returns {void} + */ + function report(node, existing, substitute) { + context.report({ + node, + messageId: "preferReflect", + data: { + existing, + substitute, + }, + }); + } + + return { + CallExpression(node) { + const methodName = (node.callee.property || {}).name; + const isReflectCall = + (node.callee.object || {}).name === "Reflect"; + const hasReflectSubstitute = Object.hasOwn( + reflectSubstitutes, + methodName, + ); + const userConfiguredException = exceptions.includes(methodName); + + if ( + hasReflectSubstitute && + !isReflectCall && + !userConfiguredException + ) { + report( + node, + existingNames[methodName], + reflectSubstitutes[methodName], + ); + } + }, + UnaryExpression(node) { + const isDeleteOperator = node.operator === "delete"; + const targetsIdentifier = node.argument.type === "Identifier"; + const userConfiguredException = exceptions.includes("delete"); + + if ( + isDeleteOperator && + !targetsIdentifier && + !userConfiguredException + ) { + report( + node, + "the delete keyword", + "Reflect.deleteProperty", + ); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-regex-literals.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-regex-literals.js new file mode 100644 index 00000000..f1414dfa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/prefer-regex-literals.js @@ -0,0 +1,605 @@ +/** + * @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals + * @author Milos Djermanovic + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const { + CALL, + CONSTRUCT, + ReferenceTracker, +} = require("@eslint-community/eslint-utils"); +const { + RegExpValidator, + visitRegExpAST, + RegExpParser, +} = require("@eslint-community/regexpp"); +const { canTokensBeAdjacent } = require("./utils/ast-utils"); +const { REGEXPP_LATEST_ECMA_VERSION } = require("./utils/regular-expressions"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines whether the given node is a string literal. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is a string literal. + */ +function isStringLiteral(node) { + return node.type === "Literal" && typeof node.value === "string"; +} + +/** + * Determines whether the given node is a regex literal. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is a regex literal. + */ +function isRegexLiteral(node) { + return node.type === "Literal" && Object.hasOwn(node, "regex"); +} + +const validPrecedingTokens = new Set([ + "(", + ";", + "[", + ",", + "=", + "+", + "*", + "-", + "?", + "~", + "%", + "**", + "!", + "typeof", + "instanceof", + "&&", + "||", + "??", + "return", + "...", + "delete", + "void", + "in", + "<", + ">", + "<=", + ">=", + "==", + "===", + "!=", + "!==", + "<<", + ">>", + ">>>", + "&", + "|", + "^", + ":", + "{", + "=>", + "*=", + "<<=", + ">>=", + ">>>=", + "^=", + "|=", + "&=", + "??=", + "||=", + "&&=", + "**=", + "+=", + "-=", + "/=", + "%=", + "/", + "do", + "break", + "continue", + "debugger", + "case", + "throw", +]); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + disallowRedundantWrapping: false, + }, + ], + + docs: { + description: + "Disallow use of the `RegExp` constructor in favor of regular expression literals", + recommended: false, + url: "https://eslint.org/docs/latest/rules/prefer-regex-literals", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + disallowRedundantWrapping: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedRegExp: + "Use a regular expression literal instead of the 'RegExp' constructor.", + replaceWithLiteral: + "Replace with an equivalent regular expression literal.", + replaceWithLiteralAndFlags: + "Replace with an equivalent regular expression literal with flags '{{ flags }}'.", + replaceWithIntendedLiteralAndFlags: + "Replace with a regular expression literal with flags '{{ flags }}'.", + unexpectedRedundantRegExp: + "Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.", + unexpectedRedundantRegExpWithFlags: + "Use regular expression literal with flags instead of the 'RegExp' constructor.", + }, + }, + + create(context) { + const [{ disallowRedundantWrapping }] = context.options; + const sourceCode = context.sourceCode; + + /** + * Determines whether the given node is a String.raw`` tagged template expression + * with a static template literal. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is String.raw`` with a static template. + */ + function isStringRawTaggedStaticTemplateLiteral(node) { + return ( + node.type === "TaggedTemplateExpression" && + astUtils.isSpecificMemberAccess(node.tag, "String", "raw") && + sourceCode.isGlobalReference( + astUtils.skipChainExpression(node.tag).object, + ) && + astUtils.isStaticTemplateLiteral(node.quasi) + ); + } + + /** + * Gets the value of a string + * @param {ASTNode} node The node to get the string of. + * @returns {string|null} The value of the node. + */ + function getStringValue(node) { + if (isStringLiteral(node)) { + return node.value; + } + + if (astUtils.isStaticTemplateLiteral(node)) { + return node.quasis[0].value.cooked; + } + + if (isStringRawTaggedStaticTemplateLiteral(node)) { + return node.quasi.quasis[0].value.raw; + } + + return null; + } + + /** + * Determines whether the given node is considered to be a static string by the logic of this rule. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is a static string. + */ + function isStaticString(node) { + return ( + isStringLiteral(node) || + astUtils.isStaticTemplateLiteral(node) || + isStringRawTaggedStaticTemplateLiteral(node) + ); + } + + /** + * Determines whether the relevant arguments of the given are all static string literals. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if all arguments are static strings. + */ + function hasOnlyStaticStringArguments(node) { + const args = node.arguments; + + if ( + (args.length === 1 || args.length === 2) && + args.every(isStaticString) + ) { + return true; + } + + return false; + } + + /** + * Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node already contains a regex literal argument. + */ + function isUnnecessarilyWrappedRegexLiteral(node) { + const args = node.arguments; + + if (args.length === 1 && isRegexLiteral(args[0])) { + return true; + } + + if ( + args.length === 2 && + isRegexLiteral(args[0]) && + isStaticString(args[1]) + ) { + return true; + } + + return false; + } + + /** + * Returns a ecmaVersion compatible for regexpp. + * @param {number} ecmaVersion The ecmaVersion to convert. + * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp. + */ + function getRegexppEcmaVersion(ecmaVersion) { + if (ecmaVersion <= 5) { + return 5; + } + return Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION); + } + + const regexppEcmaVersion = getRegexppEcmaVersion( + context.languageOptions.ecmaVersion, + ); + + /** + * Makes a character escaped or else returns null. + * @param {string} character The character to escape. + * @returns {string} The resulting escaped character. + */ + function resolveEscapes(character) { + switch (character) { + case "\n": + case "\\\n": + return "\\n"; + + case "\r": + case "\\\r": + return "\\r"; + + case "\t": + case "\\\t": + return "\\t"; + + case "\v": + case "\\\v": + return "\\v"; + + case "\f": + case "\\\f": + return "\\f"; + + case "/": + return "\\/"; + + default: + return null; + } + } + + /** + * Checks whether the given regex and flags are valid for the ecma version or not. + * @param {string} pattern The regex pattern to check. + * @param {string | undefined} flags The regex flags to check. + * @returns {boolean} True if the given regex pattern and flags are valid for the ecma version. + */ + function isValidRegexForEcmaVersion(pattern, flags) { + const validator = new RegExpValidator({ + ecmaVersion: regexppEcmaVersion, + }); + + try { + validator.validatePattern(pattern, 0, pattern.length, { + unicode: flags ? flags.includes("u") : false, + unicodeSets: flags ? flags.includes("v") : false, + }); + if (flags) { + validator.validateFlags(flags); + } + return true; + } catch { + return false; + } + } + + /** + * Checks whether two given regex flags contain the same flags or not. + * @param {string} flagsA The regex flags. + * @param {string} flagsB The regex flags. + * @returns {boolean} True if two regex flags contain same flags. + */ + function areFlagsEqual(flagsA, flagsB) { + return [...flagsA].sort().join("") === [...flagsB].sort().join(""); + } + + /** + * Merges two regex flags. + * @param {string} flagsA The regex flags. + * @param {string} flagsB The regex flags. + * @returns {string} The merged regex flags. + */ + function mergeRegexFlags(flagsA, flagsB) { + const flagsSet = new Set([...flagsA, ...flagsB]); + + return [...flagsSet].join(""); + } + + /** + * Checks whether a give node can be fixed to the given regex pattern and flags. + * @param {ASTNode} node The node to check. + * @param {string} pattern The regex pattern to check. + * @param {string} flags The regex flags + * @returns {boolean} True if a node can be fixed to the given regex pattern and flags. + */ + function canFixTo(node, pattern, flags) { + const tokenBefore = sourceCode.getTokenBefore(node); + + return ( + sourceCode.getCommentsInside(node).length === 0 && + (!tokenBefore || validPrecedingTokens.has(tokenBefore.value)) && + isValidRegexForEcmaVersion(pattern, flags) + ); + } + + /** + * Returns a safe output code considering the before and after tokens. + * @param {ASTNode} node The regex node. + * @param {string} newRegExpValue The new regex expression value. + * @returns {string} The output code. + */ + function getSafeOutput(node, newRegExpValue) { + const tokenBefore = sourceCode.getTokenBefore(node); + const tokenAfter = sourceCode.getTokenAfter(node); + + return ( + (tokenBefore && + !canTokensBeAdjacent(tokenBefore, newRegExpValue) && + tokenBefore.range[1] === node.range[0] + ? " " + : "") + + newRegExpValue + + (tokenAfter && + !canTokensBeAdjacent(newRegExpValue, tokenAfter) && + node.range[1] === tokenAfter.range[0] + ? " " + : "") + ); + } + + return { + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const traceMap = { + RegExp: { + [CALL]: true, + [CONSTRUCT]: true, + }, + }; + + for (const { node: refNode } of tracker.iterateGlobalReferences( + traceMap, + )) { + if ( + disallowRedundantWrapping && + isUnnecessarilyWrappedRegexLiteral(refNode) + ) { + const regexNode = refNode.arguments[0]; + + if (refNode.arguments.length === 2) { + const suggests = []; + + const argFlags = + getStringValue(refNode.arguments[1]) || ""; + + if ( + canFixTo( + refNode, + regexNode.regex.pattern, + argFlags, + ) + ) { + suggests.push({ + messageId: "replaceWithLiteralAndFlags", + pattern: regexNode.regex.pattern, + flags: argFlags, + }); + } + + const literalFlags = regexNode.regex.flags || ""; + const mergedFlags = mergeRegexFlags( + literalFlags, + argFlags, + ); + + if ( + !areFlagsEqual(mergedFlags, argFlags) && + canFixTo( + refNode, + regexNode.regex.pattern, + mergedFlags, + ) + ) { + suggests.push({ + messageId: + "replaceWithIntendedLiteralAndFlags", + pattern: regexNode.regex.pattern, + flags: mergedFlags, + }); + } + + context.report({ + node: refNode, + messageId: "unexpectedRedundantRegExpWithFlags", + suggest: suggests.map( + ({ flags, pattern, messageId }) => ({ + messageId, + data: { + flags, + }, + fix(fixer) { + return fixer.replaceText( + refNode, + getSafeOutput( + refNode, + `/${pattern}/${flags}`, + ), + ); + }, + }), + ), + }); + } else { + const outputs = []; + + if ( + canFixTo( + refNode, + regexNode.regex.pattern, + regexNode.regex.flags, + ) + ) { + outputs.push(sourceCode.getText(regexNode)); + } + + context.report({ + node: refNode, + messageId: "unexpectedRedundantRegExp", + suggest: outputs.map(output => ({ + messageId: "replaceWithLiteral", + fix(fixer) { + return fixer.replaceText( + refNode, + getSafeOutput(refNode, output), + ); + }, + })), + }); + } + } else if (hasOnlyStaticStringArguments(refNode)) { + let regexContent = getStringValue(refNode.arguments[0]); + let noFix = false; + let flags; + + if (refNode.arguments[1]) { + flags = getStringValue(refNode.arguments[1]); + } + + if (!canFixTo(refNode, regexContent, flags)) { + noFix = true; + } + + if ( + !/^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.> + accumulator + + sourceText.slice( + token.range[1], + allTokens[index + 1].range[0], + ), + "", + ); + } + + /** + * Returns a template literal form of the given node. + * @param {ASTNode} currentNode A node that should be converted to a template literal + * @param {string} textBeforeNode Text that should appear before the node + * @param {string} textAfterNode Text that should appear after the node + * @returns {string} A string form of this node, represented as a template literal + */ + function getTemplateLiteral( + currentNode, + textBeforeNode, + textAfterNode, + ) { + if ( + currentNode.type === "Literal" && + typeof currentNode.value === "string" + ) { + /* + * If the current node is a string literal, escape any instances of ${ or ` to prevent them from being interpreted + * as a template placeholder. However, if the code already contains a backslash before the ${ or ` + * for some reason, don't add another backslash, because that would change the meaning of the code (it would cause + * an actual backslash character to appear before the dollar sign). + */ + return `\`${currentNode.raw + .slice(1, -1) + .replace(/(? { + if (matched.lastIndexOf("\\") % 2) { + return `\\${matched}`; + } + return matched; + + // Unescape any quotes that appear in the original Literal that no longer need to be escaped. + }) + .replace( + new RegExp(`\\\\${currentNode.raw[0]}`, "gu"), + currentNode.raw[0], + )}\``; + } + + if (currentNode.type === "TemplateLiteral") { + return sourceCode.getText(currentNode); + } + + if (isConcatenation(currentNode) && hasStringLiteral(currentNode)) { + const plusSign = sourceCode.getFirstTokenBetween( + currentNode.left, + currentNode.right, + token => token.value === "+", + ); + const textBeforePlus = getTextBetween( + currentNode.left, + plusSign, + ); + const textAfterPlus = getTextBetween( + plusSign, + currentNode.right, + ); + const leftEndsWithCurly = endsWithTemplateCurly( + currentNode.left, + ); + const rightStartsWithCurly = startsWithTemplateCurly( + currentNode.right, + ); + + if (leftEndsWithCurly) { + // If the left side of the expression ends with a template curly, add the extra text to the end of the curly bracket. + // `foo${bar}` /* comment */ + 'baz' --> `foo${bar /* comment */ }${baz}` + return ( + getTemplateLiteral( + currentNode.left, + textBeforeNode, + textBeforePlus + textAfterPlus, + ).slice(0, -1) + + getTemplateLiteral( + currentNode.right, + null, + textAfterNode, + ).slice(1) + ); + } + if (rightStartsWithCurly) { + // Otherwise, if the right side of the expression starts with a template curly, add the text there. + // 'foo' /* comment */ + `${bar}baz` --> `foo${ /* comment */ bar}baz` + return ( + getTemplateLiteral( + currentNode.left, + textBeforeNode, + null, + ).slice(0, -1) + + getTemplateLiteral( + currentNode.right, + textBeforePlus + textAfterPlus, + textAfterNode, + ).slice(1) + ); + } + + /* + * Otherwise, these nodes should not be combined into a template curly, since there is nowhere to put + * the text between them. + */ + return `${getTemplateLiteral(currentNode.left, textBeforeNode, null)}${textBeforePlus}+${textAfterPlus}${getTemplateLiteral(currentNode.right, textAfterNode, null)}`; + } + + return `\`\${${textBeforeNode || ""}${sourceCode.getText(currentNode)}${textAfterNode || ""}}\``; + } + + /** + * Returns a fixer object that converts a non-string binary expression to a template literal + * @param {SourceCodeFixer} fixer The fixer object + * @param {ASTNode} node A node that should be converted to a template literal + * @returns {Object} A fix for this binary expression + */ + function fixNonStringBinaryExpression(fixer, node) { + const topBinaryExpr = getTopConcatBinaryExpression(node.parent); + + if (hasOctalOrNonOctalDecimalEscapeSequence(topBinaryExpr)) { + return null; + } + + const prefix = + astUtils.isStartOfExpressionStatement(topBinaryExpr) && + astUtils.needsPrecedingSemicolon(sourceCode, topBinaryExpr) + ? ";" + : ""; + + return fixer.replaceText( + topBinaryExpr, + `${prefix}${getTemplateLiteral(topBinaryExpr, null, null)}`, + ); + } + + /** + * Reports if a given node is string concatenation with non string literals. + * @param {ASTNode} node A node to check. + * @returns {void} + */ + function checkForStringConcat(node) { + if ( + !astUtils.isStringLiteral(node) || + !isConcatenation(node.parent) + ) { + return; + } + + const topBinaryExpr = getTopConcatBinaryExpression(node.parent); + + // Checks whether or not this node had been checked already. + if (done[topBinaryExpr.range[0]]) { + return; + } + done[topBinaryExpr.range[0]] = true; + + if (hasNonStringLiteral(topBinaryExpr)) { + context.report({ + node: topBinaryExpr, + messageId: "unexpectedStringConcatenation", + fix: fixer => fixNonStringBinaryExpression(fixer, node), + }); + } + } + + return { + Program() { + done = Object.create(null); + }, + + Literal: checkForStringConcat, + TemplateLiteral: checkForStringConcat, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/preserve-caught-error.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/preserve-caught-error.js new file mode 100644 index 00000000..b89033de --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/preserve-caught-error.js @@ -0,0 +1,687 @@ +/** + * @fileoverview Rule to preserve caught errors when re-throwing exceptions + * @author Amnish Singh Arora + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("estree").Node} ASTNode */ +/** @typedef {import("eslint").Rule.Fix} Fix */ +/** @typedef {import("eslint").Rule.RuleFixer} RuleFixer */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/* + * This is an indicator of an error cause node, that is too complicated to be detected and fixed. + * Eg, when error options is an `Identifier` or a `SpreadElement`. + */ +const UNKNOWN_CAUSE = Symbol("unknown_cause"); + +const BUILT_IN_ERROR_TYPES = new Set([ + "Error", + "EvalError", + "RangeError", + "ReferenceError", + "SyntaxError", + "TypeError", + "URIError", + "AggregateError", +]); + +/** + * Finds and returns information about the `cause` property of an error being thrown. + * @param {ASTNode} throwStatement `ThrowStatement` to be checked. + * @param {number} optionsIndex The index of the options argument in the error constructor. + * @returns {{ value: ASTNode; multipleDefinitions: boolean; } | UNKNOWN_CAUSE | null} + * Information about the `cause` of the error being thrown, such as the value node and + * whether there are multiple definitions of `cause`. `null` if there is no `cause`. + */ +function getErrorCause(throwStatement, optionsIndex) { + const throwExpression = throwStatement.argument; + + /* + * Make sure there is no `SpreadElement` at or before the `optionsIndex` + * as this messes up the effective order of arguments and makes it complicated + * to track where the actual error options need to be at + */ + const spreadExpressionIndex = throwExpression.arguments.findIndex( + arg => arg.type === "SpreadElement", + ); + if (spreadExpressionIndex >= 0 && spreadExpressionIndex <= optionsIndex) { + return UNKNOWN_CAUSE; + } + + const errorOptions = throwExpression.arguments[optionsIndex]; + + if (errorOptions) { + if (errorOptions.type === "ObjectExpression") { + if ( + errorOptions.properties.some( + prop => prop.type === "SpreadElement", + ) + ) { + /* + * If there is a spread element as part of error options, it is too complicated + * to verify if the cause is used properly and auto-fix. + */ + return UNKNOWN_CAUSE; + } + + const causeProperties = errorOptions.properties.filter( + prop => astUtils.getStaticPropertyName(prop) === "cause", + ); + + const causeProperty = causeProperties.at(-1); + return causeProperty + ? { + value: causeProperty.value, + multipleDefinitions: causeProperties.length > 1, + } + : null; + } + + // Error options exist, but too complicated to be analyzed/fixed + return UNKNOWN_CAUSE; + } + + return null; +} + +/** + * Finds and returns the `CatchClause` node, that the `node` is part of. + * @param {ASTNode} node The AST node to be evaluated. + * @returns {ASTNode | null } The closest parent `CatchClause` node, `null` if the `node` is not in a catch block. + */ +function findParentCatch(node) { + let currentNode = node; + + while (currentNode && currentNode.type !== "CatchClause") { + if ( + [ + "FunctionDeclaration", + "FunctionExpression", + "ArrowFunctionExpression", + "StaticBlock", + ].includes(currentNode.type) + ) { + /* + * Make sure the ThrowStatement is not made inside a function definition or a static block inside a high level catch. + * In such cases, the caught error is not directly related to the Throw. + * + * For example, + * try { + * } catch (error) { + * foo = { + * bar() { + * throw new Error(); + * } + * }; + * } + */ + return null; + } + currentNode = currentNode.parent; + } + + return currentNode; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + requireCatchParameter: false, + errorClassNames: [], + }, + ], + + docs: { + description: + "Disallow losing originally caught error when re-throwing custom errors", + recommended: true, + url: "https://eslint.org/docs/latest/rules/preserve-caught-error", // URL to the documentation page for this rule + }, + schema: [ + { + type: "object", + properties: { + requireCatchParameter: { + type: "boolean", + description: + "Requires the catch blocks to always have the caught error parameter so it is not discarded.", + }, + errorClassNames: { + type: "array", + description: + "Additional error class names to check for cause preservation.", + items: { + oneOf: [ + { + type: "string", + }, + { + type: "object", + required: ["name", "argumentPosition"], + properties: { + name: { + type: "string", + }, + argumentPosition: { + type: "integer", + minimum: 1, + }, + }, + additionalProperties: false, + }, + ], + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + messages: { + missingCause: + "There is no `cause` attached to the symptom error being thrown.", + incorrectCause: + "The symptom error is being thrown with an incorrect `cause`.", + includeCause: + "Include the original caught error as the `cause` of the symptom error.", + missingCatchErrorParam: + "The caught error is not accessible because the catch clause lacks the error parameter. Start referencing the caught error using the catch parameter.", + partiallyLostError: + "Re-throws cannot preserve the caught error as a part of it is being lost due to destructuring.", + caughtErrorShadowed: + "The caught error is being attached as `cause`, but is shadowed by a closer scoped redeclaration.", + }, + hasSuggestions: true, + }, + + create(context) { + const sourceCode = context.sourceCode; + const [{ requireCatchParameter, errorClassNames }] = context.options; + + const errorClassNamesMap = new Map(); + for (const item of errorClassNames) { + const name = typeof item === "string" ? item : item.name; + const argumentPosition = + typeof item === "string" ? 2 : item.argumentPosition; + + errorClassNamesMap.set(name, argumentPosition); + } + + //---------------------------------------------------------------------- + // Helpers + //---------------------------------------------------------------------- + + /** + * Checks if the given callee refers to a built-in global Error constructor. + * @param {ASTNode} callee The callee node. + * @returns {boolean} `true` if the callee is a built-in global Error constructor. + */ + function isBuiltInGlobalError(callee) { + return ( + callee.type === "Identifier" && + BUILT_IN_ERROR_TYPES.has(callee.name) && + sourceCode.isGlobalReference(callee) + ); + } + + /** + * Checks if a `ThrowStatement` is constructing and throwing a new `Error` object. + * + * Covers all the error types on `globalThis` that support `cause` property: + * https://github.com/microsoft/TypeScript/blob/main/src/lib/es2022.error.d.ts + * @param {ASTNode} throwStatement The `ThrowStatement` that needs to be checked. + * @returns {boolean} `true` if a new "Error" is being thrown, else `false`. + */ + function isThrowingNewError(throwStatement) { + if (!( + throwStatement.argument.type === "NewExpression" || + throwStatement.argument.type === "CallExpression" + )) { + return false; + } + + const callee = throwStatement.argument.callee; + + /* + * Make sure the thrown Error instance is one of the built-in global error types. + * Custom imports could shadow this, which would lead to false positives. + * e.g. import { Error } from "./my-custom-error.js"; + * throw Error("Failed to perform error prone operations"); + */ + if (isBuiltInGlobalError(callee)) { + return true; + } + + const target = + callee.type === "MemberExpression" && !callee.computed + ? callee.property + : callee; + + return ( + target.type === "Identifier" && + errorClassNamesMap.has(target.name) + ); + } + + /** + * Inserts `cause: ` into an inline options object expression. + * @param {RuleFixer} fixer The fixer object. + * @param {ASTNode} optionsNode The options object node. + * @param {string} caughtErrorName The name of the caught error (e.g., "err"). + * @returns {Fix} The fix object. + */ + function insertCauseIntoOptions(fixer, optionsNode, caughtErrorName) { + const properties = optionsNode.properties; + + if (properties.length === 0) { + // Insert inside empty braces: `{}` → `{ cause: err }` + return fixer.insertTextAfter( + sourceCode.getFirstToken(optionsNode), + `cause: ${caughtErrorName}`, + ); + } + + const lastProp = properties.at(-1); + return fixer.insertTextAfter( + lastProp, + `, cause: ${caughtErrorName}`, + ); + } + + /** + * Finds the first token that isn't followed by a closing parenthesis in a specified range. + * This is the token after which new arguments should be inserted. + * @param {Token} firstToken The first token to start searching from. + * @param {Token} lastToken The last token to scan up to (inclusive). + * @returns {Token} The first token that isn't followed by a closing parenthesis, or `lastToken` if none is found. + */ + function findInsertionTokenAfterParens(firstToken, lastToken) { + const lastIndex = lastToken.range[1]; + let token = firstToken; + let nextToken = sourceCode.getTokenAfter(token); + + while ( + nextToken.range[1] <= lastIndex && + astUtils.isClosingParenToken(nextToken) + ) { + token = nextToken; + nextToken = sourceCode.getTokenAfter(token); + } + return token; + } + + /** + * Adds arguments for a call/new expression with no arguments. + * Works for `new Error`, `new (Error)`, and forms that already include empty argument parentheses. + * @param {RuleFixer} fixer The fixer instance. + * @param {ASTNode & { callee: ASTNode }} throwExpression The thrown CallExpression or NewExpression node. + * @param {string} text The arguments to insert. + * @returns {Fix} The fixer operation. + */ + function addArgumentsToEmptyCall(fixer, throwExpression, text) { + const callClosingParenToken = + sourceCode.getLastToken(throwExpression); + const lastCalleeToken = sourceCode.getLastToken( + throwExpression.callee, + ); + const parenToken = sourceCode.getFirstTokenBetween( + lastCalleeToken, + callClosingParenToken, + astUtils.isOpeningParenToken, + ); + + if (parenToken) { + return fixer.insertTextAfter(parenToken, text); + } + + const insertionToken = findInsertionTokenAfterParens( + lastCalleeToken, + callClosingParenToken, + ); + + return fixer.insertTextAfter(insertionToken, `(${text})`); + } + + /** + * Appends additional arguments after the last argument of a call/new expression, + * accounting for any wrapping parentheses around that argument. + * @param {RuleFixer} fixer The fixer instance. + * @param {ASTNode & { arguments: ASTNode[] }} throwExpression The thrown CallExpression or NewExpression node. + * @param {string} text The additional arguments to insert, including the leading comma. + * @returns {Fix} The fixer operation. + */ + function appendArguments(fixer, throwExpression, text) { + const lastArgument = throwExpression.arguments.at(-1); + const lastArgumentToken = sourceCode.getLastToken(lastArgument); + const lastTokenBeforeArgListParen = sourceCode.getLastToken( + throwExpression, + { skip: 1 }, + ); + const insertionToken = findInsertionTokenAfterParens( + lastArgumentToken, + lastTokenBeforeArgListParen, + ); + + return fixer.insertTextAfter(insertionToken, text); + } + + //---------------------------------------------------------------------- + // Public + //---------------------------------------------------------------------- + return { + ThrowStatement(node) { + // Check if the throw is inside a catch block + const parentCatch = findParentCatch(node); + const throwStatement = node; + + // Check if a new error is being thrown in a catch block + if (parentCatch && isThrowingNewError(throwStatement)) { + if ( + parentCatch.param && + parentCatch.param.type !== "Identifier" + ) { + /* + * When a part of the caught error is being lost at the parameter level, commonly due to destructuring. + * e.g. catch({ message, ...rest }) + */ + context.report({ + messageId: "partiallyLostError", + node: parentCatch, + }); + return; + } + + const caughtError = + parentCatch.param?.type === "Identifier" + ? parentCatch.param + : null; + + // Check if there are throw statements and caught error is being ignored + if (!caughtError) { + if (requireCatchParameter) { + context.report({ + node: throwStatement, + messageId: "missingCatchErrorParam", + }); + return; + } + return; + } + + // Determine the options argument index + const callee = throwStatement.argument.callee; + const errorClassName = + callee.type === "Identifier" + ? callee.name + : callee.property.name; + + const builtInGlobalError = isBuiltInGlobalError(callee); + + let optionsIndex; + if (builtInGlobalError) { + optionsIndex = + errorClassName === "AggregateError" ? 2 : 1; + } else { + const argumentPosition = + errorClassNamesMap.get(errorClassName); + optionsIndex = argumentPosition - 1; + } + + // Check if there is a cause attached to the new error + const errorCauseInfo = getErrorCause( + throwStatement, + optionsIndex, + ); + + if (errorCauseInfo === UNKNOWN_CAUSE) { + // Error options exist, but too complicated to be analyzed/fixed + return; + } + + if (errorCauseInfo === null) { + // If there is no `cause` attached to the error being thrown. + context.report({ + messageId: "missingCause", + node: throwStatement, + suggest: [ + { + messageId: "includeCause", + fix(fixer) { + const throwExpression = + throwStatement.argument; + const args = throwExpression.arguments; + + /** + * Inserts `cause` into the options argument if it is an `ObjectExpression`. + * @param {ASTNode} optionsArg The options argument node. + * @returns {Fix | null} The fix, or `null` if the argument is not an object. + */ + function fixExistingOptions( + optionsArg, + ) { + if ( + optionsArg.type === + "ObjectExpression" + ) { + return insertCauseIntoOptions( + fixer, + optionsArg, + caughtError.name, + ); + } + return null; + } + + // AggregateError: errors, message, options + if ( + builtInGlobalError && + errorClassName === "AggregateError" + ) { + const errorsArg = args[0]; + const messageArg = args[1]; + const optionsArg = args[2]; + + if (!errorsArg) { + // Case: `throw new AggregateError()` → insert all arguments + return addArgumentsToEmptyCall( + fixer, + throwExpression, + `[], "", { cause: ${caughtError.name} }`, + ); + } + + if (!messageArg) { + // Case: `throw new AggregateError([])` → insert message and options + return appendArguments( + fixer, + throwExpression, + `, "", { cause: ${caughtError.name} }`, + ); + } + + if (!optionsArg) { + // Case: `throw new AggregateError([], "")` → insert error options only + return appendArguments( + fixer, + throwExpression, + `, { cause: ${caughtError.name} }`, + ); + } + + return fixExistingOptions( + optionsArg, + ); + } + + // Normal Error types + if (builtInGlobalError) { + const messageArg = args[0]; + const optionsArg = args[1]; + + if (!messageArg) { + // Case: `throw new Error()` → insert both message and options + return addArgumentsToEmptyCall( + fixer, + throwExpression, + `"", { cause: ${caughtError.name} }`, + ); + } + if (!optionsArg) { + // Case: `throw new Error("Some message")` → insert only options + return appendArguments( + fixer, + throwExpression, + `, { cause: ${caughtError.name} }`, + ); + } + + return fixExistingOptions( + optionsArg, + ); + } + + // Custom error types + const optionsArg = args[optionsIndex]; + + /* + * Custom error signature is unknown, so skip the suggestion rather + * than synthesize placeholder values for missing positional args. + */ + if (args.length < optionsIndex) { + return null; + } + + if (!optionsArg) { + const lastProvidedArg = args.at(-1); + + if (lastProvidedArg) { + // Options slot missing, all prior args provided → append options + return appendArguments( + fixer, + throwExpression, + `, { cause: ${caughtError.name} }`, + ); + } + + // argumentPosition: 1 and no args → insert options inside parens + return addArgumentsToEmptyCall( + fixer, + throwExpression, + `{ cause: ${caughtError.name} }`, + ); + } + + return fixExistingOptions(optionsArg); + }, + }, + ], + }); + + // We don't need to check further + return; + } + + const { value: thrownErrorCause } = errorCauseInfo; + + // If there is an attached cause, verify that it matches the caught error + if (!( + thrownErrorCause.type === "Identifier" && + thrownErrorCause.name === caughtError.name + )) { + const suggest = errorCauseInfo.multipleDefinitions + ? null // If there are multiple `cause` definitions, a suggestion could be confusing. + : [ + { + messageId: "includeCause", + fix(fixer) { + /* + * In case `cause` is attached using object property shorthand or as a method or accessor. + * e.g. throw Error("fail", { cause }); + * throw Error("fail", { cause() { doSomething(); } }); + * throw Error("fail", { get cause() { return error; } }); + */ + if ( + thrownErrorCause.parent + .method || + thrownErrorCause.parent + .shorthand || + thrownErrorCause.parent.kind !== + "init" + ) { + return fixer.replaceText( + thrownErrorCause.parent, + `cause: ${caughtError.name}`, + ); + } + + return fixer.replaceText( + thrownErrorCause, + caughtError.name, + ); + }, + }, + ]; + context.report({ + messageId: "incorrectCause", + node: thrownErrorCause, + suggest, + }); + return; + } + + /* + * If the attached cause matches the identifier name of the caught error, + * make sure it is not being shadowed by a closer scoped redeclaration. + * + * e.g. try { + * doSomething(); + * } catch (error) { + * if (whatever) { + * const error = anotherError; + * throw new Error("Something went wrong"); + * } + * } + */ + let scope = sourceCode.getScope(throwStatement); + do { + const variable = scope.set.get(caughtError.name); + if (variable) { + break; + } + scope = scope.upper; + } while (scope); + + if (scope?.block !== parentCatch) { + // Caught error is being shadowed + context.report({ + messageId: "caughtErrorShadowed", + node: throwStatement, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quote-props.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quote-props.js new file mode 100644 index 00000000..5cbf77d5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quote-props.js @@ -0,0 +1,394 @@ +/** + * @fileoverview Rule to flag non-quoted property names in object literals. + * @author Mathias Bynens + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const espree = require("espree"); +const astUtils = require("./utils/ast-utils"); +const keywords = require("./utils/keywords"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "quote-props", + url: "https://eslint.style/rules/quote-props", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: "Require quotes around object literal property names", + recommended: false, + url: "https://eslint.org/docs/latest/rules/quote-props", + }, + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: [ + "always", + "as-needed", + "consistent", + "consistent-as-needed", + ], + }, + ], + minItems: 0, + maxItems: 1, + }, + { + type: "array", + items: [ + { + enum: [ + "always", + "as-needed", + "consistent", + "consistent-as-needed", + ], + }, + { + type: "object", + properties: { + keywords: { + type: "boolean", + }, + unnecessary: { + type: "boolean", + }, + numbers: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + fixable: "code", + messages: { + requireQuotesDueToReservedWord: + "Properties should be quoted as '{{property}}' is a reserved word.", + inconsistentlyQuotedProperty: + "Inconsistently quoted property '{{key}}' found.", + unnecessarilyQuotedProperty: + "Unnecessarily quoted property '{{property}}' found.", + unquotedReservedProperty: + "Unquoted reserved word '{{property}}' used as key.", + unquotedNumericProperty: + "Unquoted number literal '{{property}}' used as key.", + unquotedPropertyFound: "Unquoted property '{{property}}' found.", + redundantQuoting: + "Properties shouldn't be quoted as all quotes are redundant.", + }, + }, + + create(context) { + const MODE = context.options[0], + KEYWORDS = context.options[1] && context.options[1].keywords, + CHECK_UNNECESSARY = + !context.options[1] || context.options[1].unnecessary !== false, + NUMBERS = context.options[1] && context.options[1].numbers, + sourceCode = context.sourceCode; + + /** + * Checks whether a certain string constitutes an ES3 token + * @param {string} tokenStr The string to be checked. + * @returns {boolean} `true` if it is an ES3 token. + */ + function isKeyword(tokenStr) { + return keywords.includes(tokenStr); + } + + /** + * Checks if an espree-tokenized key has redundant quotes (i.e. whether quotes are unnecessary) + * @param {string} rawKey The raw key value from the source + * @param {espreeTokens} tokens The espree-tokenized node key + * @param {boolean} [skipNumberLiterals=false] Indicates whether number literals should be checked + * @returns {boolean} Whether or not a key has redundant quotes. + * @private + */ + function areQuotesRedundant(rawKey, tokens, skipNumberLiterals) { + return ( + tokens.length === 1 && + tokens[0].start === 0 && + tokens[0].end === rawKey.length && + (["Identifier", "Keyword", "Null", "Boolean"].includes( + tokens[0].type, + ) || + (tokens[0].type === "Numeric" && + !skipNumberLiterals && + String(+tokens[0].value) === tokens[0].value)) + ); + } + + /** + * Returns a string representation of a property node with quotes removed + * @param {ASTNode} key Key AST Node, which may or may not be quoted + * @returns {string} A replacement string for this property + */ + function getUnquotedKey(key) { + return key.type === "Identifier" ? key.name : key.value; + } + + /** + * Returns a string representation of a property node with quotes added + * @param {ASTNode} key Key AST Node, which may or may not be quoted + * @returns {string} A replacement string for this property + */ + function getQuotedKey(key) { + if (key.type === "Literal" && typeof key.value === "string") { + // If the key is already a string literal, don't replace the quotes with double quotes. + return sourceCode.getText(key); + } + + // Otherwise, the key is either an identifier or a number literal. + return `"${key.type === "Identifier" ? key.name : key.value}"`; + } + + /** + * Ensures that a property's key is quoted only when necessary + * @param {ASTNode} node Property AST node + * @returns {void} + */ + function checkUnnecessaryQuotes(node) { + const key = node.key; + + if (node.method || node.computed || node.shorthand) { + return; + } + + if (key.type === "Literal" && typeof key.value === "string") { + let tokens; + + try { + tokens = espree.tokenize(key.value); + } catch { + return; + } + + if (tokens.length !== 1) { + return; + } + + const isKeywordToken = isKeyword(tokens[0].value); + + if (isKeywordToken && KEYWORDS) { + return; + } + + if ( + CHECK_UNNECESSARY && + areQuotesRedundant(key.value, tokens, NUMBERS) + ) { + context.report({ + node, + messageId: "unnecessarilyQuotedProperty", + data: { property: key.value }, + fix: fixer => + fixer.replaceText(key, getUnquotedKey(key)), + }); + } + } else if ( + KEYWORDS && + key.type === "Identifier" && + isKeyword(key.name) + ) { + context.report({ + node, + messageId: "unquotedReservedProperty", + data: { property: key.name }, + fix: fixer => fixer.replaceText(key, getQuotedKey(key)), + }); + } else if ( + NUMBERS && + key.type === "Literal" && + astUtils.isNumericLiteral(key) + ) { + context.report({ + node, + messageId: "unquotedNumericProperty", + data: { property: key.value }, + fix: fixer => fixer.replaceText(key, getQuotedKey(key)), + }); + } + } + + /** + * Ensures that a property's key is quoted + * @param {ASTNode} node Property AST node + * @returns {void} + */ + function checkOmittedQuotes(node) { + const key = node.key; + + if ( + !node.method && + !node.computed && + !node.shorthand && + !(key.type === "Literal" && typeof key.value === "string") + ) { + context.report({ + node, + messageId: "unquotedPropertyFound", + data: { property: key.name || key.value }, + fix: fixer => fixer.replaceText(key, getQuotedKey(key)), + }); + } + } + + /** + * Ensures that an object's keys are consistently quoted, optionally checks for redundancy of quotes + * @param {ASTNode} node Property AST node + * @param {boolean} checkQuotesRedundancy Whether to check quotes' redundancy + * @returns {void} + */ + function checkConsistency(node, checkQuotesRedundancy) { + const quotedProps = [], + unquotedProps = []; + let keywordKeyName = null, + necessaryQuotes = false; + + node.properties.forEach(property => { + const key = property.key; + + if ( + !key || + property.method || + property.computed || + property.shorthand + ) { + return; + } + + if (key.type === "Literal" && typeof key.value === "string") { + quotedProps.push(property); + + if (checkQuotesRedundancy) { + let tokens; + + try { + tokens = espree.tokenize(key.value); + } catch { + necessaryQuotes = true; + return; + } + + necessaryQuotes = + necessaryQuotes || + !areQuotesRedundant(key.value, tokens) || + (KEYWORDS && isKeyword(tokens[0].value)); + } + } else if ( + KEYWORDS && + checkQuotesRedundancy && + key.type === "Identifier" && + isKeyword(key.name) + ) { + unquotedProps.push(property); + necessaryQuotes = true; + keywordKeyName = key.name; + } else { + unquotedProps.push(property); + } + }); + + if ( + checkQuotesRedundancy && + quotedProps.length && + !necessaryQuotes + ) { + quotedProps.forEach(property => { + context.report({ + node: property, + messageId: "redundantQuoting", + fix: fixer => + fixer.replaceText( + property.key, + getUnquotedKey(property.key), + ), + }); + }); + } else if (unquotedProps.length && keywordKeyName) { + unquotedProps.forEach(property => { + context.report({ + node: property, + messageId: "requireQuotesDueToReservedWord", + data: { property: keywordKeyName }, + fix: fixer => + fixer.replaceText( + property.key, + getQuotedKey(property.key), + ), + }); + }); + } else if (quotedProps.length && unquotedProps.length) { + unquotedProps.forEach(property => { + context.report({ + node: property, + messageId: "inconsistentlyQuotedProperty", + data: { key: property.key.name || property.key.value }, + fix: fixer => + fixer.replaceText( + property.key, + getQuotedKey(property.key), + ), + }); + }); + } + } + + return { + Property(node) { + if (MODE === "always" || !MODE) { + checkOmittedQuotes(node); + } + if (MODE === "as-needed") { + checkUnnecessaryQuotes(node); + } + }, + ObjectExpression(node) { + if (MODE === "consistent") { + checkConsistency(node, false); + } + if (MODE === "consistent-as-needed") { + checkConsistency(node, true); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quotes.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quotes.js new file mode 100644 index 00000000..8630f926 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/quotes.js @@ -0,0 +1,416 @@ +/** + * @fileoverview A rule to choose between single and double quote marks + * @author Matt DuVall , Brandon Payton + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Constants +//------------------------------------------------------------------------------ + +const QUOTE_SETTINGS = { + double: { + quote: '"', + alternateQuote: "'", + description: "doublequote", + }, + single: { + quote: "'", + alternateQuote: '"', + description: "singlequote", + }, + backtick: { + quote: "`", + alternateQuote: '"', + description: "backtick", + }, +}; + +// An unescaped newline is a newline preceded by an even number of backslashes. +const UNESCAPED_LINEBREAK_PATTERN = new RegExp( + String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`, + "u", +); + +/** + * Switches quoting of javascript string between ' " and ` + * escaping and unescaping as necessary. + * Only escaping of the minimal set of characters is changed. + * Note: escaping of newlines when switching from backtick to other quotes is not handled. + * @param {string} str A string to convert. + * @returns {string} The string with changed quotes. + * @private + */ +QUOTE_SETTINGS.double.convert = + QUOTE_SETTINGS.single.convert = + QUOTE_SETTINGS.backtick.convert = + function (str) { + const newQuote = this.quote; + const oldQuote = str[0]; + + if (newQuote === oldQuote) { + return str; + } + return ( + newQuote + + str + .slice(1, -1) + .replace( + /\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu, + (match, escaped, newline) => { + if ( + escaped === oldQuote || + (oldQuote === "`" && escaped === "${") + ) { + return escaped; // unescape + } + if ( + match === newQuote || + (newQuote === "`" && match === "${") + ) { + return `\\${match}`; // escape + } + if (newline && oldQuote === "`") { + return "\\n"; // escape newlines + } + return match; + }, + ) + + newQuote + ); + }; + +const AVOID_ESCAPE = "avoid-escape"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "quotes", + url: "https://eslint.style/rules/quotes", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce the consistent use of either backticks, double, or single quotes", + recommended: false, + url: "https://eslint.org/docs/latest/rules/quotes", + }, + + fixable: "code", + + schema: [ + { + enum: ["single", "double", "backtick"], + }, + { + anyOf: [ + { + enum: ["avoid-escape"], + }, + { + type: "object", + properties: { + avoidEscape: { + type: "boolean", + }, + allowTemplateLiterals: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + wrongQuotes: "Strings must use {{description}}.", + }, + }, + + create(context) { + const quoteOption = context.options[0], + settings = QUOTE_SETTINGS[quoteOption || "double"], + options = context.options[1], + allowTemplateLiterals = + options && options.allowTemplateLiterals === true, + sourceCode = context.sourceCode; + let avoidEscape = options && options.avoidEscape === true; + + // deprecated + if (options === AVOID_ESCAPE) { + avoidEscape = true; + } + + /** + * Determines if a given node is part of JSX syntax. + * + * This function returns `true` in the following cases: + * + * - `
` ... If the literal is an attribute value, the parent of the literal is `JSXAttribute`. + * - `
foo
` ... If the literal is a text content, the parent of the literal is `JSXElement`. + * - `<>foo` ... If the literal is a text content, the parent of the literal is `JSXFragment`. + * + * In particular, this function returns `false` in the following cases: + * + * - `
` + * - `
{"foo"}
` + * + * In both cases, inside of the braces is handled as normal JavaScript. + * The braces are `JSXExpressionContainer` nodes. + * @param {ASTNode} node The Literal node to check. + * @returns {boolean} True if the node is a part of JSX, false if not. + * @private + */ + function isJSXLiteral(node) { + return ( + node.parent.type === "JSXAttribute" || + node.parent.type === "JSXElement" || + node.parent.type === "JSXFragment" + ); + } + + /** + * Checks whether or not a given node is a directive. + * The directive is a `ExpressionStatement` which has only a string literal not surrounded by + * parentheses. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a directive. + * @private + */ + function isDirective(node) { + return ( + node.type === "ExpressionStatement" && + node.expression.type === "Literal" && + typeof node.expression.value === "string" && + !astUtils.isParenthesised(sourceCode, node.expression) + ); + } + + /** + * Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue. + * @see {@link https://262.ecma-international.org/6.0/#sec-directive-prologues-and-the-use-strict-directive} + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue. + * @private + */ + function isExpressionInOrJustAfterDirectivePrologue(node) { + if (!astUtils.isTopLevelExpressionStatement(node.parent)) { + return false; + } + const block = node.parent.parent; + + // Check the node is at a prologue. + for (let i = 0; i < block.body.length; ++i) { + const statement = block.body[i]; + + if (statement === node.parent) { + return true; + } + if (!isDirective(statement)) { + break; + } + } + + return false; + } + + /** + * Checks whether or not a given node is allowed as non backtick. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is allowed as non backtick. + * @private + */ + function isAllowedAsNonBacktick(node) { + const parent = node.parent; + + switch (parent.type) { + // Directive Prologues. + case "ExpressionStatement": + return ( + !astUtils.isParenthesised(sourceCode, node) && + isExpressionInOrJustAfterDirectivePrologue(node) + ); + + // LiteralPropertyName. + case "Property": + case "PropertyDefinition": + case "MethodDefinition": + return parent.key === node && !parent.computed; + + // ModuleSpecifier. + case "ImportDeclaration": + case "ExportNamedDeclaration": + return parent.source === node; + + // ModuleExportName or ModuleSpecifier. + case "ExportAllDeclaration": + return parent.exported === node || parent.source === node; + + // ModuleExportName. + case "ImportSpecifier": + return parent.imported === node; + + // ModuleExportName. + case "ExportSpecifier": + return parent.local === node || parent.exported === node; + + // Others don't allow. + default: + return false; + } + } + + /** + * Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings. + * @param {ASTNode} node A TemplateLiteral node to check. + * @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings. + * @private + */ + function isUsingFeatureOfTemplateLiteral(node) { + const hasTag = + node.parent.type === "TaggedTemplateExpression" && + node === node.parent.quasi; + + if (hasTag) { + return true; + } + + const hasStringInterpolation = node.expressions.length > 0; + + if (hasStringInterpolation) { + return true; + } + + const isMultilineString = + node.quasis.length >= 1 && + UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw); + + if (isMultilineString) { + return true; + } + + return false; + } + + return { + Literal(node) { + const val = node.value, + rawVal = node.raw; + + if (settings && typeof val === "string") { + let isValid = + (quoteOption === "backtick" && + isAllowedAsNonBacktick(node)) || + isJSXLiteral(node) || + astUtils.isSurroundedBy(rawVal, settings.quote); + + if (!isValid && avoidEscape) { + isValid = + astUtils.isSurroundedBy( + rawVal, + settings.alternateQuote, + ) && rawVal.includes(settings.quote); + } + + if (!isValid) { + context.report({ + node, + messageId: "wrongQuotes", + data: { + description: settings.description, + }, + fix(fixer) { + if ( + quoteOption === "backtick" && + astUtils.hasOctalOrNonOctalDecimalEscapeSequence( + rawVal, + ) + ) { + /* + * An octal or non-octal decimal escape sequence in a template literal would + * produce syntax error, even in non-strict mode. + */ + return null; + } + + return fixer.replaceText( + node, + settings.convert(node.raw), + ); + }, + }); + } + } + }, + + TemplateLiteral(node) { + // Don't throw an error if backticks are expected or a template literal feature is in use. + if ( + allowTemplateLiterals || + quoteOption === "backtick" || + isUsingFeatureOfTemplateLiteral(node) + ) { + return; + } + + context.report({ + node, + messageId: "wrongQuotes", + data: { + description: settings.description, + }, + fix(fixer) { + if ( + astUtils.isTopLevelExpressionStatement( + node.parent, + ) && + !astUtils.isParenthesised(sourceCode, node) + ) { + /* + * TemplateLiterals aren't actually directives, but fixing them might turn + * them into directives and change the behavior of the code. + */ + return null; + } + return fixer.replaceText( + node, + settings.convert(sourceCode.getText(node)), + ); + }, + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/radix.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/radix.js new file mode 100644 index 00000000..c54a0351 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/radix.js @@ -0,0 +1,203 @@ +/** + * @fileoverview Rule to flag use of parseInt without a radix argument + * @author James Allardice + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Variable} Variable */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const validRadixValues = new Set( + Array.from({ length: 37 - 2 }, (_, index) => index + 2), +); + +/** + * Checks whether a given variable is shadowed or not. + * @param {Variable} variable A variable to check. + * @returns {boolean} `true` if the variable is shadowed. + */ +function isShadowed(variable) { + return variable.defs.length >= 1; +} + +/** + * Checks whether a given node is a valid value of radix or not. + * + * The following values are invalid. + * + * - A literal except integers between 2 and 36. + * - undefined. + * @param {ASTNode} radix A node of radix to check. + * @param {SourceCode} sourceCode The source code object. + * @returns {boolean} `true` if the node is valid. + */ +function isValidRadix(radix, sourceCode) { + if ( + radix.type === "UnaryExpression" && + (radix.operator === "-" || radix.operator === "+") && + radix.argument.type === "Literal" && + typeof radix.argument.value === "number" + ) { + const value = + radix.operator === "-" + ? -radix.argument.value + : radix.argument.value; + + return validRadixValues.has(value); + } + + return !( + (radix.type === "Literal" && !validRadixValues.has(radix.value)) || + (radix.type === "Identifier" && + radix.name === "undefined" && + sourceCode.isGlobalReference(radix)) + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Enforce the use of the radix argument when using `parseInt()`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/radix", + }, + + hasSuggestions: true, + + schema: [ + // deprecated + { + enum: ["always", "as-needed"], + }, + ], + + messages: { + missingParameters: "Missing parameters.", + missingRadix: "Missing radix parameter.", + invalidRadix: + "Invalid radix parameter, must be an integer between 2 and 36.", + addRadixParameter10: + "Add radix parameter `10` for parsing decimal numbers.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Checks the arguments of a given CallExpression node and reports it if it + * offends this rule. + * @param {ASTNode} node A CallExpression node to check. + * @returns {void} + */ + function checkArguments(node) { + const args = node.arguments; + const spreadIndex = args.findIndex( + arg => arg.type === "SpreadElement", + ); + + if (spreadIndex !== -1 && spreadIndex < 2) { + return; + } + + if (args.length === 0) { + context.report({ + node, + messageId: "missingParameters", + }); + } else if (args.length === 1) { + context.report({ + node, + messageId: "missingRadix", + suggest: [ + { + messageId: "addRadixParameter10", + fix(fixer) { + const lastToken = sourceCode.getLastToken(node); + const prevToken = + sourceCode.getTokenBefore(lastToken); + + const hasTrailingComma = + astUtils.isCommaToken(prevToken); + + return fixer.insertTextBefore( + lastToken, + hasTrailingComma ? " 10," : ", 10", + ); + }, + }, + ], + }); + } else if (!isValidRadix(args[1], sourceCode)) { + context.report({ + node, + messageId: "invalidRadix", + }); + } + } + + return { + "Program:exit"(node) { + const scope = sourceCode.getScope(node); + let variable; + + // Check `parseInt()` + variable = astUtils.getVariableByName(scope, "parseInt"); + if (variable && !isShadowed(variable)) { + variable.references.forEach(reference => { + const idNode = reference.identifier; + + if (astUtils.isCallee(idNode)) { + checkArguments(idNode.parent); + } + }); + } + + // Check `Number.parseInt()` + variable = astUtils.getVariableByName(scope, "Number"); + if (variable && !isShadowed(variable)) { + variable.references.forEach(reference => { + const parentNode = reference.identifier.parent; + const maybeCallee = + parentNode.parent.type === "ChainExpression" + ? parentNode.parent + : parentNode; + + if ( + astUtils.isSpecificMemberAccess( + parentNode, + "Number", + "parseInt", + ) && + astUtils.isCallee(maybeCallee) + ) { + checkArguments(maybeCallee.parent); + } + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-atomic-updates.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-atomic-updates.js new file mode 100644 index 00000000..c3935cca --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-atomic-updates.js @@ -0,0 +1,365 @@ +/** + * @fileoverview disallow assignments that can lead to race conditions due to usage of `await` or `yield` + * @author Teddy Katz + * @author Toru Nagashima + */ +"use strict"; + +/** + * Make the map from identifiers to each reference. + * @param {escope.Scope} scope The scope to get references. + * @param {Map} [outReferenceMap] The map from identifier nodes to each reference object. + * @returns {Map} `referenceMap`. + */ +function createReferenceMap(scope, outReferenceMap = new Map()) { + for (const reference of scope.references) { + if (reference.resolved === null) { + continue; + } + + outReferenceMap.set(reference.identifier, reference); + } + for (const childScope of scope.childScopes) { + if (childScope.type !== "function") { + createReferenceMap(childScope, outReferenceMap); + } + } + + return outReferenceMap; +} + +/** + * Get `reference.writeExpr` of a given reference. + * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a` + * @param {escope.Reference} reference The reference to get. + * @returns {Expression|null} The `reference.writeExpr`. + */ +function getWriteExpr(reference) { + if (reference.writeExpr) { + return reference.writeExpr; + } + let node = reference.identifier; + + while (node) { + const t = node.parent.type; + + if (t === "AssignmentExpression" && node.parent.left === node) { + return node.parent.right; + } + if (t === "MemberExpression" && node.parent.object === node) { + node = node.parent; + continue; + } + + break; + } + + return null; +} + +/** + * Checks if an expression is a variable that can only be observed within the given function. + * @param {Variable|null} variable The variable to check + * @param {boolean} isMemberAccess If `true` then this is a member access. + * @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure. + */ +function isLocalVariableWithoutEscape(variable, isMemberAccess) { + if (!variable) { + return false; // A global variable which was not defined. + } + + // If the reference is a property access and the variable is a parameter, it handles the variable is not local. + if (isMemberAccess && variable.defs.some(d => d.type === "Parameter")) { + return false; + } + + const functionScope = variable.scope.variableScope; + + return variable.references.every( + reference => reference.from.variableScope === functionScope, + ); +} + +/** + * Represents segment information. + */ +class SegmentInfo { + constructor() { + this.info = new WeakMap(); + } + + /** + * Initialize the segment information. + * @param {PathSegment} segment The segment to initialize. + * @returns {void} + */ + initialize(segment) { + const outdatedReadVariables = new Set(); + const freshReadVariables = new Set(); + + for (const prevSegment of segment.prevSegments) { + const info = this.info.get(prevSegment); + + if (info) { + info.outdatedReadVariables.forEach( + Set.prototype.add, + outdatedReadVariables, + ); + info.freshReadVariables.forEach( + Set.prototype.add, + freshReadVariables, + ); + } + } + + this.info.set(segment, { outdatedReadVariables, freshReadVariables }); + } + + /** + * Mark a given variable as read on given segments. + * @param {PathSegment[]} segments The segments that it read the variable on. + * @param {Variable} variable The variable to be read. + * @returns {void} + */ + markAsRead(segments, variable) { + for (const segment of segments) { + const info = this.info.get(segment); + + if (info) { + info.freshReadVariables.add(variable); + + // If a variable is freshly read again, then it's no more out-dated. + info.outdatedReadVariables.delete(variable); + } + } + } + + /** + * Move `freshReadVariables` to `outdatedReadVariables`. + * @param {PathSegment[]} segments The segments to process. + * @returns {void} + */ + makeOutdated(segments) { + for (const segment of segments) { + const info = this.info.get(segment); + + if (info) { + info.freshReadVariables.forEach( + Set.prototype.add, + info.outdatedReadVariables, + ); + info.freshReadVariables.clear(); + } + } + } + + /** + * Check if a given variable is outdated on the current segments. + * @param {PathSegment[]} segments The current segments. + * @param {Variable} variable The variable to check. + * @returns {boolean} `true` if the variable is outdated on the segments. + */ + isOutdated(segments, variable) { + for (const segment of segments) { + const info = this.info.get(segment); + + if (info && info.outdatedReadVariables.has(variable)) { + return true; + } + } + return false; + } +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + allowProperties: false, + }, + ], + + docs: { + description: + "Disallow assignments that can lead to race conditions due to usage of `await` or `yield`", + recommended: false, + url: "https://eslint.org/docs/latest/rules/require-atomic-updates", + }, + + fixable: null, + + schema: [ + { + type: "object", + properties: { + allowProperties: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + nonAtomicUpdate: + "Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`.", + nonAtomicObjectUpdate: + "Possible race condition: `{{value}}` might be assigned based on an outdated state of `{{object}}`.", + }, + }, + + create(context) { + const [{ allowProperties }] = context.options; + + const sourceCode = context.sourceCode; + const assignmentReferences = new Map(); + const segmentInfo = new SegmentInfo(); + let stack = null; + + return { + onCodePathStart(codePath, node) { + const scope = sourceCode.getScope(node); + const shouldVerify = + scope.type === "function" && + (scope.block.async || scope.block.generator); + + stack = { + upper: stack, + codePath, + referenceMap: shouldVerify + ? createReferenceMap(scope) + : null, + currentSegments: new Set(), + }; + }, + onCodePathEnd() { + stack = stack.upper; + }, + + // Initialize the segment information. + onCodePathSegmentStart(segment) { + segmentInfo.initialize(segment); + stack.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentStart(segment) { + stack.currentSegments.add(segment); + }, + + onUnreachableCodePathSegmentEnd(segment) { + stack.currentSegments.delete(segment); + }, + + onCodePathSegmentEnd(segment) { + stack.currentSegments.delete(segment); + }, + + // Handle references to prepare verification. + Identifier(node) { + const { referenceMap } = stack; + const reference = referenceMap && referenceMap.get(node); + + // Ignore if this is not a valid variable reference. + if (!reference) { + return; + } + const variable = reference.resolved; + const writeExpr = getWriteExpr(reference); + const isMemberAccess = + reference.identifier.parent.type === "MemberExpression"; + + // Add a fresh read variable. + if ( + reference.isRead() && + !(writeExpr && writeExpr.parent.operator === "=") + ) { + segmentInfo.markAsRead(stack.currentSegments, variable); + } + + /* + * Register the variable to verify after ESLint traversed the `writeExpr` node + * if this reference is an assignment to a variable which is referred from other closure. + */ + if ( + writeExpr && + writeExpr.parent.right === writeExpr && // ← exclude variable declarations. + !isLocalVariableWithoutEscape(variable, isMemberAccess) + ) { + let refs = assignmentReferences.get(writeExpr); + + if (!refs) { + refs = []; + assignmentReferences.set(writeExpr, refs); + } + + refs.push(reference); + } + }, + + /* + * Verify assignments. + * If the reference exists in `outdatedReadVariables` list, report it. + */ + ":expression:exit"(node) { + // referenceMap exists if this is in a resumable function scope. + if (!stack.referenceMap) { + return; + } + + // Mark the read variables on this code path as outdated. + if ( + node.type === "AwaitExpression" || + node.type === "YieldExpression" + ) { + segmentInfo.makeOutdated(stack.currentSegments); + } + + // Verify. + const references = assignmentReferences.get(node); + + if (references) { + assignmentReferences.delete(node); + + for (const reference of references) { + const variable = reference.resolved; + + if ( + segmentInfo.isOutdated( + stack.currentSegments, + variable, + ) + ) { + if (node.parent.left === reference.identifier) { + context.report({ + node: node.parent, + messageId: "nonAtomicUpdate", + data: { + value: variable.name, + }, + }); + } else if (!allowProperties) { + context.report({ + node: node.parent, + messageId: "nonAtomicObjectUpdate", + data: { + value: sourceCode.getText( + node.parent.left, + ), + object: variable.name, + }, + }); + } + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-await.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-await.js new file mode 100644 index 00000000..f297ef10 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-await.js @@ -0,0 +1,186 @@ +/** + * @fileoverview Rule to disallow async functions which have no `await` expression. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Capitalize the 1st letter of the given text. + * @param {string} text The text to capitalize. + * @returns {string} The text that the 1st letter was capitalized. + */ +function capitalizeFirstLetter(text) { + return text[0].toUpperCase() + text.slice(1); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Disallow async functions which have no `await` expression", + recommended: false, + url: "https://eslint.org/docs/latest/rules/require-await", + }, + + schema: [], + + messages: { + missingAwait: "{{name}} has no 'await' expression.", + removeAsync: "Remove 'async'.", + }, + + hasSuggestions: true, + }, + + create(context) { + const sourceCode = context.sourceCode; + let scopeInfo = null; + + /** + * Push the scope info object to the stack. + * @returns {void} + */ + function enterFunction() { + scopeInfo = { + upper: scopeInfo, + hasAwait: false, + }; + } + + /** + * Pop the top scope info object from the stack. + * Also, it reports the function if needed. + * @param {ASTNode} node The node to report. + * @returns {void} + */ + function exitFunction(node) { + if ( + !node.generator && + node.async && + !scopeInfo.hasAwait && + !astUtils.isEmptyFunction(node) + ) { + /* + * If the function belongs to a method definition or + * property, then the function's range may not include the + * `async` keyword and we should look at the parent instead. + */ + const nodeWithAsyncKeyword = + (node.parent.type === "MethodDefinition" && + node.parent.value === node) || + (node.parent.type === "Property" && + node.parent.method && + node.parent.value === node) + ? node.parent + : node; + + const asyncToken = sourceCode.getFirstToken( + nodeWithAsyncKeyword, + token => token.value === "async", + ); + const asyncRange = [ + asyncToken.range[0], + sourceCode.getTokenAfter(asyncToken, { + includeComments: true, + }).range[0], + ]; + + /* + * Removing the `async` keyword can cause parsing errors if the current + * statement is relying on automatic semicolon insertion. If ASI is currently + * being used, then we should replace the `async` keyword with a semicolon. + */ + const nextToken = sourceCode.getTokenAfter(asyncToken); + const addSemiColon = + ((astUtils.isOpeningParenToken(nextToken) && + astUtils.isStartOfExpressionStatement( + nodeWithAsyncKeyword, + )) || + (nodeWithAsyncKeyword.type === "MethodDefinition" && + astUtils.canContinueExpressionInClassBody( + nextToken, + ))) && + astUtils.needsPrecedingSemicolon( + sourceCode, + nodeWithAsyncKeyword, + ); + + context.report({ + node, + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + messageId: "missingAwait", + data: { + name: capitalizeFirstLetter( + astUtils.getFunctionNameWithKind(node), + ), + }, + suggest: [ + { + messageId: "removeAsync", + fix: fixer => + fixer.replaceTextRange( + asyncRange, + addSemiColon ? ";" : "", + ), + }, + ], + }); + } + + scopeInfo = scopeInfo.upper; + } + + return { + FunctionDeclaration: enterFunction, + FunctionExpression: enterFunction, + ArrowFunctionExpression: enterFunction, + "FunctionDeclaration:exit": exitFunction, + "FunctionExpression:exit": exitFunction, + "ArrowFunctionExpression:exit": exitFunction, + + AwaitExpression() { + if (!scopeInfo) { + return; + } + + scopeInfo.hasAwait = true; + }, + ForOfStatement(node) { + if (!scopeInfo) { + return; + } + + if (node.await) { + scopeInfo.hasAwait = true; + } + }, + VariableDeclaration(node) { + if (!scopeInfo) { + return; + } + + if (node.kind === "await using") { + scopeInfo.hasAwait = true; + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-unicode-regexp.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-unicode-regexp.js new file mode 100644 index 00000000..fd039afe --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-unicode-regexp.js @@ -0,0 +1,317 @@ +/** + * @fileoverview Rule to enforce the use of `u` or `v` flag on regular expressions. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { + CALL, + CONSTRUCT, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils"); +const astUtils = require("./utils/ast-utils.js"); +const { isValidWithUnicodeFlag } = require("./utils/regular-expressions"); + +/** + * Checks whether the flag configuration should be treated as a missing flag. + * @param {"u"|"v"|undefined} requireFlag A particular flag to require + * @param {string} flags The regex flags + * @returns {boolean} Whether the flag configuration results in a missing flag. + */ +function checkFlags(requireFlag, flags) { + let missingFlag; + + if (requireFlag === "v") { + missingFlag = !flags.includes("v"); + } else if (requireFlag === "u") { + missingFlag = !flags.includes("u"); + } else { + missingFlag = !flags.includes("u") && !flags.includes("v"); + } + + return missingFlag; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [{}], + + docs: { + description: + "Enforce the use of `u` or `v` flag on regular expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/require-unicode-regexp", + }, + + hasSuggestions: true, + + messages: { + addUFlag: "Add the 'u' flag.", + addVFlag: "Add the 'v' flag.", + requireUFlag: "Use the 'u' flag.", + requireVFlag: "Use the 'v' flag.", + }, + + schema: [ + { + type: "object", + properties: { + requireFlag: { + enum: ["u", "v"], + }, + }, + additionalProperties: false, + }, + ], + }, + + create(context) { + const sourceCode = context.sourceCode; + + const [{ requireFlag }] = context.options; + + return { + "Literal[regex]"(node) { + const flags = node.regex.flags || ""; + + const missingFlag = checkFlags(requireFlag, flags); + + if (missingFlag) { + context.report({ + messageId: + requireFlag === "v" + ? "requireVFlag" + : "requireUFlag", + node, + suggest: isValidWithUnicodeFlag( + context.languageOptions.ecmaVersion, + node.regex.pattern, + requireFlag, + ) + ? [ + { + fix(fixer) { + const replaceFlag = + requireFlag ?? "u"; + const regex = + sourceCode.getText(node); + const slashPos = + regex.lastIndexOf("/"); + + if (requireFlag) { + const flag = + requireFlag === "u" + ? "v" + : "u"; + + if ( + regex.includes( + flag, + slashPos, + ) + ) { + return fixer.replaceText( + node, + regex.slice( + 0, + slashPos, + ) + + regex + .slice(slashPos) + .replace( + flag, + requireFlag, + ), + ); + } + } + + return fixer.insertTextAfter( + node, + replaceFlag, + ); + }, + messageId: + requireFlag === "v" + ? "addVFlag" + : "addUFlag", + }, + ] + : null, + }); + } + }, + + Program(node) { + const scope = sourceCode.getScope(node); + const tracker = new ReferenceTracker(scope); + const trackMap = { + RegExp: { [CALL]: true, [CONSTRUCT]: true }, + }; + + for (const { node: refNode } of tracker.iterateGlobalReferences( + trackMap, + )) { + const [patternNode, flagsNode] = refNode.arguments; + + if (patternNode && patternNode.type === "SpreadElement") { + continue; + } + const pattern = getStringIfConstant(patternNode, scope); + const flags = getStringIfConstant(flagsNode, scope); + + let missingFlag = !flagsNode; + + if (typeof flags === "string") { + missingFlag = checkFlags(requireFlag, flags); + } + + if (missingFlag) { + context.report({ + messageId: + requireFlag === "v" + ? "requireVFlag" + : "requireUFlag", + node: refNode, + suggest: + typeof pattern === "string" && + isValidWithUnicodeFlag( + context.languageOptions.ecmaVersion, + pattern, + requireFlag, + ) + ? [ + { + fix(fixer) { + const replaceFlag = + requireFlag ?? "u"; + + if (flagsNode) { + if ( + (flagsNode.type === + "Literal" && + typeof flagsNode.value === + "string") || + flagsNode.type === + "TemplateLiteral" + ) { + const flagsNodeText = + sourceCode.getText( + flagsNode, + ); + const flag = + requireFlag === + "u" + ? "v" + : "u"; + + if ( + flags.includes( + flag, + ) + ) { + // Avoid replacing "u" in escapes like `\uXXXX` + if ( + flagsNode.type === + "Literal" && + flagsNode.raw.includes( + "\\", + ) + ) { + return null; + } + + // Avoid replacing "u" in expressions like "`${regularFlags}g`" + if ( + flagsNode.type === + "TemplateLiteral" && + (flagsNode + .expressions + .length || + flagsNode.quasis.some( + ({ + value: { + raw, + }, + }) => + raw.includes( + "\\", + ), + )) + ) { + return null; + } + + return fixer.replaceText( + flagsNode, + flagsNodeText.replace( + flag, + replaceFlag, + ), + ); + } + + return fixer.replaceText( + flagsNode, + [ + flagsNodeText.slice( + 0, + flagsNodeText.length - + 1, + ), + flagsNodeText.slice( + flagsNodeText.length - + 1, + ), + ].join( + replaceFlag, + ), + ); + } + + // We intentionally don't suggest concatenating + "u" to non-literals + return null; + } + + const penultimateToken = + sourceCode.getLastToken( + refNode, + { skip: 1 }, + ); // skip closing parenthesis + + return fixer.insertTextAfter( + penultimateToken, + astUtils.isCommaToken( + penultimateToken, + ) + ? ` "${replaceFlag}",` + : `, "${replaceFlag}"`, + ); + }, + messageId: + requireFlag === "v" + ? "addVFlag" + : "addUFlag", + }, + ] + : null, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-yield.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-yield.js new file mode 100644 index 00000000..b2900026 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/require-yield.js @@ -0,0 +1,86 @@ +/** + * @fileoverview Rule to flag the generator functions that does not have yield. + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require generator functions to contain `yield`", + recommended: true, + url: "https://eslint.org/docs/latest/rules/require-yield", + }, + + schema: [], + + messages: { + missingYield: "This generator function does not have 'yield'.", + }, + }, + + create(context) { + const stack = []; + const sourceCode = context.sourceCode; + + /** + * If the node is a generator function, start counting `yield` keywords. + * @param {Node} node A function node to check. + * @returns {void} + */ + function beginChecking(node) { + if (node.generator) { + stack.push(0); + } + } + + /** + * If the node is a generator function, end counting `yield` keywords, then + * reports result. + * @param {Node} node A function node to check. + * @returns {void} + */ + function endChecking(node) { + if (!node.generator) { + return; + } + + const countYield = stack.pop(); + + if (countYield === 0 && node.body.body.length > 0) { + context.report({ + loc: astUtils.getFunctionHeadLoc(node, sourceCode), + messageId: "missingYield", + }); + } + } + + return { + FunctionDeclaration: beginChecking, + "FunctionDeclaration:exit": endChecking, + FunctionExpression: beginChecking, + "FunctionExpression:exit": endChecking, + + // Increases the count of `yield` keyword. + YieldExpression() { + if (stack.length > 0) { + stack[stack.length - 1] += 1; + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/rest-spread-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/rest-spread-spacing.js new file mode 100644 index 00000000..bcd1c960 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/rest-spread-spacing.js @@ -0,0 +1,150 @@ +/** + * @fileoverview Enforce spacing between rest and spread operators and their expressions. + * @author Kai Cataldo + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "rest-spread-spacing", + url: "https://eslint.style/rules/rest-spread-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce spacing between rest and spread operators and their expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/rest-spread-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + ], + + messages: { + unexpectedWhitespace: + "Unexpected whitespace after {{type}} operator.", + expectedWhitespace: "Expected whitespace after {{type}} operator.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode, + alwaysSpace = context.options[0] === "always"; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Checks whitespace between rest/spread operators and their expressions + * @param {ASTNode} node The node to check + * @returns {void} + */ + function checkWhiteSpace(node) { + const operator = sourceCode.getFirstToken(node), + nextToken = sourceCode.getTokenAfter(operator), + hasWhitespace = sourceCode.isSpaceBetween(operator, nextToken); + let type; + + switch (node.type) { + case "SpreadElement": + type = "spread"; + if (node.parent.type === "ObjectExpression") { + type += " property"; + } + break; + case "RestElement": + type = "rest"; + if (node.parent.type === "ObjectPattern") { + type += " property"; + } + break; + case "ExperimentalSpreadProperty": + type = "spread property"; + break; + case "ExperimentalRestProperty": + type = "rest property"; + break; + default: + return; + } + + if (alwaysSpace && !hasWhitespace) { + context.report({ + node, + loc: operator.loc, + messageId: "expectedWhitespace", + data: { + type, + }, + fix(fixer) { + return fixer.replaceTextRange( + [operator.range[1], nextToken.range[0]], + " ", + ); + }, + }); + } else if (!alwaysSpace && hasWhitespace) { + context.report({ + node, + loc: { + start: operator.loc.end, + end: nextToken.loc.start, + }, + messageId: "unexpectedWhitespace", + data: { + type, + }, + fix(fixer) { + return fixer.removeRange([ + operator.range[1], + nextToken.range[0], + ]); + }, + }); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + SpreadElement: checkWhiteSpace, + RestElement: checkWhiteSpace, + ExperimentalSpreadProperty: checkWhiteSpace, + ExperimentalRestProperty: checkWhiteSpace, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-spacing.js new file mode 100644 index 00000000..4d00d978 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-spacing.js @@ -0,0 +1,297 @@ +/** + * @fileoverview Validates spacing before and after semicolon + * @author Mathias Schreck + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "semi-spacing", + url: "https://eslint.style/rules/semi-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing before and after semicolons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/semi-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + before: { + type: "boolean", + default: false, + }, + after: { + type: "boolean", + default: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedWhitespaceBefore: + "Unexpected whitespace before semicolon.", + unexpectedWhitespaceAfter: "Unexpected whitespace after semicolon.", + missingWhitespaceBefore: "Missing whitespace before semicolon.", + missingWhitespaceAfter: "Missing whitespace after semicolon.", + }, + }, + + create(context) { + const config = context.options[0], + sourceCode = context.sourceCode; + let requireSpaceBefore = false, + requireSpaceAfter = true; + + if (typeof config === "object") { + requireSpaceBefore = config.before; + requireSpaceAfter = config.after; + } + + /** + * Checks if a given token has leading whitespace. + * @param {Object} token The token to check. + * @returns {boolean} True if the given token has leading space, false if not. + */ + function hasLeadingSpace(token) { + const tokenBefore = sourceCode.getTokenBefore(token); + + return ( + tokenBefore && + astUtils.isTokenOnSameLine(tokenBefore, token) && + sourceCode.isSpaceBetween(tokenBefore, token) + ); + } + + /** + * Checks if a given token has trailing whitespace. + * @param {Object} token The token to check. + * @returns {boolean} True if the given token has trailing space, false if not. + */ + function hasTrailingSpace(token) { + const tokenAfter = sourceCode.getTokenAfter(token); + + return ( + tokenAfter && + astUtils.isTokenOnSameLine(token, tokenAfter) && + sourceCode.isSpaceBetween(token, tokenAfter) + ); + } + + /** + * Checks if the given token is the last token in its line. + * @param {Token} token The token to check. + * @returns {boolean} Whether or not the token is the last in its line. + */ + function isLastTokenInCurrentLine(token) { + const tokenAfter = sourceCode.getTokenAfter(token); + + return !( + tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) + ); + } + + /** + * Checks if the given token is the first token in its line + * @param {Token} token The token to check. + * @returns {boolean} Whether or not the token is the first in its line. + */ + function isFirstTokenInCurrentLine(token) { + const tokenBefore = sourceCode.getTokenBefore(token); + + return !( + tokenBefore && astUtils.isTokenOnSameLine(token, tokenBefore) + ); + } + + /** + * Checks if the next token of a given token is a closing parenthesis. + * @param {Token} token The token to check. + * @returns {boolean} Whether or not the next token of a given token is a closing parenthesis. + */ + function isBeforeClosingParen(token) { + const nextToken = sourceCode.getTokenAfter(token); + + return ( + (nextToken && astUtils.isClosingBraceToken(nextToken)) || + astUtils.isClosingParenToken(nextToken) + ); + } + + /** + * Report location example : + * + * for unexpected space `before` + * + * var a = 'b' ; + * ^^^ + * + * for unexpected space `after` + * + * var a = 'b'; c = 10; + * ^^ + * + * Reports if the given token has invalid spacing. + * @param {Token} token The semicolon token to check. + * @param {ASTNode} node The corresponding node of the token. + * @returns {void} + */ + function checkSemicolonSpacing(token, node) { + if (astUtils.isSemicolonToken(token)) { + if (hasLeadingSpace(token)) { + if (!requireSpaceBefore) { + const tokenBefore = sourceCode.getTokenBefore(token); + const loc = { + start: tokenBefore.loc.end, + end: token.loc.start, + }; + + context.report({ + node, + loc, + messageId: "unexpectedWhitespaceBefore", + fix(fixer) { + return fixer.removeRange([ + tokenBefore.range[1], + token.range[0], + ]); + }, + }); + } + } else { + if (requireSpaceBefore) { + const loc = token.loc; + + context.report({ + node, + loc, + messageId: "missingWhitespaceBefore", + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + } + + if ( + !isFirstTokenInCurrentLine(token) && + !isLastTokenInCurrentLine(token) && + !isBeforeClosingParen(token) + ) { + if (hasTrailingSpace(token)) { + if (!requireSpaceAfter) { + const tokenAfter = sourceCode.getTokenAfter(token); + const loc = { + start: token.loc.end, + end: tokenAfter.loc.start, + }; + + context.report({ + node, + loc, + messageId: "unexpectedWhitespaceAfter", + fix(fixer) { + return fixer.removeRange([ + token.range[1], + tokenAfter.range[0], + ]); + }, + }); + } + } else { + if (requireSpaceAfter) { + const loc = token.loc; + + context.report({ + node, + loc, + messageId: "missingWhitespaceAfter", + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + } + } + } + } + + /** + * Checks the spacing of the semicolon with the assumption that the last token is the semicolon. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkNode(node) { + const token = sourceCode.getLastToken(node); + + checkSemicolonSpacing(token, node); + } + + return { + VariableDeclaration: checkNode, + ExpressionStatement: checkNode, + BreakStatement: checkNode, + ContinueStatement: checkNode, + DebuggerStatement: checkNode, + DoWhileStatement: checkNode, + ReturnStatement: checkNode, + ThrowStatement: checkNode, + ImportDeclaration: checkNode, + ExportNamedDeclaration: checkNode, + ExportAllDeclaration: checkNode, + ExportDefaultDeclaration: checkNode, + ForStatement(node) { + if (node.init) { + checkSemicolonSpacing( + sourceCode.getTokenAfter(node.init), + node, + ); + } + + if (node.test) { + checkSemicolonSpacing( + sourceCode.getTokenAfter(node.test), + node, + ); + } + }, + PropertyDefinition: checkNode, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-style.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-style.js new file mode 100644 index 00000000..43b32e14 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi-style.js @@ -0,0 +1,218 @@ +/** + * @fileoverview Rule to enforce location of semicolons. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +const SELECTOR = [ + "BreakStatement", + "ContinueStatement", + "DebuggerStatement", + "DoWhileStatement", + "ExportAllDeclaration", + "ExportDefaultDeclaration", + "ExportNamedDeclaration", + "ExpressionStatement", + "ImportDeclaration", + "ReturnStatement", + "ThrowStatement", + "VariableDeclaration", + "PropertyDefinition", +].join(","); + +/** + * Get the child node list of a given node. + * This returns `BlockStatement#body`, `StaticBlock#body`, `Program#body`, + * `ClassBody#body`, or `SwitchCase#consequent`. + * This is used to check whether a node is the first/last child. + * @param {Node} node A node to get child node list. + * @returns {Node[]|null} The child node list. + */ +function getChildren(node) { + const t = node.type; + + if ( + t === "BlockStatement" || + t === "StaticBlock" || + t === "Program" || + t === "ClassBody" + ) { + return node.body; + } + if (t === "SwitchCase") { + return node.consequent; + } + return null; +} + +/** + * Check whether a given node is the last statement in the parent block. + * @param {Node} node A node to check. + * @returns {boolean} `true` if the node is the last statement in the parent block. + */ +function isLastChild(node) { + const t = node.parent.type; + + if ( + t === "IfStatement" && + node.parent.consequent === node && + node.parent.alternate + ) { + // before `else` keyword. + return true; + } + if (t === "DoWhileStatement") { + // before `while` keyword. + return true; + } + const nodeList = getChildren(node.parent); + + return nodeList !== null && nodeList.at(-1) === node; // before `}` or etc. +} + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "semi-style", + url: "https://eslint.style/rules/semi-style", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce location of semicolons", + recommended: false, + url: "https://eslint.org/docs/latest/rules/semi-style", + }, + + schema: [{ enum: ["last", "first"] }], + fixable: "whitespace", + + messages: { + expectedSemiColon: "Expected this semicolon to be at {{pos}}.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const option = context.options[0] || "last"; + + /** + * Check the given semicolon token. + * @param {Token} semiToken The semicolon token to check. + * @param {"first"|"last"} expected The expected location to check. + * @returns {void} + */ + function check(semiToken, expected) { + const prevToken = sourceCode.getTokenBefore(semiToken); + const nextToken = sourceCode.getTokenAfter(semiToken); + const prevIsSameLine = + !prevToken || astUtils.isTokenOnSameLine(prevToken, semiToken); + const nextIsSameLine = + !nextToken || astUtils.isTokenOnSameLine(semiToken, nextToken); + + if ( + (expected === "last" && !prevIsSameLine) || + (expected === "first" && !nextIsSameLine) + ) { + context.report({ + loc: semiToken.loc, + messageId: "expectedSemiColon", + data: { + pos: + expected === "last" + ? "the end of the previous line" + : "the beginning of the next line", + }, + fix(fixer) { + if ( + prevToken && + nextToken && + sourceCode.commentsExistBetween( + prevToken, + nextToken, + ) + ) { + return null; + } + + const start = prevToken + ? prevToken.range[1] + : semiToken.range[0]; + const end = nextToken + ? nextToken.range[0] + : semiToken.range[1]; + const text = expected === "last" ? ";\n" : "\n;"; + + return fixer.replaceTextRange([start, end], text); + }, + }); + } + } + + return { + [SELECTOR](node) { + if (option === "first" && isLastChild(node)) { + return; + } + + const lastToken = sourceCode.getLastToken(node); + + if (astUtils.isSemicolonToken(lastToken)) { + check(lastToken, option); + } + }, + + ForStatement(node) { + const firstSemi = + node.init && + sourceCode.getTokenAfter( + node.init, + astUtils.isSemicolonToken, + ); + const secondSemi = + node.test && + sourceCode.getTokenAfter( + node.test, + astUtils.isSemicolonToken, + ); + + if (firstSemi) { + check(firstSemi, "last"); + } + if (secondSemi) { + check(secondSemi, "last"); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi.js new file mode 100644 index 00000000..b6d28d88 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/semi.js @@ -0,0 +1,476 @@ +/** + * @fileoverview Rule to flag missing semicolons. + * @author Nicholas C. Zakas + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const FixTracker = require("./utils/fix-tracker"); +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "semi", + url: "https://eslint.style/rules/semi", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require or disallow semicolons instead of ASI", + recommended: false, + url: "https://eslint.org/docs/latest/rules/semi", + }, + + fixable: "code", + + schema: { + anyOf: [ + { + type: "array", + items: [ + { + enum: ["never"], + }, + { + type: "object", + properties: { + beforeStatementContinuationChars: { + enum: ["always", "any", "never"], + }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + { + type: "array", + items: [ + { + enum: ["always"], + }, + { + type: "object", + properties: { + omitLastInOneLineBlock: { type: "boolean" }, + omitLastInOneLineClassBody: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + minItems: 0, + maxItems: 2, + }, + ], + }, + + messages: { + missingSemi: "Missing semicolon.", + extraSemi: "Extra semicolon.", + }, + }, + + create(context) { + const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-` + const unsafeClassFieldNames = new Set(["get", "set", "static"]); + const unsafeClassFieldFollowers = new Set(["*", "in", "instanceof"]); + const options = context.options[1]; + const never = context.options[0] === "never"; + const exceptOneLine = Boolean( + options && options.omitLastInOneLineBlock, + ); + const exceptOneLineClassBody = Boolean( + options && options.omitLastInOneLineClassBody, + ); + const beforeStatementContinuationChars = + (options && options.beforeStatementContinuationChars) || "any"; + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Reports a semicolon error with appropriate location and message. + * @param {ASTNode} node The node with an extra or missing semicolon. + * @param {boolean} missing True if the semicolon is missing. + * @returns {void} + */ + function report(node, missing) { + const lastToken = sourceCode.getLastToken(node); + let messageId, fix, loc; + + if (!missing) { + messageId = "missingSemi"; + loc = { + start: lastToken.loc.end, + end: astUtils.getNextLocation( + sourceCode, + lastToken.loc.end, + ), + }; + fix = function (fixer) { + return fixer.insertTextAfter(lastToken, ";"); + }; + } else { + messageId = "extraSemi"; + loc = lastToken.loc; + fix = function (fixer) { + /* + * Expand the replacement range to include the surrounding + * tokens to avoid conflicting with no-extra-semi. + * https://github.com/eslint/eslint/issues/7928 + */ + return new FixTracker(fixer, sourceCode) + .retainSurroundingTokens(lastToken) + .remove(lastToken); + }; + } + + context.report({ + node, + loc, + messageId, + fix, + }); + } + + /** + * Check whether a given semicolon token is redundant. + * @param {Token} semiToken A semicolon token to check. + * @returns {boolean} `true` if the next token is `;` or `}`. + */ + function isRedundantSemi(semiToken) { + const nextToken = sourceCode.getTokenAfter(semiToken); + + return ( + !nextToken || + astUtils.isClosingBraceToken(nextToken) || + astUtils.isSemicolonToken(nextToken) + ); + } + + /** + * Check whether a given token is the closing brace of an arrow function. + * @param {Token} lastToken A token to check. + * @returns {boolean} `true` if the token is the closing brace of an arrow function. + */ + function isEndOfArrowBlock(lastToken) { + if (!astUtils.isClosingBraceToken(lastToken)) { + return false; + } + const node = sourceCode.getNodeByRangeIndex(lastToken.range[0]); + + return ( + node.type === "BlockStatement" && + node.parent.type === "ArrowFunctionExpression" + ); + } + + /** + * Checks if a given PropertyDefinition node followed by a semicolon + * can safely remove that semicolon. It is not to safe to remove if + * the class field name is "get", "set", or "static", or if + * followed by a generator method. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node cannot have the semicolon + * removed. + */ + function maybeClassFieldAsiHazard(node) { + if (node.type !== "PropertyDefinition") { + return false; + } + + /* + * Computed property names and non-identifiers are always safe + * as they can be distinguished from keywords easily. + */ + const needsNameCheck = + !node.computed && node.key.type === "Identifier"; + + /* + * Certain names are problematic unless they also have a + * a way to distinguish between keywords and property + * names. + */ + if (needsNameCheck && unsafeClassFieldNames.has(node.key.name)) { + /* + * Special case: If the field name is `static`, + * it is only valid if the field is marked as static, + * so "static static" is okay but "static" is not. + */ + const isStaticStatic = + node.static && node.key.name === "static"; + + /* + * For other unsafe names, we only care if there is no + * initializer. No initializer = hazard. + */ + if (!isStaticStatic && !node.value) { + return true; + } + } + + const followingToken = sourceCode.getTokenAfter(node); + + return unsafeClassFieldFollowers.has(followingToken.value); + } + + /** + * Check whether a given node is on the same line with the next token. + * @param {Node} node A statement node to check. + * @returns {boolean} `true` if the node is on the same line with the next token. + */ + function isOnSameLineWithNextToken(node) { + const prevToken = sourceCode.getLastToken(node, 1); + const nextToken = sourceCode.getTokenAfter(node); + + return ( + !!nextToken && astUtils.isTokenOnSameLine(prevToken, nextToken) + ); + } + + /** + * Check whether a given node can connect the next line if the next line is unreliable. + * @param {Node} node A statement node to check. + * @returns {boolean} `true` if the node can connect the next line. + */ + function maybeAsiHazardAfter(node) { + const t = node.type; + + if ( + t === "DoWhileStatement" || + t === "BreakStatement" || + t === "ContinueStatement" || + t === "DebuggerStatement" || + t === "ImportDeclaration" || + t === "ExportAllDeclaration" + ) { + return false; + } + if (t === "ReturnStatement") { + return Boolean(node.argument); + } + if (t === "ExportNamedDeclaration") { + return Boolean(node.declaration); + } + if (isEndOfArrowBlock(sourceCode.getLastToken(node, 1))) { + return false; + } + + return true; + } + + /** + * Check whether a given token can connect the previous statement. + * @param {Token} token A token to check. + * @returns {boolean} `true` if the token is one of `[`, `(`, `/`, `+`, `-`, ```, `++`, and `--`. + */ + function maybeAsiHazardBefore(token) { + return ( + Boolean(token) && + OPT_OUT_PATTERN.test(token.value) && + token.value !== "++" && + token.value !== "--" + ); + } + + /** + * Check if the semicolon of a given node is unnecessary, only true if: + * - next token is a valid statement divider (`;` or `}`). + * - next token is on a new line and the node is not connectable to the new line. + * @param {Node} node A statement node to check. + * @returns {boolean} whether the semicolon is unnecessary. + */ + function canRemoveSemicolon(node) { + if (isRedundantSemi(sourceCode.getLastToken(node))) { + return true; // `;;` or `;}` + } + if (maybeClassFieldAsiHazard(node)) { + return false; + } + if (isOnSameLineWithNextToken(node)) { + return false; // One liner. + } + + // continuation characters should not apply to class fields + if ( + node.type !== "PropertyDefinition" && + beforeStatementContinuationChars === "never" && + !maybeAsiHazardAfter(node) + ) { + return true; // ASI works. This statement doesn't connect to the next. + } + if (!maybeAsiHazardBefore(sourceCode.getTokenAfter(node))) { + return true; // ASI works. The next token doesn't connect to this statement. + } + + return false; + } + + /** + * Checks a node to see if it's the last item in a one-liner block. + * Block is any `BlockStatement` or `StaticBlock` node. Block is a one-liner if its + * braces (and consequently everything between them) are on the same line. + * @param {ASTNode} node The node to check. + * @returns {boolean} whether the node is the last item in a one-liner block. + */ + function isLastInOneLinerBlock(node) { + const parent = node.parent; + const nextToken = sourceCode.getTokenAfter(node); + + if (!nextToken || nextToken.value !== "}") { + return false; + } + + if (parent.type === "BlockStatement") { + return parent.loc.start.line === parent.loc.end.line; + } + + if (parent.type === "StaticBlock") { + const openingBrace = sourceCode.getFirstToken(parent, { + skip: 1, + }); // skip the `static` token + + return openingBrace.loc.start.line === parent.loc.end.line; + } + + return false; + } + + /** + * Checks a node to see if it's the last item in a one-liner `ClassBody` node. + * ClassBody is a one-liner if its braces (and consequently everything between them) are on the same line. + * @param {ASTNode} node The node to check. + * @returns {boolean} whether the node is the last item in a one-liner ClassBody. + */ + function isLastInOneLinerClassBody(node) { + const parent = node.parent; + const nextToken = sourceCode.getTokenAfter(node); + + if (!nextToken || nextToken.value !== "}") { + return false; + } + + if (parent.type === "ClassBody") { + return parent.loc.start.line === parent.loc.end.line; + } + + return false; + } + + /** + * Checks a node to see if it's followed by a semicolon. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkForSemicolon(node) { + const isSemi = astUtils.isSemicolonToken( + sourceCode.getLastToken(node), + ); + + if (never) { + if (isSemi && canRemoveSemicolon(node)) { + report(node, true); + } else if ( + !isSemi && + beforeStatementContinuationChars === "always" && + node.type !== "PropertyDefinition" && + maybeAsiHazardBefore(sourceCode.getTokenAfter(node)) + ) { + report(node); + } + } else { + const oneLinerBlock = + exceptOneLine && isLastInOneLinerBlock(node); + const oneLinerClassBody = + exceptOneLineClassBody && isLastInOneLinerClassBody(node); + const oneLinerBlockOrClassBody = + oneLinerBlock || oneLinerClassBody; + + if (isSemi && oneLinerBlockOrClassBody) { + report(node, true); + } else if (!isSemi && !oneLinerBlockOrClassBody) { + report(node); + } + } + } + + /** + * Checks to see if there's a semicolon after a variable declaration. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkForSemicolonForVariableDeclaration(node) { + const parent = node.parent; + + if ( + (parent.type !== "ForStatement" || parent.init !== node) && + (!/^For(?:In|Of)Statement/u.test(parent.type) || + parent.left !== node) + ) { + checkForSemicolon(node); + } + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + VariableDeclaration: checkForSemicolonForVariableDeclaration, + ExpressionStatement: checkForSemicolon, + ReturnStatement: checkForSemicolon, + ThrowStatement: checkForSemicolon, + DoWhileStatement: checkForSemicolon, + DebuggerStatement: checkForSemicolon, + BreakStatement: checkForSemicolon, + ContinueStatement: checkForSemicolon, + ImportDeclaration: checkForSemicolon, + ExportAllDeclaration: checkForSemicolon, + ExportNamedDeclaration(node) { + if (!node.declaration) { + checkForSemicolon(node); + } + }, + ExportDefaultDeclaration(node) { + if ( + !/(?:Class|Function)Declaration/u.test( + node.declaration.type, + ) + ) { + checkForSemicolon(node); + } + }, + PropertyDefinition: checkForSemicolon, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-imports.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-imports.js new file mode 100644 index 00000000..e97f3f05 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-imports.js @@ -0,0 +1,319 @@ +/** + * @fileoverview Rule to enforce sorted `import` declarations within modules + * @author Christian Schuller + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + allowSeparatedGroups: false, + ignoreCase: false, + ignoreDeclarationSort: false, + ignoreMemberSort: false, + memberSyntaxSortOrder: ["none", "all", "multiple", "single"], + }, + ], + + docs: { + description: "Enforce sorted `import` declarations within modules", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/sort-imports", + }, + + schema: [ + { + type: "object", + properties: { + ignoreCase: { + type: "boolean", + }, + memberSyntaxSortOrder: { + type: "array", + items: { + enum: ["none", "all", "multiple", "single"], + }, + uniqueItems: true, + minItems: 4, + maxItems: 4, + }, + ignoreDeclarationSort: { + type: "boolean", + }, + ignoreMemberSort: { + type: "boolean", + }, + allowSeparatedGroups: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + sortImportsAlphabetically: + "Imports should be sorted alphabetically.", + sortMembersAlphabetically: + "Member '{{memberName}}' of the import declaration should be sorted alphabetically.", + unexpectedSyntaxOrder: + "Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax.", + }, + }, + + create(context) { + const [ + { + ignoreCase, + ignoreDeclarationSort, + ignoreMemberSort, + memberSyntaxSortOrder, + allowSeparatedGroups, + }, + ] = context.options; + const sourceCode = context.sourceCode; + let previousDeclaration = null; + + /** + * Gets the used member syntax style. + * + * import "my-module.js" --> none + * import * as myModule from "my-module.js" --> all + * import {myMember} from "my-module.js" --> single + * import {foo, bar} from "my-module.js" --> multiple + * @param {ASTNode} node the ImportDeclaration node. + * @returns {string} used member parameter style, ["all", "multiple", "single"] + */ + function usedMemberSyntax(node) { + if (node.specifiers.length === 0) { + return "none"; + } + if (node.specifiers[0].type === "ImportNamespaceSpecifier") { + return "all"; + } + if (node.specifiers.length === 1) { + return "single"; + } + return "multiple"; + } + + /** + * Gets the group by member parameter index for given declaration. + * @param {ASTNode} node the ImportDeclaration node. + * @returns {number} the declaration group by member index. + */ + function getMemberParameterGroupIndex(node) { + return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node)); + } + + /** + * Gets the local name of the first imported module. + * @param {ASTNode} node the ImportDeclaration node. + * @returns {?string} the local name of the first imported module. + */ + function getFirstLocalMemberName(node) { + if (node.specifiers[0]) { + return node.specifiers[0].local.name; + } + return null; + } + + /** + * Calculates number of lines between two nodes. It is assumed that the given `left` node appears before + * the given `right` node in the source code. Lines are counted from the end of the `left` node till the + * start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were + * on two consecutive lines. + * @param {ASTNode} left node that appears before the given `right` node. + * @param {ASTNode} right node that appears after the given `left` node. + * @returns {number} number of lines between nodes. + */ + function getNumberOfLinesBetween(left, right) { + return Math.max(right.loc.start.line - left.loc.end.line - 1, 0); + } + + return { + ImportDeclaration(node) { + if (!ignoreDeclarationSort) { + if ( + previousDeclaration && + allowSeparatedGroups && + getNumberOfLinesBetween(previousDeclaration, node) > 0 + ) { + // reset declaration sort + previousDeclaration = null; + } + + if (previousDeclaration) { + const currentMemberSyntaxGroupIndex = + getMemberParameterGroupIndex(node), + previousMemberSyntaxGroupIndex = + getMemberParameterGroupIndex( + previousDeclaration, + ); + let currentLocalMemberName = + getFirstLocalMemberName(node), + previousLocalMemberName = + getFirstLocalMemberName(previousDeclaration); + + if (ignoreCase) { + previousLocalMemberName = + previousLocalMemberName && + previousLocalMemberName.toLowerCase(); + currentLocalMemberName = + currentLocalMemberName && + currentLocalMemberName.toLowerCase(); + } + + /* + * When the current declaration uses a different member syntax, + * then check if the ordering is correct. + * Otherwise, make a default string compare (like rule sort-vars to be consistent) of the first used local member name. + */ + if ( + currentMemberSyntaxGroupIndex !== + previousMemberSyntaxGroupIndex + ) { + if ( + currentMemberSyntaxGroupIndex < + previousMemberSyntaxGroupIndex + ) { + context.report({ + node, + messageId: "unexpectedSyntaxOrder", + data: { + syntaxA: + memberSyntaxSortOrder[ + currentMemberSyntaxGroupIndex + ], + syntaxB: + memberSyntaxSortOrder[ + previousMemberSyntaxGroupIndex + ], + }, + }); + } + } else { + if ( + previousLocalMemberName && + currentLocalMemberName && + currentLocalMemberName < previousLocalMemberName + ) { + context.report({ + node, + messageId: "sortImportsAlphabetically", + }); + } + } + } + + previousDeclaration = node; + } + + if (!ignoreMemberSort) { + const importSpecifiers = node.specifiers.filter( + specifier => specifier.type === "ImportSpecifier", + ); + const getSortableName = ignoreCase + ? specifier => specifier.local.name.toLowerCase() + : specifier => specifier.local.name; + const firstUnsortedIndex = importSpecifiers + .map(getSortableName) + .findIndex( + (name, index, array) => array[index - 1] > name, + ); + + if (firstUnsortedIndex !== -1) { + context.report({ + node: importSpecifiers[firstUnsortedIndex], + messageId: "sortMembersAlphabetically", + data: { + memberName: + importSpecifiers[firstUnsortedIndex].local + .name, + }, + fix(fixer) { + if ( + importSpecifiers.some( + specifier => + sourceCode.getCommentsBefore( + specifier, + ).length || + sourceCode.getCommentsAfter( + specifier, + ).length, + ) + ) { + // If there are comments in the ImportSpecifier list, don't rearrange the specifiers. + return null; + } + + return fixer.replaceTextRange( + [ + importSpecifiers[0].range[0], + importSpecifiers.at(-1).range[1], + ], + importSpecifiers + + // Clone the importSpecifiers array to avoid mutating it + .slice() + + // Sort the array into the desired order + .sort((specifierA, specifierB) => { + const aName = + getSortableName(specifierA); + const bName = + getSortableName(specifierB); + + return aName > bName ? 1 : -1; + }) + + // Build a string out of the sorted list of import specifiers and the text between the originals + .reduce( + (sourceText, specifier, index) => { + const textAfterSpecifier = + index === + importSpecifiers.length - 1 + ? "" + : sourceCode + .getText() + .slice( + importSpecifiers[ + index + ].range[1], + importSpecifiers[ + index + + 1 + ].range[0], + ); + + return ( + sourceText + + sourceCode.getText( + specifier, + ) + + textAfterSpecifier + ); + }, + "", + ), + ); + }, + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-keys.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-keys.js new file mode 100644 index 00000000..bbb2dc2b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-keys.js @@ -0,0 +1,268 @@ +/** + * @fileoverview Rule to require object keys to be sorted + * @author Toru Nagashima + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"), + naturalCompare = require("natural-compare"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Gets the property name of the given `Property` node. + * + * - If the property's key is an `Identifier` node, this returns the key's name + * whether it's a computed property or not. + * - If the property has a static name, this returns the static name. + * - Otherwise, this returns null. + * @param {ASTNode} node The `Property` node to get. + * @returns {string|null} The property name or null. + * @private + */ +function getPropertyName(node) { + const staticName = astUtils.getStaticPropertyName(node); + + if (staticName !== null) { + return staticName; + } + + return node.key.name || null; +} + +/** + * Functions which check that the given 2 names are in specific order. + * + * Postfix `I` is meant insensitive. + * Postfix `N` is meant natural. + * @private + */ +const isValidOrders = { + asc(a, b) { + return a <= b; + }, + ascI(a, b) { + return a.toLowerCase() <= b.toLowerCase(); + }, + ascN(a, b) { + return naturalCompare(a, b) <= 0; + }, + ascIN(a, b) { + return naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0; + }, + desc(a, b) { + return isValidOrders.asc(b, a); + }, + descI(a, b) { + return isValidOrders.ascI(b, a); + }, + descN(a, b) { + return isValidOrders.ascN(b, a); + }, + descIN(a, b) { + return isValidOrders.ascIN(b, a); + }, +}; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + "asc", + { + allowLineSeparatedGroups: false, + caseSensitive: true, + ignoreComputedKeys: false, + minKeys: 2, + natural: false, + }, + ], + + docs: { + description: "Require object keys to be sorted", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/sort-keys", + }, + + schema: [ + { + enum: ["asc", "desc"], + }, + { + type: "object", + properties: { + caseSensitive: { + type: "boolean", + }, + natural: { + type: "boolean", + }, + minKeys: { + type: "integer", + minimum: 2, + }, + allowLineSeparatedGroups: { + type: "boolean", + }, + ignoreComputedKeys: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + messages: { + sortKeys: + "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'.", + }, + }, + + create(context) { + const [ + order, + { + caseSensitive, + natural, + minKeys, + allowLineSeparatedGroups, + ignoreComputedKeys, + }, + ] = context.options; + const insensitive = !caseSensitive; + const isValidOrder = + isValidOrders[ + order + (insensitive ? "I" : "") + (natural ? "N" : "") + ]; + + // The stack to save the previous property's name for each object literals. + let stack = null; + const sourceCode = context.sourceCode; + + return { + ObjectExpression(node) { + stack = { + upper: stack, + prevNode: null, + prevBlankLine: false, + prevName: null, + numKeys: node.properties.length, + }; + }, + + "ObjectExpression:exit"() { + stack = stack.upper; + }, + + SpreadElement(node) { + if (node.parent.type === "ObjectExpression") { + stack.prevName = null; + } + }, + + Property(node) { + if (node.parent.type === "ObjectPattern") { + return; + } + + if (ignoreComputedKeys && node.computed) { + stack.prevName = null; // reset sort + return; + } + + const prevName = stack.prevName; + const numKeys = stack.numKeys; + const thisName = getPropertyName(node); + + // Get tokens between current node and previous node + const tokens = + stack.prevNode && + sourceCode.getTokensBetween(stack.prevNode, node, { + includeComments: true, + }); + + let isBlankLineBetweenNodes = stack.prevBlankLine; + + if (tokens) { + // check blank line between tokens + tokens.forEach((token, index) => { + const previousToken = tokens[index - 1]; + + if ( + previousToken && + token.loc.start.line - previousToken.loc.end.line > + 1 + ) { + isBlankLineBetweenNodes = true; + } + }); + + // check blank line between the current node and the last token + if ( + !isBlankLineBetweenNodes && + node.loc.start.line - tokens.at(-1).loc.end.line > 1 + ) { + isBlankLineBetweenNodes = true; + } + + // check blank line between the first token and the previous node + if ( + !isBlankLineBetweenNodes && + tokens[0].loc.start.line - stack.prevNode.loc.end.line > + 1 + ) { + isBlankLineBetweenNodes = true; + } + } + + stack.prevNode = node; + + if (thisName !== null) { + stack.prevName = thisName; + } + + if (allowLineSeparatedGroups && isBlankLineBetweenNodes) { + stack.prevBlankLine = thisName === null; + return; + } + + if ( + prevName === null || + thisName === null || + numKeys < minKeys + ) { + return; + } + + if (!isValidOrder(prevName, thisName)) { + context.report({ + node, + loc: node.key.loc, + messageId: "sortKeys", + data: { + thisName, + prevName, + order, + insensitive: insensitive ? "insensitive " : "", + natural: natural ? "natural " : "", + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-vars.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-vars.js new file mode 100644 index 00000000..34081b95 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/sort-vars.js @@ -0,0 +1,140 @@ +/** + * @fileoverview Rule to require sorting of variables within a single Variable Declaration block + * @author Ilya Volodin + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + { + ignoreCase: false, + }, + ], + + docs: { + description: + "Require variables within the same declaration block to be sorted", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/sort-vars", + }, + + schema: [ + { + type: "object", + properties: { + ignoreCase: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + + messages: { + sortVars: + "Variables within the same declaration block should be sorted alphabetically.", + }, + }, + + create(context) { + const [{ ignoreCase }] = context.options; + const sourceCode = context.sourceCode; + + return { + VariableDeclaration(node) { + const idDeclarations = node.declarations.filter( + decl => decl.id.type === "Identifier", + ); + const getSortableName = ignoreCase + ? decl => decl.id.name.toLowerCase() + : decl => decl.id.name; + const unfixable = idDeclarations.some( + decl => decl.init !== null && decl.init.type !== "Literal", + ); + let fixed = false; + + idDeclarations.slice(1).reduce((memo, decl) => { + const lastVariableName = getSortableName(memo), + currentVariableName = getSortableName(decl); + + if (currentVariableName < lastVariableName) { + context.report({ + node: decl, + messageId: "sortVars", + fix(fixer) { + if (unfixable || fixed) { + return null; + } + return fixer.replaceTextRange( + [ + idDeclarations[0].range[0], + idDeclarations.at(-1).range[1], + ], + idDeclarations + + // Clone the idDeclarations array to avoid mutating it + .slice() + + // Sort the array into the desired order + .sort((declA, declB) => { + const aName = + getSortableName(declA); + const bName = + getSortableName(declB); + + return aName > bName ? 1 : -1; + }) + + // Build a string out of the sorted list of identifier declarations and the text between the originals + .reduce( + (sourceText, identifier, index) => { + const textAfterIdentifier = + index === + idDeclarations.length - 1 + ? "" + : sourceCode + .getText() + .slice( + idDeclarations[ + index + ].range[1], + idDeclarations[ + index + + 1 + ].range[0], + ); + + return ( + sourceText + + sourceCode.getText( + identifier, + ) + + textAfterIdentifier + ); + }, + "", + ), + ); + }, + }); + fixed = true; + return memo; + } + return decl; + }, idDeclarations[0]); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-blocks.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-blocks.js new file mode 100644 index 00000000..524a482a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-blocks.js @@ -0,0 +1,232 @@ +/** + * @fileoverview A rule to ensure whitespace before blocks. + * @author Mathias Schreck + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Checks whether the given node represents the body of a function. + * @param {ASTNode} node the node to check. + * @returns {boolean} `true` if the node is function body. + */ +function isFunctionBody(node) { + const parent = node.parent; + + return ( + node.type === "BlockStatement" && + astUtils.isFunction(parent) && + parent.body === node + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "space-before-blocks", + url: "https://eslint.style/rules/space-before-blocks", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing before blocks", + recommended: false, + url: "https://eslint.org/docs/latest/rules/space-before-blocks", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + keywords: { + enum: ["always", "never", "off"], + }, + functions: { + enum: ["always", "never", "off"], + }, + classes: { + enum: ["always", "never", "off"], + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + unexpectedSpace: "Unexpected space before opening brace.", + missingSpace: "Missing space before opening brace.", + }, + }, + + create(context) { + const config = context.options[0], + sourceCode = context.sourceCode; + let alwaysFunctions = true, + alwaysKeywords = true, + alwaysClasses = true, + neverFunctions = false, + neverKeywords = false, + neverClasses = false; + + if (typeof config === "object") { + alwaysFunctions = config.functions === "always"; + alwaysKeywords = config.keywords === "always"; + alwaysClasses = config.classes === "always"; + neverFunctions = config.functions === "never"; + neverKeywords = config.keywords === "never"; + neverClasses = config.classes === "never"; + } else if (config === "never") { + alwaysFunctions = false; + alwaysKeywords = false; + alwaysClasses = false; + neverFunctions = true; + neverKeywords = true; + neverClasses = true; + } + + /** + * Checks whether the spacing before the given block is already controlled by another rule: + * - `arrow-spacing` checks spaces after `=>`. + * - `keyword-spacing` checks spaces after keywords in certain contexts. + * - `switch-colon-spacing` checks spaces after `:` of switch cases. + * @param {Token} precedingToken first token before the block. + * @param {ASTNode|Token} node `BlockStatement` node or `{` token of a `SwitchStatement` node. + * @returns {boolean} `true` if requiring or disallowing spaces before the given block could produce conflicts with other rules. + */ + function isConflicted(precedingToken, node) { + return ( + astUtils.isArrowToken(precedingToken) || + (astUtils.isKeywordToken(precedingToken) && + !isFunctionBody(node)) || + (astUtils.isColonToken(precedingToken) && + node.parent && + node.parent.type === "SwitchCase" && + precedingToken === + astUtils.getSwitchCaseColonToken( + node.parent, + sourceCode, + )) + ); + } + + /** + * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line. + * @param {ASTNode|Token} node The AST node of a BlockStatement. + * @returns {void} undefined. + */ + function checkPrecedingSpace(node) { + const precedingToken = sourceCode.getTokenBefore(node); + + if ( + precedingToken && + !isConflicted(precedingToken, node) && + astUtils.isTokenOnSameLine(precedingToken, node) + ) { + const hasSpace = sourceCode.isSpaceBetween( + precedingToken, + node, + ); + let requireSpace; + let requireNoSpace; + + if (isFunctionBody(node)) { + requireSpace = alwaysFunctions; + requireNoSpace = neverFunctions; + } else if (node.type === "ClassBody") { + requireSpace = alwaysClasses; + requireNoSpace = neverClasses; + } else { + requireSpace = alwaysKeywords; + requireNoSpace = neverKeywords; + } + + if (requireSpace && !hasSpace) { + context.report({ + node, + messageId: "missingSpace", + fix(fixer) { + return fixer.insertTextBefore(node, " "); + }, + }); + } else if (requireNoSpace && hasSpace) { + context.report({ + node, + messageId: "unexpectedSpace", + fix(fixer) { + return fixer.removeRange([ + precedingToken.range[1], + node.range[0], + ]); + }, + }); + } + } + } + + /** + * Checks if the CaseBlock of an given SwitchStatement node has a preceding space. + * @param {ASTNode} node The node of a SwitchStatement. + * @returns {void} undefined. + */ + function checkSpaceBeforeCaseBlock(node) { + const cases = node.cases; + let openingBrace; + + if (cases.length > 0) { + openingBrace = sourceCode.getTokenBefore(cases[0]); + } else { + openingBrace = sourceCode.getLastToken(node, 1); + } + + checkPrecedingSpace(openingBrace); + } + + return { + BlockStatement: checkPrecedingSpace, + ClassBody: checkPrecedingSpace, + SwitchStatement: checkSpaceBeforeCaseBlock, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-function-paren.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-function-paren.js new file mode 100644 index 00000000..2a555504 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-before-function-paren.js @@ -0,0 +1,202 @@ +/** + * @fileoverview Rule to validate spacing before function paren. + * @author Mathias Schreck + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "space-before-function-paren", + url: "https://eslint.style/rules/space-before-function-paren", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing before `function` definition opening parenthesis", + recommended: false, + url: "https://eslint.org/docs/latest/rules/space-before-function-paren", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + anonymous: { + enum: ["always", "never", "ignore"], + }, + named: { + enum: ["always", "never", "ignore"], + }, + asyncArrow: { + enum: ["always", "never", "ignore"], + }, + }, + additionalProperties: false, + }, + ], + }, + ], + + messages: { + unexpectedSpace: "Unexpected space before function parentheses.", + missingSpace: "Missing space before function parentheses.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const baseConfig = + typeof context.options[0] === "string" + ? context.options[0] + : "always"; + const overrideConfig = + typeof context.options[0] === "object" ? context.options[0] : {}; + + /** + * Determines whether a function has a name. + * @param {ASTNode} node The function node. + * @returns {boolean} Whether the function has a name. + */ + function isNamedFunction(node) { + if (node.id) { + return true; + } + + const parent = node.parent; + + return ( + parent.type === "MethodDefinition" || + (parent.type === "Property" && + (parent.kind === "get" || + parent.kind === "set" || + parent.method)) + ); + } + + /** + * Gets the config for a given function + * @param {ASTNode} node The function node + * @returns {string} "always", "never", or "ignore" + */ + function getConfigForFunction(node) { + if (node.type === "ArrowFunctionExpression") { + // Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar + if ( + node.async && + astUtils.isOpeningParenToken( + sourceCode.getFirstToken(node, { skip: 1 }), + ) + ) { + return overrideConfig.asyncArrow || baseConfig; + } + } else if (isNamedFunction(node)) { + return overrideConfig.named || baseConfig; + + // `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}` + } else if (!node.generator) { + return overrideConfig.anonymous || baseConfig; + } + + return "ignore"; + } + + /** + * Checks the parens of a function node + * @param {ASTNode} node A function node + * @returns {void} + */ + function checkFunction(node) { + const functionConfig = getConfigForFunction(node); + + if (functionConfig === "ignore") { + return; + } + + const rightToken = sourceCode.getFirstToken( + node, + astUtils.isOpeningParenToken, + ); + const leftToken = sourceCode.getTokenBefore(rightToken); + const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken); + + if (hasSpacing && functionConfig === "never") { + context.report({ + node, + loc: { + start: leftToken.loc.end, + end: rightToken.loc.start, + }, + messageId: "unexpectedSpace", + fix(fixer) { + const comments = + sourceCode.getCommentsBefore(rightToken); + + // Don't fix anything if there's a single line comment between the left and the right token + if (comments.some(comment => comment.type === "Line")) { + return null; + } + return fixer.replaceTextRange( + [leftToken.range[1], rightToken.range[0]], + comments.reduce( + (text, comment) => + text + sourceCode.getText(comment), + "", + ), + ); + }, + }); + } else if (!hasSpacing && functionConfig === "always") { + context.report({ + node, + loc: rightToken.loc, + messageId: "missingSpace", + fix: fixer => fixer.insertTextAfter(leftToken, " "), + }); + } + } + + return { + ArrowFunctionExpression: checkFunction, + FunctionDeclaration: checkFunction, + FunctionExpression: checkFunction, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-in-parens.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-in-parens.js new file mode 100644 index 00000000..d4deaee2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-in-parens.js @@ -0,0 +1,374 @@ +/** + * @fileoverview Disallows or enforces spaces inside of parentheses. + * @author Jonathan Rajavuori + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "space-in-parens", + url: "https://eslint.style/rules/space-in-parens", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce consistent spacing inside parentheses", + recommended: false, + url: "https://eslint.org/docs/latest/rules/space-in-parens", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + enum: ["{}", "[]", "()", "empty"], + }, + uniqueItems: true, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missingOpeningSpace: "There must be a space after this paren.", + missingClosingSpace: "There must be a space before this paren.", + rejectedOpeningSpace: "There should be no space after this paren.", + rejectedClosingSpace: "There should be no space before this paren.", + }, + }, + + create(context) { + const ALWAYS = context.options[0] === "always", + exceptionsArrayOptions = + (context.options[1] && context.options[1].exceptions) || [], + options = {}; + + let exceptions; + + if (exceptionsArrayOptions.length) { + options.braceException = exceptionsArrayOptions.includes("{}"); + options.bracketException = exceptionsArrayOptions.includes("[]"); + options.parenException = exceptionsArrayOptions.includes("()"); + options.empty = exceptionsArrayOptions.includes("empty"); + } + + /** + * Produces an object with the opener and closer exception values + * @returns {Object} `openers` and `closers` exception values + * @private + */ + function getExceptions() { + const openers = [], + closers = []; + + if (options.braceException) { + openers.push("{"); + closers.push("}"); + } + + if (options.bracketException) { + openers.push("["); + closers.push("]"); + } + + if (options.parenException) { + openers.push("("); + closers.push(")"); + } + + if (options.empty) { + openers.push(")"); + closers.push("("); + } + + return { + openers, + closers, + }; + } + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + const sourceCode = context.sourceCode; + + /** + * Determines if a token is one of the exceptions for the opener paren + * @param {Object} token The token to check + * @returns {boolean} True if the token is one of the exceptions for the opener paren + */ + function isOpenerException(token) { + return exceptions.openers.includes(token.value); + } + + /** + * Determines if a token is one of the exceptions for the closer paren + * @param {Object} token The token to check + * @returns {boolean} True if the token is one of the exceptions for the closer paren + */ + function isCloserException(token) { + return exceptions.closers.includes(token.value); + } + + /** + * Determines if an opening paren is immediately followed by a required space + * @param {Object} openingParenToken The paren token + * @param {Object} tokenAfterOpeningParen The token after it + * @returns {boolean} True if the opening paren is missing a required space + */ + function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) { + if ( + sourceCode.isSpaceBetween( + openingParenToken, + tokenAfterOpeningParen, + ) + ) { + return false; + } + + if ( + !options.empty && + astUtils.isClosingParenToken(tokenAfterOpeningParen) + ) { + return false; + } + + if (ALWAYS) { + return !isOpenerException(tokenAfterOpeningParen); + } + return isOpenerException(tokenAfterOpeningParen); + } + + /** + * Determines if an opening paren is immediately followed by a disallowed space + * @param {Object} openingParenToken The paren token + * @param {Object} tokenAfterOpeningParen The token after it + * @returns {boolean} True if the opening paren has a disallowed space + */ + function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) { + if ( + !astUtils.isTokenOnSameLine( + openingParenToken, + tokenAfterOpeningParen, + ) + ) { + return false; + } + + if (tokenAfterOpeningParen.type === "Line") { + return false; + } + + if ( + !sourceCode.isSpaceBetween( + openingParenToken, + tokenAfterOpeningParen, + ) + ) { + return false; + } + + if (ALWAYS) { + return isOpenerException(tokenAfterOpeningParen); + } + return !isOpenerException(tokenAfterOpeningParen); + } + + /** + * Determines if a closing paren is immediately preceded by a required space + * @param {Object} tokenBeforeClosingParen The token before the paren + * @param {Object} closingParenToken The paren token + * @returns {boolean} True if the closing paren is missing a required space + */ + function closerMissingSpace( + tokenBeforeClosingParen, + closingParenToken, + ) { + if ( + sourceCode.isSpaceBetween( + tokenBeforeClosingParen, + closingParenToken, + ) + ) { + return false; + } + + if ( + !options.empty && + astUtils.isOpeningParenToken(tokenBeforeClosingParen) + ) { + return false; + } + + if (ALWAYS) { + return !isCloserException(tokenBeforeClosingParen); + } + return isCloserException(tokenBeforeClosingParen); + } + + /** + * Determines if a closer paren is immediately preceded by a disallowed space + * @param {Object} tokenBeforeClosingParen The token before the paren + * @param {Object} closingParenToken The paren token + * @returns {boolean} True if the closing paren has a disallowed space + */ + function closerRejectsSpace( + tokenBeforeClosingParen, + closingParenToken, + ) { + if ( + !astUtils.isTokenOnSameLine( + tokenBeforeClosingParen, + closingParenToken, + ) + ) { + return false; + } + + if ( + !sourceCode.isSpaceBetween( + tokenBeforeClosingParen, + closingParenToken, + ) + ) { + return false; + } + + if (ALWAYS) { + return isCloserException(tokenBeforeClosingParen); + } + return !isCloserException(tokenBeforeClosingParen); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: function checkParenSpaces(node) { + exceptions = getExceptions(); + const tokens = sourceCode.tokensAndComments; + + tokens.forEach((token, i) => { + const prevToken = tokens[i - 1]; + const nextToken = tokens[i + 1]; + + // if token is not an opening or closing paren token, do nothing + if ( + !astUtils.isOpeningParenToken(token) && + !astUtils.isClosingParenToken(token) + ) { + return; + } + + // if token is an opening paren and is not followed by a required space + if ( + token.value === "(" && + openerMissingSpace(token, nextToken) + ) { + context.report({ + node, + loc: token.loc, + messageId: "missingOpeningSpace", + fix(fixer) { + return fixer.insertTextAfter(token, " "); + }, + }); + } + + // if token is an opening paren and is followed by a disallowed space + if ( + token.value === "(" && + openerRejectsSpace(token, nextToken) + ) { + context.report({ + node, + loc: { + start: token.loc.end, + end: nextToken.loc.start, + }, + messageId: "rejectedOpeningSpace", + fix(fixer) { + return fixer.removeRange([ + token.range[1], + nextToken.range[0], + ]); + }, + }); + } + + // if token is a closing paren and is not preceded by a required space + if ( + token.value === ")" && + closerMissingSpace(prevToken, token) + ) { + context.report({ + node, + loc: token.loc, + messageId: "missingClosingSpace", + fix(fixer) { + return fixer.insertTextBefore(token, " "); + }, + }); + } + + // if token is a closing paren and is preceded by a disallowed space + if ( + token.value === ")" && + closerRejectsSpace(prevToken, token) + ) { + context.report({ + node, + loc: { + start: prevToken.loc.end, + end: token.loc.start, + }, + messageId: "rejectedClosingSpace", + fix(fixer) { + return fixer.removeRange([ + prevToken.range[1], + token.range[0], + ]); + }, + }); + } + }); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-infix-ops.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-infix-ops.js new file mode 100644 index 00000000..4b2f619d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-infix-ops.js @@ -0,0 +1,249 @@ +/** + * @fileoverview Require spaces around infix operators + * @author Michael Ficarra + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const { isEqToken } = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "space-infix-ops", + url: "https://eslint.style/rules/space-infix-ops", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require spacing around infix operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/space-infix-ops", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + int32Hint: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + missingSpace: "Operator '{{operator}}' must be spaced.", + }, + }, + + create(context) { + const int32Hint = context.options[0] + ? context.options[0].int32Hint === true + : false; + const sourceCode = context.sourceCode; + + /** + * Returns the first token which violates the rule + * @param {ASTNode} left The left node of the main node + * @param {ASTNode} right The right node of the main node + * @param {string} op The operator of the main node + * @returns {Object} The violator token or null + * @private + */ + function getFirstNonSpacedToken(left, right, op) { + const operator = sourceCode.getFirstTokenBetween( + left, + right, + token => token.value === op, + ); + const prev = sourceCode.getTokenBefore(operator); + const next = sourceCode.getTokenAfter(operator); + + if ( + !sourceCode.isSpaceBetween(prev, operator) || + !sourceCode.isSpaceBetween(operator, next) + ) { + return operator; + } + + return null; + } + + /** + * Reports an AST node as a rule violation + * @param {ASTNode} mainNode The node to report + * @param {Object} culpritToken The token which has a problem + * @returns {void} + * @private + */ + function report(mainNode, culpritToken) { + context.report({ + node: mainNode, + loc: culpritToken.loc, + messageId: "missingSpace", + data: { + operator: culpritToken.value, + }, + fix(fixer) { + const previousToken = + sourceCode.getTokenBefore(culpritToken); + const afterToken = sourceCode.getTokenAfter(culpritToken); + let fixString = ""; + + if (culpritToken.range[0] - previousToken.range[1] === 0) { + fixString = " "; + } + + fixString += culpritToken.value; + + if (afterToken.range[0] - culpritToken.range[1] === 0) { + fixString += " "; + } + + return fixer.replaceText(culpritToken, fixString); + }, + }); + } + + /** + * Check if the node is binary then report + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkBinary(node) { + const leftNode = node.left.typeAnnotation + ? node.left.typeAnnotation + : node.left; + const rightNode = node.right; + + // search for = in AssignmentPattern nodes + const operator = node.operator || "="; + + const nonSpacedNode = getFirstNonSpacedToken( + leftNode, + rightNode, + operator, + ); + + if (nonSpacedNode) { + if (!(int32Hint && sourceCode.getText(node).endsWith("|0"))) { + report(node, nonSpacedNode); + } + } + } + + /** + * Check if the node is conditional + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkConditional(node) { + const nonSpacedConsequentNode = getFirstNonSpacedToken( + node.test, + node.consequent, + "?", + ); + const nonSpacedAlternateNode = getFirstNonSpacedToken( + node.consequent, + node.alternate, + ":", + ); + + if (nonSpacedConsequentNode) { + report(node, nonSpacedConsequentNode); + } + + if (nonSpacedAlternateNode) { + report(node, nonSpacedAlternateNode); + } + } + + /** + * Check if the node is a variable + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkVar(node) { + const leftNode = node.id.typeAnnotation + ? node.id.typeAnnotation + : node.id; + const rightNode = node.init; + + if (rightNode) { + const nonSpacedNode = getFirstNonSpacedToken( + leftNode, + rightNode, + "=", + ); + + if (nonSpacedNode) { + report(node, nonSpacedNode); + } + } + } + + return { + AssignmentExpression: checkBinary, + AssignmentPattern: checkBinary, + BinaryExpression: checkBinary, + LogicalExpression: checkBinary, + ConditionalExpression: checkConditional, + VariableDeclarator: checkVar, + + PropertyDefinition(node) { + if (!node.value) { + return; + } + + /* + * Because of computed properties and type annotations, some + * tokens may exist between `node.key` and `=`. + * Therefore, find the `=` from the right. + */ + const operatorToken = sourceCode.getTokenBefore( + node.value, + isEqToken, + ); + const leftToken = sourceCode.getTokenBefore(operatorToken); + const rightToken = sourceCode.getTokenAfter(operatorToken); + + if ( + !sourceCode.isSpaceBetween(leftToken, operatorToken) || + !sourceCode.isSpaceBetween(operatorToken, rightToken) + ) { + report(node, operatorToken); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-unary-ops.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-unary-ops.js new file mode 100644 index 00000000..ee587147 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/space-unary-ops.js @@ -0,0 +1,400 @@ +/** + * @fileoverview This rule should require or disallow spaces before or after unary operations. + * @author Marcin Kumorek + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "space-unary-ops", + url: "https://eslint.style/rules/space-unary-ops", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Enforce consistent spacing before or after unary operators", + recommended: false, + url: "https://eslint.org/docs/latest/rules/space-unary-ops", + }, + + fixable: "whitespace", + + schema: [ + { + type: "object", + properties: { + words: { + type: "boolean", + default: true, + }, + nonwords: { + type: "boolean", + default: false, + }, + overrides: { + type: "object", + additionalProperties: { + type: "boolean", + }, + }, + }, + additionalProperties: false, + }, + ], + messages: { + unexpectedBefore: + "Unexpected space before unary operator '{{operator}}'.", + unexpectedAfter: + "Unexpected space after unary operator '{{operator}}'.", + unexpectedAfterWord: + "Unexpected space after unary word operator '{{word}}'.", + wordOperator: + "Unary word operator '{{word}}' must be followed by whitespace.", + operator: + "Unary operator '{{operator}}' must be followed by whitespace.", + beforeUnaryExpressions: + "Space is required before unary expressions '{{token}}'.", + }, + }, + + create(context) { + const options = context.options[0] || { words: true, nonwords: false }; + + const sourceCode = context.sourceCode; + + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Check if the node is the first "!" in a "!!" convert to Boolean expression + * @param {ASTnode} node AST node + * @returns {boolean} Whether or not the node is first "!" in "!!" + */ + function isFirstBangInBangBangExpression(node) { + return ( + node && + node.type === "UnaryExpression" && + node.argument.operator === "!" && + node.argument && + node.argument.type === "UnaryExpression" && + node.argument.operator === "!" + ); + } + + /** + * Checks if an override exists for a given operator. + * @param {string} operator Operator + * @returns {boolean} Whether or not an override has been provided for the operator + */ + function overrideExistsForOperator(operator) { + return ( + options.overrides && Object.hasOwn(options.overrides, operator) + ); + } + + /** + * Gets the value that the override was set to for this operator + * @param {string} operator Operator + * @returns {boolean} Whether or not an override enforces a space with this operator + */ + function overrideEnforcesSpaces(operator) { + return options.overrides[operator]; + } + + /** + * Verify Unary Word Operator has spaces after the word operator + * @param {ASTnode} node AST node + * @param {Object} firstToken first token from the AST node + * @param {Object} secondToken second token from the AST node + * @param {string} word The word to be used for reporting + * @returns {void} + */ + function verifyWordHasSpaces(node, firstToken, secondToken, word) { + if (secondToken.range[0] === firstToken.range[1]) { + context.report({ + node, + messageId: "wordOperator", + data: { + word, + }, + fix(fixer) { + return fixer.insertTextAfter(firstToken, " "); + }, + }); + } + } + + /** + * Verify Unary Word Operator doesn't have spaces after the word operator + * @param {ASTnode} node AST node + * @param {Object} firstToken first token from the AST node + * @param {Object} secondToken second token from the AST node + * @param {string} word The word to be used for reporting + * @returns {void} + */ + function verifyWordDoesntHaveSpaces( + node, + firstToken, + secondToken, + word, + ) { + if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) { + if (secondToken.range[0] > firstToken.range[1]) { + context.report({ + node, + messageId: "unexpectedAfterWord", + data: { + word, + }, + fix(fixer) { + return fixer.removeRange([ + firstToken.range[1], + secondToken.range[0], + ]); + }, + }); + } + } + } + + /** + * Check Unary Word Operators for spaces after the word operator + * @param {ASTnode} node AST node + * @param {Object} firstToken first token from the AST node + * @param {Object} secondToken second token from the AST node + * @param {string} word The word to be used for reporting + * @returns {void} + */ + function checkUnaryWordOperatorForSpaces( + node, + firstToken, + secondToken, + word, + ) { + if (overrideExistsForOperator(word)) { + if (overrideEnforcesSpaces(word)) { + verifyWordHasSpaces(node, firstToken, secondToken, word); + } else { + verifyWordDoesntHaveSpaces( + node, + firstToken, + secondToken, + word, + ); + } + } else if (options.words) { + verifyWordHasSpaces(node, firstToken, secondToken, word); + } else { + verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word); + } + } + + /** + * Verifies YieldExpressions satisfy spacing requirements + * @param {ASTnode} node AST node + * @returns {void} + */ + function checkForSpacesAfterYield(node) { + const tokens = sourceCode.getFirstTokens(node, 3), + word = "yield"; + + if (!node.argument || node.delegate) { + return; + } + + checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], word); + } + + /** + * Verifies AwaitExpressions satisfy spacing requirements + * @param {ASTNode} node AwaitExpression AST node + * @returns {void} + */ + function checkForSpacesAfterAwait(node) { + const tokens = sourceCode.getFirstTokens(node, 3); + + checkUnaryWordOperatorForSpaces( + node, + tokens[0], + tokens[1], + "await", + ); + } + + /** + * Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator + * @param {ASTnode} node AST node + * @param {Object} firstToken First token in the expression + * @param {Object} secondToken Second token in the expression + * @returns {void} + */ + function verifyNonWordsHaveSpaces(node, firstToken, secondToken) { + if (node.prefix) { + if (isFirstBangInBangBangExpression(node)) { + return; + } + if (firstToken.range[1] === secondToken.range[0]) { + context.report({ + node, + messageId: "operator", + data: { + operator: firstToken.value, + }, + fix(fixer) { + return fixer.insertTextAfter(firstToken, " "); + }, + }); + } + } else { + if (firstToken.range[1] === secondToken.range[0]) { + context.report({ + node, + messageId: "beforeUnaryExpressions", + data: { + token: secondToken.value, + }, + fix(fixer) { + return fixer.insertTextBefore(secondToken, " "); + }, + }); + } + } + } + + /** + * Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator + * @param {ASTnode} node AST node + * @param {Object} firstToken First token in the expression + * @param {Object} secondToken Second token in the expression + * @returns {void} + */ + function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) { + if (node.prefix) { + if (secondToken.range[0] > firstToken.range[1]) { + context.report({ + node, + messageId: "unexpectedAfter", + data: { + operator: firstToken.value, + }, + fix(fixer) { + if ( + astUtils.canTokensBeAdjacent( + firstToken, + secondToken, + ) + ) { + return fixer.removeRange([ + firstToken.range[1], + secondToken.range[0], + ]); + } + return null; + }, + }); + } + } else { + if (secondToken.range[0] > firstToken.range[1]) { + context.report({ + node, + messageId: "unexpectedBefore", + data: { + operator: secondToken.value, + }, + fix(fixer) { + return fixer.removeRange([ + firstToken.range[1], + secondToken.range[0], + ]); + }, + }); + } + } + } + + /** + * Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements + * @param {ASTnode} node AST node + * @returns {void} + */ + function checkForSpaces(node) { + const tokens = + node.type === "UpdateExpression" && !node.prefix + ? sourceCode.getLastTokens(node, 2) + : sourceCode.getFirstTokens(node, 2); + const firstToken = tokens[0]; + const secondToken = tokens[1]; + + if ( + (node.type === "NewExpression" || node.prefix) && + firstToken.type === "Keyword" + ) { + checkUnaryWordOperatorForSpaces( + node, + firstToken, + secondToken, + firstToken.value, + ); + return; + } + + const operator = node.prefix ? tokens[0].value : tokens[1].value; + + if (overrideExistsForOperator(operator)) { + if (overrideEnforcesSpaces(operator)) { + verifyNonWordsHaveSpaces(node, firstToken, secondToken); + } else { + verifyNonWordsDontHaveSpaces(node, firstToken, secondToken); + } + } else if (options.nonwords) { + verifyNonWordsHaveSpaces(node, firstToken, secondToken); + } else { + verifyNonWordsDontHaveSpaces(node, firstToken, secondToken); + } + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + UnaryExpression: checkForSpaces, + UpdateExpression: checkForSpaces, + NewExpression: checkForSpaces, + YieldExpression: checkForSpacesAfterYield, + AwaitExpression: checkForSpacesAfterAwait, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/spaced-comment.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/spaced-comment.js new file mode 100644 index 00000000..cb2a9782 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/spaced-comment.js @@ -0,0 +1,447 @@ +/** + * @fileoverview Source code for spaced-comments rule + * @author Gyandeep Singh + * @deprecated in ESLint v8.53.0 + */ +"use strict"; + +const escapeRegExp = require("escape-string-regexp"); +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Escapes the control characters of a given string. + * @param {string} s A string to escape. + * @returns {string} An escaped string. + */ +function escape(s) { + return `(?:${escapeRegExp(s)})`; +} + +/** + * Escapes the control characters of a given string. + * And adds a repeat flag. + * @param {string} s A string to escape. + * @returns {string} An escaped string. + */ +function escapeAndRepeat(s) { + return `${escape(s)}+`; +} + +/** + * Parses `markers` option. + * If markers don't include `"*"`, this adds `"*"` to allow JSDoc comments. + * @param {string[]} [markers] A marker list. + * @returns {string[]} A marker list. + */ +function parseMarkersOption(markers) { + // `*` is a marker for JSDoc comments. + if (!markers.includes("*")) { + return markers.concat("*"); + } + + return markers; +} + +/** + * Creates string pattern for exceptions. + * Generated pattern: + * + * 1. A space or an exception pattern sequence. + * @param {string[]} exceptions An exception pattern list. + * @returns {string} A regular expression string for exceptions. + */ +function createExceptionsPattern(exceptions) { + let pattern = ""; + + /* + * A space or an exception pattern sequence. + * [] ==> "\s" + * ["-"] ==> "(?:\s|\-+$)" + * ["-", "="] ==> "(?:\s|(?:\-+|=+)$)" + * ["-", "=", "--=="] ==> "(?:\s|(?:\-+|=+|(?:\-\-==)+)$)" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5Cs%7C(%3F%3A%5C-%2B%7C%3D%2B%7C(%3F%3A%5C-%5C-%3D%3D)%2B)%24) + */ + if (exceptions.length === 0) { + // a space. + pattern += "\\s"; + } else { + // a space or... + pattern += "(?:\\s|"; + + if (exceptions.length === 1) { + // a sequence of the exception pattern. + pattern += escapeAndRepeat(exceptions[0]); + } else { + // a sequence of one of the exception patterns. + pattern += "(?:"; + pattern += exceptions.map(escapeAndRepeat).join("|"); + pattern += ")"; + } + pattern += `(?:$|[${Array.from(astUtils.LINEBREAKS).join("")}]))`; + } + + return pattern; +} + +/** + * Creates RegExp object for `always` mode. + * Generated pattern for beginning of comment: + * + * 1. First, a marker or nothing. + * 2. Next, a space or an exception pattern sequence. + * @param {string[]} markers A marker list. + * @param {string[]} exceptions An exception pattern list. + * @returns {RegExp} A RegExp object for the beginning of a comment in `always` mode. + */ +function createAlwaysStylePattern(markers, exceptions) { + let pattern = "^"; + + /* + * A marker or nothing. + * ["*"] ==> "\*?" + * ["*", "!"] ==> "(?:\*|!)?" + * ["*", "/", "!<"] ==> "(?:\*|\/|(?:!<))?" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5C*%7C%5C%2F%7C(%3F%3A!%3C))%3F + */ + if (markers.length === 1) { + // the marker. + pattern += escape(markers[0]); + } else { + // one of markers. + pattern += "(?:"; + pattern += markers.map(escape).join("|"); + pattern += ")"; + } + + pattern += "?"; // or nothing. + pattern += createExceptionsPattern(exceptions); + + return new RegExp(pattern, "u"); +} + +/** + * Creates RegExp object for `never` mode. + * Generated pattern for beginning of comment: + * + * 1. First, a marker or nothing (captured). + * 2. Next, a space or a tab. + * @param {string[]} markers A marker list. + * @returns {RegExp} A RegExp object for `never` mode. + */ +function createNeverStylePattern(markers) { + const pattern = `^(${markers.map(escape).join("|")})?[ \t]+`; + + return new RegExp(pattern, "u"); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "spaced-comment", + url: "https://eslint.style/rules/spaced-comment", + }, + }, + ], + }, + type: "suggestion", + + docs: { + description: + "Enforce consistent spacing after the `//` or `/*` in a comment", + recommended: false, + url: "https://eslint.org/docs/latest/rules/spaced-comment", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + type: "string", + }, + }, + markers: { + type: "array", + items: { + type: "string", + }, + }, + line: { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + type: "string", + }, + }, + markers: { + type: "array", + items: { + type: "string", + }, + }, + }, + additionalProperties: false, + }, + block: { + type: "object", + properties: { + exceptions: { + type: "array", + items: { + type: "string", + }, + }, + markers: { + type: "array", + items: { + type: "string", + }, + }, + balanced: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }, + ], + + messages: { + unexpectedSpaceAfterMarker: + "Unexpected space or tab after marker ({{refChar}}) in comment.", + expectedExceptionAfter: + "Expected exception block, space or tab after '{{refChar}}' in comment.", + unexpectedSpaceBefore: + "Unexpected space or tab before '*/' in comment.", + unexpectedSpaceAfter: + "Unexpected space or tab after '{{refChar}}' in comment.", + expectedSpaceBefore: + "Expected space or tab before '*/' in comment.", + expectedSpaceAfter: + "Expected space or tab after '{{refChar}}' in comment.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + // Unless the first option is never, require a space + const requireSpace = context.options[0] !== "never"; + + /* + * Parse the second options. + * If markers don't include `"*"`, it's added automatically for JSDoc + * comments. + */ + const config = context.options[1] || {}; + const balanced = config.block && config.block.balanced; + + const styleRules = ["block", "line"].reduce((rule, type) => { + const markers = parseMarkersOption( + (config[type] && config[type].markers) || config.markers || [], + ); + const exceptions = + (config[type] && config[type].exceptions) || + config.exceptions || + []; + const endNeverPattern = "[ \t]+$"; + + // Create RegExp object for valid patterns. + rule[type] = { + beginRegex: requireSpace + ? createAlwaysStylePattern(markers, exceptions) + : createNeverStylePattern(markers), + endRegex: + balanced && requireSpace + ? new RegExp( + `${createExceptionsPattern(exceptions)}$`, + "u", + ) + : new RegExp(endNeverPattern, "u"), + hasExceptions: exceptions.length > 0, + captureMarker: new RegExp( + `^(${markers.map(escape).join("|")})`, + "u", + ), + markers: new Set(markers), + }; + + return rule; + }, {}); + + /** + * Reports a beginning spacing error with an appropriate message. + * @param {ASTNode} node A comment node to check. + * @param {string} messageId An error message to report. + * @param {Array} match An array of match results for markers. + * @param {string} refChar Character used for reference in the error message. + * @returns {void} + */ + function reportBegin(node, messageId, match, refChar) { + const type = node.type.toLowerCase(), + commentIdentifier = type === "block" ? "/*" : "//"; + + context.report({ + node, + fix(fixer) { + const start = node.range[0]; + let end = start + 2; + + if (requireSpace) { + if (match) { + end += match[0].length; + } + return fixer.insertTextAfterRange([start, end], " "); + } + end += match[0].length; + return fixer.replaceTextRange( + [start, end], + commentIdentifier + (match[1] ? match[1] : ""), + ); + }, + messageId, + data: { refChar }, + }); + } + + /** + * Reports an ending spacing error with an appropriate message. + * @param {ASTNode} node A comment node to check. + * @param {string} messageId An error message to report. + * @param {string} match An array of the matched whitespace characters. + * @returns {void} + */ + function reportEnd(node, messageId, match) { + context.report({ + node, + fix(fixer) { + if (requireSpace) { + return fixer.insertTextAfterRange( + [node.range[0], node.range[1] - 2], + " ", + ); + } + const end = node.range[1] - 2, + start = end - match[0].length; + + return fixer.replaceTextRange([start, end], ""); + }, + messageId, + }); + } + + /** + * Reports a given comment if it's invalid. + * @param {ASTNode} node a comment node to check. + * @returns {void} + */ + function checkCommentForSpace(node) { + const type = node.type.toLowerCase(), + rule = styleRules[type], + commentIdentifier = type === "block" ? "/*" : "//"; + + // Ignores empty comments and comments that consist only of a marker. + if (node.value.length === 0 || rule.markers.has(node.value)) { + return; + } + + const beginMatch = rule.beginRegex.exec(node.value); + const endMatch = rule.endRegex.exec(node.value); + + // Checks. + if (requireSpace) { + if (!beginMatch) { + const hasMarker = rule.captureMarker.exec(node.value); + const marker = hasMarker + ? commentIdentifier + hasMarker[0] + : commentIdentifier; + + if (rule.hasExceptions) { + reportBegin( + node, + "expectedExceptionAfter", + hasMarker, + marker, + ); + } else { + reportBegin( + node, + "expectedSpaceAfter", + hasMarker, + marker, + ); + } + } + + if (balanced && type === "block" && !endMatch) { + reportEnd(node, "expectedSpaceBefore"); + } + } else { + if (beginMatch) { + if (!beginMatch[1]) { + reportBegin( + node, + "unexpectedSpaceAfter", + beginMatch, + commentIdentifier, + ); + } else { + reportBegin( + node, + "unexpectedSpaceAfterMarker", + beginMatch, + beginMatch[1], + ); + } + } + + if (balanced && type === "block" && endMatch) { + reportEnd(node, "unexpectedSpaceBefore", endMatch); + } + } + } + + return { + Program() { + const comments = sourceCode.getAllComments(); + + comments + .filter(token => token.type !== "Shebang") + .forEach(checkCommentForSpace); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/strict.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/strict.js new file mode 100644 index 00000000..fb837ade --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/strict.js @@ -0,0 +1,324 @@ +/** + * @fileoverview Rule to control usage of strict mode directives. + * @author Brandon Mills + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Gets all of the Use Strict Directives in the Directive Prologue of a group of + * statements. + * @param {ASTNode[]} statements Statements in the program or function body. + * @returns {ASTNode[]} All of the Use Strict Directives. + */ +function getUseStrictDirectives(statements) { + const directives = []; + + for (let i = 0; i < statements.length; i++) { + const statement = statements[i]; + + if ( + statement.type === "ExpressionStatement" && + statement.expression.type === "Literal" && + statement.expression.value === "use strict" + ) { + directives[i] = statement; + } else { + break; + } + } + + return directives; +} + +/** + * Checks whether a given parameter is a simple parameter. + * @param {ASTNode} node A pattern node to check. + * @returns {boolean} `true` if the node is an Identifier node. + */ +function isSimpleParameter(node) { + return node.type === "Identifier"; +} + +/** + * Checks whether a given parameter list is a simple parameter list. + * @param {ASTNode[]} params A parameter list to check. + * @returns {boolean} `true` if the every parameter is an Identifier node. + */ +function isSimpleParameterList(params) { + return params.every(isSimpleParameter); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: ["safe"], + + docs: { + description: "Require or disallow strict mode directives", + recommended: false, + url: "https://eslint.org/docs/latest/rules/strict", + }, + + schema: [ + { + enum: ["never", "global", "function", "safe"], + }, + ], + + fixable: "code", + messages: { + function: "Use the function form of 'use strict'.", + global: "Use the global form of 'use strict'.", + multiple: "Multiple 'use strict' directives.", + never: "Strict mode is not permitted.", + unnecessary: "Unnecessary 'use strict' directive.", + module: "'use strict' is unnecessary inside of modules.", + implied: + "'use strict' is unnecessary when implied strict mode is enabled.", + unnecessaryInClasses: + "'use strict' is unnecessary inside of classes.", + nonSimpleParameterList: + "'use strict' directive inside a function with non-simple parameter list throws a syntax error since ES2016.", + wrap: "Wrap {{name}} in a function with 'use strict' directive.", + }, + }, + + create(context) { + const ecmaFeatures = + context.languageOptions.parserOptions.ecmaFeatures || {}, + scopes = [], + classScopes = []; + let [mode] = context.options; + + if (ecmaFeatures.impliedStrict) { + mode = "implied"; + } else if (mode === "safe") { + mode = + ecmaFeatures.globalReturn || + context.languageOptions.sourceType === "commonjs" + ? "global" + : "function"; + } + + /** + * Determines whether a reported error should be fixed, depending on the error type. + * @param {string} errorType The type of error + * @returns {boolean} `true` if the reported error should be fixed + */ + function shouldFix(errorType) { + return ( + errorType === "multiple" || + errorType === "unnecessary" || + errorType === "module" || + errorType === "implied" || + errorType === "unnecessaryInClasses" + ); + } + + /** + * Gets a fixer function to remove a given 'use strict' directive. + * @param {ASTNode} node The directive that should be removed + * @returns {Function} A fixer function + */ + function getFixFunction(node) { + return fixer => fixer.remove(node); + } + + /** + * Report a slice of an array of nodes with a given message. + * @param {ASTNode[]} nodes Nodes. + * @param {string} start Index to start from. + * @param {string} end Index to end before. + * @param {string} messageId Message to display. + * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) + * @returns {void} + */ + function reportSlice(nodes, start, end, messageId, fix) { + nodes.slice(start, end).forEach(node => { + context.report({ + node, + messageId, + fix: fix ? getFixFunction(node) : null, + }); + }); + } + + /** + * Report all nodes in an array with a given message. + * @param {ASTNode[]} nodes Nodes. + * @param {string} messageId Message id to display. + * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) + * @returns {void} + */ + function reportAll(nodes, messageId, fix) { + reportSlice(nodes, 0, nodes.length, messageId, fix); + } + + /** + * Report all nodes in an array, except the first, with a given message. + * @param {ASTNode[]} nodes Nodes. + * @param {string} messageId Message id to display. + * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) + * @returns {void} + */ + function reportAllExceptFirst(nodes, messageId, fix) { + reportSlice(nodes, 1, nodes.length, messageId, fix); + } + + /** + * Entering a function in 'function' mode pushes a new nested scope onto the + * stack. The new scope is true if the nested function is strict mode code. + * @param {ASTNode} node The function declaration or expression. + * @param {ASTNode[]} useStrictDirectives The Use Strict Directives of the node. + * @returns {void} + */ + function enterFunctionInFunctionMode(node, useStrictDirectives) { + const isInClass = classScopes.length > 0, + isParentGlobal = + scopes.length === 0 && classScopes.length === 0, + isParentStrict = scopes.length > 0 && scopes.at(-1), + isStrict = useStrictDirectives.length > 0; + + if (isStrict) { + if (!isSimpleParameterList(node.params)) { + context.report({ + node: useStrictDirectives[0], + messageId: "nonSimpleParameterList", + }); + } else if (isParentStrict) { + context.report({ + node: useStrictDirectives[0], + messageId: "unnecessary", + fix: getFixFunction(useStrictDirectives[0]), + }); + } else if (isInClass) { + context.report({ + node: useStrictDirectives[0], + messageId: "unnecessaryInClasses", + fix: getFixFunction(useStrictDirectives[0]), + }); + } + + reportAllExceptFirst(useStrictDirectives, "multiple", true); + } else if (isParentGlobal) { + if (isSimpleParameterList(node.params)) { + context.report({ node, messageId: "function" }); + } else { + context.report({ + node, + messageId: "wrap", + data: { name: astUtils.getFunctionNameWithKind(node) }, + }); + } + } + + scopes.push(isParentStrict || isStrict); + } + + /** + * Exiting a function in 'function' mode pops its scope off the stack. + * @returns {void} + */ + function exitFunctionInFunctionMode() { + scopes.pop(); + } + + /** + * Enter a function and either: + * - Push a new nested scope onto the stack (in 'function' mode). + * - Report all the Use Strict Directives (in the other modes). + * @param {ASTNode} node The function declaration or expression. + * @returns {void} + */ + function enterFunction(node) { + const isBlock = node.body.type === "BlockStatement", + useStrictDirectives = isBlock + ? getUseStrictDirectives(node.body.body) + : []; + + if (mode === "function") { + enterFunctionInFunctionMode(node, useStrictDirectives); + } else if (useStrictDirectives.length > 0) { + if (isSimpleParameterList(node.params)) { + reportAll(useStrictDirectives, mode, shouldFix(mode)); + } else { + context.report({ + node: useStrictDirectives[0], + messageId: "nonSimpleParameterList", + }); + reportAllExceptFirst(useStrictDirectives, "multiple", true); + } + } + } + + /** @type {import('../types').Rule.RuleListener} */ + const rule = { + Program(node) { + const useStrictDirectives = getUseStrictDirectives(node.body); + + if (node.sourceType === "module") { + mode = "module"; + } + + if (mode === "global") { + if ( + node.body.length > 0 && + useStrictDirectives.length === 0 + ) { + /* + * Report the range as v9 does + */ + context.report({ + loc: { + start: node.body[0].loc.start, + end: node.body.at(-1).loc.end, + }, + messageId: "global", + }); + } + reportAllExceptFirst(useStrictDirectives, "multiple", true); + } else { + reportAll(useStrictDirectives, mode, shouldFix(mode)); + } + }, + FunctionDeclaration: enterFunction, + FunctionExpression: enterFunction, + ArrowFunctionExpression: enterFunction, + }; + + if (mode === "function") { + Object.assign(rule, { + // Inside of class bodies are always strict mode. + ClassBody() { + classScopes.push(true); + }, + "ClassBody:exit"() { + classScopes.pop(); + }, + + "FunctionDeclaration:exit": exitFunctionInFunctionMode, + "FunctionExpression:exit": exitFunctionInFunctionMode, + "ArrowFunctionExpression:exit": exitFunctionInFunctionMode, + }); + } + + return rule; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/switch-colon-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/switch-colon-spacing.js new file mode 100644 index 00000000..4690aa83 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/switch-colon-spacing.js @@ -0,0 +1,158 @@ +/** + * @fileoverview Rule to enforce spacing around colons of switch statements. + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "switch-colon-spacing", + url: "https://eslint.style/rules/switch-colon-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Enforce spacing around colons of switch statements", + recommended: false, + url: "https://eslint.org/docs/latest/rules/switch-colon-spacing", + }, + + schema: [ + { + type: "object", + properties: { + before: { type: "boolean", default: false }, + after: { type: "boolean", default: true }, + }, + additionalProperties: false, + }, + ], + fixable: "whitespace", + messages: { + expectedBefore: "Expected space(s) before this colon.", + expectedAfter: "Expected space(s) after this colon.", + unexpectedBefore: "Unexpected space(s) before this colon.", + unexpectedAfter: "Unexpected space(s) after this colon.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const options = context.options[0] || {}; + const beforeSpacing = options.before === true; // false by default + const afterSpacing = options.after !== false; // true by default + + /** + * Check whether the spacing between the given 2 tokens is valid or not. + * @param {Token} left The left token to check. + * @param {Token} right The right token to check. + * @param {boolean} expected The expected spacing to check. `true` if there should be a space. + * @returns {boolean} `true` if the spacing between the tokens is valid. + */ + function isValidSpacing(left, right, expected) { + return ( + astUtils.isClosingBraceToken(right) || + !astUtils.isTokenOnSameLine(left, right) || + sourceCode.isSpaceBetween(left, right) === expected + ); + } + + /** + * Check whether comments exist between the given 2 tokens. + * @param {Token} left The left token to check. + * @param {Token} right The right token to check. + * @returns {boolean} `true` if comments exist between the given 2 tokens. + */ + function commentsExistBetween(left, right) { + return ( + sourceCode.getFirstTokenBetween(left, right, { + includeComments: true, + filter: astUtils.isCommentToken, + }) !== null + ); + } + + /** + * Fix the spacing between the given 2 tokens. + * @param {RuleFixer} fixer The fixer to fix. + * @param {Token} left The left token of fix range. + * @param {Token} right The right token of fix range. + * @param {boolean} spacing The spacing style. `true` if there should be a space. + * @returns {Fix|null} The fix object. + */ + function fix(fixer, left, right, spacing) { + if (commentsExistBetween(left, right)) { + return null; + } + if (spacing) { + return fixer.insertTextAfter(left, " "); + } + return fixer.removeRange([left.range[1], right.range[0]]); + } + + return { + SwitchCase(node) { + const colonToken = astUtils.getSwitchCaseColonToken( + node, + sourceCode, + ); + const beforeToken = sourceCode.getTokenBefore(colonToken); + const afterToken = sourceCode.getTokenAfter(colonToken); + + if (!isValidSpacing(beforeToken, colonToken, beforeSpacing)) { + context.report({ + node, + loc: colonToken.loc, + messageId: beforeSpacing + ? "expectedBefore" + : "unexpectedBefore", + fix: fixer => + fix(fixer, beforeToken, colonToken, beforeSpacing), + }); + } + if (!isValidSpacing(colonToken, afterToken, afterSpacing)) { + context.report({ + node, + loc: colonToken.loc, + messageId: afterSpacing + ? "expectedAfter" + : "unexpectedAfter", + fix: fixer => + fix(fixer, colonToken, afterToken, afterSpacing), + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/symbol-description.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/symbol-description.js new file mode 100644 index 00000000..054c16be --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/symbol-description.js @@ -0,0 +1,70 @@ +/** + * @fileoverview Rule to enforce description with the `Symbol` object + * @author Jarek Rencz + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: "Require symbol descriptions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/symbol-description", + }, + fixable: null, + schema: [], + messages: { + expected: "Expected Symbol to have a description.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + /** + * Reports if node does not conform the rule in case rule is set to + * report missing description + * @param {ASTNode} node A CallExpression node to check. + * @returns {void} + */ + function checkArgument(node) { + if (node.arguments.length === 0) { + context.report({ + node, + messageId: "expected", + }); + } + } + + return { + "Program:exit"(node) { + const scope = sourceCode.getScope(node); + const variable = astUtils.getVariableByName(scope, "Symbol"); + + if (variable && variable.defs.length === 0) { + variable.references.forEach(reference => { + const idNode = reference.identifier; + + if (astUtils.isCallee(idNode)) { + checkArgument(idNode.parent); + } + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-curly-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-curly-spacing.js new file mode 100644 index 00000000..25e3aad0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-curly-spacing.js @@ -0,0 +1,168 @@ +/** + * @fileoverview Rule to enforce spacing around embedded expressions of template strings + * @author Toru Nagashima + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "template-curly-spacing", + url: "https://eslint.style/rules/template-curly-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require or disallow spacing around embedded expressions of template strings", + recommended: false, + url: "https://eslint.org/docs/latest/rules/template-curly-spacing", + }, + + fixable: "whitespace", + + schema: [{ enum: ["always", "never"] }], + messages: { + expectedBefore: "Expected space(s) before '}'.", + expectedAfter: "Expected space(s) after '${'.", + unexpectedBefore: "Unexpected space(s) before '}'.", + unexpectedAfter: "Unexpected space(s) after '${'.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + const always = context.options[0] === "always"; + + /** + * Checks spacing before `}` of a given token. + * @param {Token} token A token to check. This is a Template token. + * @returns {void} + */ + function checkSpacingBefore(token) { + if (!token.value.startsWith("}")) { + return; // starts with a backtick, this is the first template element in the template literal + } + + const prevToken = sourceCode.getTokenBefore(token, { + includeComments: true, + }), + hasSpace = sourceCode.isSpaceBetween(prevToken, token); + + if (!astUtils.isTokenOnSameLine(prevToken, token)) { + return; + } + + if (always && !hasSpace) { + context.report({ + loc: { + start: token.loc.start, + end: { + line: token.loc.start.line, + column: token.loc.start.column + 1, + }, + }, + messageId: "expectedBefore", + fix: fixer => fixer.insertTextBefore(token, " "), + }); + } + + if (!always && hasSpace) { + context.report({ + loc: { + start: prevToken.loc.end, + end: token.loc.start, + }, + messageId: "unexpectedBefore", + fix: fixer => + fixer.removeRange([prevToken.range[1], token.range[0]]), + }); + } + } + + /** + * Checks spacing after `${` of a given token. + * @param {Token} token A token to check. This is a Template token. + * @returns {void} + */ + function checkSpacingAfter(token) { + if (!token.value.endsWith("${")) { + return; // ends with a backtick, this is the last template element in the template literal + } + + const nextToken = sourceCode.getTokenAfter(token, { + includeComments: true, + }), + hasSpace = sourceCode.isSpaceBetween(token, nextToken); + + if (!astUtils.isTokenOnSameLine(token, nextToken)) { + return; + } + + if (always && !hasSpace) { + context.report({ + loc: { + start: { + line: token.loc.end.line, + column: token.loc.end.column - 2, + }, + end: token.loc.end, + }, + messageId: "expectedAfter", + fix: fixer => fixer.insertTextAfter(token, " "), + }); + } + + if (!always && hasSpace) { + context.report({ + loc: { + start: token.loc.end, + end: nextToken.loc.start, + }, + messageId: "unexpectedAfter", + fix: fixer => + fixer.removeRange([token.range[1], nextToken.range[0]]), + }); + } + } + + return { + TemplateElement(node) { + const token = sourceCode.getFirstToken(node); + + checkSpacingBefore(token); + checkSpacingAfter(token); + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-tag-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-tag-spacing.js new file mode 100644 index 00000000..92563d0d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/template-tag-spacing.js @@ -0,0 +1,121 @@ +/** + * @fileoverview Rule to check spacing between template tags and their literals + * @author Jonathan Wilsson + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "template-tag-spacing", + url: "https://eslint.style/rules/template-tag-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require or disallow spacing between template tags and their literals", + recommended: false, + url: "https://eslint.org/docs/latest/rules/template-tag-spacing", + }, + + fixable: "whitespace", + + schema: [{ enum: ["always", "never"] }], + messages: { + unexpected: + "Unexpected space between template tag and template literal.", + missing: "Missing space between template tag and template literal.", + }, + }, + + create(context) { + const never = context.options[0] !== "always"; + const sourceCode = context.sourceCode; + + /** + * Check if a space is present between a template tag and its literal + * @param {ASTNode} node node to evaluate + * @returns {void} + * @private + */ + function checkSpacing(node) { + const tagToken = sourceCode.getTokenBefore(node.quasi); + const literalToken = sourceCode.getFirstToken(node.quasi); + const hasWhitespace = sourceCode.isSpaceBetween( + tagToken, + literalToken, + ); + + if (never && hasWhitespace) { + context.report({ + node, + loc: { + start: tagToken.loc.end, + end: literalToken.loc.start, + }, + messageId: "unexpected", + fix(fixer) { + const comments = sourceCode.getCommentsBefore( + node.quasi, + ); + + // Don't fix anything if there's a single line comment after the template tag + if (comments.some(comment => comment.type === "Line")) { + return null; + } + + return fixer.replaceTextRange( + [tagToken.range[1], literalToken.range[0]], + comments.reduce( + (text, comment) => + text + sourceCode.getText(comment), + "", + ), + ); + }, + }); + } else if (!never && !hasWhitespace) { + context.report({ + node, + loc: { + start: node.loc.start, + end: literalToken.loc.start, + }, + messageId: "missing", + fix(fixer) { + return fixer.insertTextAfter(tagToken, " "); + }, + }); + } + } + + return { + TaggedTemplateExpression: checkSpacing, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/unicode-bom.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/unicode-bom.js new file mode 100644 index 00000000..7b054489 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/unicode-bom.js @@ -0,0 +1,73 @@ +/** + * @fileoverview Require or disallow Unicode BOM + * @author Andrew Johnston + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "layout", + + defaultOptions: ["never"], + + docs: { + description: "Require or disallow Unicode byte order mark (BOM)", + recommended: false, + url: "https://eslint.org/docs/latest/rules/unicode-bom", + }, + + fixable: "whitespace", + + schema: [ + { + enum: ["always", "never"], + }, + ], + messages: { + expected: "Expected Unicode BOM (Byte Order Mark).", + unexpected: "Unexpected Unicode BOM (Byte Order Mark).", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program: function checkUnicodeBOM(node) { + const sourceCode = context.sourceCode, + location = { column: 0, line: 1 }; + const [requireBOM] = context.options; + + if (!sourceCode.hasBOM && requireBOM === "always") { + context.report({ + node, + loc: location, + messageId: "expected", + fix(fixer) { + return fixer.insertTextBeforeRange( + [0, 1], + "\uFEFF", + ); + }, + }); + } else if (sourceCode.hasBOM && requireBOM === "never") { + context.report({ + node, + loc: location, + messageId: "unexpected", + fix(fixer) { + return fixer.removeRange([-1, 0]); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/use-isnan.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/use-isnan.js new file mode 100644 index 00000000..7bfda889 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/use-isnan.js @@ -0,0 +1,276 @@ +/** + * @fileoverview Rule to flag comparisons to the value NaN + * @author James Allardice + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Determines if the given node is a NaN `Identifier` node. + * @param {ASTNode|null} node The node to check. + * @param {SourceCode} sourceCode The source code object. + * @returns {boolean} `true` if the node is a global 'NaN' identifier. + */ +function isNaNIdentifier(node, sourceCode) { + if (!node) { + return false; + } + + const nodeToCheck = + node.type === "SequenceExpression" ? node.expressions.at(-1) : node; + + if (astUtils.isSpecificId(nodeToCheck, "NaN")) { + return sourceCode.isGlobalReference(nodeToCheck); + } + + if (astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")) { + const objectNode = astUtils.skipChainExpression(nodeToCheck).object; + return sourceCode.isGlobalReference(objectNode); + } + + return false; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + hasSuggestions: true, + type: "problem", + + docs: { + description: "Require calls to `isNaN()` when checking for `NaN`", + recommended: true, + url: "https://eslint.org/docs/latest/rules/use-isnan", + }, + + schema: [ + { + type: "object", + properties: { + enforceForSwitchCase: { + type: "boolean", + }, + enforceForIndexOf: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + defaultOptions: [ + { + enforceForIndexOf: false, + enforceForSwitchCase: true, + }, + ], + + messages: { + comparisonWithNaN: "Use the isNaN function to compare with NaN.", + switchNaN: + "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.", + caseNaN: + "'case NaN' can never match. Use Number.isNaN before the switch.", + indexOfNaN: + "Array prototype method '{{ methodName }}' cannot find NaN.", + replaceWithIsNaN: "Replace with Number.isNaN.", + replaceWithCastingAndIsNaN: + "Replace with Number.isNaN and cast to a Number.", + replaceWithFindIndex: + "Replace with Array.prototype.{{ methodName }}.", + }, + }, + + create(context) { + const [{ enforceForIndexOf, enforceForSwitchCase }] = context.options; + const sourceCode = context.sourceCode; + + const fixableOperators = new Set(["==", "===", "!=", "!=="]); + const castableOperators = new Set(["==", "!="]); + + /** + * Get a fixer for a binary expression that compares to NaN. + * @param {ASTNode} node The node to fix. + * @param {function(string): string} wrapValue A function that wraps the compared value with a fix. + * @returns {function(Fixer): Fix} The fixer function. + */ + function getBinaryExpressionFixer(node, wrapValue) { + return fixer => { + const comparedValue = isNaNIdentifier(node.left, sourceCode) + ? node.right + : node.left; + const shouldWrap = comparedValue.type === "SequenceExpression"; + const shouldNegate = node.operator[0] === "!"; + + const negation = shouldNegate ? "!" : ""; + let comparedValueText = sourceCode.getText(comparedValue); + + if (shouldWrap) { + comparedValueText = `(${comparedValueText})`; + } + + const fixedValue = wrapValue(comparedValueText); + + return fixer.replaceText(node, `${negation}${fixedValue}`); + }; + } + + /** + * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkBinaryExpression(node) { + if ( + /^(?:[<>]|[!=]=)=?$/u.test(node.operator) && + (isNaNIdentifier(node.left, sourceCode) || + isNaNIdentifier(node.right, sourceCode)) + ) { + const suggestedFixes = []; + const NaNNode = isNaNIdentifier(node.left, sourceCode) + ? node.left + : node.right; + + const isSequenceExpression = + NaNNode.type === "SequenceExpression"; + const isSuggestable = + fixableOperators.has(node.operator) && + !isSequenceExpression; + const isCastable = castableOperators.has(node.operator); + + if (isSuggestable) { + suggestedFixes.push({ + messageId: "replaceWithIsNaN", + fix: getBinaryExpressionFixer( + node, + value => `Number.isNaN(${value})`, + ), + }); + + if (isCastable) { + suggestedFixes.push({ + messageId: "replaceWithCastingAndIsNaN", + fix: getBinaryExpressionFixer( + node, + value => `Number.isNaN(Number(${value}))`, + ), + }); + } + } + + context.report({ + node, + messageId: "comparisonWithNaN", + suggest: suggestedFixes, + }); + } + } + + /** + * Checks the discriminant and all case clauses of the given `SwitchStatement` node for `switch(NaN)` and `case NaN:` + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkSwitchStatement(node) { + if (isNaNIdentifier(node.discriminant, sourceCode)) { + context.report({ node, messageId: "switchNaN" }); + } + + for (const switchCase of node.cases) { + if (isNaNIdentifier(switchCase.test, sourceCode)) { + context.report({ node: switchCase, messageId: "caseNaN" }); + } + } + } + + /** + * Checks the given `CallExpression` node for `.indexOf(NaN)` and `.lastIndexOf(NaN)`. + * @param {ASTNode} node The node to check. + * @returns {void} + */ + function checkCallExpression(node) { + const callee = astUtils.skipChainExpression(node.callee); + + if (callee.type === "MemberExpression") { + const methodName = astUtils.getStaticPropertyName(callee); + + if ( + (methodName === "indexOf" || + methodName === "lastIndexOf") && + node.arguments.length <= 2 && + isNaNIdentifier(node.arguments[0], sourceCode) + ) { + /* + * To retain side effects, it's essential to address `NaN` beforehand, which + * is not possible with fixes like `arr.findIndex(Number.isNaN)`. + */ + const isSuggestable = + node.arguments[0].type !== "SequenceExpression" && + !node.arguments[1]; + const suggestedFixes = []; + + if (isSuggestable) { + const shouldWrap = callee.computed; + const findIndexMethod = + methodName === "indexOf" + ? "findIndex" + : "findLastIndex"; + const propertyName = shouldWrap + ? `"${findIndexMethod}"` + : findIndexMethod; + + suggestedFixes.push({ + messageId: "replaceWithFindIndex", + data: { methodName: findIndexMethod }, + fix: fixer => [ + fixer.replaceText( + callee.property, + propertyName, + ), + fixer.replaceText( + node.arguments[0], + "Number.isNaN", + ), + ], + }); + } + + context.report({ + node, + messageId: "indexOfNaN", + data: { methodName }, + suggest: suggestedFixes, + }); + } + } + } + + const listeners = { + BinaryExpression: checkBinaryExpression, + }; + + if (enforceForSwitchCase) { + listeners.SwitchStatement = checkSwitchStatement; + } + + if (enforceForIndexOf) { + listeners.CallExpression = checkCallExpression; + } + + return listeners; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/ast-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/ast-utils.js new file mode 100644 index 00000000..07b4d28b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/ast-utils.js @@ -0,0 +1,2966 @@ +/** + * @fileoverview Common utils for AST. + * @author Gyandeep Singh + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { KEYS: eslintVisitorKeys } = require("eslint-visitor-keys"); +const esutils = require("esutils"); +const espree = require("espree"); +const escapeRegExp = require("escape-string-regexp"); +const { + breakableTypePattern, + createGlobalLinebreakMatcher, + lineBreakPattern, + shebangPattern, +} = require("../../shared/ast-utils"); +const globals = require("../../../conf/globals"); +const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("eslint-scope").Scope} Scope */ +/** @typedef {import("eslint-scope").Variable} Variable */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +const anyFunctionPattern = + /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u; +const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u; +const arrayMethodWithThisArgPattern = + /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|some)$/u; +const arrayOrTypedArrayPattern = /Array$/u; +const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u; +const thisTagPattern = /^[\s*]*@this/mu; + +const COMMENTS_IGNORE_PATTERN = + /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u; +const ESLINT_DIRECTIVE_PATTERN = /^(?:eslint[- ]|(?:globals?|exported) )/u; +const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]); + +// A set of node types that can contain a list of statements +const STATEMENT_LIST_PARENTS = new Set([ + "Program", + "BlockStatement", + "StaticBlock", + "SwitchCase", +]); +const LEXICAL_DECLARATION_KINDS = new Set([ + "let", + "const", + "using", + "await using", +]); + +const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u; + +// Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string +const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = + /^(?:[^\\]|\\.)*\\(?:[1-9]|0\d)/su; + +const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]); + +/** + * All builtin global variables defined in the latest ECMAScript specification. + * @type {Record} Key is the name of the variable. Value is `true` if the variable is considered writable, `false` otherwise. + */ +const ECMASCRIPT_GLOBALS = globals[`es${LATEST_ECMA_VERSION}`]; + +/** + * Checks reference if is non initializer and writable. + * @param {Reference} reference A reference to check. + * @param {number} index The index of the reference in the references. + * @param {Reference[]} references The array that the reference belongs to. + * @returns {boolean} Success/Failure + * @private + */ +function isModifyingReference(reference, index, references) { + const identifier = reference.identifier; + + /* + * Destructuring assignments can have multiple default value, so + * possibly there are multiple writeable references for the same + * identifier. + */ + const modifyingDifferentIdentifier = + index === 0 || references[index - 1].identifier !== identifier; + + return ( + identifier && + reference.init === false && + reference.isWrite() && + modifyingDifferentIdentifier + ); +} + +/** + * Checks whether the given string starts with uppercase or not. + * @param {string} s The string to check. + * @returns {boolean} `true` if the string starts with uppercase. + */ +function startsWithUpperCase(s) { + return s[0] !== s[0].toLocaleLowerCase(); +} + +/** + * Checks whether or not a node is a constructor. + * @param {ASTNode} node A function node to check. + * @returns {boolean} Whether or not a node is a constructor. + */ +function isES5Constructor(node) { + return node.id && startsWithUpperCase(node.id.name); +} + +/** + * Finds a function node from ancestors of a node. + * @param {ASTNode} node A start node to find. + * @returns {Node|null} A found function node. + */ +function getUpperFunction(node) { + for ( + let currentNode = node; + currentNode; + currentNode = currentNode.parent + ) { + if (anyFunctionPattern.test(currentNode.type)) { + return currentNode; + } + } + return null; +} + +/** + * Checks whether a given node is a function node or not. + * The following types are function nodes: + * + * - ArrowFunctionExpression + * - FunctionDeclaration + * - FunctionExpression + * @param {ASTNode|null} node A node to check. + * @returns {boolean} `true` if the node is a function node. + */ +function isFunction(node) { + return Boolean(node && anyFunctionPattern.test(node.type)); +} + +/** + * Checks whether a given node is a loop node or not. + * The following types are loop nodes: + * + * - DoWhileStatement + * - ForInStatement + * - ForOfStatement + * - ForStatement + * - WhileStatement + * @param {ASTNode|null} node A node to check. + * @returns {boolean} `true` if the node is a loop node. + */ +function isLoop(node) { + return Boolean(node && anyLoopPattern.test(node.type)); +} + +/** + * Checks whether the given node is in a loop or not. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is in a loop. + */ +function isInLoop(node) { + for ( + let currentNode = node; + currentNode && !isFunction(currentNode); + currentNode = currentNode.parent + ) { + if (isLoop(currentNode)) { + return true; + } + } + + return false; +} + +/** + * Determines whether the given node is a `null` literal. + * @param {ASTNode} node The node to check + * @returns {boolean} `true` if the node is a `null` literal + */ +function isNullLiteral(node) { + /* + * Checking `node.value === null` does not guarantee that a literal is a null literal. + * When parsing values that cannot be represented in the current environment (e.g. unicode + * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to + * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check + * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020 + */ + return ( + node.type === "Literal" && + node.value === null && + !node.regex && + !node.bigint + ); +} + +/** + * Checks whether or not a node is `null` or `undefined`. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a `null` or `undefined`. + * @public + */ +function isNullOrUndefined(node) { + return ( + isNullLiteral(node) || + (node.type === "Identifier" && node.name === "undefined") || + (node.type === "UnaryExpression" && node.operator === "void") + ); +} + +/** + * Checks whether or not a node is callee. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is callee. + */ +function isCallee(node) { + return node.parent.type === "CallExpression" && node.parent.callee === node; +} + +/** + * Returns the result of the string conversion applied to the evaluated value of the given expression node, + * if it can be determined statically. + * + * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only. + * In all other cases, this function returns `null`. + * @param {ASTNode} node Expression node. + * @returns {string|null} String value if it can be determined. Otherwise, `null`. + */ +function getStaticStringValue(node) { + switch (node.type) { + case "Literal": + if (node.value === null) { + if (isNullLiteral(node)) { + return String(node.value); // "null" + } + if (node.regex) { + return `/${node.regex.pattern}/${node.regex.flags}`; + } + if (node.bigint) { + return node.bigint; + } + + // Otherwise, this is an unknown literal. The function will return null. + } else { + return String(node.value); + } + break; + case "TemplateLiteral": + if (node.expressions.length === 0 && node.quasis.length === 1) { + return node.quasis[0].value.cooked; + } + break; + + // no default + } + + return null; +} + +/** + * Gets the property name of a given node. + * The node can be a MemberExpression, a Property, or a MethodDefinition. + * + * If the name is dynamic, this returns `null`. + * + * For examples: + * + * a.b // => "b" + * a["b"] // => "b" + * a['b'] // => "b" + * a[`b`] // => "b" + * a[100] // => "100" + * a[b] // => null + * a["a" + "b"] // => null + * a[tag`b`] // => null + * a[`${b}`] // => null + * + * let a = {b: 1} // => "b" + * let a = {["b"]: 1} // => "b" + * let a = {['b']: 1} // => "b" + * let a = {[`b`]: 1} // => "b" + * let a = {[100]: 1} // => "100" + * let a = {[b]: 1} // => null + * let a = {["a" + "b"]: 1} // => null + * let a = {[tag`b`]: 1} // => null + * let a = {[`${b}`]: 1} // => null + * @param {ASTNode} node The node to get. + * @returns {string|null} The property name if static. Otherwise, null. + */ +function getStaticPropertyName(node) { + let prop; + + switch (node && node.type) { + case "ChainExpression": + return getStaticPropertyName(node.expression); + + case "Property": + case "PropertyDefinition": + case "MethodDefinition": + case "TSPropertySignature": + case "TSMethodSignature": + prop = node.key; + break; + + case "MemberExpression": + prop = node.property; + break; + + // no default + } + + if (prop) { + if (prop.type === "Identifier" && !node.computed) { + return prop.name; + } + + return getStaticStringValue(prop); + } + + return null; +} + +/** + * Retrieve `ChainExpression#expression` value if the given node a `ChainExpression` node. Otherwise, pass through it. + * @param {ASTNode} node The node to address. + * @returns {ASTNode} The `ChainExpression#expression` value if the node is a `ChainExpression` node. Otherwise, the node. + */ +function skipChainExpression(node) { + return node && node.type === "ChainExpression" ? node.expression : node; +} + +/** + * Check if the `actual` is an expected value. + * @param {string} actual The string value to check. + * @param {string | RegExp} expected The expected string value or pattern. + * @returns {boolean} `true` if the `actual` is an expected value. + */ +function checkText(actual, expected) { + return typeof expected === "string" + ? actual === expected + : expected.test(actual); +} + +/** + * Check if a given node is an Identifier node with a given name. + * @param {ASTNode} node The node to check. + * @param {string | RegExp} name The expected name or the expected pattern of the object name. + * @returns {boolean} `true` if the node is an Identifier node with the name. + */ +function isSpecificId(node, name) { + return node.type === "Identifier" && checkText(node.name, name); +} + +/** + * Check if a given node is member access with a given object name and property name pair. + * This is regardless of optional or not. + * @param {ASTNode} node The node to check. + * @param {string | RegExp | null} objectName The expected name or the expected pattern of the object name. If this is nullish, this method doesn't check object. + * @param {string | RegExp | null} propertyName The expected name or the expected pattern of the property name. If this is nullish, this method doesn't check property. + * @returns {boolean} `true` if the node is member access with the object name and property name pair. + * The node is a `MemberExpression` or `ChainExpression`. + */ +function isSpecificMemberAccess(node, objectName, propertyName) { + const checkNode = skipChainExpression(node); + + if (checkNode.type !== "MemberExpression") { + return false; + } + + if (objectName && !isSpecificId(checkNode.object, objectName)) { + return false; + } + + if (propertyName) { + const actualPropertyName = getStaticPropertyName(checkNode); + + if ( + typeof actualPropertyName !== "string" || + !checkText(actualPropertyName, propertyName) + ) { + return false; + } + } + + return true; +} + +/** + * Check if two literal nodes are the same value. + * @param {ASTNode} left The Literal node to compare. + * @param {ASTNode} right The other Literal node to compare. + * @returns {boolean} `true` if the two literal nodes are the same value. + */ +function equalLiteralValue(left, right) { + // RegExp literal. + if (left.regex || right.regex) { + return Boolean( + left.regex && + right.regex && + left.regex.pattern === right.regex.pattern && + left.regex.flags === right.regex.flags, + ); + } + + // BigInt literal. + if (left.bigint || right.bigint) { + return left.bigint === right.bigint; + } + + return left.value === right.value; +} + +/** + * Check if two expressions reference the same value. For example: + * a = a + * a.b = a.b + * a[0] = a[0] + * a['b'] = a['b'] + * @param {ASTNode} left The left side of the comparison. + * @param {ASTNode} right The right side of the comparison. + * @param {boolean} [disableStaticComputedKey] Don't address `a.b` and `a["b"]` are the same if `true`. For backward compatibility. + * @returns {boolean} `true` if both sides match and reference the same value. + */ +function isSameReference(left, right, disableStaticComputedKey = false) { + if (left.type !== right.type) { + // Handle `a.b` and `a?.b` are samely. + if (left.type === "ChainExpression") { + return isSameReference( + left.expression, + right, + disableStaticComputedKey, + ); + } + if (right.type === "ChainExpression") { + return isSameReference( + left, + right.expression, + disableStaticComputedKey, + ); + } + + return false; + } + + switch (left.type) { + case "Super": + case "ThisExpression": + return true; + + case "Identifier": + case "PrivateIdentifier": + return left.name === right.name; + case "Literal": + return equalLiteralValue(left, right); + + case "ChainExpression": + return isSameReference( + left.expression, + right.expression, + disableStaticComputedKey, + ); + + case "MemberExpression": { + if (!disableStaticComputedKey) { + const nameA = getStaticPropertyName(left); + + // x.y = x["y"] + if (nameA !== null) { + return ( + isSameReference( + left.object, + right.object, + disableStaticComputedKey, + ) && nameA === getStaticPropertyName(right) + ); + } + } + + /* + * x[0] = x[0] + * x[y] = x[y] + * x.y = x.y + */ + return ( + left.computed === right.computed && + isSameReference( + left.object, + right.object, + disableStaticComputedKey, + ) && + isSameReference( + left.property, + right.property, + disableStaticComputedKey, + ) + ); + } + + default: + return false; + } +} + +/** + * Checks whether or not a node is `Reflect.apply`. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a `Reflect.apply`. + */ +function isReflectApply(node) { + return isSpecificMemberAccess(node, "Reflect", "apply"); +} + +/** + * Checks whether or not a node is `Array.from`. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a `Array.from`. + */ +function isArrayFromMethod(node) { + return isSpecificMemberAccess(node, arrayOrTypedArrayPattern, "from"); +} + +/** + * Checks whether or not a node is `Array.fromAsync`. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a `Array.fromAsync`. + */ +function isArrayFromAsyncMethod(node) { + return isSpecificMemberAccess(node, "Array", "fromAsync"); +} + +/** + * Checks whether or not a node is a method which expects a function as a first argument, and `thisArg` as a second argument. + * @param {ASTNode} node A node to check. + * @returns {boolean} Whether or not the node is a method which expects a function as a first argument, and `thisArg` as a second argument. + */ +function isMethodWhichHasThisArg(node) { + return isSpecificMemberAccess(node, null, arrayMethodWithThisArgPattern); +} + +/** + * Determines whether the given node is an argument of the specified global method call, at the given `index` position. + * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable. + * @param {ASTNode} node The node to check. + * @param {SourceCode} sourceCode Source code to which the node belongs. + * @param {string} objectName Name of the global object. + * @param {string} methodName Name of the method. + * @param {number} index The given position. + * @returns {boolean} `true` if the node is argument at the given position. + * @private + */ +function isArgumentOfGlobalMethodCall( + node, + sourceCode, + objectName, + methodName, + index, +) { + const callNode = node.parent; + + return ( + callNode.type === "CallExpression" && + callNode.arguments[index] === node && + isSpecificMemberAccess(callNode.callee, objectName, methodName) && + sourceCode.isGlobalReference( + skipChainExpression(callNode.callee).object, + ) + ); +} + +/** + * Determines whether the given node is used as a property descriptor. + * @param {ASTNode} node The node to check. + * @param {SourceCode} sourceCode Source code to which the node belongs. + * @returns {boolean} `true` if the node is a property descriptor. + */ +function isPropertyDescriptor(node, sourceCode) { + if ( + isArgumentOfGlobalMethodCall( + node, + sourceCode, + "Object", + "defineProperty", + 2, + ) || + isArgumentOfGlobalMethodCall( + node, + sourceCode, + "Reflect", + "defineProperty", + 2, + ) + ) { + return true; + } + + const parent = node.parent; + + if (parent.type === "Property" && parent.value === node) { + const grandparent = parent.parent; + + if ( + grandparent.type === "ObjectExpression" && + (isArgumentOfGlobalMethodCall( + grandparent, + sourceCode, + "Object", + "create", + 1, + ) || + isArgumentOfGlobalMethodCall( + grandparent, + sourceCode, + "Object", + "defineProperties", + 1, + )) + ) { + return true; + } + } + + return false; +} + +/** + * Creates the negate function of the given function. + * @param {Function} f The function to negate. + * @returns {Function} Negated function. + */ +function negate(f) { + return token => !f(token); +} + +/** + * Determines if a node is surrounded by parentheses. + * @param {SourceCode} sourceCode The ESLint source code object + * @param {ASTNode} node The node to be checked. + * @returns {boolean} True if the node is parenthesised. + * @private + */ +function isParenthesised(sourceCode, node) { + const previousToken = sourceCode.getTokenBefore(node), + nextToken = sourceCode.getTokenAfter(node); + + return ( + Boolean(previousToken && nextToken) && + previousToken.value === "(" && + previousToken.range[1] <= node.range[0] && + nextToken.value === ")" && + nextToken.range[0] >= node.range[1] + ); +} + +/** + * Checks if the given token is a `=` token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a `=` token. + */ +function isEqToken(token) { + return token.value === "=" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is an arrow token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is an arrow token. + */ +function isArrowToken(token) { + return token.value === "=>" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a comma token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a comma token. + */ +function isCommaToken(token) { + return token.value === "," && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a dot token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a dot token. + */ +function isDotToken(token) { + return token.value === "." && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a `?.` token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a `?.` token. + */ +function isQuestionDotToken(token) { + return token.value === "?." && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a semicolon token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a semicolon token. + */ +function isSemicolonToken(token) { + return token.value === ";" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a colon token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a colon token. + */ +function isColonToken(token) { + return token.value === ":" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is an opening parenthesis token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is an opening parenthesis token. + */ +function isOpeningParenToken(token) { + return token.value === "(" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a closing parenthesis token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a closing parenthesis token. + */ +function isClosingParenToken(token) { + return token.value === ")" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is an opening square bracket token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is an opening square bracket token. + */ +function isOpeningBracketToken(token) { + return token.value === "[" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a closing square bracket token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a closing square bracket token. + */ +function isClosingBracketToken(token) { + return token.value === "]" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is an opening brace token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is an opening brace token. + */ +function isOpeningBraceToken(token) { + return token.value === "{" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a closing brace token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a closing brace token. + */ +function isClosingBraceToken(token) { + return token.value === "}" && token.type === "Punctuator"; +} + +/** + * Checks if the given token is a comment token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a comment token. + */ +function isCommentToken(token) { + return ( + token.type === "Line" || + token.type === "Block" || + token.type === "Shebang" + ); +} + +/** + * Checks if the given token is a keyword token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a keyword token. + */ +function isKeywordToken(token) { + return token.type === "Keyword"; +} + +/** + * Checks whether the given node represents an ES6 export declaration. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is an export declaration. + * @private + */ +function isExportDeclaration(node) { + return ( + node.type === "ExportDefaultDeclaration" || + node.type === "ExportNamedDeclaration" || + node.type === "ExportAllDeclaration" + ); +} + +/** + * Checks for the presence of a JSDoc comment for the given node and returns it. + * @param {ASTNode} node The node to get the comment for. + * @param {SourceCode} sourceCode A SourceCode instance to get comments. + * @returns {Token|null} The Block comment token containing the JSDoc comment for the given node or null if not found. + * @private + */ +function findJSDocComment(node, sourceCode) { + const tokenBefore = sourceCode.getTokenBefore(node, { + includeComments: true, + }); + + if ( + tokenBefore && + tokenBefore.type === "Block" && + tokenBefore.value.charAt(0) === "*" && + node.loc.start.line - tokenBefore.loc.end.line <= 1 + ) { + return tokenBefore; + } + + return null; +} + +/** + * Retrieves the JSDoc comment for a given node. + * @param {ASTNode} node The node to get the comment for. + * @param {SourceCode} sourceCode A SourceCode instance to get comments. + * @returns {Token|null} The Block comment token containing the JSDoc comment for the given node or null if not found. + * @private + */ +function getJSDocComment(node, sourceCode) { + let parent = node.parent; + + switch (node.type) { + case "ClassDeclaration": + case "FunctionDeclaration": + return findJSDocComment( + isExportDeclaration(parent) ? parent : node, + sourceCode, + ); + + case "ClassExpression": + return findJSDocComment(parent.parent, sourceCode); + + case "ArrowFunctionExpression": + case "FunctionExpression": + if ( + parent.type !== "CallExpression" && + parent.type !== "NewExpression" + ) { + while ( + !sourceCode.getCommentsBefore(parent).length && + !/Function/u.test(parent.type) && + parent.type !== "MethodDefinition" && + parent.type !== "Property" + ) { + parent = parent.parent; + + if (!parent) { + break; + } + } + + if ( + parent && + parent.type !== "FunctionDeclaration" && + parent.type !== "Program" + ) { + return findJSDocComment(parent, sourceCode); + } + } + + return findJSDocComment(node, sourceCode); + + // falls through + default: + return null; + } +} + +/** + * Checks whether or not a node has a `@this` tag in its comments. + * @param {ASTNode} node A node to check. + * @param {SourceCode} sourceCode A SourceCode instance to get comments. + * @returns {boolean} Whether or not the node has a `@this` tag in its comments. + */ +function hasJSDocThisTag(node, sourceCode) { + const jsdocComment = getJSDocComment(node, sourceCode); + + if (jsdocComment && thisTagPattern.test(jsdocComment.value)) { + return true; + } + + // Checks `@this` in its leading comments for callbacks, + // because callbacks don't have its JSDoc comment. + // e.g. + // sinon.test(/* @this sinon.Sandbox */function() { this.spy(); }); + return sourceCode + .getCommentsBefore(node) + .some(comment => thisTagPattern.test(comment.value)); +} + +/** + * Gets the `(` token of the given function node. + * @param {ASTNode} node The function node to get. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {Token} `(` token. + */ +function getOpeningParenOfParams(node, sourceCode) { + // If the node is an arrow function and doesn't have parens, this returns the identifier of the first param. + if (node.type === "ArrowFunctionExpression" && node.params.length === 1) { + const argToken = sourceCode.getFirstToken(node.params[0]); + const maybeParenToken = sourceCode.getTokenBefore(argToken); + + return isOpeningParenToken(maybeParenToken) + ? maybeParenToken + : argToken; + } + + // Otherwise, returns paren. + return node.id + ? sourceCode.getTokenAfter(node.id, isOpeningParenToken) + : sourceCode.getFirstToken(node, isOpeningParenToken); +} + +/** + * Checks whether or not the tokens of two given nodes are same. + * @param {ASTNode} left A node 1 to compare. + * @param {ASTNode} right A node 2 to compare. + * @param {SourceCode} sourceCode The ESLint source code object. + * @returns {boolean} the source code for the given node. + */ +function equalTokens(left, right, sourceCode) { + const tokensL = sourceCode.getTokens(left); + const tokensR = sourceCode.getTokens(right); + + if (tokensL.length !== tokensR.length) { + return false; + } + for (let i = 0; i < tokensL.length; ++i) { + if ( + tokensL[i].type !== tokensR[i].type || + tokensL[i].value !== tokensR[i].value + ) { + return false; + } + } + + return true; +} + +/** + * Check if the given node is a true logical expression or not. + * + * The three binary expressions logical-or (`||`), logical-and (`&&`), and + * coalesce (`??`) are known as `ShortCircuitExpression`. + * But ESTree represents those by `LogicalExpression` node. + * + * This function rejects coalesce expressions of `LogicalExpression` node. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is `&&` or `||`. + * @see https://tc39.es/ecma262/#prod-ShortCircuitExpression + */ +function isLogicalExpression(node) { + return ( + node.type === "LogicalExpression" && + (node.operator === "&&" || node.operator === "||") + ); +} + +/** + * Check if the given node is a nullish coalescing expression or not. + * + * The three binary expressions logical-or (`||`), logical-and (`&&`), and + * coalesce (`??`) are known as `ShortCircuitExpression`. + * But ESTree represents those by `LogicalExpression` node. + * + * This function finds only coalesce expressions of `LogicalExpression` node. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is `??`. + */ +function isCoalesceExpression(node) { + return node.type === "LogicalExpression" && node.operator === "??"; +} + +/** + * Check if given two nodes are the pair of a logical expression and a coalesce expression. + * @param {ASTNode} left A node to check. + * @param {ASTNode} right Another node to check. + * @returns {boolean} `true` if the two nodes are the pair of a logical expression and a coalesce expression. + */ +function isMixedLogicalAndCoalesceExpressions(left, right) { + return ( + (isLogicalExpression(left) && isCoalesceExpression(right)) || + (isCoalesceExpression(left) && isLogicalExpression(right)) + ); +} + +/** + * Checks if the given operator is a logical assignment operator. + * @param {string} operator The operator to check. + * @returns {boolean} `true` if the operator is a logical assignment operator. + */ +function isLogicalAssignmentOperator(operator) { + return LOGICAL_ASSIGNMENT_OPERATORS.has(operator); +} + +/** + * Get the colon token of the given SwitchCase node. + * @param {ASTNode} node The SwitchCase node to get. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {Token} The colon token of the node. + */ +function getSwitchCaseColonToken(node, sourceCode) { + if (node.test) { + return sourceCode.getTokenAfter(node.test, isColonToken); + } + return sourceCode.getFirstToken(node, 1); +} + +/** + * Gets ESM module export name represented by the given node. + * @param {ASTNode} node `Identifier` or string `Literal` node in a position + * that represents a module export name: + * - `ImportSpecifier#imported` + * - `ExportSpecifier#local` (if it is a re-export from another module) + * - `ExportSpecifier#exported` + * - `ExportAllDeclaration#exported` + * @returns {string} The module export name. + */ +function getModuleExportName(node) { + if (node.type === "Identifier") { + return node.name; + } + + // string literal + return node.value; +} + +/** + * Returns literal's value converted to the Boolean type + * @param {ASTNode} node any `Literal` node + * @returns {boolean | null} `true` when node is truthy, `false` when node is falsy, + * `null` when it cannot be determined. + */ +function getBooleanValue(node) { + if (node.value === null) { + /* + * it might be a null literal or bigint/regex literal in unsupported environments . + * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral + * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral + */ + + if (node.raw === "null") { + return false; + } + + // regex is always truthy + if (typeof node.regex === "object") { + return true; + } + + return null; + } + + return !!node.value; +} + +/** + * Checks if a branch node of LogicalExpression short circuits the whole condition + * @param {ASTNode} node The branch of main condition which needs to be checked + * @param {string} operator The operator of the main LogicalExpression. + * @returns {boolean} true when condition short circuits whole condition + */ +function isLogicalIdentity(node, operator) { + switch (node.type) { + case "Literal": + return ( + (operator === "||" && getBooleanValue(node) === true) || + (operator === "&&" && getBooleanValue(node) === false) + ); + + case "UnaryExpression": + return operator === "&&" && node.operator === "void"; + + case "LogicalExpression": + /* + * handles `a && false || b` + * `false` is an identity element of `&&` but not `||` + */ + return ( + operator === node.operator && + (isLogicalIdentity(node.left, operator) || + isLogicalIdentity(node.right, operator)) + ); + + case "AssignmentExpression": + return ( + ["||=", "&&="].includes(node.operator) && + operator === node.operator.slice(0, -1) && + isLogicalIdentity(node.right, operator) + ); + + // no default + } + return false; +} + +/** + * Checks if an identifier is a reference to a global variable. + * @param {Scope} scope The scope in which the identifier is referenced. + * @param {ASTNode} node An identifier node to check. + * @returns {boolean} `true` if the identifier is a reference to a global variable. + */ +function isReferenceToGlobalVariable(scope, node) { + const reference = scope.references.find(ref => ref.identifier === node); + + return Boolean( + reference && + reference.resolved && + reference.resolved.scope.type === "global" && + reference.resolved.defs.length === 0, + ); +} + +/** + * Checks if a node has a constant truthiness value. + * @param {Scope} scope Scope in which the node appears. + * @param {ASTNode} node The AST node to check. + * @param {boolean} inBooleanPosition `true` if checking the test of a + * condition. `false` in all other cases. When `false`, checks if -- for + * both string and number -- if coerced to that type, the value will + * be constant. + * @returns {boolean} true when node's truthiness is constant + * @private + */ +function isConstant(scope, node, inBooleanPosition) { + // node.elements can return null values in the case of sparse arrays ex. [,] + if (!node) { + return true; + } + switch (node.type) { + case "Literal": + case "ArrowFunctionExpression": + case "FunctionExpression": + return true; + case "ClassExpression": + case "ObjectExpression": + /** + * In theory objects like: + * + * `{toString: () => a}` + * `{valueOf: () => a}` + * + * Or a classes like: + * + * `class { static toString() { return a } }` + * `class { static valueOf() { return a } }` + * + * Are not constant verifiably when `inBooleanPosition` is + * false, but it's an edge case we've opted not to handle. + */ + return true; + case "TemplateLiteral": + return ( + (inBooleanPosition && + node.quasis.some(quasi => quasi.value.cooked.length)) || + node.expressions.every(exp => isConstant(scope, exp, false)) + ); + + case "ArrayExpression": { + if (!inBooleanPosition) { + return node.elements.every(element => + isConstant(scope, element, false), + ); + } + return true; + } + + case "UnaryExpression": + if ( + node.operator === "void" || + (node.operator === "typeof" && inBooleanPosition) + ) { + return true; + } + + if (node.operator === "!") { + return isConstant(scope, node.argument, true); + } + + return isConstant(scope, node.argument, false); + + case "BinaryExpression": + return ( + isConstant(scope, node.left, false) && + isConstant(scope, node.right, false) && + node.operator !== "in" + ); + + case "LogicalExpression": { + const isLeftConstant = isConstant( + scope, + node.left, + inBooleanPosition, + ); + const isRightConstant = isConstant( + scope, + node.right, + inBooleanPosition, + ); + const isLeftShortCircuit = + isLeftConstant && isLogicalIdentity(node.left, node.operator); + const isRightShortCircuit = + inBooleanPosition && + isRightConstant && + isLogicalIdentity(node.right, node.operator); + + return ( + (isLeftConstant && isRightConstant) || + isLeftShortCircuit || + isRightShortCircuit + ); + } + case "NewExpression": + return inBooleanPosition; + case "AssignmentExpression": + if (node.operator === "=") { + return isConstant(scope, node.right, inBooleanPosition); + } + + if (["||=", "&&="].includes(node.operator) && inBooleanPosition) { + return isLogicalIdentity( + node.right, + node.operator.slice(0, -1), + ); + } + + return false; + + case "SequenceExpression": + return isConstant( + scope, + node.expressions.at(-1), + inBooleanPosition, + ); + case "SpreadElement": + return isConstant(scope, node.argument, inBooleanPosition); + case "CallExpression": + if ( + node.callee.type === "Identifier" && + node.callee.name === "Boolean" + ) { + if ( + node.arguments.length === 0 || + isConstant(scope, node.arguments[0], true) + ) { + return isReferenceToGlobalVariable(scope, node.callee); + } + } + return false; + case "Identifier": + return ( + node.name === "undefined" && + isReferenceToGlobalVariable(scope, node) + ); + + // no default + } + return false; +} + +/** + * Checks whether a node is an ExpressionStatement at the top level of a file, function body, or TypeScript module block. + * A top-level ExpressionStatement node is a directive if it contains a single unparenthesized + * string literal and if it occurs either as the first sibling or immediately after another + * directive. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether or not the node is an ExpressionStatement at the top level of a + * file, function body, or TypeScript module block. + */ +function isTopLevelExpressionStatement(node) { + if (node.type !== "ExpressionStatement") { + return false; + } + const parent = node.parent; + + return ( + parent.type === "Program" || + parent.type === "TSModuleBlock" || + (parent.type === "BlockStatement" && isFunction(parent.parent)) + ); +} + +/** + * Check whether the given node is a part of a directive prologue or not. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a part of directive prologue. + */ +function isDirective(node) { + return ( + node.type === "ExpressionStatement" && + typeof node.directive === "string" + ); +} + +/** + * Tests if a node appears at the beginning of an ancestor ExpressionStatement node. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether the node appears at the beginning of an ancestor ExpressionStatement node. + */ +function isStartOfExpressionStatement(node) { + const start = node.range[0]; + let ancestor = node; + + while ((ancestor = ancestor.parent) && ancestor.range[0] === start) { + if (ancestor.type === "ExpressionStatement") { + return true; + } + } + return false; +} + +/** + * Checks whether a token can cause continuation of a preceding expression + * (for example, of a class field initializer expression) in a class body. + * This function checks specifically for tokens that can appear at the start + * of a class member: `[` (computed key), `*` (generator method), `in` or `instanceof` (valid keys) + * Without a preceding semicolon, these tokens would be parsed as index access or operators. + * @param {Token} token The token to check. + * @returns {boolean} Whether the token can cause continuation of a preceding expression. + */ +function canContinueExpressionInClassBody(token) { + return ( + (token.type === "Punctuator" && + (token.value === "[" || token.value === "*")) || + // Different parsers may return these tokens as either "Identifier" or "Keyword" + ((token.type === "Identifier" || token.type === "Keyword") && + (token.value === "in" || token.value === "instanceof")) + ); +} + +/** + * Determines whether an opening parenthesis `(`, bracket `[`, asterisk `*`, or backtick ``` ` ``` needs to be preceded by a semicolon. + * This opening parenthesis or bracket should be at the start of an `ExpressionStatement`, a `MethodDefinition`, a `PropertyDefinition`, + * or at the start of the body of an `ArrowFunctionExpression`. + * @type {(sourceCode: SourceCode, node: ASTNode) => boolean} + * @param {SourceCode} sourceCode The source code object. + * @param {ASTNode} node A node at the position where an opening parenthesis, bracket, or asterisk will be inserted. + * @returns {boolean} Whether a semicolon is required before the opening parenthesis or bracket. + */ +let needsPrecedingSemicolon; + +{ + const BREAK_OR_CONTINUE = new Set(["BreakStatement", "ContinueStatement"]); + + // Declaration types that cannot be continued by a punctuator when ending with a string Literal that is a direct child. + const DECLARATIONS = new Set([ + "ExportAllDeclaration", + "ExportNamedDeclaration", + "ImportDeclaration", + ]); + + const IDENTIFIER_OR_KEYWORD = new Set(["Identifier", "Keyword"]); + + // Keywords that can immediately precede an ExpressionStatement node, mapped to the their node types. + const NODE_TYPES_BY_KEYWORD = { + __proto__: null, + break: "BreakStatement", + continue: "ContinueStatement", + debugger: "DebuggerStatement", + do: "DoWhileStatement", + else: "IfStatement", + return: "ReturnStatement", + yield: "YieldExpression", + }; + + /* + * Before an opening parenthesis, postfix `++` and `--` always trigger ASI; + * the tokens `:`, `;`, `{` and `=>` don't expect a semicolon, as that would count as an empty statement. + */ + const PUNCTUATORS = new Set([":", ";", "{", "=>", "++", "--"]); + + /* + * Statements that can contain an `ExpressionStatement` after a closing parenthesis. + * DoWhileStatement is an exception in that it always triggers ASI after the closing parenthesis. + */ + const STATEMENTS = new Set([ + "DoWhileStatement", + "ForInStatement", + "ForOfStatement", + "ForStatement", + "IfStatement", + "WhileStatement", + "WithStatement", + ]); + + const TS_TYPE_NODE_TYPES = new Set([ + "TSAsExpression", + "TSSatisfiesExpression", + "TSTypeAliasDeclaration", + "TSTypeAnnotation", + ]); + + /** + * Determines whether a specified node is inside a TypeScript type context. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether the node is inside a TypeScript type context. + */ + function isInType(node) { + for (let currNode = node; ;) { + const { parent } = currNode; + if (!parent) { + break; + } + if ( + TS_TYPE_NODE_TYPES.has(parent.type) && + currNode === parent.typeAnnotation + ) { + return true; + } + currNode = parent; + } + return false; + } + + needsPrecedingSemicolon = function (sourceCode, node) { + const prevToken = sourceCode.getTokenBefore(node); + + if ( + !prevToken || + (prevToken.type === "Punctuator" && + PUNCTUATORS.has(prevToken.value)) + ) { + return false; + } + + const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]); + + // Uninitialized class fields don't need a semicolon + if ( + // Key + (prevNode.parent.type === "PropertyDefinition" && + prevNode.parent.key === prevNode) || + // Closing bracket of a computed key + (prevNode.type === "PropertyDefinition" && + isClosingBracketToken(prevToken)) + ) { + return false; + } + + if ( + prevNode.type === "TSDeclareFunction" || + prevNode.parent.type === "TSImportEqualsDeclaration" || + prevNode.parent.parent?.type === "TSImportEqualsDeclaration" || + TS_TYPE_NODE_TYPES.has(prevNode.type) || + isInType(prevNode) + ) { + return false; + } + + if (isClosingParenToken(prevToken)) { + return !STATEMENTS.has(prevNode.type); + } + + if (isClosingBraceToken(prevToken)) { + return ( + (prevNode.type === "BlockStatement" && + prevNode.parent.type === "FunctionExpression" && + prevNode.parent.parent.type !== "MethodDefinition") || + (prevNode.type === "ClassBody" && + prevNode.parent.type === "ClassExpression") || + prevNode.type === "ObjectExpression" + ); + } + + if (IDENTIFIER_OR_KEYWORD.has(prevToken.type)) { + if ( + prevNode.parent.type === "VariableDeclarator" && + !prevNode.parent.init + ) { + return false; + } + if (BREAK_OR_CONTINUE.has(prevNode.parent.type)) { + return false; + } + + const keyword = prevToken.value; + const nodeType = NODE_TYPES_BY_KEYWORD[keyword]; + + return prevNode.type !== nodeType; + } + + if (prevToken.type === "String") { + return !DECLARATIONS.has(prevNode.parent.type); + } + + return true; + }; +} + +/** + * Checks if a node is used as an import attribute key, either in a static or dynamic import. + * @param {ASTNode} node The node to check. + * @returns {boolean} Whether the node is used as an import attribute key. + */ +function isImportAttributeKey(node) { + const { parent } = node; + + // static import/re-export + if (parent.type === "ImportAttribute" && parent.key === node) { + return true; + } + + // dynamic import + if ( + parent.type === "Property" && + !parent.computed && + (parent.key === node || + (parent.value === node && parent.shorthand && !parent.method)) && + parent.parent.type === "ObjectExpression" + ) { + const objectExpression = parent.parent; + const objectExpressionParent = objectExpression.parent; + + if ( + objectExpressionParent.type === "ImportExpression" && + objectExpressionParent.options === objectExpression + ) { + return true; + } + + // nested key + if ( + objectExpressionParent.type === "Property" && + objectExpressionParent.value === objectExpression + ) { + return isImportAttributeKey(objectExpressionParent.key); + } + } + + return false; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + COMMENTS_IGNORE_PATTERN, + LINEBREAKS, + LINEBREAK_MATCHER: lineBreakPattern, + SHEBANG_MATCHER: shebangPattern, + STATEMENT_LIST_PARENTS, + ECMASCRIPT_GLOBALS, + + /** + * Determines whether two adjacent tokens are on the same line. + * @param {Object} left The left token object. + * @param {Object} right The right token object. + * @returns {boolean} Whether or not the tokens are on the same line. + * @public + */ + isTokenOnSameLine(left, right) { + return left.loc.end.line === right.loc.start.line; + }, + + isNullOrUndefined, + isCallee, + isES5Constructor, + getUpperFunction, + isFunction, + isLoop, + isInLoop, + isArrayFromMethod, + isArrayFromAsyncMethod, + isPropertyDescriptor, + isParenthesised, + createGlobalLinebreakMatcher, + equalTokens, + + isArrowToken, + isClosingBraceToken, + isClosingBracketToken, + isClosingParenToken, + isColonToken, + isCommaToken, + isCommentToken, + isDotToken, + isQuestionDotToken, + isKeywordToken, + isNotClosingBraceToken: negate(isClosingBraceToken), + isNotClosingBracketToken: negate(isClosingBracketToken), + isNotClosingParenToken: negate(isClosingParenToken), + isNotColonToken: negate(isColonToken), + isNotCommaToken: negate(isCommaToken), + isNotDotToken: negate(isDotToken), + isNotQuestionDotToken: negate(isQuestionDotToken), + isNotOpeningBraceToken: negate(isOpeningBraceToken), + isNotOpeningBracketToken: negate(isOpeningBracketToken), + isNotOpeningParenToken: negate(isOpeningParenToken), + isNotSemicolonToken: negate(isSemicolonToken), + isOpeningBraceToken, + isOpeningBracketToken, + isOpeningParenToken, + isSemicolonToken, + isEqToken, + + /** + * Checks whether or not a given node is a string literal. + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is a string literal. + */ + isStringLiteral(node) { + return ( + (node.type === "Literal" && typeof node.value === "string") || + node.type === "TemplateLiteral" + ); + }, + + /** + * Checks whether a given node is a breakable statement or not. + * The node is breakable if the node is one of the following type: + * + * - DoWhileStatement + * - ForInStatement + * - ForOfStatement + * - ForStatement + * - SwitchStatement + * - WhileStatement + * @param {ASTNode} node A node to check. + * @returns {boolean} `true` if the node is breakable. + */ + isBreakableStatement(node) { + return breakableTypePattern.test(node.type); + }, + + /** + * Gets references which are non initializer and writable. + * @param {Reference[]} references An array of references. + * @returns {Reference[]} An array of only references which are non initializer and writable. + * @public + */ + getModifyingReferences(references) { + return references.filter(isModifyingReference); + }, + + /** + * Validate that a string passed in is surrounded by the specified character + * @param {string} val The text to check. + * @param {string} character The character to see if it's surrounded by. + * @returns {boolean} True if the text is surrounded by the character, false if not. + * @private + */ + isSurroundedBy(val, character) { + return val[0] === character && val.at(-1) === character; + }, + + /** + * Returns whether the provided node is an ESLint directive comment or not + * @param {Line|Block} node The comment token to be checked + * @returns {boolean} `true` if the node is an ESLint directive comment + */ + isDirectiveComment(node) { + const comment = node.value.trim(); + + return ( + (node.type === "Line" && comment.startsWith("eslint-")) || + (node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment)) + ); + }, + + /** + * Gets the trailing statement of a given node. + * + * if (code) + * consequent; + * + * When taking this `IfStatement`, returns `consequent;` statement. + * @param {ASTNode} A node to get. + * @returns {ASTNode|null} The trailing statement's node. + */ + getTrailingStatement: esutils.ast.trailingStatement, + + /** + * Finds the variable by a given name in a given scope and its upper scopes. + * @param {Scope} initScope A scope to start find. + * @param {string} name A variable name to find. + * @returns {Variable|null} A found variable or `null`. + */ + getVariableByName(initScope, name) { + let scope = initScope; + + while (scope) { + const variable = scope.set.get(name); + + if (variable) { + return variable; + } + + scope = scope.upper; + } + + return null; + }, + + /** + * Checks whether or not a given function node is the default `this` binding. + * + * First, this checks the node: + * + * - The given node is not in `PropertyDefinition#value` position. + * - The given node is not `StaticBlock`. + * - The function name does not start with uppercase. It's a convention to capitalize the names + * of constructor functions. This check is not performed if `capIsConstructor` is set to `false`. + * - The function does not have a JSDoc comment that has a `@this` tag. + * + * Next, this checks the location of the node. + * If the location is below, this judges `this` is valid. + * + * - The location is not on an object literal. + * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous + * functions only, as the name of the variable is considered to be the name of the function in this case. + * This check is not performed if `capIsConstructor` is set to `false`. + * - The location is not on an ES2015 class. + * - Its `bind`/`call`/`apply` method is not called directly. + * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given. + * @param {ASTNode} node A function node to check. It also can be an implicit function, like `StaticBlock` + * or any expression that is `PropertyDefinition#value` node. + * @param {SourceCode} sourceCode A SourceCode instance to get comments. + * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts + * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors. + * @returns {boolean} The function node is the default `this` binding. + */ + isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) { + /* + * Class field initializers are implicit functions, but ESTree doesn't have the AST node of field initializers. + * Therefore, A expression node at `PropertyDefinition#value` is a function. + * In this case, `this` is always not default binding. + */ + if ( + node.parent.type === "PropertyDefinition" && + node.parent.value === node + ) { + return false; + } + + // Class static blocks are implicit functions. In this case, `this` is always not default binding. + if (node.type === "StaticBlock") { + return false; + } + + // Check if the function has a parameter named `this`. + if ( + (node.type === "FunctionDeclaration" || + node.type === "FunctionExpression") && + node.params.some( + param => param.type === "Identifier" && param.name === "this", + ) + ) { + return false; + } + + if ( + (capIsConstructor && isES5Constructor(node)) || + hasJSDocThisTag(node, sourceCode) + ) { + return false; + } + const isAnonymous = node.id === null; + let currentNode = node; + + while (currentNode) { + const parent = currentNode.parent; + + switch (parent.type) { + /* + * Looks up the destination. + * e.g., obj.foo = nativeFoo || function foo() { ... }; + */ + case "LogicalExpression": + case "ConditionalExpression": + case "ChainExpression": + currentNode = parent; + break; + + /* + * If the upper function is IIFE, checks the destination of the return value. + * e.g. + * obj.foo = (function() { + * // setup... + * return function foo() { ... }; + * })(); + * obj.foo = (() => + * function foo() { ... } + * )(); + */ + case "ReturnStatement": { + const func = getUpperFunction(parent); + + if (func === null || !isCallee(func)) { + return true; + } + currentNode = func.parent; + break; + } + case "ArrowFunctionExpression": + if (currentNode !== parent.body || !isCallee(parent)) { + return true; + } + currentNode = parent.parent; + break; + + /* + * e.g. + * var obj = { foo() { ... } }; + * var obj = { foo: function() { ... } }; + * class A { constructor() { ... } } + * class A { foo() { ... } } + * class A { get foo() { ... } } + * class A { set foo() { ... } } + * class A { static foo() { ... } } + * class A { foo = function() { ... } } + */ + case "Property": + case "PropertyDefinition": + case "MethodDefinition": + return parent.value !== currentNode; + + /* + * e.g. + * obj.foo = function foo() { ... }; + * Foo = function() { ... }; + * [obj.foo = function foo() { ... }] = a; + * [Foo = function() { ... }] = a; + */ + case "AssignmentExpression": + case "AssignmentPattern": + if (parent.left.type === "MemberExpression") { + return false; + } + if ( + capIsConstructor && + isAnonymous && + parent.left.type === "Identifier" && + startsWithUpperCase(parent.left.name) + ) { + return false; + } + return true; + + /* + * e.g. + * var Foo = function() { ... }; + */ + case "VariableDeclarator": + return !( + capIsConstructor && + isAnonymous && + parent.init === currentNode && + parent.id.type === "Identifier" && + startsWithUpperCase(parent.id.name) + ); + + /* + * e.g. + * var foo = function foo() { ... }.bind(obj); + * (function foo() { ... }).call(obj); + * (function foo() { ... }).apply(obj, []); + */ + case "MemberExpression": + if ( + parent.object === currentNode && + isSpecificMemberAccess( + parent, + null, + bindOrCallOrApplyPattern, + ) + ) { + const maybeCalleeNode = + parent.parent.type === "ChainExpression" + ? parent.parent + : parent; + + return !( + isCallee(maybeCalleeNode) && + maybeCalleeNode.parent.arguments.length >= 1 && + !isNullOrUndefined( + maybeCalleeNode.parent.arguments[0], + ) + ); + } + return true; + + /* + * e.g. + * Reflect.apply(function() {}, obj, []); + * Array.from([], function() {}, obj); + * list.forEach(function() {}, obj); + */ + case "CallExpression": + if (isReflectApply(parent.callee)) { + return ( + parent.arguments.length !== 3 || + parent.arguments[0] !== currentNode || + isNullOrUndefined(parent.arguments[1]) + ); + } + if ( + isArrayFromMethod(parent.callee) || + isArrayFromAsyncMethod(parent.callee) + ) { + return ( + parent.arguments.length !== 3 || + parent.arguments[1] !== currentNode || + isNullOrUndefined(parent.arguments[2]) + ); + } + if (isMethodWhichHasThisArg(parent.callee)) { + return ( + parent.arguments.length !== 2 || + parent.arguments[0] !== currentNode || + isNullOrUndefined(parent.arguments[1]) + ); + } + return true; + + // Otherwise `this` is default. + default: + return true; + } + } + + /* c8 ignore next */ + return true; + }, + + /** + * Get the precedence level based on the node type + * @param {ASTNode} node node to evaluate + * @returns {number} precedence level + * @private + */ + getPrecedence(node) { + switch (node.type) { + case "SequenceExpression": + return 0; + + case "AssignmentExpression": + case "ArrowFunctionExpression": + case "YieldExpression": + return 1; + + case "ConditionalExpression": + return 3; + + case "LogicalExpression": + switch (node.operator) { + case "||": + case "??": + return 4; + case "&&": + return 5; + + // no default + } + + /* falls through */ + + case "BinaryExpression": + switch (node.operator) { + case "|": + return 6; + case "^": + return 7; + case "&": + return 8; + case "==": + case "!=": + case "===": + case "!==": + return 9; + case "<": + case "<=": + case ">": + case ">=": + case "in": + case "instanceof": + return 10; + case "<<": + case ">>": + case ">>>": + return 11; + case "+": + case "-": + return 12; + case "*": + case "/": + case "%": + return 13; + case "**": + return 15; + + // no default + } + + /* falls through */ + + case "UnaryExpression": + case "AwaitExpression": + return 16; + + case "UpdateExpression": + return 17; + + case "CallExpression": + case "ChainExpression": + case "ImportExpression": + return 18; + + case "NewExpression": + return 19; + + default: + if (node.type in eslintVisitorKeys) { + return 20; + } + + /* + * if the node is not a standard node that we know about, then assume it has the lowest precedence + * this will mean that rules will wrap unknown nodes in parentheses where applicable instead of + * unwrapping them and potentially changing the meaning of the code or introducing a syntax error. + */ + return -1; + } + }, + + /** + * Checks whether the given node is an empty block node or not. + * @param {ASTNode|null} node The node to check. + * @returns {boolean} `true` if the node is an empty block. + */ + isEmptyBlock(node) { + return Boolean( + node && node.type === "BlockStatement" && node.body.length === 0, + ); + }, + + /** + * Checks whether the given node is an empty function node or not. + * @param {ASTNode|null} node The node to check. + * @returns {boolean} `true` if the node is an empty function. + */ + isEmptyFunction(node) { + return isFunction(node) && module.exports.isEmptyBlock(node.body); + }, + + /** + * Get directives from directive prologue of a Program or Function node. + * @param {ASTNode} node The node to check. + * @returns {ASTNode[]} The directives found in the directive prologue. + */ + getDirectivePrologue(node) { + const directives = []; + + // Directive prologues only occur at the top of files or functions. + if ( + node.type === "Program" || + node.type === "FunctionDeclaration" || + node.type === "FunctionExpression" || + /* + * Do not check arrow functions with implicit return. + * `() => "use strict";` returns the string `"use strict"`. + */ + (node.type === "ArrowFunctionExpression" && + node.body.type === "BlockStatement") + ) { + const statements = + node.type === "Program" ? node.body : node.body.body; + + for (const statement of statements) { + if ( + statement.type === "ExpressionStatement" && + statement.expression.type === "Literal" + ) { + directives.push(statement); + } else { + break; + } + } + } + + return directives; + }, + + /** + * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added + * after the node will be parsed as a decimal point, rather than a property-access dot. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if this node is a decimal integer. + * @example + * + * 0 // true + * 5 // true + * 50 // true + * 5_000 // true + * 1_234_56 // true + * 08 // true + * 0192 // true + * 5. // false + * .5 // false + * 5.0 // false + * 5.00_00 // false + * 05 // false + * 0x5 // false + * 0b101 // false + * 0b11_01 // false + * 0o5 // false + * 5e0 // false + * 5e1_000 // false + * 5n // false + * 1_000n // false + * "5" // false + * + */ + isDecimalInteger(node) { + return ( + node.type === "Literal" && + typeof node.value === "number" && + DECIMAL_INTEGER_PATTERN.test(node.raw) + ); + }, + + /** + * Determines whether this token is a decimal integer numeric token. + * This is similar to isDecimalInteger(), but for tokens. + * @param {Token} token The token to check. + * @returns {boolean} `true` if this token is a decimal integer. + */ + isDecimalIntegerNumericToken(token) { + return ( + token.type === "Numeric" && + DECIMAL_INTEGER_PATTERN.test(token.value) + ); + }, + + /** + * Gets the name and kind of the given function node. + * + * - `function foo() {}` .................... `function 'foo'` + * - `(function foo() {})` .................. `function 'foo'` + * - `(function() {})` ...................... `function` + * - `function* foo() {}` ................... `generator function 'foo'` + * - `(function* foo() {})` ................. `generator function 'foo'` + * - `(function*() {})` ..................... `generator function` + * - `() => {}` ............................. `arrow function` + * - `async () => {}` ....................... `async arrow function` + * - `({ foo: function foo() {} })` ......... `method 'foo'` + * - `({ foo: function() {} })` ............. `method 'foo'` + * - `({ ['foo']: function() {} })` ......... `method 'foo'` + * - `({ [foo]: function() {} })` ........... `method` + * - `({ foo() {} })` ....................... `method 'foo'` + * - `({ foo: function* foo() {} })` ........ `generator method 'foo'` + * - `({ foo: function*() {} })` ............ `generator method 'foo'` + * - `({ ['foo']: function*() {} })` ........ `generator method 'foo'` + * - `({ [foo]: function*() {} })` .......... `generator method` + * - `({ *foo() {} })` ...................... `generator method 'foo'` + * - `({ foo: async function foo() {} })` ... `async method 'foo'` + * - `({ foo: async function() {} })` ....... `async method 'foo'` + * - `({ ['foo']: async function() {} })` ... `async method 'foo'` + * - `({ [foo]: async function() {} })` ..... `async method` + * - `({ async foo() {} })` ................. `async method 'foo'` + * - `({ get foo() {} })` ................... `getter 'foo'` + * - `({ set foo(a) {} })` .................. `setter 'foo'` + * - `class A { constructor() {} }` ......... `constructor` + * - `class A { foo() {} }` ................. `method 'foo'` + * - `class A { *foo() {} }` ................ `generator method 'foo'` + * - `class A { async foo() {} }` ........... `async method 'foo'` + * - `class A { ['foo']() {} }` ............. `method 'foo'` + * - `class A { *['foo']() {} }` ............ `generator method 'foo'` + * - `class A { async ['foo']() {} }` ....... `async method 'foo'` + * - `class A { [foo]() {} }` ............... `method` + * - `class A { *[foo]() {} }` .............. `generator method` + * - `class A { async [foo]() {} }` ......... `async method` + * - `class A { get foo() {} }` ............. `getter 'foo'` + * - `class A { set foo(a) {} }` ............ `setter 'foo'` + * - `class A { static foo() {} }` .......... `static method 'foo'` + * - `class A { static *foo() {} }` ......... `static generator method 'foo'` + * - `class A { static async foo() {} }` .... `static async method 'foo'` + * - `class A { static get foo() {} }` ...... `static getter 'foo'` + * - `class A { static set foo(a) {} }` ..... `static setter 'foo'` + * - `class A { foo = () => {}; }` .......... `method 'foo'` + * - `class A { foo = function() {}; }` ..... `method 'foo'` + * - `class A { foo = function bar() {}; }` . `method 'foo'` + * - `class A { static foo = () => {}; }` ... `static method 'foo'` + * - `class A { '#foo' = () => {}; }` ....... `method '#foo'` + * - `class A { #foo = () => {}; }` ......... `private method #foo` + * - `class A { static #foo = () => {}; }` .. `static private method #foo` + * - `class A { '#foo'() {} }` .............. `method '#foo'` + * - `class A { #foo() {} }` ................ `private method #foo` + * - `class A { static #foo() {} }` ......... `static private method #foo` + * @param {ASTNode} node The function node to get. + * @returns {string} The name and kind of the function node. + */ + getFunctionNameWithKind(node) { + const parent = node.parent; + const tokens = []; + + if ( + parent.type === "MethodDefinition" || + parent.type === "PropertyDefinition" || + node.type === "TSPropertySignature" || + node.type === "TSMethodSignature" + ) { + // The proposal uses `static` word consistently before visibility words: https://github.com/tc39/proposal-static-class-features + if (parent.static) { + tokens.push("static"); + } + if (!parent.computed && parent.key?.type === "PrivateIdentifier") { + tokens.push("private"); + } + } + if (node.async) { + tokens.push("async"); + } + if (node.generator) { + tokens.push("generator"); + } + + if (parent.type === "Property" || parent.type === "MethodDefinition") { + if (parent.kind === "constructor") { + return "constructor"; + } + if (parent.kind === "get") { + tokens.push("getter"); + } else if (parent.kind === "set") { + tokens.push("setter"); + } else { + tokens.push("method"); + } + } else if (node.type === "TSMethodSignature") { + if (node.kind === "get") { + tokens.push("getter"); + } else if (node.kind === "set") { + tokens.push("setter"); + } else { + tokens.push("method"); + } + } else if (parent.type === "PropertyDefinition") { + tokens.push("method"); + } else { + if (node.type === "ArrowFunctionExpression") { + tokens.push("arrow"); + } + tokens.push("function"); + } + + if ( + parent.type === "Property" || + parent.type === "MethodDefinition" || + parent.type === "PropertyDefinition" + ) { + if (!parent.computed && parent.key.type === "PrivateIdentifier") { + tokens.push(`#${parent.key.name}`); + } else { + const name = getStaticPropertyName(parent); + + if (name !== null) { + tokens.push(`'${name}'`); + } else if (node.id) { + tokens.push(`'${node.id.name}'`); + } + } + } else if (node.type === "TSMethodSignature") { + tokens.push(`'${getStaticPropertyName(node)}'`); + } else if (node.id) { + tokens.push(`'${node.id.name}'`); + } + + return tokens.join(" "); + }, + + /** + * Gets the location of the given function node for reporting. + * + * - `function foo() {}` + * ^^^^^^^^^^^^ + * - `(function foo() {})` + * ^^^^^^^^^^^^ + * - `(function() {})` + * ^^^^^^^^ + * - `function* foo() {}` + * ^^^^^^^^^^^^^ + * - `(function* foo() {})` + * ^^^^^^^^^^^^^ + * - `(function*() {})` + * ^^^^^^^^^ + * - `() => {}` + * ^^ + * - `async () => {}` + * ^^ + * - `({ foo: function foo() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ foo: function() {} })` + * ^^^^^^^^^^^^^ + * - `({ ['foo']: function() {} })` + * ^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function() {} })` + * ^^^^^^^^^^^^^^^ + * - `({ foo() {} })` + * ^^^ + * - `({ foo: function* foo() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ foo: function*() {} })` + * ^^^^^^^^^^^^^^ + * - `({ ['foo']: function*() {} })` + * ^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: function*() {} })` + * ^^^^^^^^^^^^^^^^ + * - `({ *foo() {} })` + * ^^^^ + * - `({ foo: async function foo() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ foo: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^ + * - `({ ['foo']: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^^^ + * - `({ [foo]: async function() {} })` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `({ async foo() {} })` + * ^^^^^^^^^ + * - `({ get foo() {} })` + * ^^^^^^^ + * - `({ set foo(a) {} })` + * ^^^^^^^ + * - `class A { constructor() {} }` + * ^^^^^^^^^^^ + * - `class A { foo() {} }` + * ^^^ + * - `class A { *foo() {} }` + * ^^^^ + * - `class A { async foo() {} }` + * ^^^^^^^^^ + * - `class A { ['foo']() {} }` + * ^^^^^^^ + * - `class A { *['foo']() {} }` + * ^^^^^^^^ + * - `class A { async ['foo']() {} }` + * ^^^^^^^^^^^^^ + * - `class A { [foo]() {} }` + * ^^^^^ + * - `class A { *[foo]() {} }` + * ^^^^^^ + * - `class A { async [foo]() {} }` + * ^^^^^^^^^^^ + * - `class A { get foo() {} }` + * ^^^^^^^ + * - `class A { set foo(a) {} }` + * ^^^^^^^ + * - `class A { static foo() {} }` + * ^^^^^^^^^^ + * - `class A { static *foo() {} }` + * ^^^^^^^^^^^ + * - `class A { static async foo() {} }` + * ^^^^^^^^^^^^^^^^ + * - `class A { static get foo() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static set foo(a) {} }` + * ^^^^^^^^^^^^^^ + * - `class A { foo = function() {} }` + * ^^^^^^^^^^^^^^ + * - `class A { static foo = function() {} }` + * ^^^^^^^^^^^^^^^^^^^^^ + * - `class A { foo = (a, b) => {} }` + * ^^^^^^ + * @param {ASTNode} node The function node to get. + * @param {SourceCode} sourceCode The source code object to get tokens. + * @returns {string} The location of the function node for reporting. + */ + getFunctionHeadLoc(node, sourceCode) { + const parent = node.parent; + let start; + let end; + + if ( + parent.type === "Property" || + parent.type === "MethodDefinition" || + parent.type === "PropertyDefinition" || + parent.type === "TSPropertySignature" || + parent.type === "TSMethodSignature" + ) { + start = parent.loc.start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } else if (node.type === "ArrowFunctionExpression") { + const arrowToken = sourceCode.getTokenBefore( + node.body, + isArrowToken, + ); + + start = arrowToken.loc.start; + end = arrowToken.loc.end; + } else { + start = node.loc.start; + end = getOpeningParenOfParams(node, sourceCode).loc.start; + } + + return { + start: Object.assign({}, start), + end: Object.assign({}, end), + }; + }, + + /** + * Gets next location when the result is not out of bound, otherwise returns null. + * + * Assumptions: + * + * - The given location represents a valid location in the given source code. + * - Columns are 0-based. + * - Lines are 1-based. + * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location. + * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end. + * The start (column 0) of that extra line is considered to be a valid location. + * + * Examples of successive locations (line, column): + * + * code: foo + * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null + * + * code: foo + * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null + * + * code: foo + * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null + * + * code: ab + * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null + * + * code: ab + * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null + * + * code: ab + * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null + * + * code: a + * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null + * + * code: + * locations: (1, 0) -> (2, 0) -> null + * + * code: + * locations: (1, 0) -> null + * @param {SourceCode} sourceCode The sourceCode + * @param {{line: number, column: number}} location The location + * @returns {{line: number, column: number} | null} Next location + */ + getNextLocation(sourceCode, { line, column }) { + if (column < sourceCode.lines[line - 1].length) { + return { + line, + column: column + 1, + }; + } + + if (line < sourceCode.lines.length) { + return { + line: line + 1, + column: 0, + }; + } + + return null; + }, + + /** + * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses + * surrounding the node. + * @param {SourceCode} sourceCode The source code object + * @param {ASTNode} node An expression node + * @returns {string} The text representing the node, with all surrounding parentheses included + */ + getParenthesisedText(sourceCode, node) { + let leftToken = sourceCode.getFirstToken(node); + let rightToken = sourceCode.getLastToken(node); + + while ( + sourceCode.getTokenBefore(leftToken) && + sourceCode.getTokenBefore(leftToken).type === "Punctuator" && + sourceCode.getTokenBefore(leftToken).value === "(" && + sourceCode.getTokenAfter(rightToken) && + sourceCode.getTokenAfter(rightToken).type === "Punctuator" && + sourceCode.getTokenAfter(rightToken).value === ")" + ) { + leftToken = sourceCode.getTokenBefore(leftToken); + rightToken = sourceCode.getTokenAfter(rightToken); + } + + return sourceCode + .getText() + .slice(leftToken.range[0], rightToken.range[1]); + }, + + /** + * Determine if a node has a possibility to be an Error object + * @param {ASTNode} node ASTNode to check + * @returns {boolean} True if there is a chance it contains an Error obj + */ + couldBeError(node) { + switch (node.type) { + case "Identifier": + case "CallExpression": + case "NewExpression": + case "MemberExpression": + case "TaggedTemplateExpression": + case "YieldExpression": + case "AwaitExpression": + case "ChainExpression": + return true; // possibly an error object. + + case "AssignmentExpression": + if (["=", "&&="].includes(node.operator)) { + return module.exports.couldBeError(node.right); + } + + if (["||=", "??="].includes(node.operator)) { + return ( + module.exports.couldBeError(node.left) || + module.exports.couldBeError(node.right) + ); + } + + /** + * All other assignment operators are mathematical assignment operators (arithmetic or bitwise). + * An assignment expression with a mathematical operator can either evaluate to a primitive value, + * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object. + */ + return false; + + case "SequenceExpression": { + const exprs = node.expressions; + + return ( + exprs.length !== 0 && + module.exports.couldBeError(exprs.at(-1)) + ); + } + + case "LogicalExpression": + /* + * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it + * doesn't short-circuit, it takes the value from the right side, so the right side must always be + * a plausible error. A future improvement could verify that the left side could be truthy by + * excluding falsy literals. + */ + if (node.operator === "&&") { + return module.exports.couldBeError(node.right); + } + + return ( + module.exports.couldBeError(node.left) || + module.exports.couldBeError(node.right) + ); + + case "ConditionalExpression": + return ( + module.exports.couldBeError(node.consequent) || + module.exports.couldBeError(node.alternate) + ); + + default: + return false; + } + }, + + /** + * Check if a given node is a numeric literal or not. + * @param {ASTNode} node The node to check. + * @returns {boolean} `true` if the node is a number or bigint literal. + */ + isNumericLiteral(node) { + return ( + node.type === "Literal" && + (typeof node.value === "number" || Boolean(node.bigint)) + ); + }, + + /** + * Determines whether two tokens can safely be placed next to each other without merging into a single token + * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used. + * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used. + * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed + * next to each other, behavior is undefined (although it should return `true` in most cases). + */ + canTokensBeAdjacent(leftValue, rightValue) { + const espreeOptions = { + ecmaVersion: espree.latestEcmaVersion, + comment: true, + range: true, + }; + + let leftToken; + + if (typeof leftValue === "string") { + let tokens; + + try { + tokens = espree.tokenize(leftValue, espreeOptions); + } catch { + return false; + } + + const comments = tokens.comments; + + leftToken = tokens.at(-1); + if (comments.length) { + const lastComment = comments.at(-1); + + if (!leftToken || lastComment.range[0] > leftToken.range[0]) { + leftToken = lastComment; + } + } + } else { + leftToken = leftValue; + } + + /* + * If a hashbang comment was passed as a token object from SourceCode, + * its type will be "Shebang" because of the way ESLint itself handles hashbangs. + * If a hashbang comment was passed in a string and then tokenized in this function, + * its type will be "Hashbang" because of the way Espree tokenizes hashbangs. + */ + if (leftToken.type === "Shebang" || leftToken.type === "Hashbang") { + return false; + } + + let rightToken; + + if (typeof rightValue === "string") { + let tokens; + + try { + tokens = espree.tokenize(rightValue, espreeOptions); + } catch { + return false; + } + + const comments = tokens.comments; + + rightToken = tokens[0]; + if (comments.length) { + const firstComment = comments[0]; + + if ( + !rightToken || + firstComment.range[0] < rightToken.range[0] + ) { + rightToken = firstComment; + } + } + } else { + rightToken = rightValue; + } + + if ( + leftToken.type === "Punctuator" || + rightToken.type === "Punctuator" + ) { + if ( + leftToken.type === "Punctuator" && + rightToken.type === "Punctuator" + ) { + const PLUS_TOKENS = new Set(["+", "++"]); + const MINUS_TOKENS = new Set(["-", "--"]); + + return !( + (PLUS_TOKENS.has(leftToken.value) && + PLUS_TOKENS.has(rightToken.value)) || + (MINUS_TOKENS.has(leftToken.value) && + MINUS_TOKENS.has(rightToken.value)) + ); + } + if (leftToken.type === "Punctuator" && leftToken.value === "/") { + return !["Block", "Line", "RegularExpression"].includes( + rightToken.type, + ); + } + return true; + } + + if ( + leftToken.type === "String" || + rightToken.type === "String" || + leftToken.type === "Template" || + rightToken.type === "Template" + ) { + return true; + } + + if ( + leftToken.type !== "Numeric" && + rightToken.type === "Numeric" && + rightToken.value.startsWith(".") + ) { + return true; + } + + if ( + leftToken.type === "Block" || + rightToken.type === "Block" || + rightToken.type === "Line" + ) { + return true; + } + + if (rightToken.type === "PrivateIdentifier") { + return true; + } + + return false; + }, + + /** + * Get the `loc` object of a given name in a `/*globals` directive comment. + * @param {SourceCode} sourceCode The source code to convert index to loc. + * @param {Comment} comment The `/*globals` directive comment which include the name. + * @param {string} name The name to find. + * @returns {SourceLocation} The `loc` object. + */ + getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) { + const namePattern = new RegExp( + `[\\s,]${escapeRegExp(name)}(?:$|[\\s,:])`, + "gu", + ); + + // To ignore the first text "global". + namePattern.lastIndex = comment.value.indexOf("global") + 6; + + // Search a given variable name. + const match = namePattern.exec(comment.value); + + // Convert the index to loc. + const start = sourceCode.getLocFromIndex( + comment.range[0] + "/*".length + (match ? match.index + 1 : 0), + ); + const end = { + line: start.line, + column: start.column + (match ? name.length : 1), + }; + + return { start, end }; + }, + + /** + * Determines whether the given raw string contains an octal escape sequence + * or a non-octal decimal escape sequence ("\8", "\9"). + * + * "\1", "\2" ... "\7", "\8", "\9" + * "\00", "\01" ... "\07", "\08", "\09" + * + * "\0", when not followed by a digit, is not an octal escape sequence. + * @param {string} rawString A string in its raw representation. + * @returns {boolean} `true` if the string contains at least one octal escape sequence + * or at least one non-octal decimal escape sequence. + */ + hasOctalOrNonOctalDecimalEscapeSequence(rawString) { + return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString); + }, + + /** + * Determines whether the given node is a template literal without expressions. + * @param {ASTNode} node Node to check. + * @returns {boolean} True if the node is a template literal without expressions. + */ + isStaticTemplateLiteral(node) { + return node.type === "TemplateLiteral" && node.expressions.length === 0; + }, + + /** + * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code. + * The braces, which make the given block body, are necessary in either of the following situations: + * + * 1. The statement is a lexical declaration. + * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace: + * + * if (a) { + * if (b) + * foo(); + * } + * else + * bar(); + * + * if (a) + * while (b) + * while (c) { + * while (d) + * if (e) + * while(f) + * foo(); + * } + * else + * bar(); + * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements. + * @param {SourceCode} sourceCode The source code + * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content) + * would change the semantics of the code or produce a syntax error. + */ + areBracesNecessary(node, sourceCode) { + /** + * Determines if the given node is a lexical declaration (let, const, using, await using, function, or class) + * @param {ASTNode} nodeToCheck The node to check + * @returns {boolean} True if the node is a lexical declaration + * @private + */ + function isLexicalDeclaration(nodeToCheck) { + if (nodeToCheck.type === "VariableDeclaration") { + return LEXICAL_DECLARATION_KINDS.has(nodeToCheck.kind); + } + + return ( + nodeToCheck.type === "FunctionDeclaration" || + nodeToCheck.type === "ClassDeclaration" + ); + } + + /** + * Checks if the given token is an `else` token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is an `else` token. + */ + function isElseKeywordToken(token) { + return token.value === "else" && token.type === "Keyword"; + } + + /** + * Determines whether the given node has an `else` keyword token as the first token after. + * @param {ASTNode} nodeToCheck The node to check. + * @returns {boolean} `true` if the node is followed by an `else` keyword token. + */ + function isFollowedByElseKeyword(nodeToCheck) { + const nextToken = sourceCode.getTokenAfter(nodeToCheck); + + return Boolean(nextToken) && isElseKeywordToken(nextToken); + } + + /** + * Determines whether the code represented by the given node contains an `if` statement + * that would become associated with an `else` keyword directly appended to that code. + * + * Examples where it returns `true`: + * + * if (a) + * foo(); + * + * if (a) { + * foo(); + * } + * + * if (a) + * foo(); + * else if (b) + * bar(); + * + * while (a) + * if (b) + * if(c) + * foo(); + * else + * bar(); + * + * Examples where it returns `false`: + * + * if (a) + * foo(); + * else + * bar(); + * + * while (a) { + * if (b) + * if(c) + * foo(); + * else + * bar(); + * } + * + * while (a) + * if (b) { + * if(c) + * foo(); + * } + * else + * bar(); + * @param {ASTNode} nodeToCheck Node representing the code to check. + * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code. + */ + function hasUnsafeIf(nodeToCheck) { + switch (nodeToCheck.type) { + case "IfStatement": + if (!nodeToCheck.alternate) { + return true; + } + return hasUnsafeIf(nodeToCheck.alternate); + case "ForStatement": + case "ForInStatement": + case "ForOfStatement": + case "LabeledStatement": + case "WithStatement": + case "WhileStatement": + return hasUnsafeIf(nodeToCheck.body); + default: + return false; + } + } + + const statement = node.body[0]; + + return ( + isLexicalDeclaration(statement) || + (hasUnsafeIf(statement) && isFollowedByElseKeyword(node)) + ); + }, + + isReferenceToGlobalVariable, + isLogicalExpression, + isCoalesceExpression, + isMixedLogicalAndCoalesceExpressions, + isNullLiteral, + getStaticStringValue, + getStaticPropertyName, + skipChainExpression, + isSpecificId, + isSpecificMemberAccess, + equalLiteralValue, + isSameReference, + isLogicalAssignmentOperator, + getSwitchCaseColonToken, + getModuleExportName, + isConstant, + isTopLevelExpressionStatement, + isDirective, + isStartOfExpressionStatement, + canContinueExpressionInClassBody, + needsPrecedingSemicolon, + isImportAttributeKey, + getOpeningParenOfParams, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/char-source.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/char-source.js new file mode 100644 index 00000000..7a25b27b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/char-source.js @@ -0,0 +1,247 @@ +/** + * @fileoverview Utility functions to locate the source text of each code unit in the value of a string literal or template token. + * @author Francesco Trotta + */ + +"use strict"; + +/** + * Represents a code unit produced by the evaluation of a JavaScript common token like a string + * literal or template token. + */ +class CodeUnit { + constructor(start, source) { + this.start = start; + this.source = source; + } + + get end() { + return this.start + this.length; + } + + get length() { + return this.source.length; + } +} + +/** + * An object used to keep track of the position in a source text where the next characters will be read. + */ +class TextReader { + constructor(source) { + this.source = source; + this.pos = 0; + } + + /** + * Advances the reading position of the specified number of characters. + * @param {number} length Number of characters to advance. + * @returns {void} + */ + advance(length) { + this.pos += length; + } + + /** + * Reads characters from the source. + * @param {number} [offset=0] The offset where reading starts, relative to the current position. + * @param {number} [length=1] Number of characters to read. + * @returns {string} A substring of source characters. + */ + read(offset = 0, length = 1) { + const start = offset + this.pos; + + return this.source.slice(start, start + length); + } +} + +const SIMPLE_ESCAPE_SEQUENCES = { + __proto__: null, + b: "\b", + f: "\f", + n: "\n", + r: "\r", + t: "\t", + v: "\v", +}; + +/** + * Reads a hex escape sequence. + * @param {TextReader} reader The reader should be positioned on the first hexadecimal digit. + * @param {number} length The number of hexadecimal digits. + * @returns {string} A code unit. + */ +function readHexSequence(reader, length) { + const str = reader.read(0, length); + const charCode = parseInt(str, 16); + + reader.advance(length); + return String.fromCharCode(charCode); +} + +/** + * Reads a Unicode escape sequence. + * @param {TextReader} reader The reader should be positioned after the "u". + * @returns {string} A code unit. + */ +function readUnicodeSequence(reader) { + const regExp = /\{(?[\dA-F]+)\}/iuy; + + regExp.lastIndex = reader.pos; + const match = regExp.exec(reader.source); + + if (match) { + const codePoint = parseInt(match.groups.hexDigits, 16); + + reader.pos = regExp.lastIndex; + return String.fromCodePoint(codePoint); + } + return readHexSequence(reader, 4); +} + +/** + * Reads an octal escape sequence. + * @param {TextReader} reader The reader should be positioned after the first octal digit. + * @param {number} maxLength The maximum number of octal digits. + * @returns {string} A code unit. + */ +function readOctalSequence(reader, maxLength) { + const [octalStr] = reader.read(-1, maxLength).match(/^[0-7]+/u); + + reader.advance(octalStr.length - 1); + const octal = parseInt(octalStr, 8); + + return String.fromCharCode(octal); +} + +/** + * Reads an escape sequence or line continuation. + * @param {TextReader} reader The reader should be positioned on the backslash. + * @returns {string} A string of zero, one or two code units. + */ +function readEscapeSequenceOrLineContinuation(reader) { + const char = reader.read(1); + + reader.advance(2); + const unitChar = SIMPLE_ESCAPE_SEQUENCES[char]; + + if (unitChar) { + return unitChar; + } + switch (char) { + case "x": + return readHexSequence(reader, 2); + case "u": + return readUnicodeSequence(reader); + case "\r": + if (reader.read() === "\n") { + reader.advance(1); + } + + // fallthrough + case "\n": + case "\u2028": + case "\u2029": + return ""; + case "0": + case "1": + case "2": + case "3": + return readOctalSequence(reader, 3); + case "4": + case "5": + case "6": + case "7": + return readOctalSequence(reader, 2); + default: + return char; + } +} + +/** + * Reads an escape sequence or line continuation and generates the respective `CodeUnit` elements. + * @param {TextReader} reader The reader should be positioned on the backslash. + * @returns {Generator} Zero, one or two `CodeUnit` elements. + */ +function* mapEscapeSequenceOrLineContinuation(reader) { + const start = reader.pos; + const str = readEscapeSequenceOrLineContinuation(reader); + const end = reader.pos; + const source = reader.source.slice(start, end); + + switch (str.length) { + case 0: + break; + case 1: + yield new CodeUnit(start, source); + break; + default: + yield new CodeUnit(start, source); + yield new CodeUnit(start, source); + break; + } +} + +/** + * Parses a string literal. + * @param {string} source The string literal to parse, including the delimiting quotes. + * @returns {CodeUnit[]} A list of code units produced by the string literal. + */ +function parseStringLiteral(source) { + const reader = new TextReader(source); + const quote = reader.read(); + + reader.advance(1); + const codeUnits = []; + + for (;;) { + const char = reader.read(); + + if (char === quote) { + break; + } + if (char === "\\") { + codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader)); + } else { + codeUnits.push(new CodeUnit(reader.pos, char)); + reader.advance(1); + } + } + return codeUnits; +} + +/** + * Parses a template token. + * @param {string} source The template token to parse, including the delimiting sequences `` ` ``, `${` and `}`. + * @returns {CodeUnit[]} A list of code units produced by the template token. + */ +function parseTemplateToken(source) { + const reader = new TextReader(source); + + reader.advance(1); + const codeUnits = []; + + for (;;) { + const char = reader.read(); + + if (char === "`" || (char === "$" && reader.read(1) === "{")) { + break; + } + if (char === "\\") { + codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader)); + } else { + let unitSource; + + if (char === "\r" && reader.read(1) === "\n") { + unitSource = "\r\n"; + } else { + unitSource = char; + } + codeUnits.push(new CodeUnit(reader.pos, unitSource)); + reader.advance(unitSource.length); + } + } + return codeUnits; +} + +module.exports = { parseStringLiteral, parseTemplateToken }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/code-path-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/code-path-utils.js new file mode 100644 index 00000000..5646466f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/code-path-utils.js @@ -0,0 +1,22 @@ +/** + * @fileoverview Code path related utilities. + */ + +"use strict"; + +/** + * Checks all segments in a set and returns true if any are reachable. + * @param {Set} segments The segments to check. + * @returns {boolean} `true` if any segment is reachable; `false` otherwise. + */ +function isAnySegmentReachable(segments) { + for (const segment of segments) { + if (segment.reachable) { + return true; + } + } + + return false; +} + +module.exports = { isAnySegmentReachable }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/fix-tracker.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/fix-tracker.js new file mode 100644 index 00000000..5721717b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/fix-tracker.js @@ -0,0 +1,125 @@ +/** + * @fileoverview Helper class to aid in constructing fix commands. + * @author Alan Pierce + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @import { SourceRange } from "@eslint/core"; + */ + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./ast-utils"); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * A helper class to combine fix options into a fix command. Currently, it + * exposes some "retain" methods that extend the range of the text being + * replaced so that other fixes won't touch that region in the same pass. + */ +class FixTracker { + /** + * Create a new FixTracker. + * @param {ruleFixer} fixer A ruleFixer instance. + * @param {SourceCode} sourceCode A SourceCode object for the current code. + */ + constructor(fixer, sourceCode) { + this.fixer = fixer; + this.sourceCode = sourceCode; + this.retainedRange = null; + } + + /** + * Mark the given range as "retained", meaning that other fixes may not + * may not modify this region in the same pass. + * @param {SourceRange} range The range to retain. + * @returns {FixTracker} The same RuleFixer, for chained calls. + */ + retainRange(range) { + this.retainedRange = range; + return this; + } + + /** + * Given a node, find the function containing it (or the entire program) and + * mark it as retained, meaning that other fixes may not modify it in this + * pass. This is useful for avoiding conflicts in fixes that modify control + * flow. + * @param {ASTNode} node The node to use as a starting point. + * @returns {FixTracker} The same RuleFixer, for chained calls. + */ + retainEnclosingFunction(node) { + const functionNode = astUtils.getUpperFunction(node); + + return this.retainRange( + functionNode ? functionNode.range : this.sourceCode.ast.range, + ); + } + + /** + * Given a node or token, find the token before and afterward, and mark that + * range as retained, meaning that other fixes may not modify it in this + * pass. This is useful for avoiding conflicts in fixes that make a small + * change to the code where the AST should not be changed. + * @param {ASTNode|Token} nodeOrToken The node or token to use as a starting + * point. The token to the left and right are use in the range. + * @returns {FixTracker} The same RuleFixer, for chained calls. + */ + retainSurroundingTokens(nodeOrToken) { + const tokenBefore = + this.sourceCode.getTokenBefore(nodeOrToken) || nodeOrToken; + const tokenAfter = + this.sourceCode.getTokenAfter(nodeOrToken) || nodeOrToken; + + return this.retainRange([tokenBefore.range[0], tokenAfter.range[1]]); + } + + /** + * Create a fix command that replaces the given range with the given text, + * accounting for any retained ranges. + * @param {SourceRange} range The range to remove in the fix. + * @param {string} text The text to insert in place of the range. + * @returns {Object} The fix command. + */ + replaceTextRange(range, text) { + let actualRange; + + if (this.retainedRange) { + actualRange = [ + Math.min(this.retainedRange[0], range[0]), + Math.max(this.retainedRange[1], range[1]), + ]; + } else { + actualRange = range; + } + + return this.fixer.replaceTextRange( + actualRange, + this.sourceCode.text.slice(actualRange[0], range[0]) + + text + + this.sourceCode.text.slice(range[1], actualRange[1]), + ); + } + + /** + * Create a fix command that removes the given node or token, accounting for + * any retained ranges. + * @param {ASTNode|Token} nodeOrToken The node or token to remove. + * @returns {Object} The fix command. + */ + remove(nodeOrToken) { + return this.replaceTextRange(nodeOrToken.range, ""); + } +} + +module.exports = FixTracker; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/keywords.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/keywords.js new file mode 100644 index 00000000..eca2076e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/keywords.js @@ -0,0 +1,67 @@ +/** + * @fileoverview A shared list of ES3 keywords. + * @author Josh Perez + */ +"use strict"; + +module.exports = [ + "abstract", + "boolean", + "break", + "byte", + "case", + "catch", + "char", + "class", + "const", + "continue", + "debugger", + "default", + "delete", + "do", + "double", + "else", + "enum", + "export", + "extends", + "false", + "final", + "finally", + "float", + "for", + "function", + "goto", + "if", + "implements", + "import", + "in", + "instanceof", + "int", + "interface", + "long", + "native", + "new", + "null", + "package", + "private", + "protected", + "public", + "return", + "short", + "static", + "super", + "switch", + "synchronized", + "this", + "throw", + "throws", + "transient", + "true", + "try", + "typeof", + "var", + "void", + "volatile", + "while", + "with", +]; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/lazy-loading-rule-map.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/lazy-loading-rule-map.js new file mode 100644 index 00000000..b9339509 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/lazy-loading-rule-map.js @@ -0,0 +1,118 @@ +/** + * @fileoverview `Map` to load rules lazily. + * @author Toru Nagashima + */ +"use strict"; + +const debug = require("debug")("eslint:rules"); + +/** @typedef {import("../../types").Rule.RuleModule} Rule */ + +/** + * The `Map` object that loads each rule when it's accessed. + * @example + * const rules = new LazyLoadingRuleMap([ + * ["eqeqeq", () => require("eqeqeq")], + * ["semi", () => require("semi")], + * ["no-unused-vars", () => require("no-unused-vars")] + * ]); + * + * rules.get("semi"); // call `() => require("semi")` here. + * + * @extends {Map} + */ +class LazyLoadingRuleMap extends Map { + /** + * Initialize this map. + * @param {Array<[string, function(): Rule]>} loaders The rule loaders. + */ + constructor(loaders) { + let remaining = loaders.length; + + super( + debug.enabled + ? loaders.map(([ruleId, load]) => { + let cache = null; + + return [ + ruleId, + () => { + if (!cache) { + debug( + "Loading rule %o (remaining=%d)", + ruleId, + --remaining, + ); + cache = load(); + } + return cache; + }, + ]; + }) + : loaders, + ); + + // `super(...iterable)` uses `this.set()`, so disable it here. + Object.defineProperty(LazyLoadingRuleMap.prototype, "set", { + configurable: true, + value: void 0, + }); + } + + /** + * Get a rule. + * Each rule will be loaded on the first access. + * @param {string} ruleId The rule ID to get. + * @returns {Rule|undefined} The rule. + */ + get(ruleId) { + const load = super.get(ruleId); + + return load && load(); + } + + /** + * Iterate rules. + * @returns {IterableIterator} Rules. + */ + *values() { + for (const load of super.values()) { + yield load(); + } + } + + /** + * Iterate rules. + * @returns {IterableIterator<[string, Rule]>} Rules. + */ + *entries() { + for (const [ruleId, load] of super.entries()) { + yield [ruleId, load()]; + } + } + + /** + * Call a function with each rule. + * @param {Function} callbackFn The callback function. + * @param {any} [thisArg] The object to pass to `this` of the callback function. + * @returns {void} + */ + forEach(callbackFn, thisArg) { + for (const [ruleId, load] of super.entries()) { + callbackFn.call(thisArg, load(), ruleId, this); + } + } +} + +// Forbid mutation. +Object.defineProperties(LazyLoadingRuleMap.prototype, { + clear: { configurable: true, value: void 0 }, + delete: { configurable: true, value: void 0 }, + [Symbol.iterator]: { + configurable: true, + writable: true, + value: LazyLoadingRuleMap.prototype.entries, + }, +}); + +module.exports = { LazyLoadingRuleMap }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/regular-expressions.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/regular-expressions.js new file mode 100644 index 00000000..6d80654b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/regular-expressions.js @@ -0,0 +1,58 @@ +/** + * @fileoverview Common utils for regular expressions. + * @author Josh Goldberg + * @author Toru Nagashima + */ + +"use strict"; + +const { RegExpValidator } = require("@eslint-community/regexpp"); + +const REGEXPP_LATEST_ECMA_VERSION = 2025; + +/** + * Checks if the given regular expression pattern would be valid with the `u` flag. + * @param {number} ecmaVersion ECMAScript version to parse in. + * @param {string} pattern The regular expression pattern to verify. + * @param {"u"|"v"} flag The type of Unicode flag + * @returns {boolean} `true` if the pattern would be valid with the `u` flag. + * `false` if the pattern would be invalid with the `u` flag or the configured + * ecmaVersion doesn't support the `u` flag. + */ +function isValidWithUnicodeFlag(ecmaVersion, pattern, flag = "u") { + if (flag === "u" && ecmaVersion <= 5) { + // ecmaVersion <= 5 doesn't support the 'u' flag + return false; + } + if (flag === "v" && ecmaVersion <= 2023) { + return false; + } + + const validator = new RegExpValidator({ + ecmaVersion: Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION), + }); + + try { + validator.validatePattern( + pattern, + void 0, + void 0, + flag === "u" + ? { + unicode: /* uFlag = */ true, + } + : { + unicodeSets: true, + }, + ); + } catch { + return false; + } + + return true; +} + +module.exports = { + isValidWithUnicodeFlag, + REGEXPP_LATEST_ECMA_VERSION, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/string-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/string-utils.js new file mode 100644 index 00000000..fdeb3665 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/string-utils.js @@ -0,0 +1,21 @@ +/** + * @fileoverview Common utils for strings. + */ +"use strict"; +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ +const LETTER_PATTERN = /\p{L}/u; +/** + * Checks if the given string contains a letter. + * @param {string} string The string to test. + * @returns {boolean} `true` if the string contains a letter. + */ +function containsLetter(string) { + return LETTER_PATTERN.test(string); +} + +module.exports = { + LETTER_PATTERN, + containsLetter, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/index.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/index.js new file mode 100644 index 00000000..0e7d5d53 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/index.js @@ -0,0 +1,16 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +const isCombiningCharacter = require("./is-combining-character"); +const isEmojiModifier = require("./is-emoji-modifier"); +const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol"); +const isSurrogatePair = require("./is-surrogate-pair"); + +module.exports = { + isCombiningCharacter, + isEmojiModifier, + isRegionalIndicatorSymbol, + isSurrogatePair, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-combining-character.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-combining-character.js new file mode 100644 index 00000000..c26e291e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-combining-character.js @@ -0,0 +1,13 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +/** + * Check whether a given character is a combining mark or not. + * @param {number} codePoint The character code to check. + * @returns {boolean} `true` if the character has the General Category of Combining Mark (M), consisting of `Mc`, `Me`, and `Mn`. + */ +module.exports = function isCombiningCharacter(codePoint) { + return /^\p{M}$/u.test(String.fromCodePoint(codePoint)); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-emoji-modifier.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-emoji-modifier.js new file mode 100644 index 00000000..526ac91d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-emoji-modifier.js @@ -0,0 +1,13 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +/** + * Check whether a given character is an emoji modifier. + * @param {number} code The character code to check. + * @returns {boolean} `true` if the character is an emoji modifier. + */ +module.exports = function isEmojiModifier(code) { + return code >= 0x1f3fb && code <= 0x1f3ff; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-regional-indicator-symbol.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-regional-indicator-symbol.js new file mode 100644 index 00000000..019d9da0 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-regional-indicator-symbol.js @@ -0,0 +1,13 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +/** + * Check whether a given character is a regional indicator symbol. + * @param {number} code The character code to check. + * @returns {boolean} `true` if the character is a regional indicator symbol. + */ +module.exports = function isRegionalIndicatorSymbol(code) { + return code >= 0x1f1e6 && code <= 0x1f1ff; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-surrogate-pair.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-surrogate-pair.js new file mode 100644 index 00000000..fbe6a401 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/utils/unicode/is-surrogate-pair.js @@ -0,0 +1,14 @@ +/** + * @author Toru Nagashima + */ +"use strict"; + +/** + * Check whether given two characters are a surrogate pair. + * @param {number} lead The code of the lead character. + * @param {number} tail The code of the tail character. + * @returns {boolean} `true` if the character pair is a surrogate pair. + */ +module.exports = function isSurrogatePair(lead, tail) { + return lead >= 0xd800 && lead < 0xdc00 && tail >= 0xdc00 && tail < 0xe000; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/valid-typeof.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/valid-typeof.js new file mode 100644 index 00000000..fd4f3d20 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/valid-typeof.js @@ -0,0 +1,171 @@ +/** + * @fileoverview Ensures that the results of typeof are compared against a valid string + * @author Ian Christian Myers + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "problem", + + defaultOptions: [ + { + requireStringLiterals: false, + }, + ], + + docs: { + description: + "Enforce comparing `typeof` expressions against valid strings", + recommended: true, + url: "https://eslint.org/docs/latest/rules/valid-typeof", + }, + + hasSuggestions: true, + + schema: [ + { + type: "object", + properties: { + requireStringLiterals: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + messages: { + invalidValue: "Invalid typeof comparison value.", + notString: "Typeof comparisons should be to string literals.", + suggestString: 'Use `"{{type}}"` instead of `{{type}}`.', + }, + }, + + create(context) { + const VALID_TYPES = new Set([ + "symbol", + "undefined", + "object", + "boolean", + "number", + "string", + "function", + "bigint", + ]), + OPERATORS = new Set(["==", "===", "!=", "!=="]); + const sourceCode = context.sourceCode; + const [{ requireStringLiterals }] = context.options; + + let globalScope; + + /** + * Checks whether the given node represents a reference to a global variable that is not declared in the source code. + * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables. + * @param {ASTNode} node `Identifier` node to check. + * @returns {boolean} `true` if the node is a reference to a global variable. + */ + function isReferenceToGlobalVariable(node) { + const variable = globalScope.set.get(node.name); + + return ( + variable && + variable.defs.length === 0 && + variable.references.some(ref => ref.identifier === node) + ); + } + + /** + * Determines whether a node is a typeof expression. + * @param {ASTNode} node The node + * @returns {boolean} `true` if the node is a typeof expression + */ + function isTypeofExpression(node) { + return ( + node.type === "UnaryExpression" && node.operator === "typeof" + ); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + Program(node) { + globalScope = sourceCode.getScope(node); + }, + + UnaryExpression(node) { + if (isTypeofExpression(node)) { + const { parent } = node; + + if ( + parent.type === "BinaryExpression" && + OPERATORS.has(parent.operator) + ) { + const sibling = + parent.left === node ? parent.right : parent.left; + + if ( + sibling.type === "Literal" || + astUtils.isStaticTemplateLiteral(sibling) + ) { + const value = + sibling.type === "Literal" + ? sibling.value + : sibling.quasis[0].value.cooked; + + if (!VALID_TYPES.has(value)) { + context.report({ + node: sibling, + messageId: "invalidValue", + }); + } + } else if ( + sibling.type === "Identifier" && + sibling.name === "undefined" && + isReferenceToGlobalVariable(sibling) + ) { + context.report({ + node: sibling, + messageId: requireStringLiterals + ? "notString" + : "invalidValue", + suggest: [ + { + messageId: "suggestString", + data: { type: "undefined" }, + fix(fixer) { + return fixer.replaceText( + sibling, + '"undefined"', + ); + }, + }, + ], + }); + } else if ( + requireStringLiterals && + !isTypeofExpression(sibling) + ) { + context.report({ + node: sibling, + messageId: "notString", + }); + } + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/vars-on-top.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/vars-on-top.js new file mode 100644 index 00000000..c790ccbd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/vars-on-top.js @@ -0,0 +1,165 @@ +/** + * @fileoverview Rule to enforce var declarations are only at the top of a function. + * @author Danny Fritz + * @author Gyandeep Singh + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + docs: { + description: + "Require `var` declarations be placed at the top of their containing scope", + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/vars-on-top", + }, + + schema: [], + messages: { + top: "All 'var' declarations must be at the top of the function scope.", + }, + }, + + create(context) { + //-------------------------------------------------------------------------- + // Helpers + //-------------------------------------------------------------------------- + + /** + * Has AST suggesting a directive. + * @param {ASTNode} node any node + * @returns {boolean} whether the given node structurally represents a directive + */ + function looksLikeDirective(node) { + return ( + node.type === "ExpressionStatement" && + node.expression.type === "Literal" && + typeof node.expression.value === "string" + ); + } + + /** + * Check to see if its a ES6 import declaration + * @param {ASTNode} node any node + * @returns {boolean} whether the given node represents a import declaration + */ + function looksLikeImport(node) { + return ( + node.type === "ImportDeclaration" || + node.type === "ImportSpecifier" || + node.type === "ImportDefaultSpecifier" || + node.type === "ImportNamespaceSpecifier" + ); + } + + /** + * Checks whether a given node is a variable declaration or not. + * @param {ASTNode} node any node + * @returns {boolean} `true` if the node is a variable declaration. + */ + function isVariableDeclaration(node) { + return ( + node.type === "VariableDeclaration" || + (node.type === "ExportNamedDeclaration" && + node.declaration && + node.declaration.type === "VariableDeclaration") + ); + } + + /** + * Checks whether this variable is on top of the block body + * @param {ASTNode} node The node to check + * @param {ASTNode[]} statements collection of ASTNodes for the parent node block + * @returns {boolean} True if var is on top otherwise false + */ + function isVarOnTop(node, statements) { + const l = statements.length; + let i = 0; + + // Skip over directives and imports. Static blocks don't have either. + if (node.parent.type !== "StaticBlock") { + for (; i < l; ++i) { + if ( + !looksLikeDirective(statements[i]) && + !looksLikeImport(statements[i]) + ) { + break; + } + } + } + + for (; i < l; ++i) { + if (!isVariableDeclaration(statements[i])) { + return false; + } + if (statements[i] === node) { + return true; + } + } + + return false; + } + + /** + * Checks whether variable is on top at the global level + * @param {ASTNode} node The node to check + * @param {ASTNode} parent Parent of the node + * @returns {void} + */ + function globalVarCheck(node, parent) { + if (!isVarOnTop(node, parent.body)) { + context.report({ node, messageId: "top" }); + } + } + + /** + * Checks whether variable is on top at functional block scope level + * @param {ASTNode} node The node to check + * @returns {void} + */ + function blockScopeVarCheck(node) { + const { parent } = node; + + if ( + parent.type === "BlockStatement" && + /Function/u.test(parent.parent.type) && + isVarOnTop(node, parent.body) + ) { + return; + } + + if ( + parent.type === "StaticBlock" && + isVarOnTop(node, parent.body) + ) { + return; + } + + context.report({ node, messageId: "top" }); + } + + //-------------------------------------------------------------------------- + // Public API + //-------------------------------------------------------------------------- + + return { + "VariableDeclaration[kind='var']"(node) { + if (node.parent.type === "ExportNamedDeclaration") { + globalVarCheck(node.parent, node.parent.parent); + } else if (node.parent.type === "Program") { + globalVarCheck(node, node.parent); + } else { + blockScopeVarCheck(node); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-iife.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-iife.js new file mode 100644 index 00000000..3ba53a15 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-iife.js @@ -0,0 +1,238 @@ +/** + * @fileoverview Rule to flag when IIFE is not wrapped in parens + * @author Ilya Volodin + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const astUtils = require("./utils/ast-utils"); +const eslintUtils = require("@eslint-community/eslint-utils"); + +//---------------------------------------------------------------------- +// Helpers +//---------------------------------------------------------------------- + +/** + * Check if the given node is callee of a `NewExpression` node + * @param {ASTNode} node node to check + * @returns {boolean} True if the node is callee of a `NewExpression` node + * @private + */ +function isCalleeOfNewExpression(node) { + const maybeCallee = + node.parent.type === "ChainExpression" ? node.parent : node; + + return ( + maybeCallee.parent.type === "NewExpression" && + maybeCallee.parent.callee === maybeCallee + ); +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "wrap-iife", + url: "https://eslint.style/rules/wrap-iife", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require parentheses around immediate `function` invocations", + recommended: false, + url: "https://eslint.org/docs/latest/rules/wrap-iife", + }, + + schema: [ + { + enum: ["outside", "inside", "any"], + }, + { + type: "object", + properties: { + functionPrototypeMethods: { + type: "boolean", + default: false, + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + messages: { + wrapInvocation: + "Wrap an immediate function invocation in parentheses.", + wrapExpression: "Wrap only the function expression in parens.", + moveInvocation: + "Move the invocation into the parens that contain the function.", + }, + }, + + create(context) { + const style = context.options[0] || "outside"; + const includeFunctionPrototypeMethods = + context.options[1] && context.options[1].functionPrototypeMethods; + + const sourceCode = context.sourceCode; + + /** + * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if() + * @param {ASTNode} node node to evaluate + * @returns {boolean} True if it is wrapped in any parens + * @private + */ + function isWrappedInAnyParens(node) { + return astUtils.isParenthesised(sourceCode, node); + } + + /** + * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count + * @param {ASTNode} node node to evaluate + * @returns {boolean} True if it is wrapped in grouping parens + * @private + */ + function isWrappedInGroupingParens(node) { + return eslintUtils.isParenthesized(1, node, sourceCode); + } + + /** + * Get the function node from an IIFE + * @param {ASTNode} node node to evaluate + * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist + */ + function getFunctionNodeFromIIFE(node) { + const callee = astUtils.skipChainExpression(node.callee); + + if (callee.type === "FunctionExpression") { + return callee; + } + + if ( + includeFunctionPrototypeMethods && + callee.type === "MemberExpression" && + callee.object.type === "FunctionExpression" && + (astUtils.getStaticPropertyName(callee) === "call" || + astUtils.getStaticPropertyName(callee) === "apply") + ) { + return callee.object; + } + + return null; + } + + return { + CallExpression(node) { + const innerNode = getFunctionNodeFromIIFE(node); + + if (!innerNode) { + return; + } + + const isCallExpressionWrapped = isWrappedInAnyParens(node), + isFunctionExpressionWrapped = + isWrappedInAnyParens(innerNode); + + if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) { + context.report({ + node, + messageId: "wrapInvocation", + fix(fixer) { + const nodeToSurround = + style === "inside" ? innerNode : node; + + return fixer.replaceText( + nodeToSurround, + `(${sourceCode.getText(nodeToSurround)})`, + ); + }, + }); + } else if (style === "inside" && !isFunctionExpressionWrapped) { + context.report({ + node, + messageId: "wrapExpression", + fix(fixer) { + // The outer call expression will always be wrapped at this point. + + if ( + isWrappedInGroupingParens(node) && + !isCalleeOfNewExpression(node) + ) { + /* + * Parenthesize the function expression and remove unnecessary grouping parens around the call expression. + * Replace the range between the end of the function expression and the end of the call expression. + * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`. + */ + + const parenAfter = + sourceCode.getTokenAfter(node); + + return fixer.replaceTextRange( + [innerNode.range[1], parenAfter.range[1]], + `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`, + ); + } + + /* + * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens. + * These parens cannot be removed, so just parenthesize the function expression. + */ + + return fixer.replaceText( + innerNode, + `(${sourceCode.getText(innerNode)})`, + ); + }, + }); + } else if (style === "outside" && !isCallExpressionWrapped) { + context.report({ + node, + messageId: "moveInvocation", + fix(fixer) { + /* + * The inner function expression will always be wrapped at this point. + * It's only necessary to replace the range between the end of the function expression + * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)` + * should get replaced with `(bar))`. + */ + const parenAfter = + sourceCode.getTokenAfter(innerNode); + + return fixer.replaceTextRange( + [parenAfter.range[0], node.range[1]], + `${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`, + ); + }, + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-regex.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-regex.js new file mode 100644 index 00000000..def392a4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/wrap-regex.js @@ -0,0 +1,91 @@ +/** + * @fileoverview Rule to flag when regex literals are not wrapped in parens + * @author Matt DuVall + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "wrap-regex", + url: "https://eslint.style/rules/wrap-regex", + }, + }, + ], + }, + type: "layout", + + docs: { + description: "Require parenthesis around regex literals", + recommended: false, + url: "https://eslint.org/docs/latest/rules/wrap-regex", + }, + + schema: [], + fixable: "code", + + messages: { + requireParens: + "Wrap the regexp literal in parens to disambiguate the slash.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + return { + Literal(node) { + const token = sourceCode.getFirstToken(node), + nodeType = token.type; + + if (nodeType === "RegularExpression") { + const beforeToken = sourceCode.getTokenBefore(node); + const afterToken = sourceCode.getTokenAfter(node); + const { parent } = node; + + if ( + parent.type === "MemberExpression" && + parent.object === node && + !( + beforeToken && + beforeToken.value === "(" && + afterToken && + afterToken.value === ")" + ) + ) { + context.report({ + node, + messageId: "requireParens", + fix: fixer => + fixer.replaceText( + node, + `(${sourceCode.getText(node)})`, + ), + }); + } + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yield-star-spacing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yield-star-spacing.js new file mode 100644 index 00000000..d5670fd1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yield-star-spacing.js @@ -0,0 +1,158 @@ +/** + * @fileoverview Rule to check the spacing around the * in yield* expressions. + * @author Bryan Smith + * @deprecated in ESLint v8.53.0 + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + deprecated: { + message: "Formatting rules are being moved out of ESLint core.", + url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", + deprecatedSince: "8.53.0", + availableUntil: "11.0.0", + replacedBy: [ + { + message: + "ESLint Stylistic now maintains deprecated stylistic core rules.", + url: "https://eslint.style/guide/migration", + plugin: { + name: "@stylistic/eslint-plugin", + url: "https://eslint.style", + }, + rule: { + name: "yield-star-spacing", + url: "https://eslint.style/rules/yield-star-spacing", + }, + }, + ], + }, + type: "layout", + + docs: { + description: + "Require or disallow spacing around the `*` in `yield*` expressions", + recommended: false, + url: "https://eslint.org/docs/latest/rules/yield-star-spacing", + }, + + fixable: "whitespace", + + schema: [ + { + oneOf: [ + { + enum: ["before", "after", "both", "neither"], + }, + { + type: "object", + properties: { + before: { type: "boolean" }, + after: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + }, + ], + messages: { + missingBefore: "Missing space before *.", + missingAfter: "Missing space after *.", + unexpectedBefore: "Unexpected space before *.", + unexpectedAfter: "Unexpected space after *.", + }, + }, + + create(context) { + const sourceCode = context.sourceCode; + + const mode = (function (option) { + if (!option || typeof option === "string") { + return { + before: { before: true, after: false }, + after: { before: false, after: true }, + both: { before: true, after: true }, + neither: { before: false, after: false }, + }[option || "after"]; + } + return option; + })(context.options[0]); + + /** + * Checks the spacing between two tokens before or after the star token. + * @param {string} side Either "before" or "after". + * @param {Token} leftToken `function` keyword token if side is "before", or + * star token if side is "after". + * @param {Token} rightToken Star token if side is "before", or identifier + * token if side is "after". + * @returns {void} + */ + function checkSpacing(side, leftToken, rightToken) { + if ( + sourceCode.isSpaceBetween(leftToken, rightToken) !== mode[side] + ) { + const after = leftToken.value === "*"; + const spaceRequired = mode[side]; + const node = after ? leftToken : rightToken; + let messageId; + + if (spaceRequired) { + messageId = + side === "before" ? "missingBefore" : "missingAfter"; + } else { + messageId = + side === "before" + ? "unexpectedBefore" + : "unexpectedAfter"; + } + + context.report({ + node, + messageId, + fix(fixer) { + if (spaceRequired) { + if (after) { + return fixer.insertTextAfter(node, " "); + } + return fixer.insertTextBefore(node, " "); + } + return fixer.removeRange([ + leftToken.range[1], + rightToken.range[0], + ]); + }, + }); + } + } + + /** + * Enforces the spacing around the star if node is a yield* expression. + * @param {ASTNode} node A yield expression node. + * @returns {void} + */ + function checkExpression(node) { + if (!node.delegate) { + return; + } + + const tokens = sourceCode.getFirstTokens(node, 3); + const yieldToken = tokens[0]; + const starToken = tokens[1]; + const nextToken = tokens[2]; + + checkSpacing("before", yieldToken, starToken); + checkSpacing("after", starToken, nextToken); + } + + return { + YieldExpression: checkExpression, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yoda.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yoda.js new file mode 100644 index 00000000..1ee74712 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/rules/yoda.js @@ -0,0 +1,362 @@ +/** + * @fileoverview Rule to require or disallow yoda comparisons + * @author Nicholas C. Zakas + */ +"use strict"; + +//-------------------------------------------------------------------------- +// Requirements +//-------------------------------------------------------------------------- + +const astUtils = require("./utils/ast-utils"); + +//-------------------------------------------------------------------------- +// Helpers +//-------------------------------------------------------------------------- + +/** + * Determines whether an operator is a comparison operator. + * @param {string} operator The operator to check. + * @returns {boolean} Whether or not it is a comparison operator. + */ +function isComparisonOperator(operator) { + return /^(?:==|===|!=|!==|<|>|<=|>=)$/u.test(operator); +} + +/** + * Determines whether an operator is an equality operator. + * @param {string} operator The operator to check. + * @returns {boolean} Whether or not it is an equality operator. + */ +function isEqualityOperator(operator) { + return /^(?:==|===)$/u.test(operator); +} + +/** + * Determines whether an operator is one used in a range test. + * Allowed operators are `<` and `<=`. + * @param {string} operator The operator to check. + * @returns {boolean} Whether the operator is used in range tests. + */ +function isRangeTestOperator(operator) { + return ["<", "<="].includes(operator); +} + +/** + * Determines whether a non-Literal node is a negative number that should be + * treated as if it were a single Literal node. + * @param {ASTNode} node Node to test. + * @returns {boolean} True if the node is a negative number that looks like a + * real literal and should be treated as such. + */ +function isNegativeNumericLiteral(node) { + return ( + node.type === "UnaryExpression" && + node.operator === "-" && + node.prefix && + astUtils.isNumericLiteral(node.argument) + ); +} + +/** + * Determines whether a non-Literal node should be treated as a single Literal node. + * @param {ASTNode} node Node to test + * @returns {boolean} True if the node should be treated as a single Literal node. + */ +function looksLikeLiteral(node) { + return ( + isNegativeNumericLiteral(node) || astUtils.isStaticTemplateLiteral(node) + ); +} + +/** + * Attempts to derive a Literal node from nodes that are treated like literals. + * @param {ASTNode} node Node to normalize. + * @returns {ASTNode} One of the following options. + * 1. The original node if the node is already a Literal + * 2. A normalized Literal node with the negative number as the value if the + * node represents a negative number literal. + * 3. A normalized Literal node with the string as the value if the node is + * a Template Literal without expression. + * 4. Otherwise `null`. + */ +function getNormalizedLiteral(node) { + if (node.type === "Literal") { + return node; + } + + if (isNegativeNumericLiteral(node)) { + return { + type: "Literal", + value: -node.argument.value, + raw: `-${node.argument.value}`, + }; + } + + if (astUtils.isStaticTemplateLiteral(node)) { + return { + type: "Literal", + value: node.quasis[0].value.cooked, + raw: node.quasis[0].value.raw, + }; + } + + return null; +} + +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ + +/** @type {import('../types').Rule.RuleModule} */ +module.exports = { + meta: { + type: "suggestion", + + defaultOptions: [ + "never", + { + exceptRange: false, + onlyEquality: false, + }, + ], + + docs: { + description: 'Require or disallow "Yoda" conditions', + recommended: false, + frozen: true, + url: "https://eslint.org/docs/latest/rules/yoda", + }, + + schema: [ + { + enum: ["always", "never"], + }, + { + type: "object", + properties: { + exceptRange: { + type: "boolean", + }, + onlyEquality: { + type: "boolean", + }, + }, + additionalProperties: false, + }, + ], + + fixable: "code", + messages: { + expected: + "Expected literal to be on the {{expectedSide}} side of {{operator}}.", + }, + }, + + create(context) { + const [when, { exceptRange, onlyEquality }] = context.options; + const always = when === "always"; + const sourceCode = context.sourceCode; + + /** + * Determines whether node represents a range test. + * A range test is a "between" test like `(0 <= x && x < 1)` or an "outside" + * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and + * both operators must be `<` or `<=`. Finally, the literal on the left side + * must be less than or equal to the literal on the right side so that the + * test makes any sense. + * @param {ASTNode} node LogicalExpression node to test. + * @returns {boolean} Whether node is a range test. + */ + function isRangeTest(node) { + const left = node.left, + right = node.right; + + /** + * Determines whether node is of the form `0 <= x && x < 1`. + * @returns {boolean} Whether node is a "between" range test. + */ + function isBetweenTest() { + if ( + node.operator === "&&" && + astUtils.isSameReference(left.right, right.left) + ) { + const leftLiteral = getNormalizedLiteral(left.left); + const rightLiteral = getNormalizedLiteral(right.right); + + if (leftLiteral === null && rightLiteral === null) { + return false; + } + + if (rightLiteral === null || leftLiteral === null) { + return true; + } + + if (leftLiteral.value <= rightLiteral.value) { + return true; + } + } + return false; + } + + /** + * Determines whether node is of the form `x < 0 || 1 <= x`. + * @returns {boolean} Whether node is an "outside" range test. + */ + function isOutsideTest() { + if ( + node.operator === "||" && + astUtils.isSameReference(left.left, right.right) + ) { + const leftLiteral = getNormalizedLiteral(left.right); + const rightLiteral = getNormalizedLiteral(right.left); + + if (leftLiteral === null && rightLiteral === null) { + return false; + } + + if (rightLiteral === null || leftLiteral === null) { + return true; + } + + if (leftLiteral.value <= rightLiteral.value) { + return true; + } + } + + return false; + } + + /** + * Determines whether node is wrapped in parentheses. + * @returns {boolean} Whether node is preceded immediately by an open + * paren token and followed immediately by a close + * paren token. + */ + function isParenWrapped() { + return astUtils.isParenthesised(sourceCode, node); + } + + return ( + node.type === "LogicalExpression" && + left.type === "BinaryExpression" && + right.type === "BinaryExpression" && + isRangeTestOperator(left.operator) && + isRangeTestOperator(right.operator) && + (isBetweenTest() || isOutsideTest()) && + isParenWrapped() + ); + } + + const OPERATOR_FLIP_MAP = { + "===": "===", + "!==": "!==", + "==": "==", + "!=": "!=", + "<": ">", + ">": "<", + "<=": ">=", + ">=": "<=", + }; + + /** + * Returns a string representation of a BinaryExpression node with its sides/operator flipped around. + * @param {ASTNode} node The BinaryExpression node + * @returns {string} A string representation of the node with the sides and operator flipped + */ + function getFlippedString(node) { + const operatorToken = sourceCode.getFirstTokenBetween( + node.left, + node.right, + token => token.value === node.operator, + ); + const lastLeftToken = sourceCode.getTokenBefore(operatorToken); + const firstRightToken = sourceCode.getTokenAfter(operatorToken); + + const source = sourceCode.getText(); + + const leftText = source.slice( + node.range[0], + lastLeftToken.range[1], + ); + const textBeforeOperator = source.slice( + lastLeftToken.range[1], + operatorToken.range[0], + ); + const textAfterOperator = source.slice( + operatorToken.range[1], + firstRightToken.range[0], + ); + const rightText = source.slice( + firstRightToken.range[0], + node.range[1], + ); + + const tokenBefore = sourceCode.getTokenBefore(node); + const tokenAfter = sourceCode.getTokenAfter(node); + let prefix = ""; + let suffix = ""; + + if ( + tokenBefore && + tokenBefore.range[1] === node.range[0] && + !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken) + ) { + prefix = " "; + } + + if ( + tokenAfter && + node.range[1] === tokenAfter.range[0] && + !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter) + ) { + suffix = " "; + } + + return ( + prefix + + rightText + + textBeforeOperator + + OPERATOR_FLIP_MAP[operatorToken.value] + + textAfterOperator + + leftText + + suffix + ); + } + + //-------------------------------------------------------------------------- + // Public + //-------------------------------------------------------------------------- + + return { + BinaryExpression(node) { + const expectedLiteral = always ? node.left : node.right; + const expectedNonLiteral = always ? node.right : node.left; + + // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error. + if ( + (expectedNonLiteral.type === "Literal" || + looksLikeLiteral(expectedNonLiteral)) && + !( + expectedLiteral.type === "Literal" || + looksLikeLiteral(expectedLiteral) + ) && + !(!isEqualityOperator(node.operator) && onlyEquality) && + isComparisonOperator(node.operator) && + !(exceptRange && isRangeTest(node.parent)) + ) { + context.report({ + node, + messageId: "expected", + data: { + operator: node.operator, + expectedSide: always ? "left" : "right", + }, + fix: fixer => + fixer.replaceText(node, getFlippedString(node)), + }); + } + }, + }; + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/parser-service.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/parser-service.js new file mode 100644 index 00000000..7aab036e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/parser-service.js @@ -0,0 +1,64 @@ +/** + * @fileoverview ESLint Parser + * @author Nicholas C. Zakas + */ +/* eslint class-methods-use-this: off -- Anticipate future constructor arguments. */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Types +//----------------------------------------------------------------------------- + +/** @typedef {import("../linter/vfile.js").VFile} VFile */ +/** @typedef {import("@eslint/core").Language} Language */ +/** @typedef {import("@eslint/core").LanguageOptions} LanguageOptions */ + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * The parser for ESLint. + */ +class ParserService { + /** + * Parses the given file synchronously. + * @param {VFile} file The file to parse. + * @param {{language:Language,languageOptions:LanguageOptions}} config The configuration to use. + * @returns {Object} An object with the parsed source code or errors. + * @throws {Error} If the parser returns a promise. + */ + parseSync(file, config) { + const { language, languageOptions } = config; + const result = language.parse(file, { languageOptions }); + + if (typeof result.then === "function") { + throw new Error("Unsupported: Language parser returned a promise."); + } + + if (result.ok) { + return { + ok: true, + sourceCode: language.createSourceCode(file, result, { + languageOptions, + }), + }; + } + + // if we made it to here there was an error + return { + ok: false, + errors: result.errors.map(error => ({ + ruleId: null, + fatal: true, + severity: 2, + message: `Parsing error: ${error.message}`, + line: error.line, + column: error.column, + })), + }; + } +} + +module.exports = { ParserService }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/processor-service.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/processor-service.js new file mode 100644 index 00000000..6f079d7b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/processor-service.js @@ -0,0 +1,100 @@ +/** + * @fileoverview ESLint Processor Service + * @author Nicholas C. Zakas + */ +/* eslint class-methods-use-this: off -- Anticipate future constructor arguments. */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const path = require("node:path"); +const { VFile } = require("../linter/vfile.js"); + +//----------------------------------------------------------------------------- +// Types +//----------------------------------------------------------------------------- + +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../linter/vfile.js").VFile} VFile */ +/** @typedef {import("@eslint/core").Language} Language */ +/** @typedef {import("eslint").Linter.Processor} Processor */ + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * The service that applies processors to files. + */ +class ProcessorService { + /** + * Preprocesses the given file synchronously. + * @param {VFile} file The file to preprocess. + * @param {{processor:Processor}} config The configuration to use. + * @returns {{ok:boolean, files?: Array, errors?: Array}} An array of preprocessed files or errors. + * @throws {Error} If the preprocessor returns a promise. + */ + preprocessSync(file, config) { + const { processor } = config; + let blocks; + + try { + blocks = processor.preprocess(file.rawBody, file.path); + } catch (ex) { + // If the message includes a leading line number, strip it: + const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`; + + return { + ok: false, + errors: [ + { + ruleId: null, + fatal: true, + severity: 2, + message, + line: ex.lineNumber, + column: ex.column, + }, + ], + }; + } + + if (typeof blocks.then === "function") { + throw new Error("Unsupported: Preprocessor returned a promise."); + } + + return { + ok: true, + files: blocks.map((block, i) => { + // Legacy behavior: return the block as a string + if (typeof block === "string") { + return block; + } + + const filePath = path.join(file.path, `${i}_${block.filename}`); + + return new VFile(filePath, block.text, { + physicalPath: file.physicalPath, + }); + }), + }; + } + + /** + * Postprocesses the given messages synchronously. + * @param {VFile} file The file to postprocess. + * @param {LintMessage[][]} messages The messages to postprocess. + * @param {{processor:Processor}} config The configuration to use. + * @returns {LintMessage[]} The postprocessed messages. + */ + postprocessSync(file, messages, config) { + const { processor } = config; + + return processor.postprocess(messages, file.path); + } +} + +module.exports = { ProcessorService }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/suppressions-service.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/suppressions-service.js new file mode 100644 index 00000000..b5616eb4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/suppressions-service.js @@ -0,0 +1,304 @@ +/** + * @fileoverview Manages the suppressed violations. + * @author Iacovos Constantinou + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const fs = require("node:fs"); +const path = require("node:path"); +const { calculateStatsPerFile } = require("../shared/message-counts"); +const stringify = require("json-stable-stringify-without-jsonify"); + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +// For VSCode IntelliSense +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../types").ESLint.LintResult} LintResult */ +/** @typedef {Record>} SuppressedViolations */ + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * Manages the suppressed violations. + */ +class SuppressionsService { + static DEFAULT_SUPPRESSIONS_FILENAME = "eslint-suppressions.json"; + + filePath = ""; + cwd = ""; + + /** + * Creates a new instance of SuppressionsService. + * @param {Object} options The options. + * @param {string} [options.filePath] The location of the suppressions file. + * @param {string} [options.cwd] The current working directory. + */ + constructor({ filePath, cwd }) { + this.filePath = filePath; + this.cwd = cwd; + } + + /** + * Updates the suppressions file based on the current violations and the provided rules. + * If no rules are provided, all violations are suppressed. + * @param {LintResult[]|undefined} results The lint results. + * @param {string[]|undefined} rules The rules to suppress. + * @returns {Promise} + */ + async suppress(results, rules) { + const suppressions = await this.load(); + + for (const result of results) { + const relativeFilePath = this.getRelativeFilePath(result.filePath); + const violationsByRule = SuppressionsService.countViolationsByRule( + result.messages, + ); + + for (const ruleId in violationsByRule) { + if (rules && !rules.includes(ruleId)) { + continue; + } + + suppressions[relativeFilePath] ??= {}; + suppressions[relativeFilePath][ruleId] = + violationsByRule[ruleId]; + } + } + + return this.save(suppressions); + } + + /** + * Removes old, unused suppressions for violations that do not occur anymore. + * @param {LintResult[]} results The lint results. + * @returns {Promise} No return value. + */ + async prune(results) { + const suppressions = await this.load(); + const { unused } = this.applySuppressions(results, suppressions); + + for (const file in unused) { + if (!suppressions[file]) { + continue; + } + + for (const rule in unused[file]) { + if (!suppressions[file][rule]) { + continue; + } + + const suppressionsCount = suppressions[file][rule].count; + const violationsCount = unused[file][rule].count; + + if (suppressionsCount === violationsCount) { + // Remove unused rules + delete suppressions[file][rule]; + } else { + // Update the count to match the new number of violations + suppressions[file][rule].count -= violationsCount; + } + } + + // Cleanup files with no rules + if (Object.keys(suppressions[file]).length === 0) { + delete suppressions[file]; + } + } + + for (const file of Object.keys(suppressions)) { + const absolutePath = path.resolve(this.cwd, file); + + if (!fs.existsSync(absolutePath)) { + delete suppressions[file]; + } + } + + return this.save(suppressions); + } + + /** + * Checks the provided suppressions against the lint results. + * + * For each file, counts the number of violations per rule. + * For each rule in each file, compares the number of violations against the counter from the suppressions file. + * If the number of violations is less or equal to the counter, messages are moved to `LintResult#suppressedMessages` and ignored. + * Otherwise, all violations are reported as usual. + * @param {LintResult[]} results The lint results. + * @param {SuppressedViolations} suppressions The suppressions. + * @returns {{ + * results: LintResult[], + * unused: SuppressedViolations + * }} The updated results and the unused suppressions. + */ + applySuppressions(results, suppressions) { + /** + * We copy the results to avoid modifying the original objects + * We remove only result messages that are matched and hence suppressed + * We leave the rest untouched to minimize the risk of losing parts of the original data + */ + const filtered = structuredClone(results); + const unused = {}; + + for (const result of filtered) { + const relativeFilePath = this.getRelativeFilePath(result.filePath); + + if (!suppressions[relativeFilePath]) { + continue; + } + + const violationsByRule = SuppressionsService.countViolationsByRule( + result.messages, + ); + let wasSuppressed = false; + + for (const ruleId in violationsByRule) { + if (!suppressions[relativeFilePath][ruleId]) { + continue; + } + + const suppressionsCount = + suppressions[relativeFilePath][ruleId].count; + const violationsCount = violationsByRule[ruleId].count; + + // Suppress messages if the number of violations is less or equal to the suppressions count + if (violationsCount <= suppressionsCount) { + SuppressionsService.suppressMessagesByRule(result, ruleId); + wasSuppressed = true; + } + + // Update the count to match the new number of violations, otherwise remove the rule entirely + if (violationsCount < suppressionsCount) { + unused[relativeFilePath] ??= {}; + unused[relativeFilePath][ruleId] ??= {}; + unused[relativeFilePath][ruleId].count = + suppressionsCount - violationsCount; + } + } + + // Mark as unused all the suppressions that were not matched against a rule + for (const ruleId in suppressions[relativeFilePath]) { + if (violationsByRule[ruleId]) { + continue; + } + + unused[relativeFilePath] ??= {}; + unused[relativeFilePath][ruleId] = + suppressions[relativeFilePath][ruleId]; + } + + // Recalculate stats if messages were suppressed + if (wasSuppressed) { + Object.assign(result, calculateStatsPerFile(result.messages)); + } + } + + return { + results: filtered, + unused, + }; + } + + /** + * Loads the suppressions file. + * @throws {Error} If the suppressions file cannot be parsed. + * @returns {Promise} The suppressions. + */ + async load() { + try { + const data = await fs.promises.readFile(this.filePath, "utf8"); + + return JSON.parse(data); + } catch (err) { + if (err.code === "ENOENT") { + return {}; + } + throw new Error( + `Failed to parse suppressions file at ${this.filePath}`, + { + cause: err, + }, + ); + } + } + + /** + * Updates the suppressions file. + * @param {SuppressedViolations} suppressions The suppressions to save. + * @returns {Promise} + * @private + */ + save(suppressions) { + return fs.promises.writeFile( + this.filePath, + stringify(suppressions, { space: 2 }), + ); + } + + /** + * Counts the violations by rule, ignoring warnings. + * @param {LintMessage[]} messages The messages to count. + * @returns {Record} The number of violations by rule. + */ + static countViolationsByRule(messages) { + return messages.reduce((totals, message) => { + if (message.severity === 2 && message.ruleId) { + totals[message.ruleId] ??= { count: 0 }; + totals[message.ruleId].count++; + } + return totals; + }, {}); + } + + /** + * Returns the relative path of a file to the current working directory. + * Always in POSIX format for consistency and interoperability. + * @param {string} filePath The file path. + * @returns {string} The relative file path. + */ + getRelativeFilePath(filePath) { + return path + .relative(this.cwd, filePath) + .split(path.sep) + .join(path.posix.sep); + } + + /** + * Moves the messages matching the rule to `LintResult#suppressedMessages` and updates the stats. + * @param {LintResult} result The result to update. + * @param {string} ruleId The rule to suppress. + * @returns {void} + */ + static suppressMessagesByRule(result, ruleId) { + const suppressedMessages = result.messages.filter( + message => message.ruleId === ruleId, + ); + + result.suppressedMessages = result.suppressedMessages.concat( + suppressedMessages.map(message => { + message.suppressions = [ + { + kind: "file", + justification: "", + }, + ]; + + return message; + }), + ); + + result.messages = result.messages.filter( + message => message.ruleId !== ruleId, + ); + } +} + +module.exports = { SuppressionsService }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/warning-service.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/warning-service.js new file mode 100644 index 00000000..a8fca1a5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/services/warning-service.js @@ -0,0 +1,87 @@ +/** + * @fileoverview Emits warnings for ESLint. + * @author Francesco Trotta + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * A service that emits warnings for ESLint. + */ +class WarningService { + /** + * Creates a new instance of the service. + * @param {{ emitWarning?: ((warning: string, type: string) => void) | undefined }} [options] A function called internally to emit warnings using API provided by the runtime. + */ + constructor({ + emitWarning = globalThis.process?.emitWarning ?? (() => {}), + } = {}) { + this.emitWarning = emitWarning; + } + + /** + * Emits a warning when circular fixes are detected while fixing a file. + * This method is used by the Linter and is safe to call outside Node.js. + * @param {string} filename The name of the file being fixed. + * @returns {void} + */ + emitCircularFixesWarning(filename) { + this.emitWarning( + `Circular fixes detected while fixing ${filename}. It is likely that you have conflicting rules in your configuration.`, + "ESLintCircularFixesWarning", + ); + } + + /** + * Emits a warning when an empty config file has been loaded. + * @param {string} configFilePath The path to the config file. + * @returns {void} + */ + emitEmptyConfigWarning(configFilePath) { + this.emitWarning( + `Running ESLint with an empty config (from ${configFilePath}). Please double-check that this is what you want. If you want to run ESLint with an empty config, export [{}] to remove this warning.`, + "ESLintEmptyConfigWarning", + ); + } + + /** + * Emits a warning when an ".eslintignore" file is found. + * @returns {void} + */ + emitESLintIgnoreWarning() { + this.emitWarning( + 'The ".eslintignore" file is no longer supported. Switch to using the "ignores" property in "eslint.config.js": https://eslint.org/docs/latest/use/configure/migration-guide#ignore-files', + "ESLintIgnoreWarning", + ); + } + + /** + * Emits a warning when an inactive flag is used. + * This method is used by the Linter and is safe to call outside Node.js. + * @param {string} flag The name of the flag. + * @param {string} message The warning message. + * @returns {void} + */ + emitInactiveFlagWarning(flag, message) { + this.emitWarning(message, `ESLintInactiveFlag_${flag}`); + } + + /** + * Emits a warning when a suboptimal concurrency setting is detected. + * Currently, this is only used to warn when the net linting ratio is low. + * @param {string} notice A notice about how to improve performance. + * @returns {void} + */ + emitPoorConcurrencyWarning(notice) { + this.emitWarning( + `You may ${notice} to improve performance.`, + "ESLintPoorConcurrencyWarning", + ); + } +} + +module.exports = { WarningService }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ajv.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ajv.js new file mode 100644 index 00000000..5c5c41bd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ajv.js @@ -0,0 +1,34 @@ +/** + * @fileoverview The instance of Ajv validator. + * @author Evgeny Poberezkin + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const Ajv = require("ajv"), + metaSchema = require("ajv/lib/refs/json-schema-draft-04.json"); + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = (additionalOptions = {}) => { + const ajv = new Ajv({ + meta: false, + useDefaults: true, + validateSchema: false, + missingRefs: "ignore", + verbose: true, + schemaId: "auto", + ...additionalOptions, + }); + + ajv.addMetaSchema(metaSchema); + // eslint-disable-next-line no-underscore-dangle -- Ajv's API + ajv._opts.defaultMeta = metaSchema.id; + + return ajv; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/assert.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/assert.js new file mode 100644 index 00000000..4dcaf41f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/assert.js @@ -0,0 +1,21 @@ +/** + * @fileoverview Assertion utilities equivalent to the Node.js node:asserts module. + * @author Josh Goldberg + */ + +"use strict"; + +/** + * Throws an error if the input is not truthy. + * @param {unknown} value The input that is checked for being truthy. + * @param {string} message Message to throw if the input is not truthy. + * @returns {void} + * @throws {Error} When the condition is not truthy. + */ +function ok(value, message = "Assertion failed.") { + if (!value) { + throw new Error(message); + } +} + +module.exports = ok; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ast-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ast-utils.js new file mode 100644 index 00000000..f7736828 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/ast-utils.js @@ -0,0 +1,30 @@ +/** + * @fileoverview Common utils for AST. + * + * This file contains only shared items for core and rules. + * If you make a utility for rules, please see `../rules/utils/ast-utils.js`. + * + * @author Toru Nagashima + */ +"use strict"; + +const breakableTypePattern = + /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u; +const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u; +const shebangPattern = /^#!([^\r\n]+)/u; + +/** + * Creates a version of the `lineBreakPattern` regex with the global flag. + * Global regexes are mutable, so this needs to be a function instead of a constant. + * @returns {RegExp} A global regular expression that matches line terminators + */ +function createGlobalLinebreakMatcher() { + return new RegExp(lineBreakPattern.source, "gu"); +} + +module.exports = { + breakableTypePattern, + lineBreakPattern, + createGlobalLinebreakMatcher, + shebangPattern, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/deep-merge-arrays.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/deep-merge-arrays.js new file mode 100644 index 00000000..4a8289c4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/deep-merge-arrays.js @@ -0,0 +1,62 @@ +/** + * @fileoverview Applies default rule options + * @author JoshuaKGoldberg + */ + +"use strict"; + +/** + * Check if the variable contains an object strictly rejecting arrays + * @param {unknown} value an object + * @returns {boolean} Whether value is an object + */ +function isObjectNotArray(value) { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +/** + * Deeply merges second on top of first, creating a new {} object if needed. + * @param {T} first Base, default value. + * @param {U} second User-specified value. + * @returns {T | U | (T & U)} Merged equivalent of second on top of first. + */ +function deepMergeObjects(first, second) { + if (second === void 0) { + return first; + } + + if (!isObjectNotArray(first) || !isObjectNotArray(second)) { + return second; + } + + const result = { ...first, ...second }; + + for (const key of Object.keys(second)) { + if (Object.prototype.propertyIsEnumerable.call(first, key)) { + result[key] = deepMergeObjects(first[key], second[key]); + } + } + + return result; +} + +/** + * Deeply merges second on top of first, creating a new [] array if needed. + * @param {T[]} first Base, default values. + * @param {U[]} second User-specified values. + * @returns {(T | U | (T & U))[]} Merged equivalent of second on top of first. + */ +function deepMergeArrays(first, second) { + if (!first || !second) { + return second || first || []; + } + + return [ + ...first.map((value, i) => + deepMergeObjects(value, i < second.length ? second[i] : void 0), + ), + ...second.slice(first.length), + ]; +} + +module.exports = { deepMergeArrays }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/directives.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/directives.js new file mode 100644 index 00000000..f1dddf59 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/directives.js @@ -0,0 +1,16 @@ +/** + * @fileoverview Common utils for directives. + * + * This file contains only shared items for directives. + * If you make a utility for rules, please see `../rules/utils/ast-utils.js`. + * + * @author gfyoung + */ +"use strict"; + +const directivesPattern = + /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u; + +module.exports = { + directivesPattern, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/flags.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/flags.js new file mode 100644 index 00000000..98c05045 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/flags.js @@ -0,0 +1,89 @@ +/** + * @fileoverview Shared flags for ESLint. + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Typedefs +//------------------------------------------------------------------------------ + +/** + * @typedef {Object} InactiveFlagData + * @property {string} description Flag description + * @property {string | null} [replacedBy] Can be either: + * - An active flag (string) that enables the same feature. + * - `null` if the feature is now enabled by default. + * - Omitted if the feature has been abandoned. + */ + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +/** + * The set of flags that change ESLint behavior with a description. + * @type {Map} + */ +const activeFlags = new Map([ + ["test_only", "Used only for testing."], + ["test_only_2", "Used only for testing."], + [ + "unstable_native_nodejs_ts_config", + "Use native Node.js to load TypeScript configuration.", + ], +]); + +/** + * The set of flags that used to be active. + * @type {Map} + */ +const inactiveFlags = new Map([ + [ + "test_only_replaced", + { + description: + "Used only for testing flags that have been replaced by other flags.", + replacedBy: "test_only", + }, + ], + [ + "test_only_enabled_by_default", + { + description: + "Used only for testing flags whose features have been enabled by default.", + replacedBy: null, + }, + ], + [ + "test_only_abandoned", + { + description: + "Used only for testing flags whose features have been abandoned.", + }, + ], +]); + +/** + * Creates a message that describes the reason the flag is inactive. + * @param {InactiveFlagData} inactiveFlagData Data for the inactive flag. + * @returns {string} Message describing the reason the flag is inactive. + */ +function getInactivityReasonMessage({ replacedBy }) { + if (typeof replacedBy === "undefined") { + return "This feature has been abandoned."; + } + + if (typeof replacedBy === "string") { + return `This flag has been renamed '${replacedBy}' to reflect its stabilization. Please use '${replacedBy}' instead.`; + } + + // null + return "This feature is now enabled by default."; +} + +module.exports = { + activeFlags, + inactiveFlags, + getInactivityReasonMessage, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/logging.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/logging.js new file mode 100644 index 00000000..3e8dfb0b --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/logging.js @@ -0,0 +1,38 @@ +/** + * @fileoverview Handle logging for ESLint + * @author Gyandeep Singh + */ + +"use strict"; + +/* eslint no-console: "off" -- Logging util */ + +/* c8 ignore next */ +module.exports = { + /** + * Cover for console.info + * @param {...any} args The elements to log. + * @returns {void} + */ + info(...args) { + console.log(...args); + }, + + /** + * Cover for console.warn + * @param {...any} args The elements to log. + * @returns {void} + */ + warn(...args) { + console.warn(...args); + }, + + /** + * Cover for console.error + * @param {...any} args The elements to log. + * @returns {void} + */ + error(...args) { + console.error(...args); + }, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/message-counts.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/message-counts.js new file mode 100644 index 00000000..a0d47e49 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/message-counts.js @@ -0,0 +1,46 @@ +/** + * @fileoverview Helpers for counting errors and warnings in lint messages. + * @author Nicholas C. Zakas + * @author Blake Sager + */ + +"use strict"; + +/** + * It will calculate the error and warning count for collection of messages per file + * @param {LintMessage[]} messages Collection of messages + * @returns {Object} Contains the stats + */ +function calculateStatsPerFile(messages) { + const stat = { + errorCount: 0, + fatalErrorCount: 0, + warningCount: 0, + fixableErrorCount: 0, + fixableWarningCount: 0, + }; + + for (let i = 0; i < messages.length; i++) { + const message = messages[i]; + + if (message.fatal || message.severity === 2) { + stat.errorCount++; + if (message.fatal) { + stat.fatalErrorCount++; + } + if (message.fix) { + stat.fixableErrorCount++; + } + } else { + stat.warningCount++; + if (message.fix) { + stat.fixableWarningCount++; + } + } + } + return stat; +} + +module.exports = { + calculateStatsPerFile, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/naming.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/naming.js new file mode 100644 index 00000000..ee6a0311 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/naming.js @@ -0,0 +1,109 @@ +/** + * @fileoverview Common helpers for naming of plugins, formatters and configs + */ + +"use strict"; + +const NAMESPACE_REGEX = /^@.*\//u; + +/** + * Brings package name to correct format based on prefix + * @param {string} name The name of the package. + * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter" + * @returns {string} Normalized name of the package + * @private + */ +function normalizePackageName(name, prefix) { + let normalizedName = name; + + /** + * On Windows, name can come in with Windows slashes instead of Unix slashes. + * Normalize to Unix first to avoid errors later on. + * https://github.com/eslint/eslint/issues/5644 + */ + if (normalizedName.includes("\\")) { + normalizedName = normalizedName.replace(/\\/gu, "/"); + } + + if (normalizedName.charAt(0) === "@") { + /** + * it's a scoped package + * package name is the prefix, or just a username + */ + const scopedPackageShortcutRegex = new RegExp( + `^(@[^/]+)(?:/(?:${prefix})?)?$`, + "u", + ), + scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u"); + + if (scopedPackageShortcutRegex.test(normalizedName)) { + normalizedName = normalizedName.replace( + scopedPackageShortcutRegex, + `$1/${prefix}`, + ); + } else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) { + /* + * for scoped packages, insert the prefix after the first / unless + * the path is already @scope/eslint or @scope/eslint-xxx-yyy + */ + normalizedName = normalizedName.replace( + /^@([^/]+)\/(.*)$/u, + `@$1/${prefix}-$2`, + ); + } + } else if (!normalizedName.startsWith(`${prefix}-`)) { + normalizedName = `${prefix}-${normalizedName}`; + } + + return normalizedName; +} + +/** + * Removes the prefix from a fullname. + * @param {string} fullname The term which may have the prefix. + * @param {string} prefix The prefix to remove. + * @returns {string} The term without prefix. + */ +function getShorthandName(fullname, prefix) { + if (fullname[0] === "@") { + let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec( + fullname, + ); + + if (matchResult) { + return matchResult[1]; + } + + matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec( + fullname, + ); + if (matchResult) { + return `${matchResult[1]}/${matchResult[2]}`; + } + } else if (fullname.startsWith(`${prefix}-`)) { + return fullname.slice(prefix.length + 1); + } + + return fullname; +} + +/** + * Gets the scope (namespace) of a term. + * @param {string} term The term which may have the namespace. + * @returns {string} The namespace of the term if it has one. + */ +function getNamespaceFromTerm(term) { + const match = term.match(NAMESPACE_REGEX); + + return match ? match[0] : ""; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + normalizePackageName, + getShorthandName, + getNamespaceFromTerm, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/option-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/option-utils.js new file mode 100644 index 00000000..0917ba52 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/option-utils.js @@ -0,0 +1,63 @@ +/** + * @fileoverview Utilities to operate on option objects. + * @author Josh Goldberg + */ + +"use strict"; + +/** + * Determines whether any of input's properties are different + * from values that already exist in original. + * @template T + * @param {Partial} input New value. + * @param {T} original Original value. + * @returns {boolean} Whether input includes an explicit difference. + */ +function containsDifferentProperty(input, original) { + if (input === original) { + return false; + } + + if ( + typeof input !== typeof original || + Array.isArray(input) !== Array.isArray(original) + ) { + return true; + } + + if (Array.isArray(input)) { + return ( + input.length !== original.length || + input.some((value, i) => + containsDifferentProperty(value, original[i]), + ) + ); + } + + if (typeof input === "object") { + if (input === null || original === null) { + return true; + } + + const inputKeys = Object.keys(input); + const originalKeys = Object.keys(original); + + return ( + inputKeys.length !== originalKeys.length || + inputKeys.some( + inputKey => + !Object.hasOwn(original, inputKey) || + containsDifferentProperty( + input[inputKey], + original[inputKey], + ), + ) + ); + } + + return true; +} + +module.exports = { + containsDifferentProperty, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/relative-module-resolver.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/relative-module-resolver.js new file mode 100644 index 00000000..14e7eec1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/relative-module-resolver.js @@ -0,0 +1,28 @@ +/** + * Utility for resolving a module relative to another module + * @author Teddy Katz + */ + +"use strict"; + +const Module = require("node:module"); + +/* + * `Module.createRequire` is added in v12.2.0. It supports URL as well. + * We only support the case where the argument is a filepath, not a URL. + */ +const createRequire = Module.createRequire; + +/** + * Resolves a Node module relative to another module + * @param {string} moduleName The name of a Node module, or a path to a Node module. + * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be + * a file rather than a directory, but the file need not actually exist. + * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath` + * @throws {Error} When the module cannot be resolved. + */ +function resolve(moduleName, relativeToPath) { + return createRequire(relativeToPath).resolve(moduleName); +} + +exports.resolve = resolve; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/runtime-info.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/runtime-info.js new file mode 100644 index 00000000..54fd7609 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/runtime-info.js @@ -0,0 +1,177 @@ +/** + * @fileoverview Utility to get information about the execution environment. + * @author Kai Cataldo + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const path = require("node:path"); +const spawn = require("cross-spawn"); +const os = require("node:os"); +const log = require("../shared/logging"); +const packageJson = require("../../package.json"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Generates and returns execution environment information. + * @returns {string} A string that contains execution environment information. + */ +function environment() { + const cache = new Map(); + + /** + * Checks if a path is a child of a directory. + * @param {string} parentPath The parent path to check. + * @param {string} childPath The path to check. + * @returns {boolean} Whether or not the given path is a child of a directory. + */ + function isChildOfDirectory(parentPath, childPath) { + return !path.relative(parentPath, childPath).startsWith(".."); + } + + /** + * Synchronously executes a shell command and formats the result. + * @param {string} cmd The command to execute. + * @param {Array} args The arguments to be executed with the command. + * @throws {Error} As may be collected by `cross-spawn.sync`. + * @returns {string} The version returned by the command. + */ + function execCommand(cmd, args) { + const key = [cmd, ...args].join(" "); + + if (cache.has(key)) { + return cache.get(key); + } + + const process = spawn.sync(cmd, args, { encoding: "utf8" }); + + if (process.error) { + throw process.error; + } + + const result = process.stdout.trim(); + + cache.set(key, result); + return result; + } + + /** + * Normalizes a version number. + * @param {string} versionStr The string to normalize. + * @returns {string} The normalized version number. + */ + function normalizeVersionStr(versionStr) { + return versionStr.startsWith("v") ? versionStr : `v${versionStr}`; + } + + /** + * Gets bin version. + * @param {string} bin The bin to check. + * @throws {Error} As may be collected by `cross-spawn.sync`. + * @returns {string} The normalized version returned by the command. + */ + function getBinVersion(bin) { + const binArgs = ["--version"]; + + try { + return normalizeVersionStr(execCommand(bin, binArgs)); + } catch (e) { + log.error( + `Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``, + ); + throw e; + } + } + + /** + * Gets installed npm package version. + * @param {string} pkg The package to check. + * @param {boolean} global Whether to check globally or not. + * @throws {Error} As may be collected by `cross-spawn.sync`. + * @returns {string} The normalized version returned by the command. + */ + function getNpmPackageVersion(pkg, { global = false } = {}) { + const npmBinArgs = ["bin", "-g"]; + const npmLsArgs = ["ls", "--depth=0", "--json", pkg]; + + if (global) { + npmLsArgs.push("-g"); + } + + try { + const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs)); + + /* + * Checking globally returns an empty JSON object, while local checks + * include the name and version of the local project. + */ + if ( + Object.keys(parsedStdout).length === 0 || + !(parsedStdout.dependencies && parsedStdout.dependencies.eslint) + ) { + return "Not found"; + } + + const [, processBinPath] = process.argv; + let npmBinPath; + + try { + npmBinPath = execCommand("npm", npmBinArgs); + } catch (e) { + log.error( + `Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``, + ); + throw e; + } + + const isGlobal = isChildOfDirectory(npmBinPath, processBinPath); + let pkgVersion = parsedStdout.dependencies.eslint.version; + + if ((global && isGlobal) || (!global && !isGlobal)) { + pkgVersion += " (Currently used)"; + } + + return normalizeVersionStr(pkgVersion); + } catch (e) { + log.error( + `Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``, + ); + throw e; + } + } + + return [ + "Environment Info:", + "", + `Node version: ${process.version}`, + `npm version: ${getBinVersion("npm")}`, + `Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`, + `Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`, + `Operating System: ${os.platform()} ${os.release()}`, + ].join("\n"); +} + +/** + * Returns version of currently executing ESLint. + * @returns {string} The version from the currently executing ESLint's package.json. + */ +function version() { + return `v${packageJson.version}`; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +module.exports = { + __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616) + environment, + version, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/serialization.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/serialization.js new file mode 100644 index 00000000..d0edf7cb --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/serialization.js @@ -0,0 +1,78 @@ +/** + * @fileoverview Serialization utils. + * @author Bryan Mishkin + */ + +"use strict"; + +/** + * Check if a value is a primitive or plain object created by the Object constructor. + * @param {any} val the value to check + * @returns {boolean} `true` if so + * @private + */ +function isSerializablePrimitiveOrPlainObject(val) { + return ( + val === null || + typeof val === "string" || + typeof val === "boolean" || + typeof val === "number" || + (typeof val === "object" && val.constructor === Object) || + Array.isArray(val) + ); +} + +/** + * Check if a value is serializable. + * Functions or objects like RegExp cannot be serialized by JSON.stringify(). + * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript + * @param {any} val The value + * @param {Set} seenObjects Objects already seen in this path from the root object. + * @returns {boolean} `true` if the value is serializable + */ +function isSerializable(val, seenObjects = new Set()) { + if (!isSerializablePrimitiveOrPlainObject(val)) { + return false; + } + if (typeof val === "object" && val !== null) { + if (seenObjects.has(val)) { + /* + * Since this is a depth-first traversal, encountering + * the same object again means there is a circular reference. + * Objects with circular references are not serializable. + */ + return false; + } + for (const property in val) { + if (Object.hasOwn(val, property)) { + if (!isSerializablePrimitiveOrPlainObject(val[property])) { + return false; + } + if ( + typeof val[property] === "object" && + val[property] !== null + ) { + if ( + /* + * We're creating a new Set of seen objects because we want to + * ensure that `val` doesn't appear again in this path, but it can appear + * in other paths. This allows for reusing objects in the graph, as long as + * there are no cycles. + */ + !isSerializable( + val[property], + new Set([...seenObjects, val]), + ) + ) { + return false; + } + } + } + } + } + return true; +} + +module.exports = { + isSerializable, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/severity.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/severity.js new file mode 100644 index 00000000..382704b5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/severity.js @@ -0,0 +1,49 @@ +/** + * @fileoverview Helpers for severity values (e.g. normalizing different types). + * @author Bryan Mishkin + */ + +"use strict"; + +/** + * Convert severity value of different types to a string. + * @param {string|number} severity severity value + * @throws error if severity is invalid + * @returns {string} severity string + */ +function normalizeSeverityToString(severity) { + if ([2, "2", "error"].includes(severity)) { + return "error"; + } + if ([1, "1", "warn"].includes(severity)) { + return "warn"; + } + if ([0, "0", "off"].includes(severity)) { + return "off"; + } + throw new Error(`Invalid severity value: ${severity}`); +} + +/** + * Convert severity value of different types to a number. + * @param {string|number} severity severity value + * @throws error if severity is invalid + * @returns {number} severity number + */ +function normalizeSeverityToNumber(severity) { + if ([2, "2", "error"].includes(severity)) { + return 2; + } + if ([1, "1", "warn"].includes(severity)) { + return 1; + } + if ([0, "0", "off"].includes(severity)) { + return 0; + } + throw new Error(`Invalid severity value: ${severity}`); +} + +module.exports = { + normalizeSeverityToString, + normalizeSeverityToNumber, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/stats.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/stats.js new file mode 100644 index 00000000..791b7708 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/stats.js @@ -0,0 +1,30 @@ +/** + * @fileoverview Provides helper functions to start/stop the time measurements + * that are provided by the ESLint 'stats' option. + * @author Mara Kiefer + */ +"use strict"; + +/** + * Start time measurement + * @returns {[number, number]} t variable for tracking time + */ +function startTime() { + return process.hrtime(); +} + +/** + * End time measurement + * @param {[number, number]} t Variable for tracking time + * @returns {number} The measured time in milliseconds + */ +function endTime(t) { + const time = process.hrtime(t); + + return time[0] * 1e3 + time[1] / 1e6; +} + +module.exports = { + startTime, + endTime, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/string-utils.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/string-utils.js new file mode 100644 index 00000000..954c5bff --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/string-utils.js @@ -0,0 +1,58 @@ +/** + * @fileoverview Utilities to operate on strings. + * @author Stephen Wade + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +// eslint-disable-next-line no-control-regex -- intentionally including control characters +const ASCII_REGEX = /^[\u0000-\u007f]*$/u; + +/** @type {Intl.Segmenter | undefined} */ +let segmenter; + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Converts the first letter of a string to uppercase. + * @param {string} string The string to operate on + * @returns {string} The converted string + */ +function upperCaseFirst(string) { + if (string.length <= 1) { + return string.toUpperCase(); + } + return string[0].toUpperCase() + string.slice(1); +} + +/** + * Counts graphemes in a given string. + * @param {string} value A string to count graphemes. + * @returns {number} The number of graphemes in `value`. + */ +function getGraphemeCount(value) { + if (ASCII_REGEX.test(value)) { + return value.length; + } + + segmenter ??= new Intl.Segmenter("en-US"); // en-US locale should be supported everywhere + let graphemeCount = 0; + + // eslint-disable-next-line no-unused-vars -- for-of needs a variable + for (const unused of segmenter.segment(value)) { + graphemeCount++; + } + + return graphemeCount; +} + +module.exports = { + upperCaseFirst, + getGraphemeCount, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/text-table.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/text-table.js new file mode 100644 index 00000000..ac5bc39d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/text-table.js @@ -0,0 +1,69 @@ +/** + * @fileoverview Optimized version of the `text-table` npm module to improve performance by replacing inefficient regex-based + * whitespace trimming with a modern built-in method. + * + * This modification addresses a performance issue reported in https://github.com/eslint/eslint/issues/18709 + * + * The `text-table` module is published under the MIT License. For the original source, refer to: + * https://www.npmjs.com/package/text-table. + */ + +/* + * + * This software is released under the MIT license: + * + * 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. + */ + +"use strict"; + +module.exports = function (rows_, opts) { + const hsep = " "; + const align = opts.align; + const stringLength = opts.stringLength; + + // Cache the length of each cell so it's only computed once per cell. + const cellLengths = rows_.map(row => row.map(c => stringLength(c))); + + const sizes = cellLengths.reduce((acc, row) => { + row.forEach((n, ix) => { + if (!acc[ix] || n > acc[ix]) { + acc[ix] = n; + } + }); + return acc; + }, []); + + return rows_ + .map((row, rowIndex) => + row + .map((c, ix) => { + const n = sizes[ix] - cellLengths[rowIndex][ix] || 0; + const s = n > 0 ? " ".repeat(n) : ""; + + if (align[ix] === "r") { + return s + c; + } + + return c + s; + }) + .join(hsep) + .trimEnd(), + ) + .join("\n"); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/translate-cli-options.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/translate-cli-options.js new file mode 100644 index 00000000..190c0747 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/translate-cli-options.js @@ -0,0 +1,223 @@ +/** + * @fileoverview Translates CLI options into ESLint constructor options. + * @author Nicholas C. Zakas + * @author Francesco Trotta + */ + +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const { normalizeSeverityToString } = require("./severity"); +const { getShorthandName, normalizePackageName } = require("./naming"); +const { ModuleImporter } = require("@humanwhocodes/module-importer"); + +//------------------------------------------------------------------------------ +// Types +//------------------------------------------------------------------------------ + +/** @typedef {import("../types").ESLint.Options} ESLintOptions */ +/** @typedef {import("../types").Linter.LintMessage} LintMessage */ +/** @typedef {import("../options").ParsedCLIOptions} ParsedCLIOptions */ +/** @typedef {import("../types").ESLint.Plugin} Plugin */ + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Loads plugins with the specified names. + * @param {{ "import": (name: string) => Promise }} importer An object with an `import` method called once for each plugin. + * @param {string[]} pluginNames The names of the plugins to be loaded, with or without the "eslint-plugin-" prefix. + * @returns {Promise>} A mapping of plugin short names to implementations. + */ +async function loadPlugins(importer, pluginNames) { + const plugins = {}; + + await Promise.all( + pluginNames.map(async pluginName => { + const longName = normalizePackageName(pluginName, "eslint-plugin"); + const module = await importer.import(longName); + + if (!("default" in module)) { + throw new Error( + `"${longName}" cannot be used with the \`--plugin\` option because its default module does not provide a \`default\` export`, + ); + } + + const shortName = getShorthandName(pluginName, "eslint-plugin"); + + plugins[shortName] = module.default; + }), + ); + + return plugins; +} + +/** + * Predicate function for whether or not to apply fixes in quiet mode. + * If a message is a warning, do not apply a fix. + * @param {LintMessage} message The lint result. + * @returns {boolean} `true` if the lint message is an error (and thus should be + * autofixed), `false` otherwise. + */ +function quietFixPredicate(message) { + return message.severity === 2; +} + +/** + * Predicate function for whether or not to run a rule in quiet mode. + * If a rule is set to warning, do not run it. + * @param {{ ruleId: string; severity: number; }} rule The rule id and severity. + * @returns {boolean} `true` if the lint rule should run, `false` otherwise. + */ +function quietRuleFilter(rule) { + return rule.severity === 2; +} + +//------------------------------------------------------------------------------ +// Public Interface +//------------------------------------------------------------------------------ + +/** + * Translates the CLI options into the options expected by the ESLint constructor. + * @param {ParsedCLIOptions} cliOptions The CLI options to translate. + * @returns {Promise} The options object for the ESLint constructor. + */ +async function translateOptions({ + cache, + cacheFile, + cacheLocation, + cacheStrategy, + concurrency, + config, + configLookup, + errorOnUnmatchedPattern, + ext, + fix, + fixDryRun, + fixType, + flag, + global, + ignore, + ignorePattern, + inlineConfig, + parser, + parserOptions, + plugin, + quiet, + reportUnusedDisableDirectives, + reportUnusedDisableDirectivesSeverity, + reportUnusedInlineConfigs, + rule, + stats, + warnIgnored, + passOnNoPatterns, + maxWarnings, +}) { + const importer = new ModuleImporter(); + + let overrideConfigFile = + typeof config === "string" ? config : !configLookup; + if (overrideConfigFile === false) { + overrideConfigFile = void 0; + } + + const languageOptions = {}; + + if (global) { + languageOptions.globals = global.reduce((obj, name) => { + if (name.endsWith(":true")) { + obj[name.slice(0, -5)] = "writable"; + } else { + obj[name] = "readonly"; + } + return obj; + }, {}); + } + + if (parserOptions) { + languageOptions.parserOptions = parserOptions; + } + + if (parser) { + languageOptions.parser = await importer.import(parser); + } + + const overrideConfig = [ + { + ...(Object.keys(languageOptions).length > 0 + ? { languageOptions } + : {}), + rules: rule ? rule : {}, + }, + ]; + + if ( + reportUnusedDisableDirectives || + reportUnusedDisableDirectivesSeverity !== void 0 + ) { + overrideConfig[0].linterOptions = { + reportUnusedDisableDirectives: reportUnusedDisableDirectives + ? "error" + : normalizeSeverityToString( + reportUnusedDisableDirectivesSeverity, + ), + }; + } + + if (reportUnusedInlineConfigs !== void 0) { + overrideConfig[0].linterOptions = { + ...overrideConfig[0].linterOptions, + reportUnusedInlineConfigs: normalizeSeverityToString( + reportUnusedInlineConfigs, + ), + }; + } + + if (plugin) { + overrideConfig[0].plugins = await loadPlugins(importer, plugin); + } + + if (ext) { + overrideConfig.push({ + files: ext.map( + extension => + `**/*${extension.startsWith(".") ? "" : "."}${extension}`, + ), + }); + } + + /* + * For performance reasons rules not marked as 'error' are filtered out in quiet mode. As maxWarnings + * requires rules set to 'warn' to be run, we only filter out 'warn' rules if maxWarnings is not specified. + */ + const ruleFilter = + quiet && maxWarnings === -1 ? quietRuleFilter : () => true; + + const options = { + allowInlineConfig: inlineConfig, + cache, + cacheLocation: cacheLocation || cacheFile, + cacheStrategy, + concurrency, + errorOnUnmatchedPattern, + fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true), + fixTypes: fixType, + flags: flag, + ignore, + ignorePatterns: ignorePattern, + overrideConfig, + overrideConfigFile, + passOnNoPatterns, + ruleFilter, + stats, + warnIgnored, + }; + + return options; +} + +module.exports = translateOptions; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/traverser.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/traverser.js new file mode 100644 index 00000000..e13b2cfa --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/shared/traverser.js @@ -0,0 +1,202 @@ +/** + * @fileoverview Traverser to traverse AST trees. + * @author Nicholas C. Zakas + * @author Toru Nagashima + */ +"use strict"; + +//------------------------------------------------------------------------------ +// Requirements +//------------------------------------------------------------------------------ + +const vk = require("eslint-visitor-keys"); +const debug = require("debug")("eslint:traverser"); + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Do nothing. + * @returns {void} + */ +function noop() { + // do nothing. +} + +/** + * Check whether the given value is an ASTNode or not. + * @param {any} x The value to check. + * @returns {boolean} `true` if the value is an ASTNode. + */ +function isNode(x) { + return x !== null && typeof x === "object" && typeof x.type === "string"; +} + +/** + * Get the visitor keys of a given node. + * @param {Object} visitorKeys The map of visitor keys. + * @param {ASTNode} node The node to get their visitor keys. + * @returns {string[]} The visitor keys of the node. + */ +function getVisitorKeys(visitorKeys, node) { + let keys = visitorKeys[node.type]; + + if (!keys) { + keys = vk.getKeys(node); + debug( + 'Unknown node type "%s": Estimated visitor keys %j', + node.type, + keys, + ); + } + + return keys; +} + +/** + * The traverser class to traverse AST trees. + */ +class Traverser { + constructor() { + this._current = null; + this._parents = []; + this._skipped = false; + this._broken = false; + this._visitorKeys = null; + this._enter = null; + this._leave = null; + } + + /** + * Gives current node. + * @returns {ASTNode} The current node. + */ + current() { + return this._current; + } + + /** + * Gives a copy of the ancestor nodes. + * @returns {ASTNode[]} The ancestor nodes. + */ + parents() { + return this._parents.slice(0); + } + + /** + * Break the current traversal. + * @returns {void} + */ + break() { + this._broken = true; + } + + /** + * Skip child nodes for the current traversal. + * @returns {void} + */ + skip() { + this._skipped = true; + } + + /** + * Traverse the given AST tree. + * @param {ASTNode} node The root node to traverse. + * @param {Object} options The option object. + * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`. + * @param {Function} [options.enter=noop] The callback function which is called on entering each node. + * @param {Function} [options.leave=noop] The callback function which is called on leaving each node. + * @returns {void} + */ + traverse(node, options) { + this._current = null; + this._parents = []; + this._skipped = false; + this._broken = false; + this._visitorKeys = options.visitorKeys || vk.KEYS; + this._enter = options.enter || noop; + this._leave = options.leave || noop; + this._traverse(node, null); + } + + /** + * Traverse the given AST tree recursively. + * @param {ASTNode} node The current node. + * @param {ASTNode|null} parent The parent node. + * @returns {void} + * @private + */ + _traverse(node, parent) { + if (!isNode(node)) { + return; + } + + this._current = node; + this._skipped = false; + this._enter(node, parent); + + if (!this._skipped && !this._broken) { + const keys = getVisitorKeys(this._visitorKeys, node); + + if (keys.length >= 1) { + this._parents.push(node); + for (let i = 0; i < keys.length && !this._broken; ++i) { + const child = node[keys[i]]; + + if (Array.isArray(child)) { + for ( + let j = 0; + j < child.length && !this._broken; + ++j + ) { + this._traverse(child[j], node); + } + } else { + this._traverse(child, node); + } + } + this._parents.pop(); + } + } + + if (!this._broken) { + this._leave(node, parent); + } + + this._current = parent; + } + + /** + * Calculates the keys to use for traversal. + * @param {ASTNode} node The node to read keys from. + * @returns {string[]} An array of keys to visit on the node. + * @private + */ + static getKeys(node) { + return vk.getKeys(node); + } + + /** + * Traverse the given AST tree. + * @param {ASTNode} node The root node to traverse. + * @param {Object} options The option object. + * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`. + * @param {Function} [options.enter=noop] The callback function which is called on entering each node. + * @param {Function} [options.leave=noop] The callback function which is called on leaving each node. + * @returns {void} + */ + static traverse(node, options) { + new Traverser().traverse(node, options); + } + + /** + * The default visitor keys. + * @type {Object} + */ + static get DEFAULT_VISITOR_KEYS() { + return vk.KEYS; + } +} + +module.exports = Traverser; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/config-api.d.ts b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/config-api.d.ts new file mode 100644 index 00000000..b3bfa77d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/config-api.d.ts @@ -0,0 +1,20 @@ +/** + * @fileoverview typings for "eslint/config" module + * @author Nicholas C. Zakas + */ + +import { + type Config, + type ConfigObject, + defineConfig, + globalIgnores, + includeIgnoreFile, +} from "@eslint/config-helpers"; + +export { + type Config, + type ConfigObject, + defineConfig, + globalIgnores, + includeIgnoreFile, +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/index.d.ts b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/index.d.ts new file mode 100644 index 00000000..6edb3a6f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/index.d.ts @@ -0,0 +1,1546 @@ +/** + * @fileoverview This file contains the core types for ESLint. It was initially extracted + * from the `@types/eslint` package. + */ + +/* + * MIT License + * Copyright (c) Microsoft Corporation. + * + * 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 + */ + +import * as ESTree from "estree"; +import type { + DeprecatedInfo, + LanguageOptions as GenericLanguageOptions, + RuleContext as CoreRuleContext, + RuleDefinition, + SourceRange, + TextSourceCode, + TraversalStep, + RulesConfig, + GlobalAccess, + GlobalsConfig, + LinterOptionsConfig, + EnvironmentConfig, + ObjectMetaProperties as CoreObjectMetaProperties, + Plugin as CorePlugin, + LintMessage as CoreLintMessage, + Processor as CoreProcessor, + ConfigObject, + LegacyConfigObject, + SeverityName, + SeverityLevel, + Severity as CoreSeverity, + EcmaVersion as CoreEcmaVersion, + ConfigOverride as CoreConfigOverride, + ProcessorFile as CoreProcessorFile, + RulesMeta, + RuleConfig, + RuleTextEditor, + RuleTextEdit, + RuleVisitor, + BaseConfig as CoreBaseConfig, + RuleFixer as CoreRuleFixer, + ViolationReportBase, + ViolationMessage, + ViolationLocation, + SuggestionMessage, + LintSuggestion as CoreLintSuggestion, + JavaScriptSourceType, + HasRules as CoreHasRules, + SuggestedEditBase, + SuggestedEdit, + ViolationReport, + MessagePlaceholderData, +} from "@eslint/core"; +import type { + CustomRuleDefinitionType, + CustomRuleTypeDefinitions, + CustomRuleVisitorWithExit, +} from "@eslint/plugin-kit"; + +//------------------------------------------------------------------------------ +// Exports +//------------------------------------------------------------------------------ + +export namespace AST { + type TokenType = + | "Boolean" + | "Null" + | "Identifier" + | "PrivateIdentifier" + | "Keyword" + | "Punctuator" + | "JSXIdentifier" + | "JSXText" + | "Numeric" + | "String" + | "Template" + | "RegularExpression"; + + interface Token { + type: TokenType; + value: string; + range: Range; + loc: SourceLocation; + } + + interface SourceLocation { + start: ESTree.Position; + end: ESTree.Position; + } + + type Range = SourceRange; + + interface Program extends ESTree.Program { + comments: ESTree.Comment[]; + tokens: Token[]; + loc: SourceLocation; + range: Range; + } +} + +interface JSXIdentifier extends ESTree.BaseNode { + type: "JSXIdentifier"; + name: string; +} + +export namespace Scope { + interface ScopeManager { + scopes: Scope[]; + globalScope: Scope | null; + + acquire(node: ESTree.Node, inner?: boolean): Scope | null; + + getDeclaredVariables(node: ESTree.Node): Variable[]; + + addGlobals(names: ReadonlyArray): void; + } + + interface Scope { + type: + | "block" + | "catch" + | "class" + | "class-field-initializer" + | "class-static-block" + | "for" + | "function" + | "function-expression-name" + | "global" + | "module" + | "switch" + | "with"; + isStrict: boolean; + upper: Scope | null; + childScopes: Scope[]; + variableScope: Scope; + block: ESTree.Node; + variables: Variable[]; + set: Map; + references: Reference[]; + through: Reference[]; + functionExpressionScope: boolean; + implicit?: { + variables: Variable[]; + set: Map; + }; + } + + interface Variable { + name: string; + scope: Scope; + identifiers: ESTree.Identifier[]; + references: Reference[]; + defs: Definition[]; + } + + interface Reference { + identifier: ESTree.Identifier | JSXIdentifier; + from: Scope; + resolved: Variable | null; + writeExpr?: ESTree.Expression | null; + init?: boolean; + + isWrite(): boolean; + + isRead(): boolean; + + isWriteOnly(): boolean; + + isReadOnly(): boolean; + + isReadWrite(): boolean; + } + + type DefinitionType = + | { type: "CatchClause"; node: ESTree.CatchClause; parent: null } + | { + type: "ClassName"; + node: ESTree.ClassDeclaration | ESTree.ClassExpression; + parent: null; + } + | { + type: "FunctionName"; + node: ESTree.FunctionDeclaration | ESTree.FunctionExpression; + parent: null; + } + | { + type: "ImplicitGlobalVariable"; + node: + | ESTree.AssignmentExpression + | ESTree.ForInStatement + | ESTree.ForOfStatement; + parent: null; + } + | { + type: "ImportBinding"; + node: + | ESTree.ImportSpecifier + | ESTree.ImportDefaultSpecifier + | ESTree.ImportNamespaceSpecifier; + parent: ESTree.ImportDeclaration; + } + | { + type: "Parameter"; + node: + | ESTree.FunctionDeclaration + | ESTree.FunctionExpression + | ESTree.ArrowFunctionExpression; + parent: null; + } + | { + type: "Variable"; + node: ESTree.VariableDeclarator; + parent: ESTree.VariableDeclaration; + }; + + type Definition = DefinitionType & { name: ESTree.Identifier }; +} + +// #region SourceCode + +export class SourceCode implements TextSourceCode<{ + LangOptions: Linter.LanguageOptions; + RootNode: AST.Program; + SyntaxElementWithLoc: AST.Token | ESTree.Node; + ConfigNode: ESTree.Comment; +}> { + text: string; + ast: AST.Program; + lines: string[]; + hasBOM: boolean; + parserServices: SourceCode.ParserServices; + scopeManager: Scope.ScopeManager; + visitorKeys: SourceCode.VisitorKeys; + + constructor(text: string, ast: AST.Program); + constructor(config: SourceCode.Config); + + static splitLines(text: string): string[]; + + getLoc(syntaxElement: AST.Token | ESTree.Node): ESTree.SourceLocation; + getRange(syntaxElement: AST.Token | ESTree.Node): SourceRange; + + getText( + node?: ESTree.Node, + beforeCount?: number, + afterCount?: number, + ): string; + + getLines(): string[]; + + getAllComments(): ESTree.Comment[]; + + getAncestors(node: ESTree.Node): ESTree.Node[]; + + getDeclaredVariables(node: ESTree.Node): Scope.Variable[]; + + getNodeByRangeIndex(index: number): ESTree.Node | null; + + getLocFromIndex(index: number): ESTree.Position; + + getIndexFromLoc(location: ESTree.Position): number; + + // Inherited methods from TokenStore + // --------------------------------- + + getTokenByRangeStart( + offset: number, + options?: { includeComments: false }, + ): AST.Token | null; + getTokenByRangeStart( + offset: number, + options: { includeComments: boolean }, + ): AST.Token | ESTree.Comment | null; + + getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions; + + getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions; + + getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions; + + getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions; + + getTokenBefore: SourceCode.UnaryCursorWithSkipOptions; + + getTokensBefore: SourceCode.UnaryCursorWithCountOptions; + + getTokenAfter: SourceCode.UnaryCursorWithSkipOptions; + + getTokensAfter: SourceCode.UnaryCursorWithCountOptions; + + getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions; + + getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions; + + getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions; + + getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions; + + getTokensBetween: SourceCode.BinaryCursorWithCountOptions; + + getTokens: (( + node: ESTree.Node, + beforeCount?: number, + afterCount?: number, + ) => AST.Token[]) & + SourceCode.UnaryNodeCursorWithCountOptions; + + commentsExistBetween( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + ): boolean; + + getCommentsBefore(nodeOrToken: ESTree.Node | AST.Token): ESTree.Comment[]; + + getCommentsAfter(nodeOrToken: ESTree.Node | AST.Token): ESTree.Comment[]; + + getCommentsInside(node: ESTree.Node): ESTree.Comment[]; + + getScope(node: ESTree.Node): Scope.Scope; + + isSpaceBetween( + first: ESTree.Node | AST.Token, + second: ESTree.Node | AST.Token, + ): boolean; + + isGlobalReference(node: ESTree.Identifier): boolean; + + markVariableAsUsed(name: string, refNode?: ESTree.Node): boolean; + + traverse(): Iterable; +} + +export namespace SourceCode { + interface Config { + text: string; + ast: AST.Program; + hasBOM?: boolean | undefined; + parserServices?: ParserServices | null | undefined; + scopeManager?: Scope.ScopeManager | null | undefined; + visitorKeys?: VisitorKeys | null | undefined; + } + + type ParserServices = any; + + interface VisitorKeys { + [nodeType: string]: string[]; + } + + interface UnaryNodeCursorWithSkipOptions { + ( + node: ESTree.Node, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + skip?: number | undefined; + }, + ): T | null; + ( + node: ESTree.Node, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + skip?: number | undefined; + }, + ): T | null; + ( + node: ESTree.Node, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + skip?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token | null; + ( + node: ESTree.Node, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + skip?: number | undefined; + }, + ): AST.Token | ESTree.Comment | null; + } + + interface UnaryNodeCursorWithCountOptions { + ( + node: ESTree.Node, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + count?: number | undefined; + }, + ): T[]; + ( + node: ESTree.Node, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + count?: number | undefined; + }, + ): T[]; + ( + node: ESTree.Node, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + count?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token[]; + ( + node: ESTree.Node, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + count?: number | undefined; + }, + ): Array; + } + + interface UnaryCursorWithSkipOptions { + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + skip?: number | undefined; + }, + ): T | null; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + skip?: number | undefined; + }, + ): T | null; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + skip?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token | null; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + skip?: number | undefined; + }, + ): AST.Token | ESTree.Comment | null; + } + + interface UnaryCursorWithCountOptions { + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + count?: number | undefined; + }, + ): T[]; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + count?: number | undefined; + }, + ): T[]; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + count?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token[]; + ( + node: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + count?: number | undefined; + }, + ): Array; + } + + interface BinaryCursorWithSkipOptions { + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + skip?: number | undefined; + }, + ): T | null; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + skip?: number | undefined; + }, + ): T | null; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + skip?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token | null; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + skip?: number | undefined; + }, + ): AST.Token | ESTree.Comment | null; + } + + interface BinaryCursorWithCountOptions { + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: + | ((token: AST.Token) => token is T) + | { + filter: (token: AST.Token) => token is T; + includeComments?: false | undefined; + count?: number | undefined; + }, + ): T[]; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter: ( + tokenOrComment: AST.Token | ESTree.Comment, + ) => tokenOrComment is T; + includeComments: boolean; + count?: number | undefined; + }, + ): T[]; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options?: + | { + filter?: ((token: AST.Token) => boolean) | undefined; + includeComments?: false | undefined; + count?: number | undefined; + } + | ((token: AST.Token) => boolean) + | number, + ): AST.Token[]; + ( + left: ESTree.Node | AST.Token | ESTree.Comment, + right: ESTree.Node | AST.Token | ESTree.Comment, + options: { + filter?: + | ((token: AST.Token | ESTree.Comment) => boolean) + | undefined; + includeComments: boolean; + count?: number | undefined; + }, + ): Array; + } +} + +// #endregion + +export type JSSyntaxElement = { + type: string; + loc?: ESTree.SourceLocation | null | undefined; +}; + +export namespace Rule { + interface RuleModule extends RuleDefinition<{ + LangOptions: Linter.LanguageOptions; + Code: SourceCode; + RuleOptions: any[]; + Visitor: RuleListener; + Node: JSSyntaxElement; + MessageIds: string; + ExtRuleDocs: {}; + }> { + create(context: RuleContext): RuleListener; + } + + type NodeTypes = ESTree.Node["type"]; + + interface NodeListener extends CustomRuleVisitorWithExit< + { + [Node in Rule.Node as Node["type"]]?: + ((node: Node) => void) | undefined; + } & { + // A `Program` visitor's node type has no `parent` property. + Program?: ((node: AST.Program) => void) | undefined; + } + > {} + + interface NodeParentExtension { + parent: Node; + } + + type Node = + | (AST.Program & { parent: null }) + | (Exclude & NodeParentExtension); + + interface RuleListener extends NodeListener { + onCodePathStart?(codePath: CodePath, node: Node): void; + + onCodePathEnd?(codePath: CodePath, node: Node): void; + + onCodePathSegmentStart?(segment: CodePathSegment, node: Node): void; + + onCodePathSegmentEnd?(segment: CodePathSegment, node: Node): void; + + onUnreachableCodePathSegmentStart?( + segment: CodePathSegment, + node: Node, + ): void; + + onUnreachableCodePathSegmentEnd?( + segment: CodePathSegment, + node: Node, + ): void; + + onCodePathSegmentLoop?( + fromSegment: CodePathSegment, + toSegment: CodePathSegment, + node: Node, + ): void; + + [key: string]: + | ((codePath: CodePath, node: Node) => void) + | ((segment: CodePathSegment, node: Node) => void) + | (( + fromSegment: CodePathSegment, + toSegment: CodePathSegment, + node: Node, + ) => void) + | ((node: Node) => void) + | NodeListener[keyof NodeListener] + | undefined; + } + + type CodePathOrigin = + | "program" + | "function" + | "class-field-initializer" + | "class-static-block"; + + interface CodePathSegmentTraversalController { + skip(): void; + break(): void; + } + + type CodePathSegmentTraversalCallback = ( + this: CodePath, + segment: CodePathSegment, + controller: CodePathSegmentTraversalController, + ) => void; + + interface CodePathTraversalOptions { + first?: CodePathSegment | undefined; + last?: CodePathSegment | undefined; + } + + interface CodePath { + id: string; + origin: CodePathOrigin; + initialSegment: CodePathSegment; + finalSegments: CodePathSegment[]; + returnedSegments: CodePathSegment[]; + thrownSegments: CodePathSegment[]; + upper: CodePath | null; + childCodePaths: CodePath[]; + traverseSegments(callback: CodePathSegmentTraversalCallback): void; + traverseSegments( + options: CodePathTraversalOptions, + callback: CodePathSegmentTraversalCallback, + ): void; + } + + interface CodePathSegment { + id: string; + nextSegments: CodePathSegment[]; + prevSegments: CodePathSegment[]; + allNextSegments: CodePathSegment[]; + allPrevSegments: CodePathSegment[]; + reachable: boolean; + } + + type RuleMetaData = RulesMeta; + + interface RuleContext extends CoreRuleContext<{ + LangOptions: Linter.LanguageOptions; + Code: SourceCode; + RuleOptions: any[]; + Node: JSSyntaxElement; + MessageIds: string; + }> {} + + type ReportFixer = CoreRuleFixer; + + /** @deprecated Use `ReportDescriptorOptions` instead. */ + type ReportDescriptorOptionsBase = Omit; + + type SuggestionReportOptions = SuggestedEditBase; + type SuggestionDescriptorMessage = SuggestionMessage; + type SuggestionReportDescriptor = SuggestedEdit; + + // redundant with ReportDescriptorOptionsBase but kept for clarity + type ReportDescriptorOptions = ViolationReportBase; + + type ReportDescriptor = ViolationReport; + type ReportDescriptorMessage = ViolationMessage; + type ReportDescriptorLocation = ViolationLocation; + + type RuleFixer = RuleTextEditor; + type Fix = RuleTextEdit; +} + +export type JSRuleDefinitionTypeOptions = CustomRuleTypeDefinitions; + +export type JSRuleDefinition< + Options extends Partial = {}, +> = CustomRuleDefinitionType< + { + LangOptions: Linter.LanguageOptions; + Code: SourceCode; + Visitor: Rule.RuleListener; + Node: JSSyntaxElement; + }, + Options +>; + +// #region Linter + +export class Linter { + static readonly version: string; + + version: string; + + constructor(options?: { cwd?: string | undefined; configType?: "flat" }); + + verify( + code: SourceCode | string, + config: Linter.Config | Linter.Config[], + filename?: string, + ): Linter.LintMessage[]; + verify( + code: SourceCode | string, + config: Linter.Config | Linter.Config[], + options: Linter.LintOptions, + ): Linter.LintMessage[]; + + verifyAndFix( + code: string, + config: Linter.Config | Linter.Config[], + filename?: string, + ): Linter.FixReport; + verifyAndFix( + code: string, + config: Linter.Config | Linter.Config[], + options: Linter.FixOptions, + ): Linter.FixReport; + + getSourceCode(): SourceCode; + + getTimes(): Linter.Stats["times"]; + + getFixPassCount(): Linter.Stats["fixPasses"]; +} + +export namespace Linter { + /** + * The numeric severity level for a rule. + * + * - `0` means off. + * - `1` means warn. + * - `2` means error. + * + * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities) + */ + type Severity = SeverityLevel; + + /** + * The human readable severity level for a rule. + * + * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities) + */ + type StringSeverity = SeverityName; + + /** + * The numeric or human readable severity level for a rule. + * + * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities) + */ + type RuleSeverity = CoreSeverity; + + /** + * An array containing the rule severity level, followed by the rule options. + * + * @see [Rules](https://eslint.org/docs/latest/use/configure/rules) + */ + type RuleSeverityAndOptions = [ + RuleSeverity, + ...Partial, + ]; + + /** + * The severity level for the rule or an array containing the rule severity level, followed by the rule options. + * + * @see [Rules](https://eslint.org/docs/latest/use/configure/rules) + */ + type RuleEntry = RuleConfig; + + /** + * The rules config object is a key/value map of rule names and their severity and options. + */ + type RulesRecord = RulesConfig; + + /** + * A configuration object that may have a `rules` block. + */ + type HasRules = + CoreHasRules; + + /** + * The ECMAScript version of the code being linted. + */ + type EcmaVersion = CoreEcmaVersion; + + /** + * The type of JavaScript source code. + */ + type SourceType = JavaScriptSourceType; + + /** + * ESLint legacy configuration. + * + * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/) + */ + type BaseConfig< + Rules extends RulesConfig = RulesConfig, + OverrideRules extends RulesConfig = Rules, + > = CoreBaseConfig; + + /** + * The overwrites that apply more differing configuration to specific files or directories. + */ + type ConfigOverride = + CoreConfigOverride; + + /** + * ESLint legacy configuration. + * + * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/) + */ + // https://github.com/eslint/eslint/blob/v8.57.0/conf/config-schema.js + type LegacyConfig< + Rules extends RulesConfig = RulesConfig, + OverrideRules extends RulesConfig = Rules, + > = LegacyConfigObject; + + /** + * Parser options. + * + * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options) + */ + interface ParserOptions { + /** + * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3). + * + * @default false + */ + allowReserved?: boolean | undefined; + /** + * An object indicating which additional language features you'd like to use. + * + * @see https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options + */ + ecmaFeatures?: + | { + /** + * Allow `return` statements in the global scope. + * + * @default false + */ + globalReturn?: boolean | undefined; + /** + * Enable global [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) (if `ecmaVersion` is 5 or greater). + * + * @default false + */ + impliedStrict?: boolean | undefined; + /** + * Enable [JSX](https://react.github.io/jsx/). + * + * @default false + */ + jsx?: boolean | undefined; + [key: string]: any; + } + | undefined; + [key: string]: any; + } + + /** + * Options used for linting code with `Linter#verify` and `Linter#verifyAndFix`. + */ + interface LintOptions { + filename?: string | undefined; + preprocess?: ((code: string) => string[]) | undefined; + postprocess?: + ((problemLists: LintMessage[][]) => LintMessage[]) | undefined; + filterCodeBlock?: + ((filename: string, text: string) => boolean) | undefined; + disableFixes?: boolean | undefined; + allowInlineConfig?: boolean | undefined; + reportUnusedDisableDirectives?: boolean | undefined; + } + + type LintSuggestion = CoreLintSuggestion; + type LintMessage = CoreLintMessage; + + interface LintSuppression { + kind: string; + justification: string; + } + + interface SuppressedLintMessage extends LintMessage { + /** The suppression info. */ + suppressions: LintSuppression[]; + } + + interface FixOptions extends LintOptions { + fix?: boolean | undefined; + } + + interface FixReport { + fixed: boolean; + output: string; + messages: LintMessage[]; + } + + // Temporarily loosen type for just flat config files (see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68232) + type NonESTreeParser = ESLint.ObjectMetaProperties & + ( + | { + parse(text: string, options?: any): unknown; + } + | { + parseForESLint( + text: string, + options?: any, + ): Omit & { + ast: unknown; + scopeManager?: unknown; + }; + } + ); + + type ESTreeParser = ESLint.ObjectMetaProperties & + ( + | { parse(text: string, options?: any): AST.Program } + | { parseForESLint(text: string, options?: any): ESLintParseResult } + ); + + type Parser = NonESTreeParser | ESTreeParser; + + interface ESLintParseResult { + /** The AST object. */ + ast: AST.Program; + + /** The services that the parser provides. */ + services?: SourceCode.ParserServices | undefined; + + /** The scope manager of the AST. */ + scopeManager?: Scope.ScopeManager | undefined; + + /** The visitor keys of the AST. */ + visitorKeys?: SourceCode.VisitorKeys | undefined; + } + + type ProcessorFile = CoreProcessorFile; + + // https://eslint.org/docs/latest/extend/plugins#processors-in-plugins + type Processor = + CoreProcessor; + + type Config = ConfigObject; + + /** @deprecated Use `Config` instead of `FlatConfig` */ + type FlatConfig = Config; + + type GlobalConf = GlobalAccess; + type Globals = GlobalsConfig; + + interface LanguageOptions extends GenericLanguageOptions { + /** + * The version of ECMAScript to support. May be any year (i.e., 2022) or + * version (i.e., 5). Set to "latest" for the most recent supported version. + * @default "latest" + */ + ecmaVersion?: EcmaVersion | undefined; + + /** + * The type of JavaScript source code. Possible values are "script" for + * traditional script files, "module" for ECMAScript modules (ESM), and + * "commonjs" for CommonJS files. (default: "module" for .js and .mjs + * files; "commonjs" for .cjs files) + */ + sourceType?: SourceType | undefined; + + /** + * An object specifying additional objects that should be added to the + * global scope during linting. + */ + globals?: Globals | undefined; + + /** + * An object containing a parse() or parseForESLint() method. + * If not configured, the default ESLint parser (Espree) will be used. + */ + parser?: Parser | undefined; + + /** + * An object specifying additional options that are passed directly to the + * parser() method on the parser. The available options are parser-dependent + */ + parserOptions?: Linter.ParserOptions | undefined; + } + + type LinterOptions = LinterOptionsConfig; + + /** + * Performance statistics. + */ + interface Stats { + /** + * The number of times ESLint has applied at least one fix after linting. + */ + fixPasses: number; + + /** + * The times spent on (parsing, fixing, linting) a file, where the linting refers to the timing information for each rule. + */ + times: { passes: TimePass[] }; + } + + interface TimePass { + /** + * The parse object containing all parse time information. + * If no parsing was performed, the property is omitted. + */ + parse?: { total: number }; + + /** + * The rules object containing all lint time information for each rule. + */ + rules?: Record; + + /** + * The fix object containing all fix time information. + */ + fix: { total: number }; + + /** + * The total time that is spent on (parsing, fixing, linting) a file. + */ + total: number; + } +} + +// #endregion + +// #region ESLint + +export class ESLint { + static configType: "flat"; + + static readonly version: string; + + /** + * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint. + * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present. + */ + static readonly defaultConfig: Linter.Config[]; + + static outputFixes(results: ESLint.LintResult[]): Promise; + + static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[]; + + constructor(options?: ESLint.Options); + + lintFiles(patterns: string | string[]): Promise; + + lintText( + code: string, + options?: { + filePath?: string | undefined; + warnIgnored?: boolean | undefined; + }, + ): Promise; + + getRulesMetaForResults( + results: ESLint.LintResult[], + ): ESLint.LintResultData["rulesMeta"]; + + hasFlag(flag: string): boolean; + + calculateConfigForFile(filePath: string): Promise; + + findConfigFile(filePath?: string): Promise; + + isPathIgnored(filePath: string): Promise; + + loadFormatter(nameOrPath?: string): Promise; + + static fromOptionsModule(optionsURL: { + readonly href: string; + }): Promise; +} + +export namespace ESLint { + type ConfigData = Omit< + Linter.LegacyConfig, + "$schema" + >; + + type Environment = EnvironmentConfig; + type ObjectMetaProperties = CoreObjectMetaProperties; + type Plugin = CorePlugin; + + type FixType = "directive" | "problem" | "suggestion" | "layout"; + + type CacheStrategy = "content" | "metadata"; + + /** The options with which to configure the ESLint instance. */ + interface Options { + // File enumeration + + /** The value to use for the current working directory. */ + cwd?: string | undefined; + + /** If `false` then `ESLint#lintFiles()` doesn't throw even if no target files found. Defaults to `true`. */ + errorOnUnmatchedPattern?: boolean | undefined; + + /** + * Set to false to skip glob resolution of input file paths to lint (default: true). + * If false, each input file path is assumed to be a non-glob path to an existing file. + */ + globInputPaths?: boolean | undefined; + + /** False disables all ignore patterns except for the default ones. */ + ignore?: boolean | undefined; + + /** Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`. */ + ignorePatterns?: string[] | null | undefined; + + /** When set to true, missing patterns cause the linting operation to short circuit and not report any failures. */ + passOnNoPatterns?: boolean | undefined; + + /** Show warnings when the file list includes ignored files. */ + warnIgnored?: boolean | undefined; + + // Linting + + /** Enable or disable inline configuration comments. */ + allowInlineConfig?: boolean | undefined; + + /** Base config, extended by all configs used with this instance. */ + baseConfig?: Linter.Config | Linter.Config[] | null | undefined; + + /** Override config, overrides all configs used with this instance. */ + overrideConfig?: Linter.Config | Linter.Config[] | null | undefined; + + /** + * Searches for default config file when falsy; doesn't do any config file lookup when `true`; considered to be a config filename when a string. + */ + overrideConfigFile?: string | true | null | undefined; + + /** An array of plugin implementations. */ + plugins?: Record | null | undefined; + + /** + * Default is `() => true`. A predicate function that filters rules to be run. + * This function is called with an object containing `ruleId` and `severity`, and returns `true` if the rule should be run. + */ + ruleFilter?: + | ((arg: { + ruleId: string; + severity: Exclude; + }) => boolean) + | undefined; + + /** True enables added statistics on lint results. */ + stats?: boolean | undefined; + + // Autofix + + /** Execute in autofix mode. If a function, should return a boolean. */ + fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined; + + /** Array of rule types to apply fixes for. */ + fixTypes?: FixType[] | null | undefined; + + // Cache-related + + /** Enable result caching. */ + cache?: boolean | undefined; + + /** The cache file to use instead of .eslintcache. */ + cacheLocation?: string | undefined; + + /** The strategy used to detect changed files. */ + cacheStrategy?: CacheStrategy | undefined; + + /** If true, apply suppressions automatically. Defaults to false. */ + applySuppressions?: boolean | undefined; + + /** Path to suppressions file. Relative to cwd. Defaults to eslint-suppressions.json in cwd. */ + suppressionsLocation?: string | undefined; + + // Other Options + + /** Maximum number of linting threads, "auto" to choose automatically, "off" for no multithreading. */ + concurrency?: number | "auto" | "off" | undefined; + + /** Array of feature flags to enable. */ + flags?: string[] | undefined; + } + + /** A linting result. */ + interface LintResult { + /** The path to the file that was linted. */ + filePath: string; + + /** All of the messages for the result. */ + messages: Linter.LintMessage[]; + + /** All of the suppressed messages for the result. */ + suppressedMessages: Linter.SuppressedLintMessage[]; + + /** Number of errors for the result. */ + errorCount: number; + + /** Number of fatal errors for the result. */ + fatalErrorCount: number; + + /** Number of warnings for the result. */ + warningCount: number; + + /** Number of fixable errors for the result. */ + fixableErrorCount: number; + + /** Number of fixable warnings for the result. */ + fixableWarningCount: number; + + /** The source code of the file that was linted, with as many fixes applied as possible. */ + output?: string | undefined; + + /** The source code of the file that was linted. */ + source?: string | undefined; + + /** The performance statistics collected with the `stats` flag. */ + stats?: Linter.Stats | undefined; + + /** The list of used deprecated rules. */ + usedDeprecatedRules: DeprecatedRuleUse[]; + } + + /** + * Information provided when the maximum warning threshold is exceeded. + */ + interface MaxWarningsExceeded { + /** + * Number of warnings to trigger nonzero exit code. + */ + maxWarnings: number; + + /** + * Number of warnings found while linting. + */ + foundWarnings: number; + } + + interface LintResultData extends ResultsMeta { + cwd: string; + rulesMeta: { + [ruleId: string]: Rule.RuleMetaData; + }; + } + + /** + * Information about deprecated rules. + */ + interface DeprecatedRuleUse { + /** + * The rule ID. + */ + ruleId: string; + + /** + * The rule IDs that replace this deprecated rule. + */ + replacedBy: string[]; + + /** + * The raw deprecated info provided by the rule. + * - Undefined if the rule's `meta.deprecated` property is a boolean. + * - Unset when using the legacy eslintrc configuration. + */ + info?: DeprecatedInfo | undefined; + } + + /** + * Metadata about results for formatters. + */ + interface ResultsMeta { + /** + * Whether or not to use color in the formatter output. + * - If `--color` was set, this property is `true`. + * - If `--no-color` was set, it is `false`. + * - If neither option was provided, the property is omitted. + */ + color?: boolean | undefined; + + /** + * Present if the maxWarnings threshold was exceeded. + */ + maxWarningsExceeded?: MaxWarningsExceeded | undefined; + } + + /** The type of an object resolved by {@link ESLint.loadFormatter}. */ + interface LoadedFormatter { + /** + * Used to call the underlying formatter. + * @param results An array of lint results to format. + * @param resultsMeta An object with optional `color` and `maxWarningsExceeded` properties that will be + * passed to the underlying formatter function along with other properties set by ESLint. + * This argument can be omitted if `color` and `maxWarningsExceeded` are not needed. + * @return The formatter output. + */ + format( + results: LintResult[], + resultsMeta?: ResultsMeta, + ): string | Promise; + } + + // The documented type name is `LoadedFormatter`, but `Formatter` has been historically more used. + type Formatter = LoadedFormatter; + + /** + * The expected signature of a custom formatter. + * @param results An array of lint results to format. + * @param context Additional information for the formatter. + * @return The formatter output. + */ + type FormatterFunction = ( + results: LintResult[], + context: LintResultData, + ) => string | Promise; + + // Docs reference the types by those name + type EditInfo = Rule.Fix; +} + +// #endregion + +/** + * Loads the correct `ESLint` constructor. + */ +export function loadESLint(): Promise; + +// #region RuleTester + +export class RuleTester { + static describe: ((...args: any) => any) | null; + static it: ((...args: any) => any) | null; + static itOnly: ((...args: any) => any) | null; + static setDefaultConfig(config: Linter.Config): void; + static getDefaultConfig(): Linter.Config; + static resetDefaultConfig(): void; + + constructor(config?: Linter.Config); + + run( + name: string, + rule: RuleDefinition, + tests: { + valid: Array; + invalid: RuleTester.InvalidTestCase[]; + /** + * Additional assertions for the "error" matchers of invalid test cases to enforce consistency. + */ + assertionOptions?: { + /** + * If true, each `errors` block must check the expected error + * message, either via a string in the `errors` array, or via + * `message`/`messageId` in an errors object. + * `"message"`/`"messageId"` can be used to further limit the + * message assertions to the respective versions. + */ + requireMessage?: boolean | "message" | "messageId"; + /** + * If true, each `errors` block must be an array of objects, + * that each check all location properties `line`, `column`, + * `endLine`, `endColumn`, the later may be omitted, if the + * error does not contain them. + */ + requireLocation?: boolean; + /** + * If true, each error and suggestion with a `messageId` must specify a `data` + * property if the referenced message contains placeholders. + * `"error"` and `"suggestion" limit the assertion to errors and suggestions respectively. + */ + requireData?: boolean | "error" | "suggestion"; + }; + }, + ): void; + + static only( + item: string | RuleTester.ValidTestCase | RuleTester.InvalidTestCase, + ): RuleTester.ValidTestCase | RuleTester.InvalidTestCase; +} + +export namespace RuleTester { + interface ValidTestCase extends Omit< + Linter.Config, + | "name" + | "basePath" + | "files" + | "ignores" + | "linterOptions" + | "plugins" + | "rules" + > { + name?: string; + code: string; + options?: any[]; + filename?: string | undefined; + only?: boolean; + before?: () => void; + after?: () => void; + } + + interface SuggestionOutput { + messageId?: string; + desc?: string; + data?: MessagePlaceholderData | undefined; + output: string; + } + + interface InvalidTestCase extends ValidTestCase { + errors: number | Array; + output?: string | null | undefined; + } + + interface TestCaseError { + message?: string | RegExp; + messageId?: string; + data?: MessagePlaceholderData | undefined; + line?: number | undefined; + column?: number | undefined; + endLine?: number | undefined; + endColumn?: number | undefined; + suggestions?: SuggestionOutput[] | number | undefined; + } +} + +// #endregion diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/rules.d.ts b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/rules.d.ts new file mode 100644 index 00000000..d17bce5d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/rules.d.ts @@ -0,0 +1,5629 @@ +/** + * @fileoverview This file contains the rule types for ESLint. It was initially extracted + * from the `@types/eslint` package. + */ + +/* + * MIT License + * Copyright (c) Microsoft Corporation. + * + * 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 + */ + +//------------------------------------------------------------------------------ +// Imports +//------------------------------------------------------------------------------ + +import { Linter } from "./index"; + +//----------------------------------------------------------------------------- +// Helper types +//----------------------------------------------------------------------------- + +interface NoRestrictedImportPathCommonOptions { + name: string; + message?: string; + allowTypeImports?: boolean; +} + +type EitherImportNamesOrAllowImportName = + | { importNames?: string[]; allowImportNames?: never } + | { allowImportNames?: string[]; importNames?: never }; + +type ValidNoRestrictedImportPathOptions = NoRestrictedImportPathCommonOptions & + EitherImportNamesOrAllowImportName; + +interface NoRestrictedImportPatternCommonOptions { + message?: string; + caseSensitive?: boolean; + allowTypeImports?: boolean; +} + +// Base type for group or regex constraint, ensuring mutual exclusivity +type EitherGroupOrRegEx = + { group: string[]; regex?: never } | { regex: string; group?: never }; + +// Base type for import name specifiers, ensuring mutual exclusivity +type EitherNameSpecifiers = + | { + importNames?: string[]; + importNamePattern?: string; + allowImportNames?: never; + allowImportNamePattern?: never; + } + | { + allowImportNames?: string[]; + importNames?: never; + importNamePattern?: never; + allowImportNamePattern?: never; + } + | { + allowImportNamePattern?: string; + importNames?: never; + allowImportNames?: never; + importNamePattern?: never; + }; + +// Adds oneOf and not constraints, ensuring group or regex are present and mutually exclusive sets for importNames, allowImportNames, etc., as per the schema. +type ValidNoRestrictedImportPatternOptions = + NoRestrictedImportPatternCommonOptions & + EitherGroupOrRegEx & + EitherNameSpecifiers; + +interface CapitalizedCommentsCommonOptions { + ignorePattern?: string; + /** + * @default false + */ + ignoreInlineComments?: boolean; + /** + * @default false + */ + ignoreConsecutiveComments?: boolean; +} + +//----------------------------------------------------------------------------- +// Public types +//----------------------------------------------------------------------------- + +export interface ESLintRules extends Linter.RulesRecord { + /** + * Rule to enforce getter and setter pairs in objects and classes. + * + * @since 0.22.0 + * @see https://eslint.org/docs/latest/rules/accessor-pairs + */ + "accessor-pairs": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + setWithoutGet: boolean; + /** + * @default false + */ + getWithoutSet: boolean; + /** + * @default true + */ + enforceForClassMembers: boolean; + /** + * @default false + */ + enforceForTSTypes: boolean; + }>, + ] + >; + + /** + * Rule to enforce linebreaks after opening and before closing array brackets. + * + * @since 4.0.0-alpha.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`array-bracket-newline`](https://eslint.style/rules/array-bracket-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/array-bracket-newline + */ + "array-bracket-newline": Linter.RuleEntry< + [ + | "always" + | "never" + | "consistent" + | Partial<{ + /** + * @default true + */ + multiline: boolean; + /** + * @default null + */ + minItems: number | null; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing inside array brackets. + * + * @since 0.24.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`array-bracket-spacing`](https://eslint.style/rules/array-bracket-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/array-bracket-spacing + */ + "array-bracket-spacing": + | Linter.RuleEntry< + [ + "never", + Partial<{ + /** + * @default false + */ + singleValue: boolean; + /** + * @default false + */ + objectsInArrays: boolean; + /** + * @default false + */ + arraysInArrays: boolean; + }>, + ] + > + | Linter.RuleEntry< + [ + "always", + Partial<{ + /** + * @default true + */ + singleValue: boolean; + /** + * @default true + */ + objectsInArrays: boolean; + /** + * @default true + */ + arraysInArrays: boolean; + }>, + ] + >; + + /** + * Rule to enforce `return` statements in callbacks of array methods. + * + * @since 2.0.0-alpha-1 + * @see https://eslint.org/docs/latest/rules/array-callback-return + */ + "array-callback-return": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowImplicit: boolean; + /** + * @default false + */ + checkForEach: boolean; + /** + * @default false + */ + allowVoid: boolean; + }>, + ] + >; + + /** + * Rule to enforce line breaks after each array element. + * + * @since 4.0.0-rc.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`array-element-newline`](https://eslint.style/rules/array-element-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/array-element-newline + */ + "array-element-newline": Linter.RuleEntry< + [ + | "always" + | "never" + | "consistent" + | Partial<{ + /** + * @default true + */ + multiline: boolean; + /** + * @default null + */ + minItems: number | null; + }>, + ] + >; + + /** + * Rule to require braces around arrow function bodies. + * + * @since 1.8.0 + * @see https://eslint.org/docs/latest/rules/arrow-body-style + */ + "arrow-body-style": + | Linter.RuleEntry< + [ + "as-needed", + Partial<{ + /** + * @default false + */ + requireReturnForObjectLiteral: boolean; + }>, + ] + > + | Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to require parentheses around arrow function arguments. + * + * @since 1.0.0-rc-1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`arrow-parens`](https://eslint.style/rules/arrow-parens) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/arrow-parens + */ + "arrow-parens": + | Linter.RuleEntry<["always"]> + | Linter.RuleEntry< + [ + "as-needed", + Partial<{ + /** + * @default false + */ + requireForBlockBody: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing before and after the arrow in arrow functions. + * + * @since 1.0.0-rc-1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`arrow-spacing`](https://eslint.style/rules/arrow-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/arrow-spacing + */ + "arrow-spacing": Linter.RuleEntry<[]>; + + /** + * Rule to enforce the use of variables within the scope they are defined. + * + * @since 0.1.0 + * @see https://eslint.org/docs/latest/rules/block-scoped-var + */ + "block-scoped-var": Linter.RuleEntry<[]>; + + /** + * Rule to disallow or enforce spaces inside of blocks after opening block and before closing block. + * + * @since 1.2.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`block-spacing`](https://eslint.style/rules/block-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/block-spacing + */ + "block-spacing": Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to enforce consistent brace style for blocks. + * + * @since 0.0.7 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`brace-style`](https://eslint.style/rules/brace-style) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/brace-style + */ + "brace-style": Linter.RuleEntry< + [ + "1tbs" | "stroustrup" | "allman", + Partial<{ + /** + * @default false + */ + allowSingleLine: boolean; + }>, + ] + >; + + /** + * Rule to require `return` statements after callbacks. + * + * @since 1.0.0-rc-1 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`callback-return`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/callback-return.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/callback-return + */ + "callback-return": Linter.RuleEntry<[string[]]>; + + /** + * Rule to enforce camelcase naming convention. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/camelcase + */ + camelcase: Linter.RuleEntry< + [ + Partial<{ + /** + * @default 'always' + */ + properties: "always" | "never"; + /** + * @default false + */ + ignoreDestructuring: boolean; + /** + * @since 6.7.0 + * @default false + */ + ignoreImports: boolean; + /** + * @since 7.4.0 + * @default false + */ + ignoreGlobals: boolean; + /** + * @remarks + * Also accept for regular expression patterns + */ + allow: string[]; + }>, + ] + >; + + /** + * Rule to enforce or disallow capitalization of the first letter of a comment. + * + * @since 3.11.0 + * @see https://eslint.org/docs/latest/rules/capitalized-comments + */ + "capitalized-comments": Linter.RuleEntry< + [ + "always" | "never", + ( + | CapitalizedCommentsCommonOptions + | Partial<{ + line: CapitalizedCommentsCommonOptions; + block: CapitalizedCommentsCommonOptions; + }> + ), + ] + >; + + /** + * Rule to enforce that class methods utilize `this`. + * + * @since 3.4.0 + * @see https://eslint.org/docs/latest/rules/class-methods-use-this + */ + "class-methods-use-this": Linter.RuleEntry< + [ + Partial<{ + exceptMethods: string[]; + /** + * @default true + */ + enforceForClassFields: boolean; + /** + * @default false + */ + ignoreOverrideMethods: boolean; + ignoreClassesWithImplements: "all" | "public-fields"; + }>, + ] + >; + + /** + * Rule to require or disallow trailing commas. + * + * @since 0.16.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`comma-dangle`](https://eslint.style/rules/comma-dangle) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/comma-dangle + */ + "comma-dangle": Linter.RuleEntry< + [ + | "never" + | "always" + | "always-multiline" + | "only-multiline" + | Partial<{ + /** + * @default 'never' + */ + arrays: + | "never" + | "always" + | "always-multiline" + | "only-multiline"; + /** + * @default 'never' + */ + objects: + | "never" + | "always" + | "always-multiline" + | "only-multiline"; + /** + * @default 'never' + */ + imports: + | "never" + | "always" + | "always-multiline" + | "only-multiline"; + /** + * @default 'never' + */ + exports: + | "never" + | "always" + | "always-multiline" + | "only-multiline"; + /** + * @default 'never' + */ + functions: + | "never" + | "always" + | "always-multiline" + | "only-multiline"; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing before and after commas. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`comma-spacing`](https://eslint.style/rules/comma-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/comma-spacing + */ + "comma-spacing": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + before: boolean; + /** + * @default true + */ + after: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent comma style. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`comma-style`](https://eslint.style/rules/comma-style) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/comma-style + */ + "comma-style": Linter.RuleEntry< + [ + "last" | "first", + Partial<{ + exceptions: Record; + }>, + ] + >; + + /** + * Rule to enforce a maximum cyclomatic complexity allowed in a program. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/complexity + */ + complexity: Linter.RuleEntry< + [ + | Partial<{ + /** + * @default 20 + */ + max: number; + /** + * @deprecated + * @default 20 + */ + maximum: number; + /** + * @default "classic" + * @since 9.12.0 + */ + variant: "classic" | "modified"; + }> + | number, + ] + >; + + /** + * Rule to enforce consistent spacing inside computed property brackets. + * + * @since 0.23.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`computed-property-spacing`](https://eslint.style/rules/computed-property-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/computed-property-spacing + */ + "computed-property-spacing": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require `return` statements to either always or never specify values. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/consistent-return + */ + "consistent-return": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + treatUndefinedAsUnspecified: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent naming when capturing the current execution context. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/consistent-this + */ + "consistent-this": Linter.RuleEntry<[...string[]]>; + + /** + * Rule to require `super()` calls in constructors. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.24.0 + * @see https://eslint.org/docs/latest/rules/constructor-super + */ + "constructor-super": Linter.RuleEntry<[]>; + + /** + * Rule to enforce consistent brace style for all control statements. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/curly + */ + curly: Linter.RuleEntry< + ["all"] | ["multi" | "multi-line" | "multi-or-nest", "consistent"?] + >; + + /** + * Rule to require `default` cases in `switch` statements. + * + * @since 0.6.0 + * @see https://eslint.org/docs/latest/rules/default-case + */ + "default-case": Linter.RuleEntry< + [ + Partial<{ + /** + * @default '^no default$' + */ + commentPattern: string; + }>, + ] + >; + + /** + * Rule to enforce `default` clauses in `switch` statements to be last. + * + * @since 7.0.0-alpha.0 + * @see https://eslint.org/docs/latest/rules/default-case-last + */ + "default-case-last": Linter.RuleEntry<[]>; + + /** + * Rule to enforce default parameters to be last. + * + * @since 6.4.0 + * @see https://eslint.org/docs/latest/rules/default-param-last + */ + "default-param-last": Linter.RuleEntry<[]>; + + /** + * Rule to enforce consistent newlines before and after dots. + * + * @since 0.21.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`dot-location`](https://eslint.style/rules/dot-location) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/dot-location + */ + "dot-location": Linter.RuleEntry<["object" | "property"]>; + + /** + * Rule to enforce dot notation whenever possible. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/dot-notation + */ + "dot-notation": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + allowKeywords: boolean; + allowPattern: string; + }>, + ] + >; + + /** + * Rule to require or disallow newline at the end of files. + * + * @since 0.7.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`eol-last`](https://eslint.style/rules/eol-last) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/eol-last + */ + "eol-last": Linter.RuleEntry< + [ + "always" | "never", // | 'unix' | 'windows' + ] + >; + + /** + * Rule to require the use of `===` and `!==`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/eqeqeq + */ + eqeqeq: + | Linter.RuleEntry< + [ + "always", + Partial<{ + /** + * @default 'always' + */ + null: "always" | "never" | "ignore"; + }>, + ] + > + | Linter.RuleEntry<["smart" | "allow-null"]>; + + /** + * Rule to enforce `for` loop update clause moving the counter in the right direction. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 4.0.0-beta.0 + * @see https://eslint.org/docs/latest/rules/for-direction + */ + "for-direction": Linter.RuleEntry<[]>; + + /** + * Rule to require or disallow spacing between function identifiers and their invocations. + * + * @since 3.3.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`function-call-spacing`](https://eslint.style/rules/function-call-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/func-call-spacing + */ + "func-call-spacing": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require function names to match the name of the variable or property to which they are assigned. + * + * @since 3.8.0 + * @see https://eslint.org/docs/latest/rules/func-name-matching + */ + "func-name-matching": + | Linter.RuleEntry< + [ + "always" | "never", + Partial<{ + /** + * @default false + */ + considerPropertyDescriptor: boolean; + /** + * @default false + */ + includeCommonJSModuleExports: boolean; + }>, + ] + > + | Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + considerPropertyDescriptor: boolean; + /** + * @default false + */ + includeCommonJSModuleExports: boolean; + }>, + ] + >; + + /** + * Rule to require or disallow named `function` expressions. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/func-names + */ + "func-names": Linter.RuleEntry< + [ + "always" | "as-needed" | "never", + Partial<{ + generators: "always" | "as-needed" | "never"; + }>, + ] + >; + + /** + * Rule to enforce the consistent use of either `function` declarations or expressions assigned to variables. + * + * @since 0.2.0 + * @see https://eslint.org/docs/latest/rules/func-style + */ + "func-style": Linter.RuleEntry< + [ + "expression" | "declaration", + Partial<{ + /** + * @default false + */ + allowArrowFunctions: boolean; + /** + * @default false + */ + allowTypeAnnotation: boolean; + overrides: { + namedExports: "declaration" | "expression" | "ignore"; + }; + }>, + ] + >; + + /** + * Rule to enforce line breaks between arguments of a function call. + * + * @since 6.2.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`function-call-argument-newline`](https://eslint.style/rules/function-call-argument-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/function-call-argument-newline + */ + "function-call-argument-newline": Linter.RuleEntry< + [ + /** + * @default "always" + */ + "always" | "never" | "consistent", + ] + >; + + /** + * Rule to enforce consistent line breaks inside function parentheses. + * + * @since 4.6.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`function-paren-newline`](https://eslint.style/rules/function-paren-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/function-paren-newline + */ + "function-paren-newline": Linter.RuleEntry< + [ + | "always" + | "never" + | "multiline" + | "multiline-arguments" + | "consistent" + | Partial<{ + minItems: number; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing around `*` operators in generator functions. + * + * @since 0.17.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`generator-star-spacing`](https://eslint.style/rules/generator-star-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/generator-star-spacing + */ + "generator-star-spacing": Linter.RuleEntry< + [ + | Partial<{ + before: boolean; + after: boolean; + named: + | Partial<{ + before: boolean; + after: boolean; + }> + | "before" + | "after" + | "both" + | "neither"; + anonymous: + | Partial<{ + before: boolean; + after: boolean; + }> + | "before" + | "after" + | "both" + | "neither"; + method: + | Partial<{ + before: boolean; + after: boolean; + }> + | "before" + | "after" + | "both" + | "neither"; + }> + | "before" + | "after" + | "both" + | "neither", + ] + >; + + /** + * Rule to enforce `return` statements in getters. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 4.2.0 + * @see https://eslint.org/docs/latest/rules/getter-return + */ + "getter-return": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowImplicit: boolean; + }>, + ] + >; + + /** + * Rule to require `require()` calls to be placed at top-level module scope. + * + * @since 1.4.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`global-require`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/global-require.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/global-require + */ + "global-require": Linter.RuleEntry<[]>; + + /** + * Rule to require grouped accessor pairs in object literals and classes. + * + * @since 6.7.0 + * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs + */ + "grouped-accessor-pairs": Linter.RuleEntry< + [ + "anyOrder" | "getBeforeSet" | "setBeforeGet", + Partial<{ + /** + * @default false + */ + enforceForTSTypes: boolean; + }>, + ] + >; + + /** + * Rule to require `for-in` loops to include an `if` statement. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/guard-for-in + */ + "guard-for-in": Linter.RuleEntry<[]>; + + /** + * Rule to require error handling in callbacks. + * + * @since 0.4.5 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`handle-callback-err`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/handle-callback-err.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/handle-callback-err + */ + "handle-callback-err": Linter.RuleEntry<[string]>; + + /** + * Rule to disallow specified identifiers. + * + * @since 2.0.0-beta.2 + * @deprecated since 7.5.0. + * The rule was renamed. + * Please, use [`id-denylist`](https://eslint.org/docs/rules/id-denylist). + * @see https://eslint.org/docs/latest/rules/id-blacklist + */ + "id-blacklist": Linter.RuleEntry<[...string[]]>; + + /** + * Rule to disallow specified identifiers. + * + * @since 7.4.0 + * @see https://eslint.org/docs/latest/rules/id-denylist + */ + "id-denylist": Linter.RuleEntry; + + /** + * Rule to enforce minimum and maximum identifier lengths. + * + * @since 1.0.0 + * @see https://eslint.org/docs/latest/rules/id-length + */ + "id-length": Linter.RuleEntry< + [ + Partial<{ + /** + * @default 2 + */ + min: number; + /** + * @default Infinity + */ + max: number; + /** + * @default 'always' + */ + properties: "always" | "never"; + exceptions: string[]; + exceptionPatterns: string[]; + }>, + ] + >; + + /** + * Rule to require identifiers to match a specified regular expression. + * + * @since 1.0.0 + * @see https://eslint.org/docs/latest/rules/id-match + */ + "id-match": Linter.RuleEntry< + [ + string, + Partial<{ + /** + * @default false + */ + properties: boolean; + /** + * @default false + */ + classFields: boolean; + /** + * @default false + */ + onlyDeclarations: boolean; + /** + * @default false + */ + ignoreDestructuring: boolean; + }>, + ] + >; + + /** + * Rule to enforce the location of arrow function bodies. + * + * @since 4.12.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`implicit-arrow-linebreak`](https://eslint.style/rules/implicit-arrow-linebreak) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak + */ + "implicit-arrow-linebreak": Linter.RuleEntry<["beside" | "below"]>; + + /** + * Rule to enforce consistent indentation. + * + * @since 0.14.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`indent`](https://eslint.style/rules/indent) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/indent + */ + indent: Linter.RuleEntry< + [ + number | "tab", + Partial<{ + /** + * @default 0 + */ + SwitchCase: number; + /** + * @default 1 + */ + VariableDeclarator: + | Partial<{ + /** + * @default 1 + */ + var: number | "first"; + /** + * @default 1 + */ + let: number | "first"; + /** + * @default 1 + */ + const: number | "first"; + }> + | number + | "first"; + /** + * @default 1 + */ + outerIIFEBody: number; + /** + * @default 1 + */ + MemberExpression: number | "off"; + /** + * @default { parameters: 1, body: 1 } + */ + FunctionDeclaration: Partial<{ + /** + * @default 1 + */ + parameters: number | "first" | "off"; + /** + * @default 1 + */ + body: number; + }>; + /** + * @default { parameters: 1, body: 1 } + */ + FunctionExpression: Partial<{ + /** + * @default 1 + */ + parameters: number | "first" | "off"; + /** + * @default 1 + */ + body: number; + }>; + /** + * @default { arguments: 1 } + */ + CallExpression: Partial<{ + /** + * @default 1 + */ + arguments: number | "first" | "off"; + }>; + /** + * @default 1 + */ + ArrayExpression: number | "first" | "off"; + /** + * @default 1 + */ + ObjectExpression: number | "first" | "off"; + /** + * @default 1 + */ + ImportDeclaration: number | "first" | "off"; + /** + * @default false + */ + flatTernaryExpressions: boolean; + ignoredNodes: string[]; + /** + * @default false + */ + ignoreComments: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent indentation. + * + * @since 4.0.0-alpha.0 + * @deprecated since 4.0.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`indent`](https://eslint.style/rules/indent) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/indent-legacy + */ + "indent-legacy": Linter.RuleEntry< + [ + number | "tab", + Partial<{ + /** + * @default 0 + */ + SwitchCase: number; + /** + * @default 1 + */ + VariableDeclarator: + | Partial<{ + /** + * @default 1 + */ + var: number | "first"; + /** + * @default 1 + */ + let: number | "first"; + /** + * @default 1 + */ + const: number | "first"; + }> + | number + | "first"; + /** + * @default 1 + */ + outerIIFEBody: number; + /** + * @default 1 + */ + MemberExpression: number | "off"; + /** + * @default { parameters: 1, body: 1 } + */ + FunctionDeclaration: Partial<{ + /** + * @default 1 + */ + parameters: number | "first" | "off"; + /** + * @default 1 + */ + body: number; + }>; + /** + * @default { parameters: 1, body: 1 } + */ + FunctionExpression: Partial<{ + /** + * @default 1 + */ + parameters: number | "first" | "off"; + /** + * @default 1 + */ + body: number; + }>; + /** + * @default { arguments: 1 } + */ + CallExpression: Partial<{ + /** + * @default 1 + */ + arguments: number | "first" | "off"; + }>; + /** + * @default 1 + */ + ArrayExpression: number | "first" | "off"; + /** + * @default 1 + */ + ObjectExpression: number | "first" | "off"; + /** + * @default 1 + */ + ImportDeclaration: number | "first" | "off"; + /** + * @default false + */ + flatTernaryExpressions: boolean; + ignoredNodes: string[]; + /** + * @default false + */ + ignoreComments: boolean; + }>, + ] + >; + + /** + * Rule to require or disallow initialization in variable declarations. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/init-declarations + */ + "init-declarations": + | Linter.RuleEntry<["always"]> + | Linter.RuleEntry< + [ + "never", + Partial<{ + ignoreForLoopInit: boolean; + }>, + ] + >; + + /** + * Rule to enforce the consistent use of either double or single quotes in JSX attributes. + * + * @since 1.4.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`jsx-quotes`](https://eslint.style/rules/jsx-quotes) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/jsx-quotes + */ + "jsx-quotes": Linter.RuleEntry<["prefer-double" | "prefer-single"]>; + + /** + * Rule to enforce consistent spacing between keys and values in object literal properties. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`key-spacing`](https://eslint.style/rules/key-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/key-spacing + */ + "key-spacing": Linter.RuleEntry< + [ + | Partial< + | { + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + align: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'colon' + */ + on: "value" | "colon"; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }> + | "value" + | "colon"; + } + | { + singleLine?: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }> + | undefined; + multiLine?: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + align: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'colon' + */ + on: "value" | "colon"; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }> + | "value" + | "colon"; + }> + | undefined; + } + > + | { + align: Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'colon' + */ + on: "value" | "colon"; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }>; + singleLine?: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }> + | undefined; + multiLine?: + | Partial<{ + /** + * @default false + */ + beforeColon: boolean; + /** + * @default true + */ + afterColon: boolean; + /** + * @default 'strict' + */ + mode: "strict" | "minimum"; + }> + | undefined; + }, + ] + >; + + /** + * Rule to enforce consistent spacing before and after keywords. + * + * @since 2.0.0-beta.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`keyword-spacing`](https://eslint.style/rules/keyword-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/keyword-spacing + */ + "keyword-spacing": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + before: boolean; + /** + * @default true + */ + after: boolean; + overrides: Record< + string, + Partial<{ + before: boolean; + after: boolean; + }> + >; + }>, + ] + >; + + /** + * Rule to enforce position of line comments. + * + * @since 3.5.0 + * @deprecated since 9.3.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`line-comment-position`](https://eslint.style/rules/line-comment-position) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/line-comment-position + */ + "line-comment-position": Linter.RuleEntry< + [ + Partial<{ + /** + * @default 'above' + */ + position: "above" | "beside"; + ignorePattern: string; + /** + * @default true + */ + applyDefaultIgnorePatterns: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent linebreak style. + * + * @since 0.21.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`linebreak-style`](https://eslint.style/rules/linebreak-style) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/linebreak-style + */ + "linebreak-style": Linter.RuleEntry<["unix" | "windows"]>; + + /** + * Rule to require empty lines around comments. + * + * @since 0.22.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`lines-around-comment`](https://eslint.style/rules/lines-around-comment) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/lines-around-comment + */ + "lines-around-comment": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + beforeBlockComment: boolean; + /** + * @default false + */ + afterBlockComment: boolean; + /** + * @default false + */ + beforeLineComment: boolean; + /** + * @default false + */ + afterLineComment: boolean; + /** + * @default false + */ + allowBlockStart: boolean; + /** + * @default false + */ + allowBlockEnd: boolean; + /** + * @default false + */ + allowObjectStart: boolean; + /** + * @default false + */ + allowObjectEnd: boolean; + /** + * @default false + */ + allowArrayStart: boolean; + /** + * @default false + */ + allowArrayEnd: boolean; + /** + * @default false + */ + allowClassStart: boolean; + /** + * @default false + */ + allowClassEnd: boolean; + ignorePattern: string; + /** + * @default true + */ + applyDefaultIgnorePatterns: boolean; + }>, + ] + >; + + /** + * Rule to require or disallow newlines around directives. + * + * @since 3.5.0 + * @deprecated since 4.0.0. + * The rule was replaced with a more general rule. + * Please, use [`padding-line-between-statements`](https://eslint.style/rules/padding-line-between-statements) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/lines-around-directive + */ + "lines-around-directive": Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to require or disallow an empty line between class members. + * + * @since 4.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`lines-between-class-members`](https://eslint.style/rules/lines-between-class-members) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/lines-between-class-members + */ + "lines-between-class-members": Linter.RuleEntry< + [ + ( + | "always" + | "never" + | { + enforce: Array<{ + blankLine: "always" | "never"; + prev: "method" | "field" | "*"; + next: "method" | "field" | "*"; + }>; + } + ), + Partial<{ + /** + * @default false + */ + exceptAfterSingleLine: boolean; + }>, + ] + >; + + /** + * Rule to require or disallow logical assignment operator shorthand. + * + * @since 8.24.0 + * @see https://eslint.org/docs/latest/rules/logical-assignment-operators + */ + "logical-assignment-operators": + | Linter.RuleEntry< + [ + "always", + Partial<{ + /** + * @default false + */ + enforceForIfStatements: boolean; + }>, + ] + > + | Linter.RuleEntry<["never"]>; + + /** + * Rule to enforce a maximum number of classes per file. + * + * @since 5.0.0-alpha.3 + * @see https://eslint.org/docs/latest/rules/max-classes-per-file + */ + "max-classes-per-file": Linter.RuleEntry< + [ + | number + | Partial<{ + /** + * @default false + */ + ignoreExpressions: boolean; + /** + * @default 1 + */ + max: number; + }>, + ] + >; + + /** + * Rule to enforce a maximum depth that blocks can be nested. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/max-depth + */ + "max-depth": Linter.RuleEntry< + [ + | number + | Partial<{ + /** + * @deprecated + * @default 4 + */ + maximum: number; + /** + * @default 4 + */ + max: number; + }>, + ] + >; + + /** + * Rule to enforce a maximum line length. + * + * @since 0.0.9 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`max-len`](https://eslint.style/rules/max-len) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/max-len + */ + "max-len": Linter.RuleEntry< + [ + Partial<{ + /** + * @default 80 + */ + code: number; + /** + * @default 4 + */ + tabWidth: number; + comments: number; + ignorePattern: string; + /** + * @default false + */ + ignoreComments: boolean; + /** + * @default false + */ + ignoreTrailingComments: boolean; + /** + * @default false + */ + ignoreUrls: boolean; + /** + * @default false + */ + ignoreStrings: boolean; + /** + * @default false + */ + ignoreTemplateLiterals: boolean; + /** + * @default false + */ + ignoreRegExpLiterals: boolean; + }>, + ] + >; + + /** + * Rule to enforce a maximum number of lines per file. + * + * @since 2.12.0 + * @see https://eslint.org/docs/latest/rules/max-lines + */ + "max-lines": Linter.RuleEntry< + [ + | Partial<{ + /** + * @default 300 + */ + max: number; + /** + * @default false + */ + skipBlankLines: boolean; + /** + * @default false + */ + skipComments: boolean; + }> + | number, + ] + >; + + /** + * Rule to enforce a maximum number of lines of code in a function. + * + * @since 5.0.0 + * @see https://eslint.org/docs/latest/rules/max-lines-per-function + */ + "max-lines-per-function": Linter.RuleEntry< + [ + | number + | Partial<{ + /** + * @default 50 + */ + max: number; + /** + * @default false + */ + skipBlankLines: boolean; + /** + * @default false + */ + skipComments: boolean; + /** + * @default false + */ + IIFEs: boolean; + }>, + ] + >; + + /** + * Rule to enforce a maximum depth that callbacks can be nested. + * + * @since 0.2.0 + * @see https://eslint.org/docs/latest/rules/max-nested-callbacks + */ + "max-nested-callbacks": Linter.RuleEntry< + [ + | number + | Partial<{ + /** + * @deprecated + * @default 10 + */ + maximum: number; + /** + * @default 10 + */ + max: number; + /** + * @default false + */ + checkConstructorCallCallbacks: boolean; + }>, + ] + >; + + /** + * Rule to enforce a maximum number of parameters in function definitions. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/max-params + */ + "max-params": Linter.RuleEntry< + [ + | number + | Partial<{ + /** + * @deprecated + * @default 3 + */ + maximum: number; + /** + * @default 3 + */ + max: number; + /** + * @deprecated Replaced with `countThis' + * @default false + */ + countVoidThis: boolean; + /** + * @default "except-void" + */ + countThis: "always" | "never" | "except-void"; + }>, + ] + >; + + /** + * Rule to enforce a maximum number of statements allowed in function blocks. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/max-statements + */ + "max-statements": Linter.RuleEntry< + [ + ( + | number + | Partial<{ + /** + * @deprecated + * @default 10 + */ + maximum: number; + /** + * @default 10 + */ + max: number; + }> + ), + Partial<{ + /** + * @default false + */ + ignoreTopLevelFunctions: boolean; + }>, + ] + >; + + /** + * Rule to enforce a maximum number of statements allowed per line. + * + * @since 2.5.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`max-statements-per-line`](https://eslint.style/rules/max-statements-per-line) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/max-statements-per-line + */ + "max-statements-per-line": Linter.RuleEntry< + [ + | Partial<{ + /** + * @default 1 + */ + max: number; + }> + | number, + ] + >; + + /** + * Rule to enforce a particular style for multiline comments. + * + * @since 4.10.0 + * @deprecated since 9.3.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`multiline-comment-style`](https://eslint.style/rules/multiline-comment-style) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/multiline-comment-style + */ + "multiline-comment-style": Linter.RuleEntry< + ["starred-block" | "bare-block" | "separate-lines"] + >; + + /** + * Rule to enforce newlines between operands of ternary expressions. + * + * @since 3.1.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`multiline-ternary`](https://eslint.style/rules/multiline-ternary) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/multiline-ternary + */ + "multiline-ternary": Linter.RuleEntry< + ["always" | "always-multiline" | "never"] + >; + + /** + * Rule to require constructor names to begin with a capital letter. + * + * @since 0.0.3-0 + * @see https://eslint.org/docs/latest/rules/new-cap + */ + "new-cap": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + newIsCap: boolean; + /** + * @default true + */ + capIsNew: boolean; + newIsCapExceptions: string[]; + newIsCapExceptionPattern: string; + capIsNewExceptions: string[]; + capIsNewExceptionPattern: string; + /** + * @default true + */ + properties: boolean; + }>, + ] + >; + + /** + * Rule to enforce or disallow parentheses when invoking a constructor with no arguments. + * + * @since 0.0.6 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`new-parens`](https://eslint.style/rules/new-parens) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/new-parens + */ + "new-parens": Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to require or disallow an empty line after variable declarations. + * + * @since 0.18.0 + * @deprecated since 4.0.0. + * The rule was replaced with a more general rule. + * Please, use [`padding-line-between-statements`](https://eslint.style/rules/padding-line-between-statements) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/newline-after-var + */ + "newline-after-var": Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to require an empty line before `return` statements. + * + * @since 2.3.0 + * @deprecated since 4.0.0. + * The rule was replaced with a more general rule. + * Please, use [`padding-line-between-statements`](https://eslint.style/rules/padding-line-between-statements) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/newline-before-return + */ + "newline-before-return": Linter.RuleEntry<[]>; + + /** + * Rule to require a newline after each call in a method chain. + * + * @since 2.0.0-rc.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`newline-per-chained-call`](https://eslint.style/rules/newline-per-chained-call) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/newline-per-chained-call + */ + "newline-per-chained-call": Linter.RuleEntry< + [ + { + /** + * @default 2 + */ + ignoreChainWithDepth: number; + }, + ] + >; + + /** + * Rule to disallow the use of `alert`, `confirm`, and `prompt`. + * + * @since 0.0.5 + * @see https://eslint.org/docs/latest/rules/no-alert + */ + "no-alert": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `Array` constructors. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-array-constructor + */ + "no-array-constructor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow using an async function as a Promise executor. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 5.3.0 + * @see https://eslint.org/docs/latest/rules/no-async-promise-executor + */ + "no-async-promise-executor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `await` inside of loops. + * + * @since 3.12.0 + * @see https://eslint.org/docs/latest/rules/no-await-in-loop + */ + "no-await-in-loop": Linter.RuleEntry<[]>; + + /** + * Rule to disallow bitwise operators. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-bitwise + */ + "no-bitwise": Linter.RuleEntry< + [ + Partial<{ + /** + * @default [] + */ + allow: Array< + | "^" + | "|" + | "&" + | "<<" + | ">>" + | ">>>" + | "^=" + | "|=" + | "&=" + | "<<=" + | ">>=" + | ">>>=" + | "~" + >; + /** + * @default false + */ + int32Hint: boolean; + }>, + ] + >; + + /** + * Rule to disallow use of the `Buffer()` constructor. + * + * @since 4.0.0-alpha.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-deprecated-api`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-buffer-constructor + */ + "no-buffer-constructor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of `arguments.caller` or `arguments.callee`. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/no-caller + */ + "no-caller": Linter.RuleEntry<[]>; + + /** + * Rule to disallow lexical declarations in case clauses. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.9.0 + * @see https://eslint.org/docs/latest/rules/no-case-declarations + */ + "no-case-declarations": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `catch` clause parameters from shadowing variables in the outer scope. + * + * @since 0.0.9 + * @deprecated since 5.1.0. + * This rule was renamed. + * Please, use [`no-shadow`](https://eslint.org/docs/rules/no-shadow). + * @see https://eslint.org/docs/latest/rules/no-catch-shadow + */ + "no-catch-shadow": Linter.RuleEntry<[]>; + + /** + * Rule to disallow reassigning class members. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/no-class-assign + */ + "no-class-assign": Linter.RuleEntry<[]>; + + /** + * Rule to disallow comparing against `-0`. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 3.17.0 + * @see https://eslint.org/docs/latest/rules/no-compare-neg-zero + */ + "no-compare-neg-zero": Linter.RuleEntry<[]>; + + /** + * Rule to disallow assignment operators in conditional expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-cond-assign + */ + "no-cond-assign": Linter.RuleEntry<["except-parens" | "always"]>; + + /** + * Rule to disallow arrow functions where they could be confused with comparisons. + * + * @since 2.0.0-alpha-2 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-confusing-arrow`](https://eslint.style/rules/no-confusing-arrow) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-confusing-arrow + */ + "no-confusing-arrow": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + allowParens: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of `console`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-console + */ + "no-console": Linter.RuleEntry< + [ + Partial<{ + allow: Array; + }>, + ] + >; + + /** + * Rule to disallow reassigning `const`, `using`, and `await using` variables. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/no-const-assign + */ + "no-const-assign": Linter.RuleEntry<[]>; + + /** + * Rule to disallow expressions where the operation doesn't affect the value. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 8.14.0 + * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression + */ + "no-constant-binary-expression": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + checkRelationalComparisons: boolean; + }>, + ] + >; + + /** + * Rule to disallow constant expressions in conditions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.4.1 + * @see https://eslint.org/docs/latest/rules/no-constant-condition + */ + "no-constant-condition": Linter.RuleEntry< + [ + { + /** + * @default "allExceptWhileTrue" + */ + checkLoops: "all" | "allExceptWhileTrue" | "none" | boolean; + }, + ] + >; + + /** + * Rule to disallow returning value from constructor. + * + * @since 6.7.0 + * @see https://eslint.org/docs/latest/rules/no-constructor-return + */ + "no-constructor-return": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `continue` statements. + * + * @since 0.19.0 + * @see https://eslint.org/docs/latest/rules/no-continue + */ + "no-continue": Linter.RuleEntry<[]>; + + /** + * Rule to disallow control characters in regular expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.1.0 + * @see https://eslint.org/docs/latest/rules/no-control-regex + */ + "no-control-regex": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of `debugger`. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-debugger + */ + "no-debugger": Linter.RuleEntry<[]>; + + /** + * Rule to disallow deleting variables. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-delete-var + */ + "no-delete-var": Linter.RuleEntry<[]>; + + /** + * Rule to disallow equal signs explicitly at the beginning of regular expressions. + * + * @since 0.1.0 + * @see https://eslint.org/docs/latest/rules/no-div-regex + */ + "no-div-regex": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate arguments in `function` definitions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.16.0 + * @see https://eslint.org/docs/latest/rules/no-dupe-args + */ + "no-dupe-args": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate class members. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.2.0 + * @see https://eslint.org/docs/latest/rules/no-dupe-class-members + */ + "no-dupe-class-members": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate conditions in if-else-if chains. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 6.7.0 + * @see https://eslint.org/docs/latest/rules/no-dupe-else-if + */ + "no-dupe-else-if": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate keys in object literals. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-dupe-keys + */ + "no-dupe-keys": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate case labels. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.17.0 + * @see https://eslint.org/docs/latest/rules/no-duplicate-case + */ + "no-duplicate-case": Linter.RuleEntry<[]>; + + /** + * Rule to disallow duplicate module imports. + * + * @since 2.5.0 + * @see https://eslint.org/docs/latest/rules/no-duplicate-imports + */ + "no-duplicate-imports": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + includeExports: boolean; + /** + * @default false + */ + allowSeparateTypeImports: boolean; + }>, + ] + >; + + /** + * Rule to disallow `else` blocks after `return` statements in `if` statements. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-else-return + */ + "no-else-return": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + allowElseIf: boolean; + }>, + ] + >; + + /** + * Rule to disallow empty block statements. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-empty + */ + "no-empty": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowEmptyCatch: boolean; + }>, + ] + >; + + /** + * Rule to disallow empty character classes in regular expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.22.0 + * @see https://eslint.org/docs/latest/rules/no-empty-character-class + */ + "no-empty-character-class": Linter.RuleEntry<[]>; + + /** + * Rule to disallow empty functions. + * + * @since 2.0.0 + * @see https://eslint.org/docs/latest/rules/no-empty-function + */ + "no-empty-function": Linter.RuleEntry< + [ + Partial<{ + /** + * @default [] + */ + allow: Array< + | "functions" + | "arrowFunctions" + | "generatorFunctions" + | "methods" + | "generatorMethods" + | "getters" + | "setters" + | "constructors" + | "asyncFunctions" + | "asyncMethods" + | "privateConstructors" + | "protectedConstructors" + | "decoratedFunctions" + | "overrideMethods" + >; + }>, + ] + >; + + /** + * Rule to disallow empty destructuring patterns. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.7.0 + * @see https://eslint.org/docs/latest/rules/no-empty-pattern + */ + "no-empty-pattern": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowObjectPatternsAsParameters: boolean; + }>, + ] + >; + + /** + * Rule to disallow empty static blocks. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 8.27.0 + * @see https://eslint.org/docs/latest/rules/no-empty-static-block + */ + "no-empty-static-block": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `null` comparisons without type-checking operators. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-eq-null + */ + "no-eq-null": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of `eval()`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-eval + */ + "no-eval": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowIndirect: boolean; + }>, + ] + >; + + /** + * Rule to disallow reassigning exceptions in `catch` clauses. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-ex-assign + */ + "no-ex-assign": Linter.RuleEntry<[]>; + + /** + * Rule to disallow extending native types. + * + * @since 0.1.4 + * @see https://eslint.org/docs/latest/rules/no-extend-native + */ + "no-extend-native": Linter.RuleEntry< + [ + Partial<{ + exceptions: string[]; + }>, + ] + >; + + /** + * Rule to disallow unnecessary calls to `.bind()`. + * + * @since 0.8.0 + * @see https://eslint.org/docs/latest/rules/no-extra-bind + */ + "no-extra-bind": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary boolean casts. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-extra-boolean-cast + */ + "no-extra-boolean-cast": Linter.RuleEntry< + [ + | Partial<{ + /** + * @since 9.3.0 + * @default false + */ + enforceForInnerExpressions: boolean; + /** + * @deprecated + */ + enforceForLogicalOperands: never; + }> + | Partial<{ + /** + * @deprecated + * @since 7.0.0-alpha.2 + * @default false + */ + enforceForLogicalOperands: boolean; + enforceForInnerExpressions: never; + }>, + ] + >; + + /** + * Rule to disallow unnecessary labels. + * + * @since 2.0.0-rc.0 + * @see https://eslint.org/docs/latest/rules/no-extra-label + */ + "no-extra-label": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary parentheses. + * + * @since 0.1.4 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-extra-parens`](https://eslint.style/rules/no-extra-parens) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-extra-parens + */ + "no-extra-parens": + | Linter.RuleEntry< + [ + "all", + Partial<{ + /** + * @default true, + */ + conditionalAssign: boolean; + /** + * @default true + */ + returnAssign: boolean; + /** + * @default true + */ + nestedBinaryExpressions: boolean; + /** + * @default 'none' + */ + ignoreJSX: + "none" | "all" | "multi-line" | "single-line"; + /** + * @default true + */ + enforceForArrowConditionals: boolean; + }>, + ] + > + | Linter.RuleEntry<["functions"]>; + + /** + * Rule to disallow unnecessary semicolons. + * + * @since 0.0.9 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-extra-semi`](https://eslint.style/rules/no-extra-semi) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-extra-semi + */ + "no-extra-semi": Linter.RuleEntry<[]>; + + /** + * Rule to disallow fallthrough of `case` statements. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/no-fallthrough + */ + "no-fallthrough": Linter.RuleEntry< + [ + Partial<{ + /** + * @default 'falls?\s?through' + */ + commentPattern: string; + /** + * @default false + */ + allowEmptyCase: boolean; + /** + * @default false + */ + reportUnusedFallthroughComment: boolean; + }>, + ] + >; + + /** + * Rule to disallow leading or trailing decimal points in numeric literals. + * + * @since 0.0.6 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-floating-decimal`](https://eslint.style/rules/no-floating-decimal) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-floating-decimal + */ + "no-floating-decimal": Linter.RuleEntry<[]>; + + /** + * Rule to disallow reassigning `function` declarations. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-func-assign + */ + "no-func-assign": Linter.RuleEntry<[]>; + + /** + * Rule to disallow assignments to native objects or read-only global variables. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 3.3.0 + * @see https://eslint.org/docs/latest/rules/no-global-assign + */ + "no-global-assign": Linter.RuleEntry< + [ + Partial<{ + exceptions: string[]; + }>, + ] + >; + + /** + * Rule to disallow shorthand type conversions. + * + * @since 1.0.0-rc-2 + * @see https://eslint.org/docs/latest/rules/no-implicit-coercion + */ + "no-implicit-coercion": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + boolean: boolean; + /** + * @default true + */ + number: boolean; + /** + * @default true + */ + string: boolean; + /** + * @default false + */ + disallowTemplateShorthand: boolean; + /** + * @default [] + */ + allow: Array<"~" | "!!" | "+" | "- -" | "-" | "*">; + }>, + ] + >; + + /** + * Rule to disallow declarations in the global scope. + * + * @since 2.0.0-alpha-1 + * @see https://eslint.org/docs/latest/rules/no-implicit-globals + */ + "no-implicit-globals": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + lexicalBindings: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of `eval()`-like methods. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/no-implied-eval + */ + "no-implied-eval": Linter.RuleEntry<[]>; + + /** + * Rule to disallow assigning to imported bindings. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 6.4.0 + * @see https://eslint.org/docs/latest/rules/no-import-assign + */ + "no-import-assign": Linter.RuleEntry<[]>; + + /** + * Rule to disallow inline comments after code. + * + * @since 0.10.0 + * @see https://eslint.org/docs/latest/rules/no-inline-comments + */ + "no-inline-comments": Linter.RuleEntry< + [ + Partial<{ + ignorePattern: string; + }>, + ] + >; + + /** + * Rule to disallow variable or `function` declarations in nested blocks. + * + * @since 0.6.0 + * @see https://eslint.org/docs/latest/rules/no-inner-declarations + */ + "no-inner-declarations": Linter.RuleEntry< + [ + "functions" | "both", + Partial<{ + /** + * @default "allow" + */ + blockScopedFunctions: "allow" | "disallow"; + }>, + ] + >; + + /** + * Rule to disallow invalid regular expression strings in `RegExp` constructors. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.1.4 + * @see https://eslint.org/docs/latest/rules/no-invalid-regexp + */ + "no-invalid-regexp": Linter.RuleEntry< + [ + Partial<{ + allowConstructorFlags: string[]; + }>, + ] + >; + + /** + * Rule to disallow use of `this` in contexts where the value of `this` is `undefined`. + * + * @since 1.0.0-rc-2 + * @see https://eslint.org/docs/latest/rules/no-invalid-this + */ + "no-invalid-this": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + capIsConstructor: boolean; + }>, + ] + >; + + /** + * Rule to disallow irregular whitespace. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.9.0 + * @see https://eslint.org/docs/latest/rules/no-irregular-whitespace + */ + "no-irregular-whitespace": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + skipStrings: boolean; + /** + * @default false + */ + skipComments: boolean; + /** + * @default false + */ + skipRegExps: boolean; + /** + * @default false + */ + skipTemplates: boolean; + /** + * @default false + */ + skipJSXText: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of the `__iterator__` property. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-iterator + */ + "no-iterator": Linter.RuleEntry<[]>; + + /** + * Rule to disallow labels that share a name with a variable. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-label-var + */ + "no-label-var": Linter.RuleEntry<[]>; + + /** + * Rule to disallow labeled statements. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-labels + */ + "no-labels": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowLoop: boolean; + /** + * @default false + */ + allowSwitch: boolean; + }>, + ] + >; + + /** + * Rule to disallow unnecessary nested blocks. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-lone-blocks + */ + "no-lone-blocks": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `if` statements as the only statement in `else` blocks. + * + * @since 0.6.0 + * @see https://eslint.org/docs/latest/rules/no-lonely-if + */ + "no-lonely-if": Linter.RuleEntry<[]>; + + /** + * Rule to disallow function declarations that contain unsafe references inside loop statements. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-loop-func + */ + "no-loop-func": Linter.RuleEntry<[]>; + + /** + * Rule to disallow literal numbers that lose precision. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 7.1.0 + * @see https://eslint.org/docs/latest/rules/no-loss-of-precision + */ + "no-loss-of-precision": Linter.RuleEntry<[]>; + + /** + * Rule to disallow magic numbers. + * + * @since 1.7.0 + * @see https://eslint.org/docs/latest/rules/no-magic-numbers + */ + "no-magic-numbers": Linter.RuleEntry< + [ + Partial<{ + /** + * @default [] + */ + ignore: Array; + /** + * @default false + */ + ignoreArrayIndexes: boolean; + /** + * @default false + */ + ignoreDefaultValues: boolean; + /** + * @default false + */ + ignoreClassFieldInitialValues: boolean; + /** + * @default false + */ + enforceConst: boolean; + /** + * @default false + */ + detectObjects: boolean; + /** + * @default false + */ + ignoreEnums: boolean; + /** + * @default false + */ + ignoreNumericLiteralTypes: boolean; + /** + * @default false + */ + ignoreReadonlyClassProperties: boolean; + /** + * @default false + */ + ignoreTypeIndexes: boolean; + }>, + ] + >; + + /** + * Rule to disallow characters which are made with multiple code points in character class syntax. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 5.3.0 + * @see https://eslint.org/docs/latest/rules/no-misleading-character-class + */ + "no-misleading-character-class": Linter.RuleEntry< + [ + Partial<{ + /** + * @since 9.3.0 + * @default false + */ + allowEscape: boolean; + }>, + ] + >; + + /** + * Rule to disallow mixed binary operators. + * + * @since 2.12.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-mixed-operators`](https://eslint.style/rules/no-mixed-operators) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-mixed-operators + */ + "no-mixed-operators": Linter.RuleEntry< + [ + Partial<{ + /** + * @default + * [ + * ["+", "-", "*", "/", "%", "**"], + * ["&", "|", "^", "~", "<<", ">>", ">>>"], + * ["==", "!=", "===", "!==", ">", ">=", "<", "<="], + * ["&&", "||"], + * ["in", "instanceof"] + * ] + */ + groups: string[][]; + /** + * @default true + */ + allowSamePrecedence: boolean; + }>, + ] + >; + + /** + * Rule to disallow `require` calls to be mixed with regular variable declarations. + * + * @since 0.0.9 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-mixed-requires`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-mixed-requires.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-mixed-requires + */ + "no-mixed-requires": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + grouping: boolean; + /** + * @default false + */ + allowCall: boolean; + }>, + ] + >; + + /** + * Rule to disallow mixed spaces and tabs for indentation. + * + * @since 0.7.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-mixed-spaces-and-tabs`](https://eslint.style/rules/no-mixed-spaces-and-tabs) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs + */ + "no-mixed-spaces-and-tabs": Linter.RuleEntry<["smart-tabs"]>; + + /** + * Rule to disallow use of chained assignment expressions. + * + * @since 3.14.0 + * @see https://eslint.org/docs/latest/rules/no-multi-assign + */ + "no-multi-assign": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + ignoreNonDeclaration: boolean; + }>, + ] + >; + + /** + * Rule to disallow multiple spaces. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-multi-spaces`](https://eslint.style/rules/no-multi-spaces) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-multi-spaces + */ + "no-multi-spaces": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + ignoreEOLComments: boolean; + /** + * @default { Property: true } + */ + exceptions: Record; + }>, + ] + >; + + /** + * Rule to disallow multiline strings. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-multi-str + */ + "no-multi-str": Linter.RuleEntry<[]>; + + /** + * Rule to disallow multiple empty lines. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-multiple-empty-lines`](https://eslint.style/rules/no-multiple-empty-lines) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-multiple-empty-lines + */ + "no-multiple-empty-lines": Linter.RuleEntry< + [ + | Partial<{ + /** + * @default 2 + */ + max: number; + maxEOF: number; + maxBOF: number; + }> + | number, + ] + >; + + /** + * Rule to disallow assignments to native objects or read-only global variables. + * + * @since 0.0.9 + * @deprecated since 3.3.0. + * Renamed rule. + * Please, use [`no-global-assign`](https://eslint.org/docs/rules/no-global-assign). + * @see https://eslint.org/docs/latest/rules/no-native-reassign + */ + "no-native-reassign": Linter.RuleEntry< + [ + Partial<{ + exceptions: string[]; + }>, + ] + >; + + /** + * Rule to disallow negated conditions. + * + * @since 1.6.0 + * @see https://eslint.org/docs/latest/rules/no-negated-condition + */ + "no-negated-condition": Linter.RuleEntry<[]>; + + /** + * Rule to disallow negating the left operand in `in` expressions. + * + * @since 0.1.2 + * @deprecated since 3.3.0. + * Renamed rule. + * Please, use [`no-unsafe-negation`](https://eslint.org/docs/rules/no-unsafe-negation). + * @see https://eslint.org/docs/latest/rules/no-negated-in-lhs + */ + "no-negated-in-lhs": Linter.RuleEntry<[]>; + + /** + * Rule to disallow nested ternary expressions. + * + * @since 0.2.0 + * @see https://eslint.org/docs/latest/rules/no-nested-ternary + */ + "no-nested-ternary": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators outside of assignments or comparisons. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/no-new + */ + "no-new": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators with the `Function` object. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/no-new-func + */ + "no-new-func": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators with global non-constructor functions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 8.27.0 + * @see https://eslint.org/docs/latest/rules/no-new-native-nonconstructor + */ + "no-new-native-nonconstructor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `Object` constructors. + * + * @since 0.0.9 + * @deprecated since 8.50.0. + * The new rule flags more situations where object literal syntax can be used, and it does not report a problem when the `Object` constructor is invoked with an argument. + * Please, use [`no-object-constructor`](https://eslint.org/docs/rules/no-object-constructor). + * @see https://eslint.org/docs/latest/rules/no-new-object + */ + "no-new-object": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators with calls to `require`. + * + * @since 0.6.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-new-require`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-new-require.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-new-require + */ + "no-new-require": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators with the `Symbol` object. + * + * @since 2.0.0-beta.1 + * @deprecated since 9.0.0. + * The rule was replaced with a more general rule. + * Please, use [`no-new-native-nonconstructor`](https://eslint.org/docs/latest/rules/no-new-native-nonconstructor). + * @see https://eslint.org/docs/latest/rules/no-new-symbol + */ + "no-new-symbol": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `new` operators with the `String`, `Number`, and `Boolean` objects. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/no-new-wrappers + */ + "no-new-wrappers": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `\8` and `\9` escape sequences in string literals. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 7.14.0 + * @see https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape + */ + "no-nonoctal-decimal-escape": Linter.RuleEntry<[]>; + + /** + * Rule to disallow calling global object properties as functions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-obj-calls + */ + "no-obj-calls": Linter.RuleEntry<[]>; + + /** + * Rule to disallow calls to the `Object` constructor without an argument. + * + * @since 8.50.0 + * @see https://eslint.org/docs/latest/rules/no-object-constructor + */ + "no-object-constructor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow octal literals. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/no-octal + */ + "no-octal": Linter.RuleEntry<[]>; + + /** + * Rule to disallow octal escape sequences in string literals. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-octal-escape + */ + "no-octal-escape": Linter.RuleEntry<[]>; + + /** + * Rule to disallow reassigning function parameters. + * + * @since 0.18.0 + * @see https://eslint.org/docs/latest/rules/no-param-reassign + */ + "no-param-reassign": Linter.RuleEntry< + [ + | { + props?: false; + } + | ({ + props: true; + } & Partial<{ + /** + * @default [] + */ + ignorePropertyModificationsFor: string[]; + /** + * @since 6.6.0 + * @default [] + */ + ignorePropertyModificationsForRegex: string[]; + }>), + ] + >; + + /** + * Rule to disallow string concatenation with `__dirname` and `__filename`. + * + * @since 0.4.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-path-concat`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-path-concat.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-path-concat + */ + "no-path-concat": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the unary operators `++` and `--`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-plusplus + */ + "no-plusplus": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowForLoopAfterthoughts: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of `process.env`. + * + * @since 0.9.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-process-env`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-env.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-process-env + */ + "no-process-env": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of `process.exit()`. + * + * @since 0.4.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-process-exit`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-exit.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-process-exit + */ + "no-process-exit": Linter.RuleEntry<[]>; + + /** + * Rule to disallow returning values from Promise executor functions. + * + * @since 7.3.0 + * @see https://eslint.org/docs/latest/rules/no-promise-executor-return + */ + "no-promise-executor-return": Linter.RuleEntry< + [ + { + /** + * @default false + */ + allowVoid?: boolean; + }, + ] + >; + + /** + * Rule to disallow the use of the `__proto__` property. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-proto + */ + "no-proto": Linter.RuleEntry<[]>; + + /** + * Rule to disallow calling some `Object.prototype` methods directly on objects. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 2.11.0 + * @see https://eslint.org/docs/latest/rules/no-prototype-builtins + */ + "no-prototype-builtins": Linter.RuleEntry<[]>; + + /** + * Rule to disallow variable redeclaration. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-redeclare + */ + "no-redeclare": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + builtinGlobals: boolean; + }>, + ] + >; + + /** + * Rule to disallow multiple spaces in regular expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-regex-spaces + */ + "no-regex-spaces": Linter.RuleEntry<[]>; + + /** + * Rule to disallow specified names in exports. + * + * @since 7.0.0-alpha.0 + * @see https://eslint.org/docs/latest/rules/no-restricted-exports + */ + "no-restricted-exports": Linter.RuleEntry< + [ + Partial<{ + /** + * @default [] + */ + restrictedNamedExports: string[]; + /** + * @since 9.3.0 + */ + restrictedNamedExportsPattern: string; + /** + * @since 8.33.0 + */ + restrictDefaultExports: Partial<{ + /** + * @default false + */ + direct: boolean; + /** + * @default false + */ + named: boolean; + /** + * @default false + */ + defaultFrom: boolean; + /** + * @default false + */ + namedFrom: boolean; + /** + * @default false + */ + namespaceFrom: boolean; + }>; + }>, + ] + >; + + /** + * Rule to disallow specified global variables. + * + * @since 2.3.0 + * @see https://eslint.org/docs/latest/rules/no-restricted-globals + */ + "no-restricted-globals": Linter.RuleEntry< + [ + ...( + | Array< + | string + | { + name: string; + message?: string | undefined; + } + > + | Array<{ + globals: Array< + | string + | { + name: string; + message?: string | undefined; + } + >; + checkGlobalObject?: boolean; + globalObjects?: string[]; + }> + ), + ] + >; + + /** + * Rule to disallow specified modules when loaded by `import`. + * + * @since 2.0.0-alpha-1 + * @see https://eslint.org/docs/latest/rules/no-restricted-imports + */ + "no-restricted-imports": Linter.RuleEntry< + [ + ...Array< + | string + | ValidNoRestrictedImportPathOptions + | Partial<{ + paths: Array< + string | ValidNoRestrictedImportPathOptions + >; + patterns: + | Array + | Array; + }> + >, + ] + >; + + /** + * Rule to disallow specified modules when loaded by `require`. + * + * @since 0.6.0 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-restricted-require`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-restricted-require.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-restricted-modules + */ + "no-restricted-modules": Linter.RuleEntry< + [ + ...Array< + | string + | { + name: string; + message?: string | undefined; + } + | Partial<{ + paths: Array< + | string + | { + name: string; + message?: string | undefined; + } + >; + patterns: string[]; + }> + >, + ] + >; + + /** + * Rule to disallow certain properties on certain objects. + * + * @since 3.5.0 + * @see https://eslint.org/docs/latest/rules/no-restricted-properties + */ + "no-restricted-properties": Linter.RuleEntry< + [ + ...Array< + | { + object: string; + property?: string | undefined; + message?: string | undefined; + } + | { + property: string; + allowObjects?: string[]; + message?: string | undefined; + } + | { + object: string; + allowProperties?: string[]; + message?: string | undefined; + } + >, + ] + >; + + /** + * Rule to disallow specified syntax. + * + * @since 1.4.0 + * @see https://eslint.org/docs/latest/rules/no-restricted-syntax + */ + "no-restricted-syntax": Linter.RuleEntry< + [ + ...Array< + | string + | { + selector: string; + message?: string | undefined; + } + >, + ] + >; + + /** + * Rule to disallow assignment operators in `return` statements. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-return-assign + */ + "no-return-assign": Linter.RuleEntry<["except-parens" | "always"]>; + + /** + * Rule to disallow unnecessary `return await`. + * + * @since 3.10.0 + * @deprecated since 8.46.0. + * The original assumption of the rule no longer holds true because of engine optimization. + * @see https://eslint.org/docs/latest/rules/no-return-await + */ + "no-return-await": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `javascript:` URLs. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-script-url + */ + "no-script-url": Linter.RuleEntry<[]>; + + /** + * Rule to disallow assignments where both sides are exactly the same. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 2.0.0-rc.0 + * @see https://eslint.org/docs/latest/rules/no-self-assign + */ + "no-self-assign": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + props: boolean; + }>, + ] + >; + + /** + * Rule to disallow comparisons where both sides are exactly the same. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-self-compare + */ + "no-self-compare": Linter.RuleEntry<[]>; + + /** + * Rule to disallow comma operators. + * + * @since 0.5.1 + * @see https://eslint.org/docs/latest/rules/no-sequences + */ + "no-sequences": Linter.RuleEntry< + [ + Partial<{ + /** + * @since 7.23.0 + * @default true + */ + allowInParentheses: boolean; + }>, + ] + >; + + /** + * Rule to disallow returning values from setters. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 6.7.0 + * @see https://eslint.org/docs/latest/rules/no-setter-return + */ + "no-setter-return": Linter.RuleEntry<[]>; + + /** + * Rule to disallow variable declarations from shadowing variables declared in the outer scope. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-shadow + */ + "no-shadow": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + builtinGlobals: boolean; + /** + * @default 'functions' + */ + hoist: + | "functions" + | "all" + | "never" + | "types" + | "functions-and-types"; + allow: string[]; + /** + * @since 8.10.0 + * @default false + */ + ignoreOnInitialization: boolean; + /** + * @default true + */ + ignoreTypeValueShadow: boolean; + /** + * @default true + */ + ignoreFunctionTypeParameterNameValueShadow: boolean; + }>, + ] + >; + + /** + * Rule to disallow identifiers from shadowing restricted names. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.1.4 + * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names + */ + "no-shadow-restricted-names": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + reportGlobalThis: boolean; + }>, + ] + >; + + /** + * Rule to disallow spacing between function identifiers and their applications (deprecated). + * + * @since 0.1.2 + * @deprecated since 3.3.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`function-call-spacing`](https://eslint.style/rules/function-call-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-spaced-func + */ + "no-spaced-func": Linter.RuleEntry<[]>; + + /** + * Rule to disallow sparse arrays. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.4.0 + * @see https://eslint.org/docs/latest/rules/no-sparse-arrays + */ + "no-sparse-arrays": Linter.RuleEntry<[]>; + + /** + * Rule to disallow synchronous methods. + * + * @since 0.0.9 + * @deprecated since 7.0.0. + * Node.js rules were moved out of ESLint core. + * Please, use [`no-sync`](https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-sync.md) in [`eslint-plugin-n`](https://github.com/eslint-community/eslint-plugin-n). + * @see https://eslint.org/docs/latest/rules/no-sync + */ + "no-sync": Linter.RuleEntry< + [ + { + /** + * @default false + */ + allowAtRootLevel: boolean; + }, + ] + >; + + /** + * Rule to disallow all tabs. + * + * @since 3.2.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-tabs`](https://eslint.style/rules/no-tabs) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-tabs + */ + "no-tabs": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowIndentationTabs: boolean; + }>, + ] + >; + + /** + * Rule to disallow template literal placeholder syntax in regular strings. + * + * @since 3.3.0 + * @see https://eslint.org/docs/latest/rules/no-template-curly-in-string + */ + "no-template-curly-in-string": Linter.RuleEntry<[]>; + + /** + * Rule to disallow ternary operators. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-ternary + */ + "no-ternary": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `this`/`super` before calling `super()` in constructors. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.24.0 + * @see https://eslint.org/docs/latest/rules/no-this-before-super + */ + "no-this-before-super": Linter.RuleEntry<[]>; + + /** + * Rule to disallow throwing literals as exceptions. + * + * @since 0.15.0 + * @see https://eslint.org/docs/latest/rules/no-throw-literal + */ + "no-throw-literal": Linter.RuleEntry<[]>; + + /** + * Rule to disallow trailing whitespace at the end of lines. + * + * @since 0.7.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-trailing-spaces`](https://eslint.style/rules/no-trailing-spaces) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-trailing-spaces + */ + "no-trailing-spaces": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + skipBlankLines: boolean; + /** + * @default false + */ + ignoreComments: boolean; + }>, + ] + >; + + /** + * Rule to disallow `let` or `var` variables that are read but never assigned. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 9.27.0 + * @see https://eslint.org/docs/latest/rules/no-unassigned-vars + */ + "no-unassigned-vars": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of undeclared variables unless mentioned in \/*global *\/ comments. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-undef + */ + "no-undef": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + typeof: boolean; + }>, + ] + >; + + /** + * Rule to disallow initializing variables to `undefined`. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/no-undef-init + */ + "no-undef-init": Linter.RuleEntry<[]>; + + /** + * Rule to disallow the use of `undefined` as an identifier. + * + * @since 0.7.1 + * @see https://eslint.org/docs/latest/rules/no-undefined + */ + "no-undefined": Linter.RuleEntry<[]>; + + /** + * Rule to disallow dangling underscores in identifiers. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-underscore-dangle + */ + "no-underscore-dangle": Linter.RuleEntry< + [ + Partial<{ + allow: string[]; + /** + * @default false + */ + allowAfterThis: boolean; + /** + * @default false + */ + allowAfterSuper: boolean; + /** + * @since 6.7.0 + * @default false + */ + allowAfterThisConstructor: boolean; + /** + * @default false + */ + enforceInMethodNames: boolean; + /** + * @since 8.15.0 + * @default false + */ + enforceInClassFields: boolean; + /** + * @since 8.31.0 + * @default true + */ + allowInArrayDestructuring: boolean; + /** + * @since 8.31.0 + * @default true + */ + allowInObjectDestructuring: boolean; + /** + * @since 7.7.0 + * @default true + */ + allowFunctionParams: boolean; + }>, + ] + >; + + /** + * Rule to disallow confusing multiline expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.24.0 + * @see https://eslint.org/docs/latest/rules/no-unexpected-multiline + */ + "no-unexpected-multiline": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unmodified loop conditions. + * + * @since 2.0.0-alpha-2 + * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition + */ + "no-unmodified-loop-condition": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + checkConditionalExpressions: boolean; + }>, + ] + >; + + /** + * Rule to disallow ternary operators when simpler alternatives exist. + * + * @since 0.21.0 + * @see https://eslint.org/docs/latest/rules/no-unneeded-ternary + */ + "no-unneeded-ternary": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + defaultAssignment: boolean; + }>, + ] + >; + + /** + * Rule to disallow unreachable code after `return`, `throw`, `continue`, and `break` statements. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/no-unreachable + */ + "no-unreachable": Linter.RuleEntry<[]>; + + /** + * Rule to disallow loops with a body that allows only one iteration. + * + * @since 7.3.0 + * @see https://eslint.org/docs/latest/rules/no-unreachable-loop + */ + "no-unreachable-loop": Linter.RuleEntry< + [ + Partial<{ + /** + * @default [] + */ + ignore: Array< + | "WhileStatement" + | "DoWhileStatement" + | "ForStatement" + | "ForInStatement" + | "ForOfStatement" + >; + }>, + ] + >; + + /** + * Rule to disallow control flow statements in `finally` blocks. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 2.9.0 + * @see https://eslint.org/docs/latest/rules/no-unsafe-finally + */ + "no-unsafe-finally": Linter.RuleEntry<[]>; + + /** + * Rule to disallow negating the left operand of relational operators. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 3.3.0 + * @see https://eslint.org/docs/latest/rules/no-unsafe-negation + */ + "no-unsafe-negation": Linter.RuleEntry< + [ + Partial<{ + /** + * @since 6.6.0 + * @default false + */ + enforceForOrderingRelations: boolean; + }>, + ] + >; + + /** + * Rule to disallow use of optional chaining in contexts where the `undefined` value is not allowed. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 7.15.0 + * @see https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining + */ + "no-unsafe-optional-chaining": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + disallowArithmeticOperators: boolean; + }>, + ] + >; + + /** + * Rule to disallow unused expressions. + * + * @since 0.1.0 + * @see https://eslint.org/docs/latest/rules/no-unused-expressions + */ + "no-unused-expressions": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowShortCircuit: boolean; + /** + * @default false + */ + allowTernary: boolean; + /** + * @default false + */ + allowTaggedTemplates: boolean; + /** + * @since 7.20.0 + * @default false + */ + enforceForJSX: boolean; + /** + * @default false + */ + ignoreDirectives: boolean; + }>, + ] + >; + + /** + * Rule to disallow unused labels. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 2.0.0-rc.0 + * @see https://eslint.org/docs/latest/rules/no-unused-labels + */ + "no-unused-labels": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unused private class members. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 8.1.0 + * @see https://eslint.org/docs/latest/rules/no-unused-private-class-members + */ + "no-unused-private-class-members": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unused variables. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-unused-vars + */ + "no-unused-vars": Linter.RuleEntry< + [ + | "all" + | "local" + | Partial<{ + /** + * @default 'all' + */ + vars: "all" | "local"; + varsIgnorePattern: string; + /** + * @default 'after-used' + */ + args: "after-used" | "all" | "none"; + /** + * @default false + */ + ignoreRestSiblings: boolean; + argsIgnorePattern: string; + /** + * @default 'all' + */ + caughtErrors: "none" | "all"; + caughtErrorsIgnorePattern: string; + destructuredArrayIgnorePattern: string; + /** + * @default false + */ + ignoreClassWithStaticInitBlock: boolean; + /** + * @default false + */ + ignoreUsingDeclarations: boolean; + /** + * @default false + */ + reportUsedIgnorePattern: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of variables before they are defined. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/no-use-before-define + */ + "no-use-before-define": Linter.RuleEntry< + [ + | Partial<{ + /** + * @default true + */ + functions: boolean; + /** + * @default true + */ + classes: boolean; + /** + * @default true + */ + variables: boolean; + /** + * @default false + */ + allowNamedExports: boolean; + /** + * @default true + */ + enums: boolean; + /** + * @default true + */ + typedefs: boolean; + /** + * @default true + */ + ignoreTypeReferences: boolean; + }> + | "nofunc", + ] + >; + + /** + * Rule to disallow variable assignments when the value is not used. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 9.0.0-alpha.1 + * @see https://eslint.org/docs/latest/rules/no-useless-assignment + */ + "no-useless-assignment": Linter.RuleEntry<[]>; + + /** + * Rule to disallow useless backreferences in regular expressions. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 7.0.0-alpha.0 + * @see https://eslint.org/docs/latest/rules/no-useless-backreference + */ + "no-useless-backreference": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary calls to `.call()` and `.apply()`. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/no-useless-call + */ + "no-useless-call": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary `catch` clauses. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 5.11.0 + * @see https://eslint.org/docs/latest/rules/no-useless-catch + */ + "no-useless-catch": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary computed property keys in objects and classes. + * + * @since 2.9.0 + * @see https://eslint.org/docs/latest/rules/no-useless-computed-key + */ + "no-useless-computed-key": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + enforceForClassMembers: boolean; + }>, + ] + >; + + /** + * Rule to disallow unnecessary concatenation of literals or template literals. + * + * @since 1.3.0 + * @see https://eslint.org/docs/latest/rules/no-useless-concat + */ + "no-useless-concat": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary constructors. + * + * @since 2.0.0-beta.1 + * @see https://eslint.org/docs/latest/rules/no-useless-constructor + */ + "no-useless-constructor": Linter.RuleEntry<[]>; + + /** + * Rule to disallow unnecessary escape characters. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 2.5.0 + * @see https://eslint.org/docs/latest/rules/no-useless-escape + */ + "no-useless-escape": Linter.RuleEntry< + [ + Partial<{ + allowRegexCharacters: string[]; + }>, + ] + >; + + /** + * Rule to disallow renaming import, export, and destructured assignments to the same name. + * + * @since 2.11.0 + * @see https://eslint.org/docs/latest/rules/no-useless-rename + */ + "no-useless-rename": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + ignoreImport: boolean; + /** + * @default false + */ + ignoreExport: boolean; + /** + * @default false + */ + ignoreDestructuring: boolean; + }>, + ] + >; + + /** + * Rule to disallow redundant return statements. + * + * @since 3.9.0 + * @see https://eslint.org/docs/latest/rules/no-useless-return + */ + "no-useless-return": Linter.RuleEntry<[]>; + + /** + * Rule to require `let` or `const` instead of `var`. + * + * @since 0.12.0 + * @see https://eslint.org/docs/latest/rules/no-var + */ + "no-var": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `void` operators. + * + * @since 0.8.0 + * @see https://eslint.org/docs/latest/rules/no-void + */ + "no-void": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowAsStatement: boolean; + }>, + ] + >; + + /** + * Rule to disallow specified warning terms in comments. + * + * @since 0.4.4 + * @see https://eslint.org/docs/latest/rules/no-warning-comments + */ + "no-warning-comments": Linter.RuleEntry< + [ + Partial<{ + /** + * @default ["todo", "fixme", "xxx"] + */ + terms: string[]; + /** + * @default 'start' + */ + location: "start" | "anywhere"; + decoration: string[]; + }>, + ] + >; + + /** + * Rule to disallow whitespace before properties. + * + * @since 2.0.0-beta.1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`no-whitespace-before-property`](https://eslint.style/rules/no-whitespace-before-property) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/no-whitespace-before-property + */ + "no-whitespace-before-property": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `with` statements. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.2 + * @see https://eslint.org/docs/latest/rules/no-with + */ + "no-with": Linter.RuleEntry<[]>; + + /** + * Rule to enforce the location of single-line statements. + * + * @since 3.17.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`nonblock-statement-body-position`](https://eslint.style/rules/nonblock-statement-body-position) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/nonblock-statement-body-position + */ + "nonblock-statement-body-position": Linter.RuleEntry< + [ + "beside" | "below" | "any", + Partial<{ + overrides: Record; + }>, + ] + >; + + /** + * Rule to enforce consistent line breaks after opening and before closing braces. + * + * @since 2.12.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`object-curly-newline`](https://eslint.style/rules/object-curly-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/object-curly-newline + */ + "object-curly-newline": Linter.RuleEntry< + [ + | "always" + | "never" + | Partial<{ + /** + * @default false + */ + multiline: boolean; + minProperties: number; + /** + * @default true + */ + consistent: boolean; + }> + | Partial< + Record< + | "ObjectExpression" + | "ObjectPattern" + | "ImportDeclaration" + | "ExportDeclaration", + | "always" + | "never" + | Partial<{ + /** + * @default false + */ + multiline: boolean; + minProperties: number; + /** + * @default true + */ + consistent: boolean; + }> + > + >, + ] + >; + + /** + * Rule to enforce consistent spacing inside braces. + * + * @since 0.22.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`object-curly-spacing`](https://eslint.style/rules/object-curly-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/object-curly-spacing + */ + "object-curly-spacing": + | Linter.RuleEntry< + [ + "never", + { + /** + * @default false + */ + arraysInObjects: boolean; + /** + * @default false + */ + objectsInObjects: boolean; + }, + ] + > + | Linter.RuleEntry< + [ + "always", + { + /** + * @default true + */ + arraysInObjects: boolean; + /** + * @default true + */ + objectsInObjects: boolean; + }, + ] + >; + + /** + * Rule to enforce placing object properties on separate lines. + * + * @since 2.10.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`object-property-newline`](https://eslint.style/rules/object-property-newline) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/object-property-newline + */ + "object-property-newline": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowAllPropertiesOnSameLine: boolean; + }>, + ] + >; + + /** + * Rule to require or disallow method and property shorthand syntax for object literals. + * + * @since 0.20.0 + * @see https://eslint.org/docs/latest/rules/object-shorthand + */ + "object-shorthand": + | Linter.RuleEntry< + [ + "always" | "methods", + Partial<{ + /** + * @default false + */ + avoidQuotes: boolean; + /** + * @default false + */ + ignoreConstructors: boolean; + /** + * @since 8.22.0 + */ + methodsIgnorePattern: string; + /** + * @default false + */ + avoidExplicitReturnArrows: boolean; + }>, + ] + > + | Linter.RuleEntry< + [ + "properties", + Partial<{ + /** + * @default false + */ + avoidQuotes: boolean; + }>, + ] + > + | Linter.RuleEntry<["never" | "consistent" | "consistent-as-needed"]>; + + /** + * Rule to enforce variables to be declared either together or separately in functions. + * + * @since 0.0.9 + * @see https://eslint.org/docs/latest/rules/one-var + */ + "one-var": Linter.RuleEntry< + [ + | "always" + | "never" + | "consecutive" + | Partial< + { + /** + * @default false + */ + separateRequires: boolean; + } & Record< + "var" | "let" | "const" | "using" | "awaitUsing", + "always" | "never" | "consecutive" + > + > + | Partial< + Record< + "initialized" | "uninitialized", + "always" | "never" | "consecutive" + > + >, + ] + >; + + /** + * Rule to require or disallow newlines around variable declarations. + * + * @since 2.0.0-beta.3 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`one-var-declaration-per-line`](https://eslint.style/rules/one-var-declaration-per-line) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/one-var-declaration-per-line + */ + "one-var-declaration-per-line": Linter.RuleEntry< + ["initializations" | "always"] + >; + + /** + * Rule to require or disallow assignment operator shorthand where possible. + * + * @since 0.10.0 + * @see https://eslint.org/docs/latest/rules/operator-assignment + */ + "operator-assignment": Linter.RuleEntry<["always" | "never"]>; + + /** + * Rule to enforce consistent linebreak style for operators. + * + * @since 0.19.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`operator-linebreak`](https://eslint.style/rules/operator-linebreak) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/operator-linebreak + */ + "operator-linebreak": Linter.RuleEntry< + [ + "after" | "before" | "none", + Partial<{ + overrides: Record; + }>, + ] + >; + + /** + * Rule to require or disallow padding within blocks. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`padded-blocks`](https://eslint.style/rules/padded-blocks) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/padded-blocks + */ + "padded-blocks": Linter.RuleEntry< + [ + ( + | "always" + | "never" + | Partial< + Record< + "blocks" | "classes" | "switches", + "always" | "never" + > + > + ), + { + /** + * @default false + */ + allowSingleLineBlocks: boolean; + }, + ] + >; + + /** + * Rule to require or disallow padding lines between statements. + * + * @since 4.0.0-beta.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`padding-line-between-statements`](https://eslint.style/rules/padding-line-between-statements) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/padding-line-between-statements + */ + "padding-line-between-statements": Linter.RuleEntry< + [ + ...Array< + { + blankLine: "any" | "never" | "always"; + } & Record<"prev" | "next", string | string[]> + >, + ] + >; + + /** + * Rule to require using arrow functions for callbacks. + * + * @since 1.2.0 + * @see https://eslint.org/docs/latest/rules/prefer-arrow-callback + */ + "prefer-arrow-callback": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowNamedFunctions: boolean; + /** + * @default true + */ + allowUnboundThis: boolean; + }>, + ] + >; + + /** + * Rule to require `const` declarations for variables that are never reassigned after declared. + * + * @since 0.23.0 + * @see https://eslint.org/docs/latest/rules/prefer-const + */ + "prefer-const": Linter.RuleEntry< + [ + Partial<{ + /** + * @default 'any' + */ + destructuring: "any" | "all"; + /** + * @default false + */ + ignoreReadBeforeAssign: boolean; + }>, + ] + >; + + /** + * Rule to require destructuring from arrays and/or objects. + * + * @since 3.13.0 + * @see https://eslint.org/docs/latest/rules/prefer-destructuring + */ + "prefer-destructuring": Linter.RuleEntry< + [ + Partial< + | { + VariableDeclarator: Partial<{ + array: boolean; + object: boolean; + }>; + AssignmentExpression: Partial<{ + array: boolean; + object: boolean; + }>; + } + | { + array: boolean; + object: boolean; + } + >, + Partial<{ + enforceForRenamedProperties: boolean; + }>, + ] + >; + + /** + * Rule to disallow the use of `Math.pow` in favor of the `**` operator. + * + * @since 6.7.0 + * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator + */ + "prefer-exponentiation-operator": Linter.RuleEntry<[]>; + + /** + * Rule to enforce using named capture group in regular expression. + * + * @since 5.15.0 + * @see https://eslint.org/docs/latest/rules/prefer-named-capture-group + */ + "prefer-named-capture-group": Linter.RuleEntry<[]>; + + /** + * Rule to disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals. + * + * @since 3.5.0 + * @see https://eslint.org/docs/latest/rules/prefer-numeric-literals + */ + "prefer-numeric-literals": Linter.RuleEntry<[]>; + + /** + * Rule to disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`. + * + * @since 8.5.0 + * @see https://eslint.org/docs/latest/rules/prefer-object-has-own + */ + "prefer-object-has-own": Linter.RuleEntry<[]>; + + /** + * Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead. + * + * @since 5.0.0-alpha.3 + * @see https://eslint.org/docs/latest/rules/prefer-object-spread + */ + "prefer-object-spread": Linter.RuleEntry<[]>; + + /** + * Rule to require using Error objects as Promise rejection reasons. + * + * @since 3.14.0 + * @see https://eslint.org/docs/latest/rules/prefer-promise-reject-errors + */ + "prefer-promise-reject-errors": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + allowEmptyReject: boolean; + }>, + ] + >; + + /** + * Rule to require `Reflect` methods where applicable. + * + * @since 1.0.0-rc-2 + * @deprecated since 3.9.0. + * The original intention of this rule was misguided. + * @see https://eslint.org/docs/latest/rules/prefer-reflect + */ + "prefer-reflect": Linter.RuleEntry< + [ + Partial<{ + exceptions: string[]; + }>, + ] + >; + + /** + * Rule to disallow use of the `RegExp` constructor in favor of regular expression literals. + * + * @since 6.4.0 + * @see https://eslint.org/docs/latest/rules/prefer-regex-literals + */ + "prefer-regex-literals": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + disallowRedundantWrapping: boolean; + }>, + ] + >; + + /** + * Rule to require rest parameters instead of `arguments`. + * + * @since 2.0.0-alpha-1 + * @see https://eslint.org/docs/latest/rules/prefer-rest-params + */ + "prefer-rest-params": Linter.RuleEntry<[]>; + + /** + * Rule to require spread operators instead of `.apply()`. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/prefer-spread + */ + "prefer-spread": Linter.RuleEntry<[]>; + + /** + * Rule to require template literals instead of string concatenation. + * + * @since 1.2.0 + * @see https://eslint.org/docs/latest/rules/prefer-template + */ + "prefer-template": Linter.RuleEntry<[]>; + + /** + * Rule to disallow losing originally caught error when re-throwing custom errors. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 9.35.0 + * @see https://eslint.org/docs/latest/rules/preserve-caught-error + */ + "preserve-caught-error": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + requireCatchParameter: boolean; + /** + * @default [] + */ + errorClassNames: Array< + | string + | { + name: string; + argumentPosition: number; + } + >; + }>, + ] + >; + + /** + * Rule to require quotes around object literal property names. + * + * @since 0.0.6 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`quote-props`](https://eslint.style/rules/quote-props) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/quote-props + */ + "quote-props": + | Linter.RuleEntry<["always" | "consistent"]> + | Linter.RuleEntry< + [ + "as-needed", + Partial<{ + /** + * @default false + */ + keywords: boolean; + /** + * @default true + */ + unnecessary: boolean; + /** + * @default false + */ + numbers: boolean; + }>, + ] + > + | Linter.RuleEntry< + [ + "consistent-as-needed", + Partial<{ + /** + * @default false + */ + keywords: boolean; + }>, + ] + >; + + /** + * Rule to enforce the consistent use of either backticks, double, or single quotes. + * + * @since 0.0.7 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`quotes`](https://eslint.style/rules/quotes) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/quotes + */ + quotes: Linter.RuleEntry< + [ + "double" | "single" | "backtick", + Partial<{ + /** + * @default false + */ + avoidEscape: boolean; + /** + * @default false + */ + allowTemplateLiterals: boolean; + }>, + ] + >; + + /** + * Rule to enforce the use of the radix argument when using `parseInt()`. + * + * @since 0.0.7 + * @see https://eslint.org/docs/latest/rules/radix + */ + radix: Linter.RuleEntry<["always" | "as-needed"]>; + + /** + * Rule to disallow assignments that can lead to race conditions due to usage of `await` or `yield`. + * + * @since 5.3.0 + * @see https://eslint.org/docs/latest/rules/require-atomic-updates + */ + "require-atomic-updates": Linter.RuleEntry< + [ + Partial<{ + /** + * @since 8.3.0 + * @default false + */ + allowProperties: boolean; + }>, + ] + >; + + /** + * Rule to disallow async functions which have no `await` expression. + * + * @since 3.11.0 + * @see https://eslint.org/docs/latest/rules/require-await + */ + "require-await": Linter.RuleEntry<[]>; + + /** + * Rule to enforce the use of `u` or `v` flag on regular expressions. + * + * @since 5.3.0 + * @see https://eslint.org/docs/latest/rules/require-unicode-regexp + */ + "require-unicode-regexp": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + requireFlag: "u" | "v"; + }>, + ] + >; + + /** + * Rule to require generator functions to contain `yield`. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 1.0.0-rc-1 + * @see https://eslint.org/docs/latest/rules/require-yield + */ + "require-yield": Linter.RuleEntry<[]>; + + /** + * Rule to enforce spacing between rest and spread operators and their expressions. + * + * @since 2.12.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`rest-spread-spacing`](https://eslint.style/rules/rest-spread-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/rest-spread-spacing + */ + "rest-spread-spacing": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require or disallow semicolons instead of ASI. + * + * @since 0.0.6 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`semi`](https://eslint.style/rules/semi) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/semi + */ + semi: + | Linter.RuleEntry< + [ + "always", + Partial<{ + /** + * @default false + */ + omitLastInOneLineBlock: boolean; + }>, + ] + > + | Linter.RuleEntry< + [ + "never", + Partial<{ + /** + * @default 'any' + */ + beforeStatementContinuationChars: + "any" | "always" | "never"; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing before and after semicolons. + * + * @since 0.16.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`semi-spacing`](https://eslint.style/rules/semi-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/semi-spacing + */ + "semi-spacing": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + before: boolean; + /** + * @default true + */ + after: boolean; + }>, + ] + >; + + /** + * Rule to enforce location of semicolons. + * + * @since 4.0.0-beta.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`semi-style`](https://eslint.style/rules/semi-style) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/semi-style + */ + "semi-style": Linter.RuleEntry<["last" | "first"]>; + + /** + * Rule to enforce sorted `import` declarations within modules. + * + * @since 2.0.0-beta.1 + * @see https://eslint.org/docs/latest/rules/sort-imports + */ + "sort-imports": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + ignoreCase: boolean; + /** + * @default false + */ + ignoreDeclarationSort: boolean; + /** + * @default false + */ + ignoreMemberSort: boolean; + /** + * @default ['none', 'all', 'multiple', 'single'] + */ + memberSyntaxSortOrder: Array< + "none" | "all" | "multiple" | "single" + >; + /** + * @default false + */ + allowSeparatedGroups: boolean; + }>, + ] + >; + + /** + * Rule to require object keys to be sorted. + * + * @since 3.3.0 + * @see https://eslint.org/docs/latest/rules/sort-keys + */ + "sort-keys": Linter.RuleEntry< + [ + "asc" | "desc", + Partial<{ + /** + * @default true + */ + caseSensitive: boolean; + /** + * @default 2 + */ + minKeys: number; + /** + * @default false + */ + natural: boolean; + /** + * @default false + */ + allowLineSeparatedGroups: boolean; + /** + * @default false + */ + ignoreComputedKeys: boolean; + }>, + ] + >; + + /** + * Rule to require variables within the same declaration block to be sorted. + * + * @since 0.2.0 + * @see https://eslint.org/docs/latest/rules/sort-vars + */ + "sort-vars": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + ignoreCase: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing before blocks. + * + * @since 0.9.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`space-before-blocks`](https://eslint.style/rules/space-before-blocks) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/space-before-blocks + */ + "space-before-blocks": Linter.RuleEntry< + [ + | "always" + | "never" + | Partial< + Record< + "functions" | "keywords" | "classes", + "always" | "never" | "off" + > + >, + ] + >; + + /** + * Rule to enforce consistent spacing before `function` definition opening parenthesis. + * + * @since 0.18.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`space-before-function-paren`](https://eslint.style/rules/space-before-function-paren) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/space-before-function-paren + */ + "space-before-function-paren": Linter.RuleEntry< + [ + | "always" + | "never" + | Partial< + Record< + "anonymous" | "named" | "asyncArrow", + "always" | "never" | "ignore" + > + >, + ] + >; + + /** + * Rule to enforce consistent spacing inside parentheses. + * + * @since 0.8.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`space-in-parens`](https://eslint.style/rules/space-in-parens) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/space-in-parens + */ + "space-in-parens": Linter.RuleEntry< + [ + "never" | "always", + Partial<{ + exceptions: string[]; + }>, + ] + >; + + /** + * Rule to require spacing around infix operators. + * + * @since 0.2.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`space-infix-ops`](https://eslint.style/rules/space-infix-ops) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/space-infix-ops + */ + "space-infix-ops": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + int32Hint: boolean; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing before or after unary operators. + * + * @since 0.10.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`space-unary-ops`](https://eslint.style/rules/space-unary-ops) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/space-unary-ops + */ + "space-unary-ops": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + words: boolean; + /** + * @default false + */ + nonwords: boolean; + overrides: Record; + }>, + ] + >; + + /** + * Rule to enforce consistent spacing after the `//` or `/*` in a comment. + * + * @since 0.23.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`spaced-comment`](https://eslint.style/rules/spaced-comment) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/spaced-comment + */ + "spaced-comment": Linter.RuleEntry< + [ + "always" | "never", + { + exceptions: string[]; + markers: string[]; + line: { + exceptions: string[]; + markers: string[]; + }; + block: { + exceptions: string[]; + markers: string[]; + /** + * @default false + */ + balanced: boolean; + }; + }, + ] + >; + + /** + * Rule to require or disallow strict mode directives. + * + * @since 0.1.0 + * @see https://eslint.org/docs/latest/rules/strict + */ + strict: Linter.RuleEntry<["safe" | "global" | "function" | "never"]>; + + /** + * Rule to enforce spacing around colons of switch statements. + * + * @since 4.0.0-beta.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`switch-colon-spacing`](https://eslint.style/rules/switch-colon-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/switch-colon-spacing + */ + "switch-colon-spacing": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + before: boolean; + /** + * @default true + */ + after: boolean; + }>, + ] + >; + + /** + * Rule to require symbol descriptions. + * + * @since 3.4.0 + * @see https://eslint.org/docs/latest/rules/symbol-description + */ + "symbol-description": Linter.RuleEntry<[]>; + + /** + * Rule to require or disallow spacing around embedded expressions of template strings. + * + * @since 2.0.0-rc.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`template-curly-spacing`](https://eslint.style/rules/template-curly-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/template-curly-spacing + */ + "template-curly-spacing": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require or disallow spacing between template tags and their literals. + * + * @since 3.15.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`template-tag-spacing`](https://eslint.style/rules/template-tag-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/template-tag-spacing + */ + "template-tag-spacing": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require or disallow Unicode byte order mark (BOM). + * + * @since 2.11.0 + * @see https://eslint.org/docs/latest/rules/unicode-bom + */ + "unicode-bom": Linter.RuleEntry<["never" | "always"]>; + + /** + * Rule to require calls to `isNaN()` when checking for `NaN`. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.0.6 + * @see https://eslint.org/docs/latest/rules/use-isnan + */ + "use-isnan": Linter.RuleEntry< + [ + Partial<{ + /** + * @default true + */ + enforceForSwitchCase: boolean; + /** + * @default false + */ + enforceForIndexOf: boolean; + }>, + ] + >; + + /** + * Rule to enforce comparing `typeof` expressions against valid strings. + * + * @remarks + * Recommended by ESLint, the rule was enabled in `eslint:recommended`. + * + * @since 0.5.0 + * @see https://eslint.org/docs/latest/rules/valid-typeof + */ + "valid-typeof": Linter.RuleEntry< + [ + Partial<{ + /** + * @default false + */ + requireStringLiterals: boolean; + }>, + ] + >; + + /** + * Rule to require `var` declarations be placed at the top of their containing scope. + * + * @since 0.8.0 + * @see https://eslint.org/docs/latest/rules/vars-on-top + */ + "vars-on-top": Linter.RuleEntry<[]>; + + /** + * Rule to require parentheses around immediate `function` invocations. + * + * @since 0.0.9 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`wrap-iife`](https://eslint.style/rules/wrap-iife) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/wrap-iife + */ + "wrap-iife": Linter.RuleEntry< + [ + "outside" | "inside" | "any", + Partial<{ + /** + * @default false + */ + functionPrototypeMethods: boolean; + }>, + ] + >; + + /** + * Rule to require parenthesis around regex literals. + * + * @since 0.1.0 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`wrap-regex`](https://eslint.style/rules/wrap-regex) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/wrap-regex + */ + "wrap-regex": Linter.RuleEntry<[]>; + + /** + * Rule to require or disallow spacing around the `*` in `yield*` expressions. + * + * @since 2.0.0-alpha-1 + * @deprecated since 8.53.0. + * Formatting rules are being moved out of ESLint core. + * Please, use [`yield-star-spacing`](https://eslint.style/rules/yield-star-spacing) in [`@stylistic/eslint-plugin`](https://eslint.style). + * @see https://eslint.org/docs/latest/rules/yield-star-spacing + */ + "yield-star-spacing": Linter.RuleEntry< + [ + | Partial<{ + before: boolean; + after: boolean; + }> + | "before" + | "after" + | "both" + | "neither", + ] + >; + + /** + * Rule to require or disallow "Yoda" conditions. + * + * @since 0.7.1 + * @see https://eslint.org/docs/latest/rules/yoda + */ + yoda: + | Linter.RuleEntry< + [ + "never", + Partial<{ + exceptRange: boolean; + onlyEquality: boolean; + }>, + ] + > + | Linter.RuleEntry<["always"]>; +} diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/universal.d.ts b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/universal.d.ts new file mode 100644 index 00000000..df4fdecd --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/universal.d.ts @@ -0,0 +1,6 @@ +/** + * @fileoverview typings for "eslint/universal" module + * @author 唯然 + */ + +export { Linter } from "./index"; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/use-at-your-own-risk.d.ts b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/use-at-your-own-risk.d.ts new file mode 100644 index 00000000..1b8a0b67 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/types/use-at-your-own-risk.d.ts @@ -0,0 +1,34 @@ +/** + * @fileoverview This file contains the types for the use-at-your-own-risk + * entrypoint. It was initially extracted from the `@types/eslint` package. + */ + +/* + * MIT License + * Copyright (c) Microsoft Corporation. + * + * 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 + */ + +import { Rule } from "./index.js"; + +/** @deprecated */ +export const builtinRules: Map; + +/** @deprecated */ +export function shouldUseFlatConfig(): Promise; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/universal.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/universal.js new file mode 100644 index 00000000..51bac584 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/universal.js @@ -0,0 +1,10 @@ +/** + * @fileoverview exports for browsers + * @author 唯然 + */ + +"use strict"; + +const { Linter } = require("./linter/linter"); + +module.exports = { Linter }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/unsupported-api.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/unsupported-api.js new file mode 100644 index 00000000..d46b4028 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/lib/unsupported-api.js @@ -0,0 +1,21 @@ +/** + * @fileoverview APIs that are not officially supported by ESLint. + * These APIs may change or be removed at any time. Use at your + * own risk. + * @author Nicholas C. Zakas + */ + +"use strict"; + +//----------------------------------------------------------------------------- +// Requirements +//----------------------------------------------------------------------------- + +const { shouldUseFlatConfig } = require("./eslint/eslint"); +const builtinRules = require("./rules"); + +//----------------------------------------------------------------------------- +// Exports +//----------------------------------------------------------------------------- + +module.exports = { builtinRules, shouldUseFlatConfig }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/all-matched-files-ignored.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/all-matched-files-ignored.js new file mode 100644 index 00000000..9ae894e4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/all-matched-files-ignored.js @@ -0,0 +1,21 @@ +"use strict"; + +module.exports = function (it) { + const { pattern } = it; + + return ` +You are linting "${pattern}", but all of the files matching the glob pattern "${pattern}" are ignored. + +If you don't want to lint these files, remove the pattern "${pattern}" from the list of arguments passed to ESLint. + +If you do want to lint these files, explicitly list one or more of the files from this glob that you'd like to lint to see more details about why they are ignored. + + * If the file is ignored because of a matching ignore pattern, check global ignores in your config file. + https://eslint.org/docs/latest/use/configure/ignore + + * If the file is ignored because no matching configuration was supplied, check file patterns in your config file. + https://eslint.org/docs/latest/use/configure/configuration-files#specify-files-with-arbitrary-extensions + + * If the file is ignored because it is located outside of the base path, change the location of your config file to be in a parent directory. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-file-missing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-file-missing.js new file mode 100644 index 00000000..7ae76408 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-file-missing.js @@ -0,0 +1,16 @@ +"use strict"; + +module.exports = function () { + return ` +ESLint couldn't find an eslint.config.* file. + +From ESLint v9.0.0, the default configuration file is now eslint.config.*. +If you are using a .eslintrc.* file, please follow the migration guide +to update your configuration file to the new format: + +https://eslint.org/docs/latest/use/configure/migration-guide + +If you still have problems after following the migration guide, please stop by +https://eslint.org/chat/help to chat with the team. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-plugin-missing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-plugin-missing.js new file mode 100644 index 00000000..20736749 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-plugin-missing.js @@ -0,0 +1,14 @@ +"use strict"; + +module.exports = function (it) { + const { pluginName, ruleId } = it; + + return ` +A configuration object specifies rule "${ruleId}", but could not find plugin "${pluginName}". + +Common causes of this problem include: + +1. The "${pluginName}" plugin is not defined in your configuration file. +2. The "${pluginName}" plugin is not defined within the same configuration object in which the "${ruleId}" rule is applied. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-serialize-function.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-serialize-function.js new file mode 100644 index 00000000..4300e47e --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/config-serialize-function.js @@ -0,0 +1,30 @@ +"use strict"; + +module.exports = function ({ key, objectKey }) { + // special case for parsers + const isParser = + objectKey === "parser" && (key === "parse" || key === "parseForESLint"); + const parserMessage = ` + This typically happens when you're using a custom parser that does not +provide a "meta" property, which is how ESLint determines the serialized +representation. Please open an issue with the maintainer of the custom parser +and share this link: + +https://eslint.org/docs/latest/extend/custom-parsers#meta-data-in-custom-parsers +`.trim(); + + return ` +The requested operation requires ESLint to serialize configuration data, +but the configuration key "${objectKey}.${key}" contains a function value, +which cannot be serialized. + +${ + isParser + ? parserMessage + : "Please double-check your configuration for errors." +} + +If you still have problems, please stop by https://eslint.org/chat/help to chat +with the team. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-incompat.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-incompat.js new file mode 100644 index 00000000..b6189ac1 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-incompat.js @@ -0,0 +1,117 @@ +"use strict"; + +/* eslint consistent-return: 0 -- no default case */ + +const messages = { + env: ` +A config object is using the "env" key, which is not supported in flat config system. + +Flat config uses "languageOptions.globals" to define global variables for your files. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#configure-language-options + +If you're not using "env" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + extends: ` +A config object is using the "extends" key, which is not supported in flat config system. + +Instead of "extends", you can include config objects that you'd like to extend from directly in the flat config array. + +If you're using "extends" in your config file, please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#predefined-and-shareable-configs + +If you're not using "extends" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + globals: ` +A config object is using the "globals" key, which is not supported in flat config system. + +Flat config uses "languageOptions.globals" to define global variables for your files. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#configure-language-options + +If you're not using "globals" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + ignorePatterns: ` +A config object is using the "ignorePatterns" key, which is not supported in flat config system. + +Flat config uses "ignores" to specify files to ignore. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#ignore-files + +If you're not using "ignorePatterns" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + noInlineConfig: ` +A config object is using the "noInlineConfig" key, which is not supported in flat config system. + +Flat config uses "linterOptions.noInlineConfig" to specify files to ignore. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#linter-options +`, + + overrides: ` +A config object is using the "overrides" key, which is not supported in flat config system. + +Flat config is an array that acts like the eslintrc "overrides" array. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#glob-based-configs + +If you're not using "overrides" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + parser: ` +A config object is using the "parser" key, which is not supported in flat config system. + +Flat config uses "languageOptions.parser" to override the default parser. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#custom-parsers + +If you're not using "parser" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + parserOptions: ` +A config object is using the "parserOptions" key, which is not supported in flat config system. + +Flat config uses "languageOptions.parserOptions" to specify parser options. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#configure-language-options + +If you're not using "parserOptions" directly (it may be coming from a plugin), please see the following: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`, + + reportUnusedDisableDirectives: ` +A config object is using the "reportUnusedDisableDirectives" key, which is not supported in flat config system. + +Flat config uses "linterOptions.reportUnusedDisableDirectives" to specify files to ignore. + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#linter-options +`, + + root: ` +A config object is using the "root" key, which is not supported in flat config system. + +Flat configs always act as if they are the root config file, so this key can be safely removed. +`, +}; + +module.exports = function ({ key }) { + return messages[key].trim(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-plugins.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-plugins.js new file mode 100644 index 00000000..c5ae55c7 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/eslintrc-plugins.js @@ -0,0 +1,27 @@ +"use strict"; + +module.exports = function ({ plugins }) { + const isArrayOfStrings = typeof plugins[0] === "string"; + + return ` +A config object has a "plugins" key defined as an array${isArrayOfStrings ? " of strings" : ""}. It looks something like this: + + { + "plugins": ${JSON.stringify(plugins)} + } + +Flat config requires "plugins" to be an object, like this: + + { + plugins: { + ${isArrayOfStrings && plugins[0] ? plugins[0] : "namespace"}: pluginObject + } + } + +Please see the following page for information on how to convert your config object into the correct format: +https://eslint.org/docs/latest/use/configure/migration-guide#import-plugins-and-custom-parsers + +If you're using a shareable config that you cannot rewrite in flat config format, then use the compatibility utility: +https://eslint.org/docs/latest/use/configure/migration-guide#use-eslintrc-configs-in-flat-config +`; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/extend-config-missing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/extend-config-missing.js new file mode 100644 index 00000000..32e41e96 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/extend-config-missing.js @@ -0,0 +1,13 @@ +"use strict"; + +module.exports = function (it) { + const { configName, importerName } = it; + + return ` +ESLint couldn't find the config "${configName}" to extend from. Please check that the name of the config is correct. + +The config "${configName}" was referenced from the config file in "${importerName}". + +If you still have problems, please stop by https://eslint.org/chat/help to chat with the team. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/failed-to-read-json.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/failed-to-read-json.js new file mode 100644 index 00000000..3244e842 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/failed-to-read-json.js @@ -0,0 +1,11 @@ +"use strict"; + +module.exports = function (it) { + const { path, message } = it; + + return ` +Failed to read JSON file at ${path}: + +${message} +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/file-not-found.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/file-not-found.js new file mode 100644 index 00000000..50e483bc --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/file-not-found.js @@ -0,0 +1,10 @@ +"use strict"; + +module.exports = function (it) { + const { pattern, globDisabled } = it; + + return ` +No files matching the pattern "${pattern}"${globDisabled ? " (with disabling globs)" : ""} were found. +Please check for typing mistakes in the pattern. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-options.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-options.js new file mode 100644 index 00000000..506d4c42 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-options.js @@ -0,0 +1,17 @@ +"use strict"; + +const { stringifyValueForError } = require("./shared"); + +module.exports = function ({ ruleId, value }) { + return ` +Configuration for rule "${ruleId}" is invalid. Each rule must have a severity ("off", 0, "warn", 1, "error", or 2) and may be followed by additional options for the rule. + +You passed '${stringifyValueForError(value, 4)}', which doesn't contain a valid severity. + +If you're attempting to configure rule options, perhaps you meant: + + "${ruleId}": ["error", ${stringifyValueForError(value, 8)}] + +See https://eslint.org/docs/latest/use/configure/rules#use-configuration-files for configuring rules. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-severity.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-severity.js new file mode 100644 index 00000000..45b28f57 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/invalid-rule-severity.js @@ -0,0 +1,13 @@ +"use strict"; + +const { stringifyValueForError } = require("./shared"); + +module.exports = function ({ ruleId, value }) { + return ` +Configuration for rule "${ruleId}" is invalid. Expected severity of "off", 0, "warn", 1, "error", or 2. + +You passed '${stringifyValueForError(value, 4)}'. + +See https://eslint.org/docs/latest/use/configure/rules#use-configuration-files for configuring rules. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/no-config-found.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/no-config-found.js new file mode 100644 index 00000000..4421206d --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/no-config-found.js @@ -0,0 +1,15 @@ +"use strict"; + +module.exports = function (it) { + const { directoryPath } = it; + + return ` +ESLint couldn't find a configuration file. To set up a configuration file for this project, please run: + + npm init @eslint/config@latest + +ESLint looked for configuration files in ${directoryPath} and its ancestors. If it found none, it then looked in your home directory. + +If you think you already have a configuration file or if you need more help, please stop by the ESLint Discord server: https://eslint.org/chat +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-conflict.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-conflict.js new file mode 100644 index 00000000..d90df0ca --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-conflict.js @@ -0,0 +1,22 @@ +"use strict"; + +module.exports = function (it) { + const { pluginId, plugins } = it; + + let result = `ESLint couldn't determine the plugin "${pluginId}" uniquely. +`; + + for (const { filePath, importerName } of plugins) { + result += ` +- ${filePath} (loaded in "${importerName}")`; + } + + result += ` + +Please remove the "plugins" setting from either config or remove either plugin installation. + +If you still can't figure out the problem, please see https://eslint.org/docs/latest/use/troubleshooting. +`; + + return result; +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-invalid.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-invalid.js new file mode 100644 index 00000000..fc9ff6ab --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-invalid.js @@ -0,0 +1,16 @@ +"use strict"; + +module.exports = function (it) { + const { configName, importerName } = it; + + return ` +"${configName}" is invalid syntax for a config specifier. + +* If your intention is to extend from a configuration exported from the plugin, add the configuration name after a slash: e.g. "${configName}/myConfig". +* If this is the name of a shareable config instead of a plugin, remove the "plugin:" prefix: i.e. "${configName.slice("plugin:".length)}". + +"${configName}" was referenced from the config file in "${importerName}". + +If you still can't figure out the problem, please see https://eslint.org/docs/latest/use/troubleshooting. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-missing.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-missing.js new file mode 100644 index 00000000..6152a6a4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/plugin-missing.js @@ -0,0 +1,19 @@ +"use strict"; + +module.exports = function (it) { + const { pluginName, resolvePluginsRelativeTo, importerName } = it; + + return ` +ESLint couldn't find the plugin "${pluginName}". + +(The package "${pluginName}" was not found when loaded as a Node module from the directory "${resolvePluginsRelativeTo}".) + +It's likely that the plugin isn't installed correctly. Try reinstalling by running the following: + + npm install ${pluginName}@latest --save-dev + +The plugin "${pluginName}" was referenced from the config file in "${importerName}". + +If you still can't figure out the problem, please see https://eslint.org/docs/latest/use/troubleshooting. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/rule-unsupported-language.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/rule-unsupported-language.js new file mode 100644 index 00000000..19e8dbd2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/rule-unsupported-language.js @@ -0,0 +1,18 @@ +"use strict"; + +module.exports = function ({ ruleIds, language }) { + return ` +The following rules do not support the language "${language}": +${ruleIds.map(id => `\t- "${id}"`).join("\n")} + +To fix this error, either: +- Remove the rule from your configuration, or set its severity to "off". +- Use the "files" option to apply the rule only to files of the supported language, for example: + { + files: ["**/*.js"], + rules: { "${ruleIds[0]}": "error" } + } + +See https://eslint.org/docs/latest/use/configure/rules for more information. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/shared.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/shared.js new file mode 100644 index 00000000..4244ed68 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/shared.js @@ -0,0 +1,23 @@ +/** + * @fileoverview Shared utilities for error messages. + * @author Josh Goldberg + */ + +"use strict"; + +/** + * Converts a value to a string that may be printed in errors. + * @param {any} value The invalid value. + * @param {number} indentation How many spaces to indent + * @returns {string} The value, stringified. + */ +function stringifyValueForError(value, indentation) { + return value + ? JSON.stringify(value, null, 4).replace( + /\n/gu, + `\n${" ".repeat(indentation)}`, + ) + : `${value}`; +} + +module.exports = { stringifyValueForError }; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/whitespace-found.js b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/whitespace-found.js new file mode 100644 index 00000000..c6160216 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/messages/whitespace-found.js @@ -0,0 +1,11 @@ +"use strict"; + +module.exports = function (it) { + const { pluginName } = it; + + return ` +ESLint couldn't find the plugin "${pluginName}". because there is whitespace in the name. Please check your configuration and remove all whitespace from the plugin name. + +If you still can't figure out the problem, please stop by https://eslint.org/chat/help to chat with the team. +`.trimStart(); +}; diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/eslint b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/eslint new file mode 100755 index 00000000..b6651420 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/eslint @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/..:$basedir_abs/../../..:$basedir_abs/../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/..:$basedir_abs/../../..:$basedir_abs/../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../bin/eslint.js" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../bin/eslint.js" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../bin/eslint.js" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../bin/eslint.js" "$@" +else + exec node "$basedir_abs/../../bin/eslint.js" "$@" +fi +# cmd-shim-target=../../bin/eslint.js diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/jiti b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/jiti new file mode 100755 index 00000000..ca085d14 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/node_modules/.bin/jiti @@ -0,0 +1,74 @@ +#!/bin/sh +# Resolve $0 through symlinks so basedir is the shim's real directory. +# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim. +# +# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, +# uname, and printf go through `command -p`, which searches the system default +# path instead. A dependency's bin cannot stand in for one of them and take over +# the shim before it reaches its target. Directories come from `${link%/*}`, +# which needs no helper at all. +link="$0" +# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup +# and stands for a file in the current directory. +case "$link" in + */*|*\\*) ;; + *) link="./$link" ;; +esac +hops=0 +while [ -L "$link" ] && [ "$hops" -lt 40 ]; do + hops=$((hops+1)) + target=$(command -p readlink "$link") + case "$target" in + /*) link="$target" ;; + *) link="${link%/*}/$target" ;; + esac +done +basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g') +basedir="${basedir%/*}" +basedir_win="$basedir" +exe="" +msys="" + +case `command -p uname -a` in + *CYGWIN*|*MINGW*|*MSYS*) + if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + elif command -v cygpath > /dev/null 2>&1; then + basedir_win=`cygpath -w "$basedir"` + fi + exe=".exe" + msys="true" + ;; + *WSL2*) + if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then + basedir_win="$converted" + exe=".exe" + elif command -v wslpath > /dev/null 2>&1; then + basedir_win="$(wslpath -w "$basedir" 2> /dev/null)" + if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then + basedir_win="$basedir" + else + exe=".exe" + fi + fi + ;; +esac + +basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $? +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="$basedir_abs/../../../../../jiti@2.7.0/node_modules/jiti/node_modules:$basedir_abs/../../../../../jiti@2.7.0/node_modules:$basedir_abs/../../../../../node_modules" +else + export NODE_PATH="$basedir_abs/../../../../../jiti@2.7.0/node_modules/jiti/node_modules:$basedir_abs/../../../../../jiti@2.7.0/node_modules:$basedir_abs/../../../../../node_modules:$NODE_PATH" +fi +if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then + exec "$basedir/node.exe" "$basedir_win/../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir_abs/../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif command -v node >/dev/null 2>&1; then + exec node "$basedir_abs/../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then + exec node.exe "$basedir_win/../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +else + exec node "$basedir_abs/../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs" "$@" +fi +# cmd-shim-target=../../../../../jiti@2.7.0/node_modules/jiti/lib/jiti-cli.mjs diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/package.json b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/package.json new file mode 100644 index 00000000..8213de8a --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/eslint/package.json @@ -0,0 +1,245 @@ +{ + "name": "eslint", + "version": "10.11.0", + "author": "Nicholas C. Zakas ", + "description": "An AST-based pattern checker for JavaScript.", + "type": "commonjs", + "bin": { + "eslint": "./bin/eslint.js" + }, + "main": "./lib/api.js", + "types": "./lib/types/index.d.ts", + "exports": { + ".": { + "types": "./lib/types/index.d.ts", + "default": "./lib/api.js" + }, + "./config": { + "types": "./lib/types/config-api.d.ts", + "default": "./lib/config-api.js" + }, + "./package.json": "./package.json", + "./use-at-your-own-risk": { + "types": "./lib/types/use-at-your-own-risk.d.ts", + "default": "./lib/unsupported-api.js" + }, + "./rules": { + "types": "./lib/types/rules.d.ts" + }, + "./universal": { + "types": "./lib/types/universal.d.ts", + "default": "./lib/universal.js" + } + }, + "typesVersions": { + "*": { + "use-at-your-own-risk": [ + "./lib/types/use-at-your-own-risk.d.ts" + ], + "rules": [ + "./lib/types/rules.d.ts" + ], + "universal": [ + "./lib/types/universal.d.ts" + ], + "config": [ + "./lib/types/config-api.d.ts" + ] + } + }, + "scripts": { + "build:docs:update-links": "node tools/fetch-docs-links.js", + "build:site": "node Makefile.js gensite", + "build:webpack": "node Makefile.js webpack", + "build:readme": "node tools/update-readme.js", + "build:rules-index": "node Makefile.js generateRuleIndexPage", + "fmt": "prettier --write .", + "fmt:check": "prettier --check .", + "lint": "node Makefile.js lint", + "lint:docs:js": "node Makefile.js lintDocsJS", + "lint:docs:rule-examples": "node Makefile.js checkRuleExamples", + "lint:unused": "knip", + "lint:fix": "node Makefile.js lint -- fix", + "lint:fix:docs:js": "node Makefile.js lintDocsJS -- fix", + "lint:rule-types": "node tools/update-rule-type-headers.js --check", + "lint:types": "attw --pack", + "release:generate:alpha": "node Makefile.js generatePrerelease -- alpha", + "release:generate:beta": "node Makefile.js generatePrerelease -- beta", + "release:generate:latest": "node Makefile.js generateRelease -- latest", + "release:generate:maintenance": "node Makefile.js generateRelease -- maintenance", + "release:generate:rc": "node Makefile.js generatePrerelease -- rc", + "release:publish": "node Makefile.js publishRelease", + "test": "node Makefile.js test", + "test:browser": "node Makefile.js cypress", + "test:cli": "mocha", + "test:ecosystem": "node tools/test-ecosystem/index.mjs", + "test:ecosystem:update": "node tools/test-ecosystem/update.mjs", + "test:emfile": "node tools/check-emfile-handling.js", + "test:fuzz": "node Makefile.js fuzz", + "test:performance": "node Makefile.js perf", + "test:pnpm": "cd tests/pnpm && node check.js && pnpm install && pnpm exec tsc", + "test:types": "tsc -p tests/lib/types/tsconfig.json && npm run test:types --workspaces --if-present", + "test:types:5.3": "npx -p typescript@5.3 -y -- tsc -p tsconfig.types-legacy.json", + "test:types:5.x": "npx -p typescript@5.x -y -- tsc -p tsconfig.types.json", + "test:types:7.x": "npx -p @typescript/native-preview@latest -y -- tsgo -p tsconfig.types.json", + "test:types:all": "npm run test:types && npm run test:types:5.3 && npm run test:types:5.x && npm run test:types:7.x" + }, + "allowScripts": { + "core-js": false, + "cypress": false, + "re2": true, + "yorkie": true + }, + "workspaces": [ + "packages/*" + ], + "gitHooks": { + "pre-commit": "lint-staged" + }, + "lint-staged": { + "*.{js,json,jsonc,json5,yml,yaml}": [ + "eslint --fix", + "prettier --write" + ], + "docs/src/**/*.md": [ + "markdownlint-cli2 --fix", + "prettier --write" + ], + "!({{*.,**/*.}{js,json,jsonc,json5,yml,yaml},docs/src/**/*.md})": "prettier --write --ignore-unknown", + "lib/rules/*.js": [ + "node tools/update-eslint-all.js", + "node tools/update-eslint-recommended.js", + "node tools/update-rule-type-headers.js", + "git add packages/js/src/configs/*.js lib/types/rules.d.ts" + ], + "docs/src/rules/*.md": [ + "node tools/check-rule-examples.js", + "node tools/fetch-docs-links.js", + "git add docs/src/_data/further_reading_links.json" + ], + "docs/**/*.svg": "npx -y svgo -r --multipass" + }, + "files": [ + "LICENSE", + "README.md", + "bin", + "conf", + "lib", + "messages" + ], + "repository": "eslint/eslint", + "funding": "https://eslint.org/donate", + "homepage": "https://eslint.org", + "bugs": "https://github.com/eslint/eslint/issues/", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.2", + "@eslint/config-array": "^0.23.5", + "@eslint/config-helpers": "^0.7.0", + "@eslint/core": "^1.2.1", + "@eslint/plugin-kit": "^0.7.3", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^9.1.2", + "eslint-visitor-keys": "^5.0.1", + "espree": "^11.2.0", + "esquery": "^1.7.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "11.1.5 || >11.1.6 <12", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "minimatch": "^10.2.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.18.3", + "@babel/core": "^7.4.3", + "@babel/preset-env": "^7.4.3", + "@cypress/webpack-preprocessor": "^6.0.2", + "@eslint/eslintrc": "^3.3.7", + "@eslint/json": "^2.1.0", + "@types/esquery": "^1.5.4", + "@types/node": "^22.13.14", + "@typescript-eslint/parser": "^8.58.2", + "babel-loader": "^8.0.5", + "c8": "^11.0.0", + "chai": "^4.0.1", + "cheerio": "^0.22.0", + "common-tags": "^1.8.0", + "core-js": "^3.1.3", + "cypress": "^14.1.0", + "ejs": "^3.0.2", + "eslint": "file:.", + "eslint-config-eslint": "file:packages/eslint-config-eslint", + "eslint-plugin-eslint-plugin": "^7.3.2", + "eslint-plugin-expect-type": "^0.6.0", + "eslint-plugin-yml": "^1.14.0", + "eslint-release": "^3.3.0", + "eslint-rule-extender": "^0.0.1", + "eslump": "^3.0.0", + "esprima": "^4.0.1", + "fs-teardown": "^0.1.3", + "glob": "^10.0.0", + "globals": "^16.2.0", + "got": "^11.8.3", + "gray-matter": "^4.0.3", + "jiti": "^2.6.1", + "knip": "^6.13.1", + "lint-staged": "^11.0.0", + "markdown-it": "^14.2.0", + "markdown-it-container": "^4.0.0", + "markdownlint-cli2": "^0.22.0", + "marked": "^4.0.8", + "metascraper": "^5.25.7", + "metascraper-description": "^5.25.7", + "metascraper-image": "^5.29.3", + "metascraper-logo": "^5.25.7", + "metascraper-logo-favicon": "^5.25.7", + "metascraper-title": "^5.25.7", + "mocha": "^11.7.1", + "node-polyfill-webpack-plugin": "^1.0.3", + "npm-license": "^0.3.3", + "prettier": "3.9.6", + "progress": "^2.0.3", + "proxyquire": "^2.0.1", + "regenerator-runtime": "^0.14.0", + "semver": "^7.5.3", + "shelljs": "^0.10.0", + "sinon": "^11.0.0", + "typescript": "^6.0.3", + "webpack": "^5.109.2", + "webpack-cli": "^4.5.0", + "yorkie": "^2.0.0" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + }, + "keywords": [ + "ast", + "lint", + "javascript", + "ecmascript", + "espree" + ], + "license": "MIT", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } +} diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/espree b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/espree new file mode 120000 index 00000000..9201827f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/espree @@ -0,0 +1 @@ +../../espree@11.2.0/node_modules/espree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esquery b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esquery new file mode 120000 index 00000000..b3e2c852 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esquery @@ -0,0 +1 @@ +../../esquery@1.7.0/node_modules/esquery \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esutils b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esutils new file mode 120000 index 00000000..7d64b08f --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/esutils @@ -0,0 +1 @@ +../../esutils@2.0.3/node_modules/esutils \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/fast-deep-equal b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/fast-deep-equal new file mode 120000 index 00000000..c61b4c88 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/fast-deep-equal @@ -0,0 +1 @@ +../../fast-deep-equal@3.1.3/node_modules/fast-deep-equal \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/file-entry-cache b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/file-entry-cache new file mode 120000 index 00000000..ca2cf3c8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/file-entry-cache @@ -0,0 +1 @@ +../../file-entry-cache@11.1.5/node_modules/file-entry-cache \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/find-up b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/find-up new file mode 120000 index 00000000..f3682b84 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/find-up @@ -0,0 +1 @@ +../../find-up@5.0.0/node_modules/find-up \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/glob-parent b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/glob-parent new file mode 120000 index 00000000..1acec251 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/glob-parent @@ -0,0 +1 @@ +../../glob-parent@6.0.2/node_modules/glob-parent \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ignore b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ignore new file mode 120000 index 00000000..39193988 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/ignore @@ -0,0 +1 @@ +../../ignore@5.3.2/node_modules/ignore \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/imurmurhash b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/imurmurhash new file mode 120000 index 00000000..ca8c8e46 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/imurmurhash @@ -0,0 +1 @@ +../../imurmurhash@0.1.4/node_modules/imurmurhash \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/is-glob b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/is-glob new file mode 120000 index 00000000..1c00d5e4 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/is-glob @@ -0,0 +1 @@ +../../is-glob@4.0.3/node_modules/is-glob \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/jiti b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/jiti new file mode 120000 index 00000000..fa17aa98 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/jiti @@ -0,0 +1 @@ +../../jiti@2.7.0/node_modules/jiti \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/json-stable-stringify-without-jsonify b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/json-stable-stringify-without-jsonify new file mode 120000 index 00000000..9afd3cad --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/json-stable-stringify-without-jsonify @@ -0,0 +1 @@ +../../json-stable-stringify-without-jsonify@1.0.1/node_modules/json-stable-stringify-without-jsonify \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/minimatch b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/minimatch new file mode 120000 index 00000000..46179da5 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/minimatch @@ -0,0 +1 @@ +../../minimatch@10.2.6/node_modules/minimatch \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/natural-compare b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/natural-compare new file mode 120000 index 00000000..1d16aca8 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/natural-compare @@ -0,0 +1 @@ +../../natural-compare@1.4.0/node_modules/natural-compare \ No newline at end of file diff --git a/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/optionator b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/optionator new file mode 120000 index 00000000..5781afc2 --- /dev/null +++ b/backend/node_modules/.pnpm/eslint@10.11.0_jiti@2.7.0/node_modules/optionator @@ -0,0 +1 @@ +../../optionator@0.9.4/node_modules/optionator \ No newline at end of file diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/@types/estree b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/@types/estree new file mode 120000 index 00000000..fda8efea --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/@types/estree @@ -0,0 +1 @@ +../../../@types+estree@1.0.9/node_modules/@types/estree \ No newline at end of file diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/LICENSE b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/LICENSE new file mode 100644 index 00000000..63b62098 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/LICENSE @@ -0,0 +1,7 @@ +Copyright (c) 2015-20 [these people](https://github.com/Rich-Harris/estree-walker/graphs/contributors) + +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/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/README.md b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/README.md new file mode 100644 index 00000000..d739d1bf --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/README.md @@ -0,0 +1,48 @@ +# estree-walker + +Simple utility for walking an [ESTree](https://github.com/estree/estree)-compliant AST, such as one generated by [acorn](https://github.com/marijnh/acorn). + + +## Installation + +```bash +npm i estree-walker +``` + + +## Usage + +```js +var walk = require('estree-walker').walk; +var acorn = require('acorn'); + +ast = acorn.parse(sourceCode, options); // https://github.com/acornjs/acorn + +walk(ast, { + enter(node, parent, prop, index) { + // some code happens + }, + leave(node, parent, prop, index) { + // some code happens + } +}); +``` + +Inside the `enter` function, calling `this.skip()` will prevent the node's children being walked, or the `leave` function (which is optional) being called. + +Call `this.replace(new_node)` in either `enter` or `leave` to replace the current node with a new one. + +Call `this.remove()` in either `enter` or `leave` to remove the current node. + +## Why not use estraverse? + +The ESTree spec is evolving to accommodate ES6/7. I've had a couple of experiences where [estraverse](https://github.com/estools/estraverse) was unable to handle an AST generated by recent versions of acorn, because it hard-codes visitor keys. + +estree-walker, by contrast, simply enumerates a node's properties to find child nodes (and child lists of nodes), and is therefore resistant to spec changes. It's also much smaller. (The performance, if you're wondering, is basically identical.) + +None of which should be taken as criticism of estraverse, which has more features and has been battle-tested in many more situations, and for which I'm very grateful. + + +## License + +MIT diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/package.json b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/package.json new file mode 100644 index 00000000..c9f54edd --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/package.json @@ -0,0 +1,38 @@ +{ + "name": "estree-walker", + "description": "Traverse an ESTree-compliant AST", + "version": "3.0.3", + "private": false, + "author": "Rich Harris", + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/Rich-Harris/estree-walker" + }, + "type": "module", + "module": "./src/index.js", + "exports": { + "./package.json": "./package.json", + ".": { + "types": "./types/index.d.ts", + "import": "./src/index.js" + } + }, + "types": "types/index.d.ts", + "scripts": { + "prepublishOnly": "tsc && npm test", + "test": "uvu test" + }, + "dependencies": { + "@types/estree": "^1.0.0" + }, + "devDependencies": { + "typescript": "^4.9.0", + "uvu": "^0.5.1" + }, + "files": [ + "src", + "types", + "README.md" + ] +} diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js new file mode 100644 index 00000000..f068c713 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js @@ -0,0 +1,152 @@ +import { WalkerBase } from './walker.js'; + +/** + * @typedef { import('estree').Node} Node + * @typedef { import('./walker.js').WalkerContext} WalkerContext + * @typedef {( + * this: WalkerContext, + * node: Node, + * parent: Node | null, + * key: string | number | symbol | null | undefined, + * index: number | null | undefined + * ) => Promise} AsyncHandler + */ + +export class AsyncWalker extends WalkerBase { + /** + * + * @param {AsyncHandler} [enter] + * @param {AsyncHandler} [leave] + */ + constructor(enter, leave) { + super(); + + /** @type {boolean} */ + this.should_skip = false; + + /** @type {boolean} */ + this.should_remove = false; + + /** @type {Node | null} */ + this.replacement = null; + + /** @type {WalkerContext} */ + this.context = { + skip: () => (this.should_skip = true), + remove: () => (this.should_remove = true), + replace: (node) => (this.replacement = node) + }; + + /** @type {AsyncHandler | undefined} */ + this.enter = enter; + + /** @type {AsyncHandler | undefined} */ + this.leave = leave; + } + + /** + * @template {Node} Parent + * @param {Node} node + * @param {Parent | null} parent + * @param {keyof Parent} [prop] + * @param {number | null} [index] + * @returns {Promise} + */ + async visit(node, parent, prop, index) { + if (node) { + if (this.enter) { + const _should_skip = this.should_skip; + const _should_remove = this.should_remove; + const _replacement = this.replacement; + this.should_skip = false; + this.should_remove = false; + this.replacement = null; + + await this.enter.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const skipped = this.should_skip; + const removed = this.should_remove; + + this.should_skip = _should_skip; + this.should_remove = _should_remove; + this.replacement = _replacement; + + if (skipped) return node; + if (removed) return null; + } + + /** @type {keyof Node} */ + let key; + + for (key in node) { + /** @type {unknown} */ + const value = node[key]; + + if (value && typeof value === 'object') { + if (Array.isArray(value)) { + const nodes = /** @type {Array} */ (value); + for (let i = 0; i < nodes.length; i += 1) { + const item = nodes[i]; + if (isNode(item)) { + if (!(await this.visit(item, node, key, i))) { + // removed + i--; + } + } + } + } else if (isNode(value)) { + await this.visit(value, node, key, null); + } + } + } + + if (this.leave) { + const _replacement = this.replacement; + const _should_remove = this.should_remove; + this.replacement = null; + this.should_remove = false; + + await this.leave.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const removed = this.should_remove; + + this.replacement = _replacement; + this.should_remove = _should_remove; + + if (removed) return null; + } + } + + return node; + } +} + +/** + * Ducktype a node. + * + * @param {unknown} value + * @returns {value is Node} + */ +function isNode(value) { + return ( + value !== null && typeof value === 'object' && 'type' in value && typeof value.type === 'string' + ); +} diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js new file mode 100644 index 00000000..933ea4f2 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js @@ -0,0 +1,34 @@ +import { SyncWalker } from './sync.js'; +import { AsyncWalker } from './async.js'; + +/** + * @typedef {import('estree').Node} Node + * @typedef {import('./sync.js').SyncHandler} SyncHandler + * @typedef {import('./async.js').AsyncHandler} AsyncHandler + */ + +/** + * @param {Node} ast + * @param {{ + * enter?: SyncHandler + * leave?: SyncHandler + * }} walker + * @returns {Node | null} + */ +export function walk(ast, { enter, leave }) { + const instance = new SyncWalker(enter, leave); + return instance.visit(ast, null); +} + +/** + * @param {Node} ast + * @param {{ + * enter?: AsyncHandler + * leave?: AsyncHandler + * }} walker + * @returns {Promise} + */ +export async function asyncWalk(ast, { enter, leave }) { + const instance = new AsyncWalker(enter, leave); + return await instance.visit(ast, null); +} diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js new file mode 100644 index 00000000..171fb360 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js @@ -0,0 +1,152 @@ +import { WalkerBase } from './walker.js'; + +/** + * @typedef { import('estree').Node} Node + * @typedef { import('./walker.js').WalkerContext} WalkerContext + * @typedef {( + * this: WalkerContext, + * node: Node, + * parent: Node | null, + * key: string | number | symbol | null | undefined, + * index: number | null | undefined + * ) => void} SyncHandler + */ + +export class SyncWalker extends WalkerBase { + /** + * + * @param {SyncHandler} [enter] + * @param {SyncHandler} [leave] + */ + constructor(enter, leave) { + super(); + + /** @type {boolean} */ + this.should_skip = false; + + /** @type {boolean} */ + this.should_remove = false; + + /** @type {Node | null} */ + this.replacement = null; + + /** @type {WalkerContext} */ + this.context = { + skip: () => (this.should_skip = true), + remove: () => (this.should_remove = true), + replace: (node) => (this.replacement = node) + }; + + /** @type {SyncHandler | undefined} */ + this.enter = enter; + + /** @type {SyncHandler | undefined} */ + this.leave = leave; + } + + /** + * @template {Node} Parent + * @param {Node} node + * @param {Parent | null} parent + * @param {keyof Parent} [prop] + * @param {number | null} [index] + * @returns {Node | null} + */ + visit(node, parent, prop, index) { + if (node) { + if (this.enter) { + const _should_skip = this.should_skip; + const _should_remove = this.should_remove; + const _replacement = this.replacement; + this.should_skip = false; + this.should_remove = false; + this.replacement = null; + + this.enter.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const skipped = this.should_skip; + const removed = this.should_remove; + + this.should_skip = _should_skip; + this.should_remove = _should_remove; + this.replacement = _replacement; + + if (skipped) return node; + if (removed) return null; + } + + /** @type {keyof Node} */ + let key; + + for (key in node) { + /** @type {unknown} */ + const value = node[key]; + + if (value && typeof value === 'object') { + if (Array.isArray(value)) { + const nodes = /** @type {Array} */ (value); + for (let i = 0; i < nodes.length; i += 1) { + const item = nodes[i]; + if (isNode(item)) { + if (!this.visit(item, node, key, i)) { + // removed + i--; + } + } + } + } else if (isNode(value)) { + this.visit(value, node, key, null); + } + } + } + + if (this.leave) { + const _replacement = this.replacement; + const _should_remove = this.should_remove; + this.replacement = null; + this.should_remove = false; + + this.leave.call(this.context, node, parent, prop, index); + + if (this.replacement) { + node = this.replacement; + this.replace(parent, prop, index, node); + } + + if (this.should_remove) { + this.remove(parent, prop, index); + } + + const removed = this.should_remove; + + this.replacement = _replacement; + this.should_remove = _should_remove; + + if (removed) return null; + } + } + + return node; + } +} + +/** + * Ducktype a node. + * + * @param {unknown} value + * @returns {value is Node} + */ +function isNode(value) { + return ( + value !== null && typeof value === 'object' && 'type' in value && typeof value.type === 'string' + ); +} diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js new file mode 100644 index 00000000..6dc6bd7b --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js @@ -0,0 +1,61 @@ +/** + * @typedef { import('estree').Node} Node + * @typedef {{ + * skip: () => void; + * remove: () => void; + * replace: (node: Node) => void; + * }} WalkerContext + */ + +export class WalkerBase { + constructor() { + /** @type {boolean} */ + this.should_skip = false; + + /** @type {boolean} */ + this.should_remove = false; + + /** @type {Node | null} */ + this.replacement = null; + + /** @type {WalkerContext} */ + this.context = { + skip: () => (this.should_skip = true), + remove: () => (this.should_remove = true), + replace: (node) => (this.replacement = node) + }; + } + + /** + * @template {Node} Parent + * @param {Parent | null | undefined} parent + * @param {keyof Parent | null | undefined} prop + * @param {number | null | undefined} index + * @param {Node} node + */ + replace(parent, prop, index, node) { + if (parent && prop) { + if (index != null) { + /** @type {Array} */ (parent[prop])[index] = node; + } else { + /** @type {Node} */ (parent[prop]) = node; + } + } + } + + /** + * @template {Node} Parent + * @param {Parent | null | undefined} parent + * @param {keyof Parent | null | undefined} prop + * @param {number | null | undefined} index + */ + remove(parent, prop, index) { + if (parent && prop) { + if (index !== null && index !== undefined) { + /** @type {Array} */ (parent[prop]).splice(index, 1); + } else { + delete parent[prop]; + } + } + } +} diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/async.d.ts b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/async.d.ts new file mode 100644 index 00000000..db0825aa --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/async.d.ts @@ -0,0 +1,36 @@ +/** + * @typedef { import('estree').Node} Node + * @typedef { import('./walker.js').WalkerContext} WalkerContext + * @typedef {( + * this: WalkerContext, + * node: Node, + * parent: Node | null, + * key: string | number | symbol | null | undefined, + * index: number | null | undefined + * ) => Promise} AsyncHandler + */ +export class AsyncWalker extends WalkerBase { + /** + * + * @param {AsyncHandler} [enter] + * @param {AsyncHandler} [leave] + */ + constructor(enter?: AsyncHandler | undefined, leave?: AsyncHandler | undefined); + /** @type {AsyncHandler | undefined} */ + enter: AsyncHandler | undefined; + /** @type {AsyncHandler | undefined} */ + leave: AsyncHandler | undefined; + /** + * @template {Node} Parent + * @param {Node} node + * @param {Parent | null} parent + * @param {keyof Parent} [prop] + * @param {number | null} [index] + * @returns {Promise} + */ + visit(node: Node, parent: Parent | null, prop?: keyof Parent | undefined, index?: number | null | undefined): Promise; +} +export type Node = import('estree').Node; +export type WalkerContext = import('./walker.js').WalkerContext; +export type AsyncHandler = (this: WalkerContext, node: Node, parent: Node | null, key: string | number | symbol | null | undefined, index: number | null | undefined) => Promise; +import { WalkerBase } from "./walker.js"; diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/index.d.ts b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/index.d.ts new file mode 100644 index 00000000..c25afed9 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/index.d.ts @@ -0,0 +1,32 @@ +/** + * @typedef {import('estree').Node} Node + * @typedef {import('./sync.js').SyncHandler} SyncHandler + * @typedef {import('./async.js').AsyncHandler} AsyncHandler + */ +/** + * @param {Node} ast + * @param {{ + * enter?: SyncHandler + * leave?: SyncHandler + * }} walker + * @returns {Node | null} + */ +export function walk(ast: Node, { enter, leave }: { + enter?: SyncHandler; + leave?: SyncHandler; +}): Node | null; +/** + * @param {Node} ast + * @param {{ + * enter?: AsyncHandler + * leave?: AsyncHandler + * }} walker + * @returns {Promise} + */ +export function asyncWalk(ast: Node, { enter, leave }: { + enter?: AsyncHandler; + leave?: AsyncHandler; +}): Promise; +export type Node = import('estree').Node; +export type SyncHandler = import('./sync.js').SyncHandler; +export type AsyncHandler = import('./async.js').AsyncHandler; diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/sync.d.ts b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/sync.d.ts new file mode 100644 index 00000000..3612b7ff --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/sync.d.ts @@ -0,0 +1,36 @@ +/** + * @typedef { import('estree').Node} Node + * @typedef { import('./walker.js').WalkerContext} WalkerContext + * @typedef {( + * this: WalkerContext, + * node: Node, + * parent: Node | null, + * key: string | number | symbol | null | undefined, + * index: number | null | undefined + * ) => void} SyncHandler + */ +export class SyncWalker extends WalkerBase { + /** + * + * @param {SyncHandler} [enter] + * @param {SyncHandler} [leave] + */ + constructor(enter?: SyncHandler | undefined, leave?: SyncHandler | undefined); + /** @type {SyncHandler | undefined} */ + enter: SyncHandler | undefined; + /** @type {SyncHandler | undefined} */ + leave: SyncHandler | undefined; + /** + * @template {Node} Parent + * @param {Node} node + * @param {Parent | null} parent + * @param {keyof Parent} [prop] + * @param {number | null} [index] + * @returns {Node | null} + */ + visit(node: Node, parent: Parent | null, prop?: keyof Parent | undefined, index?: number | null | undefined): Node | null; +} +export type Node = import('estree').Node; +export type WalkerContext = import('./walker.js').WalkerContext; +export type SyncHandler = (this: WalkerContext, node: Node, parent: Node | null, key: string | number | symbol | null | undefined, index: number | null | undefined) => void; +import { WalkerBase } from "./walker.js"; diff --git a/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/walker.d.ts b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/walker.d.ts new file mode 100644 index 00000000..a3fa29c1 --- /dev/null +++ b/backend/node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/types/walker.d.ts @@ -0,0 +1,39 @@ +/** + * @typedef { import('estree').Node} Node + * @typedef {{ + * skip: () => void; + * remove: () => void; + * replace: (node: Node) => void; + * }} WalkerContext + */ +export class WalkerBase { + /** @type {boolean} */ + should_skip: boolean; + /** @type {boolean} */ + should_remove: boolean; + /** @type {Node | null} */ + replacement: Node | null; + /** @type {WalkerContext} */ + context: WalkerContext; + /** + * @template {Node} Parent + * @param {Parent | null | undefined} parent + * @param {keyof Parent | null | undefined} prop + * @param {number | null | undefined} index + * @param {Node} node + */ + replace(parent: Parent | null | undefined, prop: keyof Parent | null | undefined, index: number | null | undefined, node: Node): void; + /** + * @template {Node} Parent + * @param {Parent | null | undefined} parent + * @param {keyof Parent | null | undefined} prop + * @param {number | null | undefined} index + */ + remove(parent: Parent_1 | null | undefined, prop: keyof Parent_1 | null | undefined, index: number | null | undefined): void; +} +export type Node = import('estree').Node; +export type WalkerContext = { + skip: () => void; + remove: () => void; + replace: (node: Node) => void; +}; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/LICENSE b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/LICENSE new file mode 100644 index 00000000..deede247 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/LICENSE @@ -0,0 +1,191 @@ + Copyright 2024 Misha Kaletsky + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/README.md b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/README.md new file mode 100644 index 00000000..f17e9c68 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/README.md @@ -0,0 +1,1027 @@ +# expect-type + +[![CI](https://github.com/mmkal/expect-type/actions/workflows/ci.yml/badge.svg)](https://github.com/mmkal/expect-type/actions/workflows/ci.yml) +![npm](https://img.shields.io/npm/dt/expect-type) +[![X Follow](https://img.shields.io/twitter/follow/mmkal)](https://x.com/mmkalmmkal) + +Compile-time tests for types. Useful to make sure types don't regress into being overly permissive as changes go in over time. + +Similar to `expect`, but with type-awareness. Gives you access to several type-matchers that let you make assertions about the form of a reference or generic type parameter. + +```ts +import {expectTypeOf} from 'expect-type' +import {foo, bar} from '../foo' + +// make sure `foo` has type {a: number} +expectTypeOf(foo).toEqualTypeOf<{a: number}>() + +// make sure `bar` is a function taking a string: +expectTypeOf(bar).parameter(0).toBeString() +expectTypeOf(bar).returns.not.toBeAny() +``` + +It can be used in your existing test files (and is actually [built in to vitest](https://vitest.dev/guide/testing-types)). Or it can be used in any other type-checked file you'd like - it's built into existing tooling with no dependencies. No extra build step, cli tool, IDE extension, or lint plugin is needed. Just import the function and start writing tests. Failures will be at compile time - they'll appear in your IDE and when you run `tsc`. + +See below for lots more examples. + +## Contents + +- [Contents](#contents) +- [Installation and usage](#installation-and-usage) +- [Documentation](#documentation) + - [Features](#features) + - [Why is my assertion failing?](#why-is-my-assertion-failing) + - [Why is `.toMatchTypeOf` deprecated?](#why-is-tomatchtypeof-deprecated) + - [Internal type helpers](#internal-type-helpers) + - [Error messages](#error-messages) + - [Concrete "expected" objects vs type arguments](#concrete-expected-objects-vs-type-arguments) + - [Overloaded functions](#overloaded-functions) + - [Within test frameworks](#within-test-frameworks) + - [Vitest](#vitest) + - [Jest & `eslint-plugin-jest`](#jest--eslint-plugin-jest) + - [Limitations](#limitations) +- [Similar projects](#similar-projects) + - [Comparison](#comparison) +- [TypeScript backwards-compatibility](#typescript-backwards-compatibility) +- [Contributing](#contributing) + - [Documentation of limitations through tests](#documentation-of-limitations-through-tests) + + +## Installation and usage + +```cli +npm install expect-type --save-dev +``` + +```typescript +import {expectTypeOf} from 'expect-type' +``` + +## Documentation + +The `expectTypeOf` method takes a single argument or a generic type parameter. Neither it nor the functions chained off its return value have any meaningful runtime behaviour. The assertions you write will be _compile-time_ errors if they don't hold true. + +### Features + + +Check an object's type with `.toEqualTypeOf`: + +```typescript +expectTypeOf({a: 1}).toEqualTypeOf<{a: number}>() +``` + +`.toEqualTypeOf` can check that two concrete objects have equivalent types (note: when these assertions _fail_, the error messages can be less informative vs the generic type argument syntax above - see [error messages docs](#error-messages)): + +```typescript +expectTypeOf({a: 1}).toEqualTypeOf({a: 1}) +``` + +`.toEqualTypeOf` succeeds for objects with different values, but the same type: + +```typescript +expectTypeOf({a: 1}).toEqualTypeOf({a: 2}) +``` + +`.toEqualTypeOf` fails on excess properties: + +```typescript +// @ts-expect-error +expectTypeOf({a: 1, b: 1}).toEqualTypeOf<{a: number}>() +``` + +To allow for extra properties on an object type, use `.toMatchObjectType`. This is a strict check, but only on the subset of keys that are in the expected type: + +```typescript +expectTypeOf({a: 1, b: 1}).toMatchObjectType<{a: number}>() +``` + +`.toMatchObjectType` can check partial matches on deeply nested objects: + +```typescript +const user = { + email: 'a@b.com', + name: 'John Doe', + address: {street: '123 2nd St', city: 'New York', zip: '10001', state: 'NY', country: 'USA'}, +} + +expectTypeOf(user).toMatchObjectType<{name: string; address: {city: string}}>() +``` + +To check that a type extends another type, use `.toExtend`: + +```typescript +expectTypeOf('some string').toExtend() +// @ts-expect-error +expectTypeOf({a: 1}).toExtend<{b: number}>() +``` + +`.toExtend` can be used with object types, but `.toMatchObjectType` is usually a better choice when dealing with objects, since it's stricter: + +```typescript +expectTypeOf({a: 1, b: 2}).toExtend<{a: number}>() // avoid this +expectTypeOf({a: 1, b: 2}).toMatchObjectType<{a: number}>() // prefer this +``` + +`.toEqualTypeOf`, `.toMatchObjectType`, and `.toExtend` all fail on missing properties: + +```typescript +// @ts-expect-error +expectTypeOf({a: 1}).toEqualTypeOf<{a: number; b: number}>() +// @ts-expect-error +expectTypeOf({a: 1}).toMatchObjectType<{a: number; b: number}>() +// @ts-expect-error +expectTypeOf({a: 1}).toExtend<{a: number; b: number}>() +``` + +Another example of the difference between `.toExtend`, `.toMatchObjectType`, and `.toEqualTypeOf`. `.toExtend` can be used for "is-a" relationships: + +```typescript +type Fruit = {type: 'Fruit'; edible: boolean} +type Apple = {type: 'Fruit'; name: 'Apple'; edible: true} + +expectTypeOf().toExtend() + +// @ts-expect-error - the `editable` property isn't an exact match. In `Apple`, it's `true`, which extends `boolean`, but they're not identical. +expectTypeOf().toMatchObjectType() + +// @ts-expect-error - Apple is not an identical type to Fruit, it's a subtype +expectTypeOf().toEqualTypeOf() + +// @ts-expect-error - Apple is a Fruit, but not vice versa +expectTypeOf().toExtend() +``` + +Assertions can be inverted with `.not`: + +```typescript +expectTypeOf({a: 1}).not.toExtend<{b: 1}>() +expectTypeOf({a: 1}).not.toMatchObjectType<{b: 1}>() +``` + +`.not` can be easier than relying on `// @ts-expect-error`: + +```typescript +type Fruit = {type: 'Fruit'; edible: boolean} +type Apple = {type: 'Fruit'; name: 'Apple'; edible: true} + +expectTypeOf().toExtend() + +expectTypeOf().not.toExtend() +expectTypeOf().not.toEqualTypeOf() +``` + +Catch any/unknown/never types: + +```typescript +expectTypeOf().toBeUnknown() +expectTypeOf().toBeAny() +expectTypeOf().toBeNever() + +// @ts-expect-error +expectTypeOf().toBeNumber() +``` + +`.toEqualTypeOf` distinguishes between deeply-nested `any` and `unknown` properties: + +```typescript +expectTypeOf<{deeply: {nested: any}}>().not.toEqualTypeOf<{deeply: {nested: unknown}}>() +``` + +You can test for basic JavaScript types: + +```typescript +expectTypeOf(() => 1).toBeFunction() +expectTypeOf({}).toBeObject() +expectTypeOf([]).toBeArray() +expectTypeOf('').toBeString() +expectTypeOf(1).toBeNumber() +expectTypeOf(true).toBeBoolean() +expectTypeOf(() => {}).returns.toBeVoid() +expectTypeOf(Promise.resolve(123)).resolves.toBeNumber() +expectTypeOf(Symbol(1)).toBeSymbol() +expectTypeOf(1n).toBeBigInt() +``` + +`.toBe...` methods allow for types that extend the expected type: + +```typescript +expectTypeOf().toBeNumber() +expectTypeOf<1>().toBeNumber() + +expectTypeOf().toBeArray() +expectTypeOf().toBeArray() + +expectTypeOf().toBeString() +expectTypeOf<'foo'>().toBeString() + +expectTypeOf().toBeBoolean() +expectTypeOf().toBeBoolean() + +expectTypeOf().toBeBigInt() +expectTypeOf<0n>().toBeBigInt() +``` + +`.toBe...` methods protect against `any`: + +```typescript +const goodIntParser = (s: string) => Number.parseInt(s, 10) +const badIntParser = (s: string) => JSON.parse(s) // uh-oh - works at runtime if the input is a number, but return 'any' + +expectTypeOf(goodIntParser).returns.toBeNumber() +// @ts-expect-error - if you write a test like this, `.toBeNumber()` will let you know your implementation returns `any`. +expectTypeOf(badIntParser).returns.toBeNumber() +``` + +Nullable types: + +```typescript +expectTypeOf(undefined).toBeUndefined() +expectTypeOf(undefined).toBeNullable() +expectTypeOf(undefined).not.toBeNull() + +expectTypeOf(null).toBeNull() +expectTypeOf(null).toBeNullable() +expectTypeOf(null).not.toBeUndefined() + +expectTypeOf<1 | undefined>().toBeNullable() +expectTypeOf<1 | null>().toBeNullable() +expectTypeOf<1 | undefined | null>().toBeNullable() +``` + +Use `.branded.inspect` to find badly-defined paths: + +This finds `any` and `never` types deep within objects. This can be useful for debugging, or for validating large or complex types. If there are `any` or `never` types lurking deep within the type, your IDE will highlight the bad paths. + +Note: this is a fairly heavy operation, so you might not want to actually commit the assertions to source control. + +```typescript +const bad = (metadata: string) => ({ + name: 'Bob', + dob: new Date('1970-01-01'), + meta: { + raw: metadata, + parsed: JSON.parse(metadata), // whoops, any! + }, + exitCode: process.exit(), // whoops, never! +}) + +expectTypeOf(bad).returns.branded.inspect({ + foundProps: { + '.meta.parsed': 'any', + '.exitCode': 'never', + }, +}) +``` + +You can use `.branded.inspect` to confirm there are no unexpected types: + +```typescript +const good = (metadata: string) => ({ + name: 'Bob', + dob: new Date('1970-01-01'), + meta: { + raw: metadata, + parsed: JSON.parse(metadata) as unknown, // here we just cast, but you should use zod/similar validation libraries + }, + exitCode: 0, +}) + +expectTypeOf(good).returns.branded.inspect({ + foundProps: {}, +}) + +// You can also use it to search for other types. Valid options for `findType` are currently only `'never' | 'any' | 'unknown'`. + +expectTypeOf(good).returns.branded.inspect<{findType: 'unknown'}>({ + foundProps: { + '.meta.parsed': 'unknown', + }, +}) +``` + +`.toBeAny()` vs `.branded.inspect()`: + +`.toBeAny()` and `.branded.inspect(...)` answer different questions, so reach for them in different situations. + +Use `.toBeAny()` (usually via `.toHaveProperty(...)`) when you already know _which_ property should — or shouldn't — be `any`, and want to pin that exact spot. This is the right tool when a property is deliberately `any` and you want a regression test guarding it, or when you want to assert a specific property is _not_ `any` after giving it a real type. + +Reach for `.branded.inspect(...)` when you _don't_ know where a bad type might be hiding. It walks the whole type and reports every `any`/`never` path it finds, so it's the tool for catching anys lurking deep inside a large or complex object — `.foo.bar.baz` could be `any` and you'd never think to check it by hand. + +```typescript +const bad = (metadata: string) => ({ + name: 'Bob', + meta: { + parsed: JSON.parse(metadata), // whoops, any! + }, +}) + +// `.toBeAny()`: you already know which property to check. +expectTypeOf(bad).returns.toHaveProperty('meta').toHaveProperty('parsed').toBeAny() + +// `.branded.inspect()`: surface _any_ `any` hiding anywhere in the (possibly huge) type, without knowing where to look. +expectTypeOf(bad).returns.branded.inspect({ + foundProps: { + '.meta.parsed': 'any', + }, +}) +``` + +More `.not` examples: + +```typescript +expectTypeOf(1).not.toBeUnknown() +expectTypeOf(1).not.toBeAny() +expectTypeOf(1).not.toBeNever() +expectTypeOf(1).not.toBeNull() +expectTypeOf(1).not.toBeUndefined() +expectTypeOf(1).not.toBeNullable() +expectTypeOf(1).not.toBeBigInt() +``` + +Detect assignability of unioned types: + +```typescript +expectTypeOf().toExtend() +expectTypeOf().not.toExtend() +``` + +Use `.extract` and `.exclude` to narrow down complex union types: + +```typescript +type ResponsiveProp = T | T[] | {xs?: T; sm?: T; md?: T} +const getResponsiveProp = (_props: T): ResponsiveProp => ({}) +type CSSProperties = {margin?: string; padding?: string} + +const cssProperties: CSSProperties = {margin: '1px', padding: '2px'} + +expectTypeOf(getResponsiveProp(cssProperties)) + .exclude() + .exclude<{xs?: unknown}>() + .toEqualTypeOf() + +expectTypeOf(getResponsiveProp(cssProperties)) + .extract() + .toEqualTypeOf() + +expectTypeOf(getResponsiveProp(cssProperties)) + .extract<{xs?: any}>() + .toEqualTypeOf<{xs?: CSSProperties; sm?: CSSProperties; md?: CSSProperties}>() + +expectTypeOf>().exclude().toHaveProperty('sm') +expectTypeOf>().exclude().not.toHaveProperty('xxl') +``` + +`.extract` and `.exclude` return never if no types remain after exclusion: + +```typescript +type Person = {name: string; age: number} +type Customer = Person & {customerId: string} +type Employee = Person & {employeeId: string} + +expectTypeOf().extract<{foo: string}>().toBeNever() +expectTypeOf().exclude<{name: string}>().toBeNever() +``` + +Use `.pick` to pick a set of properties from an object: + +```typescript +type Person = {name: string; age: number} + +expectTypeOf().pick<'name'>().toEqualTypeOf<{name: string}>() +``` + +Use `.omit` to remove a set of properties from an object: + +```typescript +type Person = {name: string; age: number} + +expectTypeOf().omit<'name'>().toEqualTypeOf<{age: number}>() +``` + +Make assertions about object properties: + +```typescript +const obj = {a: 1, b: ''} + +// check that properties exist (or don't) with `.toHaveProperty` +expectTypeOf(obj).toHaveProperty('a') +expectTypeOf(obj).not.toHaveProperty('c') + +// check types of properties +expectTypeOf(obj).toHaveProperty('a').toBeNumber() +expectTypeOf(obj).toHaveProperty('b').toBeString() +expectTypeOf(obj).toHaveProperty('a').not.toBeString() +``` + +`.toEqualTypeOf` can be used to distinguish between functions: + +```typescript +type NoParam = () => void +type HasParam = (s: string) => void + +expectTypeOf().not.toEqualTypeOf() +``` + +But often it's preferable to use `.parameters` or `.returns` for more specific function assertions: + +```typescript +type NoParam = () => void +type HasParam = (s: string) => void + +expectTypeOf().parameters.toEqualTypeOf<[]>() +expectTypeOf().returns.toBeVoid() + +expectTypeOf().parameters.toEqualTypeOf<[string]>() +expectTypeOf().returns.toBeVoid() +``` + +Up to ten overloads will produce union types for `.parameters` and `.returns`: + +```typescript +type Factorize = { + (input: number): number[] + (input: bigint): bigint[] +} + +expectTypeOf().parameters.not.toEqualTypeOf<[number]>() +expectTypeOf().parameters.toEqualTypeOf<[number] | [bigint]>() +expectTypeOf().returns.toEqualTypeOf() + +expectTypeOf().parameter(0).toEqualTypeOf() +``` + +Note that these aren't exactly like TypeScript's built-in Parameters<...> and ReturnType<...>: + +The TypeScript builtins simply choose a single overload (see the [Overloaded functions](#overloaded-functions) section for more information) + +```typescript +type Factorize = { + (input: number): number[] + (input: bigint): bigint[] +} + +// overload using `number` is ignored! +expectTypeOf>().toEqualTypeOf<[bigint]>() +expectTypeOf>().toEqualTypeOf() +``` + +More examples of ways to work with functions - parameters using `.parameter(n)` or `.parameters`, and return values using `.returns`: + +```typescript +const f = (a: number) => [a, a] + +expectTypeOf(f).toBeFunction() + +expectTypeOf(f).toBeCallableWith(1) +expectTypeOf(f).not.toBeAny() +expectTypeOf(f).returns.not.toBeAny() +expectTypeOf(f).returns.toEqualTypeOf([1, 2]) +expectTypeOf(f).returns.toEqualTypeOf([1, 2, 3]) +expectTypeOf(f).parameter(0).not.toEqualTypeOf('1') +expectTypeOf(f).parameter(0).toEqualTypeOf(1) +expectTypeOf(1).parameter(0).toBeNever() + +const twoArgFunc = (a: number, b: string) => ({a, b}) + +expectTypeOf(twoArgFunc).parameters.toEqualTypeOf<[number, string]>() +``` + +`.toBeCallableWith` allows for overloads. You can also use it to narrow down the return type for given input parameters.: + +```typescript +type Factorize = { + (input: number): number[] + (input: bigint): bigint[] +} + +expectTypeOf().toBeCallableWith(6) +expectTypeOf().toBeCallableWith(6n) +``` + +`.toBeCallableWith` returns a type that can be used to narrow down the return type for given input parameters.: + +```typescript +type Factorize = { + (input: number): number[] + (input: bigint): bigint[] +} +expectTypeOf().toBeCallableWith(6).returns.toEqualTypeOf() +expectTypeOf().toBeCallableWith(6n).returns.toEqualTypeOf() +``` + +`.toBeCallableWith` can be used to narrow down the parameters of a function: + +```typescript +type Delete = { + (path: string): void + (paths: string[], options?: {force: boolean}): void +} + +expectTypeOf().toBeCallableWith('abc').parameters.toEqualTypeOf<[string]>() +expectTypeOf() + .toBeCallableWith(['abc', 'def'], {force: true}) + .parameters.toEqualTypeOf<[string[], {force: boolean}?]>() + +expectTypeOf().toBeCallableWith('abc').parameter(0).toBeString() +expectTypeOf().toBeCallableWith('abc').parameter(1).toBeUndefined() + +expectTypeOf() + .toBeCallableWith(['abc', 'def', 'ghi']) + .parameter(0) + .toEqualTypeOf() + +expectTypeOf() + .toBeCallableWith(['abc', 'def', 'ghi']) + .parameter(1) + .toEqualTypeOf<{force: boolean} | undefined>() +``` + +You can't use `.toBeCallableWith` with `.not` - you need to use ts-expect-error:: + +```typescript +const f = (a: number) => [a, a] + +// @ts-expect-error +expectTypeOf(f).toBeCallableWith('foo') +``` + +Use `.map` to transform types: + +This can be useful for generic functions or complex types which you can't access via `.toBeCallableWith`, `.toHaveProperty` etc. The callback function isn't called at runtime, which can make this a useful way to get complex inferred types without worrying about running code. + +```typescript +const capitalize = (input: S) => + (input.slice(0, 1).toUpperCase() + input.slice(1)) as Capitalize + +expectTypeOf(capitalize) + .map(fn => fn('hello world')) + .toEqualTypeOf<'Hello world'>() +``` + +You can also check type guards & type assertions: + +```typescript +const assertNumber = (v: any): asserts v is number => { + if (typeof v !== 'number') { + throw new TypeError('Nope !') + } +} + +expectTypeOf(assertNumber).asserts.toBeNumber() + +const isString = (v: any): v is string => typeof v === 'string' + +expectTypeOf(isString).guards.toBeString() + +const isBigInt = (value: any): value is bigint => typeof value === 'bigint' + +expectTypeOf(isBigInt).guards.toBeBigInt() +``` + +Assert on constructor parameters: + +```typescript +expectTypeOf(Date).toBeConstructibleWith('1970') +expectTypeOf(Date).toBeConstructibleWith(0) +expectTypeOf(Date).toBeConstructibleWith(new Date()) +expectTypeOf(Date).toBeConstructibleWith() + +expectTypeOf(Date).constructorParameters.toEqualTypeOf< + | [] + | [value: string | number] + | [value: string | number | Date] + | [ + year: number, + monthIndex: number, + date?: number | undefined, + hours?: number | undefined, + minutes?: number | undefined, + seconds?: number | undefined, + ms?: number | undefined, + ] +>() +``` + +Constructor overloads: + +```typescript +class DBConnection { + constructor() + constructor(connectionString: string) + constructor(options: {host: string; port: number}) + constructor(..._: unknown[]) {} +} + +expectTypeOf(DBConnection).toBeConstructibleWith() +expectTypeOf(DBConnection).toBeConstructibleWith('localhost') +expectTypeOf(DBConnection).toBeConstructibleWith({host: 'localhost', port: 1234}) +// @ts-expect-error - as when calling `new DBConnection(...)` you can't actually use the `(...args: unknown[])` overlaod, it's purely for the implementation. +expectTypeOf(DBConnection).toBeConstructibleWith(1, 2) +``` + +Check function `this` parameters: + +```typescript +function greet(this: {name: string}, message: string) { + return `Hello ${this.name}, here's your message: ${message}` +} + +expectTypeOf(greet).thisParameter.toEqualTypeOf<{name: string}>() +``` + +`thisParameter` supports overloads: + +```typescript +type GreetOverloaded = { + (this: {name: string}, message: string): string + (this: {id: number}, message: string): string +} + +expectTypeOf().thisParameter.toEqualTypeOf<{name: string} | {id: number}>() +``` + +`thisParameter` supports overloads where some overloads lack `this`: + +```typescript +type GreetOverloaded = { + (this: {name: string}, message: string): string + (message: string): string +} + +// When an overload lacks an explicit `this`, TypeScript infers `unknown` for it, +// so the union `{name: string} | unknown` collapses to `unknown`. +expectTypeOf().thisParameter.toBeUnknown() +``` + +Distinguish between functions with different `this` parameters: + +```typescript +function greetFormal(this: {title: string; name: string}, message: string) { + return `Dear ${this.title} ${this.name}, here's your message: ${message}` +} + +function greetCasual(this: {name: string}, message: string) { + return `Hi ${this.name}, here's your message: ${message}` +} + +expectTypeOf(greetFormal).not.toEqualTypeOf(greetCasual) +``` + +Class instance types: + +```typescript +expectTypeOf(Date).instance.toHaveProperty('toISOString') +``` + +Promise resolution types can be checked with `.resolves`: + +```typescript +const asyncFunc = async () => 123 + +expectTypeOf(asyncFunc).returns.resolves.toBeNumber() +``` + +Array items can be checked with `.items`: + +```typescript +expectTypeOf([1, 2, 3]).items.toBeNumber() +expectTypeOf([1, 2, 3]).items.not.toBeString() +``` + +You can also compare arrays directly: + +```typescript +expectTypeOf().not.toEqualTypeOf() +``` + +Check that functions never return: + +```typescript +const thrower = () => { + throw new Error('oh no') +} + +expectTypeOf(thrower).returns.toBeNever() +``` + +Generics can be used rather than references: + +```typescript +expectTypeOf<{a: string}>().not.toEqualTypeOf<{a: number}>() +``` + +Distinguish between missing/null/optional properties: + +```typescript +expectTypeOf<{a?: number}>().not.toEqualTypeOf<{}>() +expectTypeOf<{a?: number}>().not.toEqualTypeOf<{a: number}>() +expectTypeOf<{a?: number}>().not.toEqualTypeOf<{a: number | undefined}>() +expectTypeOf<{a?: number | null}>().not.toEqualTypeOf<{a: number | null}>() +expectTypeOf<{a: {b?: number}}>().not.toEqualTypeOf<{a: {}}>() +``` + +Detect the difference between regular and `readonly` properties: + +```typescript +type A1 = {readonly a: string; b: string} +type E1 = {a: string; b: string} + +expectTypeOf().toExtend() +expectTypeOf().not.toEqualTypeOf() + +type A2 = {a: string; b: {readonly c: string}} +type E2 = {a: string; b: {c: string}} + +expectTypeOf().toExtend() +expectTypeOf().not.toEqualTypeOf() +``` + +Distinguish between classes with different constructors: + +```typescript +class A { + value: number + constructor(a: 1) { + this.value = a + } +} +class B { + value: number + constructor(b: 2) { + this.value = b + } +} + +expectTypeOf().not.toEqualTypeOf() + +class C { + value: number + constructor(c: 1) { + this.value = c + } +} + +expectTypeOf().toEqualTypeOf() +``` + +Known limitation: Intersection types can cause issues with `toEqualTypeOf`: + +```typescript +// @ts-expect-error the following line doesn't compile, even though the types are arguably the same. +// See https://github.com/mmkal/expect-type/pull/21 +expectTypeOf<{a: 1} & {b: 2}>().toEqualTypeOf<{a: 1; b: 2}>() +``` + +To workaround for simple cases, you can use a mapped type: + +```typescript +type Simplify = {[K in keyof T]: T[K]} + +expectTypeOf>().toEqualTypeOf<{a: 1; b: 2}>() +``` + +But this won't work if the nesting is deeper in the type. For these situations, you can use the `.branded` helper. Note that this comes at a performance cost, and can cause the compiler to 'give up' if used with excessively deep types, so use sparingly. This helper is under `.branded` because it deeply transforms the Actual and Expected types into a pseudo-AST: + +```typescript +// @ts-expect-error +expectTypeOf<{a: {b: 1} & {c: 1}}>().toEqualTypeOf<{a: {b: 1; c: 1}}>() + +expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.toEqualTypeOf<{a: {b: 1; c: 1}}>() +``` + +Be careful with `.branded` for very deep or complex types, though. If possible you should find a way to simplify your test to avoid needing to use it: + +```typescript +// This *should* result in an error, but the "branding" mechanism produces too large a type and TypeScript just gives up! https://github.com/microsoft/TypeScript/issues/50670 +expectTypeOf<() => () => () => () => 1>().branded.toEqualTypeOf<() => () => () => () => 2>() + +// @ts-expect-error the non-branded implementation catches the error as expected. +expectTypeOf<() => () => () => () => 1>().toEqualTypeOf<() => () => () => () => 2>() +``` + +So, if you have an extremely deep type that ALSO has an intersection in it, you're out of luck and this library won't be able to test your type properly: + +```typescript +// @ts-expect-error this fails, but it should succeed. +expectTypeOf<() => () => () => () => {a: 1} & {b: 2}>().toEqualTypeOf< + () => () => () => () => {a: 1; b: 2} +>() + +// this succeeds, but it should fail. +expectTypeOf<() => () => () => () => {a: 1} & {b: 2}>().branded.toEqualTypeOf< + () => () => () => () => {a: 1; c: 2} +>() +``` + +Another limitation: passing `this` references to `expectTypeOf` results in errors.: + +```typescript +class B { + b = 'b' + + foo() { + // @ts-expect-error + expectTypeOf(this).toEqualTypeOf(this) + } +} + +// Instead of the above, try something like this: +expectTypeOf(B).instance.toEqualTypeOf<{b: string; foo: () => void}>() +``` + + +Overloads limitation for TypeScript <5.3: Due to a [TypeScript bug fixed in 5.3](https://github.com/microsoft/TypeScript/issues/28867), overloaded functions which include an overload resembling `(...args: unknown[]) => unknown` will exclude `unknown[]` from `.parameters` and exclude `unknown` from `.returns`: + +```typescript +type Factorize = { + (...args: unknown[]): unknown + (input: number): number[] + (input: bigint): bigint[] +} + +expectTypeOf().parameters.toEqualTypeOf<[number] | [bigint]>() +expectTypeOf().returns.toEqualTypeOf() +``` + +This overload, however, allows any input and returns an unknown output anyway, so it's not very useful. If you are worried about this for some reason, you'll have to update TypeScript to 5.3+. + +### Why is my assertion failing? + +For complex types, an assertion might fail when it should if the `Actual` type contains a deeply-nested intersection type but the `Expected` doesn't. In these cases you can use `.branded` as described above: + +```typescript +// @ts-expect-error this unfortunately fails - a TypeScript limitation prevents making this pass without a big perf hit +expectTypeOf<{a: {b: 1} & {c: 1}}>().toEqualTypeOf<{a: {b: 1; c: 1}}>() + +expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.toEqualTypeOf<{a: {b: 1; c: 1}}>() +``` + +### Why is `.toMatchTypeOf` deprecated? + +The `.toMatchTypeOf` method is deprecated in favour of `.toMatchObjectType` (when strictly checking against an object type with a subset of keys), or `.toExtend` (when checking for "is-a" relationships). There are no foreseeable plans to remove `.toMatchTypeOf`, but there's no reason to continue using it - `.toMatchObjectType` is stricter, and `.toExtend` is identical. + +### Internal type helpers + +🚧 This library also exports some helper types for performing boolean operations on types, checking extension/equality in various ways, branding types, and checking for various special types like `never`, `any`, `unknown`. Use at your own risk! Nothing is stopping you from using these beyond this warning: + +>All internal types that are not documented here are _not_ part of the supported API surface, and may be renamed, modified, or removed, without warning or documentation in release notes. + +For a dedicated internal type library, feel free to look at the [source code](./src/index.ts) for inspiration - or better, use a library like [type-fest](https://npmjs.com/package/type-fest). + +### Error messages + +When types don't match, `.toEqualTypeOf` and `.toMatchTypeOf` use a special helper type to produce error messages that are as actionable as possible. But there's a bit of a nuance to understanding them. Since the assertions are written "fluently", the failure should be on the "expected" type, not the "actual" type (`expect().toEqualTypeOf()`). This means that type errors can be a little confusing - so this library produces a `MismatchInfo` type to try to make explicit what the expectation is. For example: + +```ts +expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>() +``` + +Is an assertion that will fail, since `{a: 1}` has type `{a: number}` and not `{a: string}`. The error message in this case will read something like this: + +``` +test/test.ts:999:999 - error TS2344: Type '{ a: string; }' does not satisfy the constraint '{ a: \\"Expected: string, Actual: number\\"; }'. + Types of property 'a' are incompatible. + Type 'string' is not assignable to type '\\"Expected: string, Actual: number\\"'. + +999 expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>() +``` + +Note that the type constraint reported is a human-readable messaging specifying both the "expected" and "actual" types. Rather than taking the sentence `Types of property 'a' are incompatible // Type 'string' is not assignable to type "Expected: string, Actual: number"` literally - just look at the property name (`'a'`) and the message: `Expected: string, Actual: number`. This will tell you what's wrong, in most cases. Extremely complex types will, of course, be more effort to debug, and may require some experimentation. Please [raise an issue](https://github.com/mmkal/expect-type) if the error messages are misleading. + +The `toBe...` methods (like `toBeString`, `toBeNumber`, `toBeVoid`, etc.) fail by resolving to a non-callable type when the `Actual` type under test doesn't match up. For example, the failure for an assertion like `expectTypeOf(1).toBeString()` will look something like this: + +``` +test/test.ts:999:999 - error TS2349: This expression is not callable. + Type 'ExpectString' has no call signatures. + +999 expectTypeOf(1).toBeString() + ~~~~~~~~~~ +``` + +The `This expression is not callable` part isn't all that helpful - the meaningful error is the next line, `Type 'ExpectString has no call signatures`. This essentially means you passed a number but asserted it should be a string. + +If TypeScript added support for ["throw" types](https://github.com/microsoft/TypeScript/pull/40468) these error messages could be improved. Until then they will take a certain amount of squinting. + +#### Concrete "expected" objects vs type arguments + +Error messages for an assertion like this: + +```ts +expectTypeOf({a: 1}).toEqualTypeOf({a: ''}) +``` + +Will be less helpful than for an assertion like this: + +```ts +expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>() +``` + +This is because the TypeScript compiler needs to infer the type argument for the `.toEqualTypeOf({a: ''})` style and this library can only mark it as a failure by comparing it against a generic `Mismatch` type. So, where possible, use a type argument rather than a concrete type for `.toEqualTypeOf` and `toMatchTypeOf`. If it's much more convenient to compare two concrete types, you can use `typeof`: + +```ts +const one = valueFromFunctionOne({some: {complex: inputs}}) +const two = valueFromFunctionTwo({some: {other: inputs}}) + +expectTypeOf(one).toEqualTypeof() +``` + +### Overloaded functions + +Due to a TypeScript [design limitation](https://github.com/microsoft/TypeScript/issues/32164#issuecomment-506810756), the native TypeScript `Parameters<...>` and `ReturnType<...>` helpers only return types from one variant of an overloaded function. This limitation doesn't apply to expect-type, since it is not used to author TypeScript code, only to assert on existing types. So, we use a workaround for this TypeScript behaviour to assert on _all_ overloads as a union (actually, not necessarily _all_ - we cap out at 10 overloads). + +### Within test frameworks + +### Vitest + +`expectTypeOf` is built in to [vitest](https://vitest.dev/guide/testing-types), so you can import `expectTypeOf` from the vitest library directly if you prefer. Note that there is no set release cadence, at time of writing, so vitest may not always be using the very latest version. + +```ts +import {expectTypeOf} from 'vitest' +import {mount} from './mount.js' + +test('my types work properly', () => { + expectTypeOf(mount).toBeFunction() + expectTypeOf(mount).parameter(0).toEqualTypeOf<{name: string}>() + + expectTypeOf(mount({name: 42})).toBeString() +}) +``` + +#### Jest & `eslint-plugin-jest` + +If you're using Jest along with `eslint-plugin-jest`, and you put assertions inside `test(...)` definitions, you may get warnings from the [`jest/expect-expect`](https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/expect-expect.md) rule, complaining that "Test has no assertions" for tests that only use `expectTypeOf()`. + +To remove this warning, configure the ESLint rule to consider `expectTypeOf` as an assertion: + +```json +"rules": { + // ... + "jest/expect-expect": [ + "warn", + { + "assertFunctionNames": [ + "expect", "expectTypeOf" + ] + } + ], + // ... +} +``` + +### Limitations + +A summary of some of the limitations of this library. Some of these are documented more fully elsewhere. + +1. Intersection types can result in failures when the expected and actual types are not identically defined, even when they are effectively identical. See [Why is my assertion failing](#why-is-my-assertion-failing) for details. TL;DR: use `.brand` in these cases - and accept the performance hit that it comes with. +1. `toBeCallableWith` will likely fail if you try to use it with a generic function or an overload. See [this issue](https://github.com/mmkal/expect-type/issues/50) for an example and how to work around it. +1. (For now) overloaded functions might trip up the `.parameter` and `.parameters` helpers. This matches how the built-in TypeScript helper `Parameters<...>` works. This may be improved in the future though ([see related issue](https://github.com/mmkal/expect-type/issues/30)). +1. `expectTypeOf(this).toEqualTypeOf(this)` inside class methods does not work. + +## Similar projects + +Other projects with similar goals: + +- [`tsd`](https://github.com/SamVerschueren/tsd) is a CLI that runs the TypeScript type checker over assertions +- [`ts-expect`](https://github.com/TypeStrong/ts-expect) exports several generic helper types to perform type assertions +- [`dtslint`](https://github.com/Microsoft/dtslint) does type checks via comment directives and tslint +- [`type-plus`](https://github.com/unional/type-plus) comes with various type and runtime TypeScript assertions +- [`static-type-assert`](https://github.com/ksxnodemodules/static-type-assert) type assertion functions + +### Comparison + +The key differences in this project are: + +- a fluent, jest-inspired API, making the difference between `actual` and `expected` clear. This is helpful with complex types and assertions. +- inverting assertions intuitively and easily via `expectTypeOf(...).not` +- checks generics properly and strictly ([tsd doesn't](https://github.com/SamVerschueren/tsd/issues/142)) +- first-class support for: + - `any` (as well as `unknown` and `never`) (see issues outstanding at time of writing in tsd for [never](https://github.com/SamVerschueren/tsd/issues/78) and [any](https://github.com/SamVerschueren/tsd/issues/82)). + - This can be especially useful in combination with `not`, to protect against functions returning too-permissive types. For example, `const parseFile = (filename: string) => JSON.parse(readFileSync(filename).toString())` returns `any`, which could lead to errors. After giving it a proper return-type, you can add a test for this with `expect(parseFile).returns.not.toBeAny()` + - object properties + - function parameters + - function return values + - constructor parameters + - class instances + - array item values + - nullable types +- assertions on types "matching" rather than exact type equality, for "is-a" relationships e.g. `expectTypeOf(square).toExtend()` +- built into existing tooling. No extra build step, cli tool, IDE extension, or lint plugin is needed. Just import the function and start writing tests. Failures will be at compile time - they'll appear in your IDE and when you run `tsc`. +- small implementation with no dependencies. [Take a look!](./src/index.ts) (tsd, for comparison, is [2.6MB](https://bundlephobia.com/result?p=tsd@0.13.1) because it ships a patched version of TypeScript). + +## TypeScript backwards-compatibility + +There is a CI job called `test-types` that checks whether the tests still pass with certain older TypeScript versions. To check the supported TypeScript versions, [refer to the job definition](./.github/workflows/ci.yml). + +## Contributing + +In most cases, it's worth checking existing issues or creating one to discuss a new feature or a bug fix before opening a pull request. + +Once you're ready to make a pull request: clone the repo, and install pnpm if you don't have it already with `npm install --global pnpm`. Lockfiles for `npm` and `yarn` are gitignored. + +If you're adding a feature, you should write a self-contained usage example in the form of a test, in [test/usage.test.ts](./test/usage.test.ts). This file is used to populate the bulk of this readme using [eslint-plugin-codegen](https://npmjs.com/package/eslint-plugin-codegen), and to generate an ["errors" test file](./test/errors.test.ts), which captures the error messages that are emitted for failing assertions by the TypeScript compiler. So, the test name should be written as a human-readable sentence explaining the usage example. Have a look at the existing tests for an idea of the style. + +After adding the tests, run `npm run lint -- --fix` to update the readme, and `npm test -- --updateSnapshot` to update the errors test. The generated documentation and tests should be pushed to the same branch as the source code, and submitted as a pull request. CI will test that the docs and tests are up to date if you forget to run these commands. + +### Documentation of limitations through tests + +Limitations of the library are documented through tests in `usage.test.ts`. This means that if a future TypeScript version (or library version) fixes the limitation, the test will start failing, and it will be automatically removed from the documentation once it no longer applies. diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/SECURITY.md b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/SECURITY.md new file mode 100644 index 00000000..3f988a6f --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/SECURITY.md @@ -0,0 +1,14 @@ +# Security Policy + +## Supported Versions + +Version 1.0.0 will be supported with security updates. + +| Version | Supported | +| ------- | ------------------ | +| 1.x.x | :white_check_mark: | +| < 1.0 | :x: | + +## Reporting a Vulnerability + +To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure. diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.d.ts b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.d.ts new file mode 100644 index 00000000..9f154433 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.d.ts @@ -0,0 +1,141 @@ +import type { ConstructorOverloadParameters, NumOverloads, OverloadsInfoUnion } from './overloads'; +import type { IsNever, IsAny, IsUnknown, ReadonlyKeys, RequiredKeys, OptionalKeys, MutuallyExtends, UnionToTuple, IsTuple, UnionToIntersection, TupleToRecord, IsRecord } from './utils'; +export type DeepBrandOptions = { + nominalTypes: {}; +}; +export type DeepBrandOptionsDefaults = { + nominalTypes: { + Date: Date; + }; +}; +export type NominalType = Options['nominalTypes'] extends infer N ? { + [K in keyof N]: MutuallyExtends extends true ? K : never; +}[keyof N] : never; +/** + * Represents a deeply branded type. + * + * Recursively walk a type and replace it with a branded type related to the + * original. This is useful for equality-checking stricter than + * `A extends B ? B extends A ? true : false : false`, because it detects the + * difference between a few edge-case types that vanilla TypeScript + * doesn't by default: + * - `any` vs `unknown` + * - `{ readonly a: string }` vs `{ a: string }` + * - `{ a?: string }` vs `{ a: string | undefined }` + * + * __Note__: not very performant for complex types - this should only be used + * when you know you need it. If doing an equality check, it's almost always + * better to use {@linkcode StrictEqualUsingTSInternalIdenticalToOperator}. + */ +export type DeepBrand = IsNever extends true ? { + type: 'never'; +} : IsAny extends true ? { + type: 'any'; +} : IsUnknown extends true ? { + type: 'unknown'; +} : NominalType extends infer Nominal ? IsNever extends true ? T extends string | number | boolean | symbol | bigint | null | undefined | void ? { + type: 'primitive'; + value: T; +} : T extends new (...args: any[]) => any ? { + type: 'constructor'; + params: ConstructorOverloadParameters; + instance: DeepBrand any>>, Options>; +} : T extends (...args: infer P) => infer R ? NumOverloads extends 1 ? { + type: 'function'; + params: DeepBrand; + return: DeepBrand; + this: DeepBrand, Options>; + props: DeepBrand, Options>; +} : UnionToTuple> extends infer OverloadsTuple ? { + type: 'overloads'; + overloads: { + [K in keyof OverloadsTuple]: DeepBrand; + }; +} : never : T extends any[] ? IsTuple extends true ? { + type: 'tuple'; + items: { + [K in keyof T]: DeepBrand; + }; +} : { + type: 'array'; + items: DeepBrand; +} : IsRecord extends true ? { + type: 'record'; + keys: keyof T; + values: DeepBrand; +} : { + type: 'object'; + properties: { + [K in keyof T]: DeepBrand; + }; + readonly: ReadonlyKeys; + required: RequiredKeys; + optional: OptionalKeys; + constructorParams: ConstructorOverloadParameters extends infer P ? IsNever

extends true ? never : DeepBrand : never; +} : { + type: Nominal; +} : never; +/** + * Checks if two types are strictly equal using branding. + */ +export type StrictEqualUsingBranding = MutuallyExtends, DeepBrand>; +/** + * @internal don't use this unless you are deeply familiar with it! + * + * Walks over a type `T`, assuming that it's the output of the {@linkcode DeepBrand} utility. It looks for leaf nodes looking like `{type: FindType}`. + * When it finds them, it merges them into a string->string record, keeping track of a rough representation of the path-location. + * For simple objects, this path will roughly match dot-prop notation but it also traverses into all the structures that `DeepBrand` can emit. + * But it also goes into overloads, function parameters, return types, etc. The output is an ugly intersection of objects along with a marker `{deepBrandLeafNode: true}` + * which is purely for internal use. The output should not be shown to end-users! + */ +type _DeepPropTypesOfBranded = IsNever extends true ? {} : T extends string ? {} : T extends { + type: FindType; +} ? { + [K in PathTo]: T['type']; +} & { + deepBrandLeafNode: true; +} : T extends any[] ? _DeepPropTypesOfBranded, PathTo, FindType> : UnionToIntersection<{ + [K in keyof T]: Extract<_DeepPropTypesOfBranded>}`, FindType>, { + deepBrandLeafNode: true; + }>; +}[keyof T]>; +/** Required options for for {@linkcode DeepBrandPropNotes}. */ +export type DeepBrandPropNotesOptions = Partial & { + findType: 'any' | 'never' | 'unknown'; +}; +/** Default options for for {@linkcode DeepBrandPropNotes}. */ +export type DeepBrandPropNotesOptionsDefaults = { + findType: 'any' | 'never'; +}; +/** + * For an input type `T`, finds all deeply-nested properties in the {@linkcode DeepBrand} representation of it. + * + * The output is a developer-readable shallow record of prop-path -> resolved type. + * @example + * ```ts + * type X = {a: any; b: boolean; c: {d: any}} + * const notes: DeepBrandPropNotes = { + * '.a': 'any', + * '.c.d': 'any', + * } + * ``` + */ +export type DeepBrandPropNotes = _DeepPropTypesOfBranded, '', Options['findType']> extends infer X ? {} extends X ? Record : { + [K in Exclude]: X[K]; +} : never; +/** + * @internal + * + * Helper to coerce a type `K` that you are already pretty sure is a string because it camed from a `keyof T` type expression. + * Useful because sometimes TypeScript forgets that. + * When it's not a string or number, it will output a big ugly literal type `'UNEXPECTED_NON_LITERAL_PROP'` - try to avoid this! + */ +export type Prop = K extends string | number ? K : 'UNEXPECTED_NON_LITERAL_PROP'; +/** + * Gets a sensible suffix to a property path for a {@linkcode DeepBrand} output type. + * `[number]` for arrays, empty string for objects, and parenthesised-input for anything else. + */ +type DeepBrandPropPathSuffix = T extends { + type: string; +} ? K extends 'items' ? '[number]' : K extends 'properties' ? '' : `(${Prop})` : `.${Prop}`; +export {}; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.js b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.js new file mode 100644 index 00000000..c8ad2e54 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/branding.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.d.ts b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.d.ts new file mode 100644 index 00000000..51cc2312 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.d.ts @@ -0,0 +1,946 @@ +import { DeepBrandOptions, DeepBrandOptionsDefaults, StrictEqualUsingBranding, DeepBrandPropNotes, DeepBrandPropNotesOptions, DeepBrandPropNotesOptionsDefaults } from './branding'; +import type { ExpectAny, ExpectArray, ExpectBigInt, ExpectBoolean, ExpectFunction, ExpectNever, ExpectNull, ExpectNullable, ExpectNumber, ExpectObject, ExpectString, ExpectSymbol, ExpectUndefined, ExpectUnknown, ExpectVoid, MismatchInfo, Scolder } from './messages'; +import type { ConstructorOverloadParameters, OverloadParameters, OverloadReturnTypes, OverloadThisParameterTypes, OverloadsNarrowedByParameters } from './overloads'; +import type { AValue, DeepPickMatchingProps, Extends, IsUnion, MismatchArgs, Not, StrictEqualUsingTSInternalIdenticalToOperator } from './utils'; +export * from './branding'; +export * from './messages'; +export * from './overloads'; +export * from './utils'; +/** + * Represents the positive assertion methods available for type checking in the + * {@linkcode expectTypeOf()} utility. + */ +export interface PositiveExpectTypeOf extends BaseExpectTypeOf { + /** + * Similar to jest's `expect(...).toMatchObject(...)` but for types. + * Deeply "picks" the properties of the actual type based on the expected type, then performs a strict check to make sure the types match `Expected`. + * + * **Note**: optional properties on the {@linkcode Expected | expected type} are not allowed to be missing on the {@linkcode Actual | actual type}. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchObjectType<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toMatchObjectType<{ a: number; c?: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toMatchObjectType: extends true ? 'toMatchObject does not support union types' : Not>> extends true ? 'toMatchObject only supports object types' : StrictEqualUsingTSInternalIdenticalToOperator, Expected> extends true ? unknown : MismatchInfo, Expected>>(...MISMATCH: MismatchArgs, Expected>, true>) => true; + /** + * Check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} that allows for extra properties. + * This is roughly equivalent to an `extends` constraint in a function type argument. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toExtend<{ a: number }>() + * + * expectTypeOf({ a: 1 }).not.toExtend<{ b: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toExtend: extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>) => true; + toEqualTypeOf: { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, true>): true; + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>): true; + }; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + */ + toMatchTypeOf: { + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, true>): true; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>): true; + }; + /** + * Checks whether an object has a given property. + * + * @example + * check that properties exist + * ```ts + * const obj = { a: 1, b: '' } + * + * expectTypeOf(obj).toHaveProperty('a') + * + * expectTypeOf(obj).not.toHaveProperty('c') + * ``` + * + * @param key - The property key to check for. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toHaveProperty: (key: KeyType, ...MISMATCH: MismatchArgs, true>) => KeyType extends keyof Actual ? PositiveExpectTypeOf : true; + /** + * Inverts the result of the following assertions. + * + * @example + * ```ts + * expectTypeOf({ a: 1 }).not.toMatchTypeOf({ b: 1 }) + * ``` + */ + not: NegativeExpectTypeOf; + /** + * Intersection types can cause issues with + * {@linkcode toEqualTypeOf | .toEqualTypeOf()}: + * ```ts + * // ❌ The following line doesn't compile, even though the types are arguably the same. + * expectTypeOf<{ a: 1 } & { b: 2 }>().toEqualTypeOf<{ a: 1; b: 2 }>() + * ``` + * This helper works around this problem by using + * a more permissive but less performant check. + * + * __Note__: This comes at a performance cost, and can cause the compiler + * to 'give up' if used with excessively deep types, so use sparingly. + * + * @see {@link https://github.com/mmkal/expect-type/pull/21 | Reference} + */ + branded: Branded; +} +export interface Branded { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toEqualTypeOf: extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>) => true; + /** + * Walk a type to find every deeply-nested path that resolves to `any` or `never`, useful for catching + * badly-defined types hiding inside large or complex objects. + * + * Pass `{foundProps: {}}` to assert there are none - a type error will list the offending paths if there are. + * Otherwise pass `foundProps` as a record of `path -> flagged type` to acknowledge the ones you expect. + * The compiler tells you the exact paths (and what they resolve to) if you get it wrong. + * + * Use the `findType` type argument to search for `'any'`, `'never'`, or `'unknown'` instead of the default (`'any' | 'never'`). + * + * @param params An object with a `foundProps` record mapping each flagged path to its resolved type. For a + * well-defined type with no issues, pass `{foundProps: {}}`. + * @returns true + * + * @example + * ```ts + * type BadType = {a: any; nested: {b: never}; list: Array<{c: any}>} + * + * // \@ts-expect-error there are `any`/`never` paths, so you can't claim there are none. + * expectTypeOf().branded.inspect({foundProps: {}}) + * + * // ...instead, enumerate them (the compiler reports the exact paths if this is wrong): + * expectTypeOf().branded.inspect({ + * foundProps: { + * '.a': 'any', + * '.nested.b': 'never', + * '.list[number].c': 'any', + * }, + * }) + * ``` + * + * @example + * ```ts + * type GoodType = {b: boolean; c: string} + * + * expectTypeOf().branded.inspect({foundProps: {}}) + * ``` + * + * @example + * ```ts + * // search for `unknown` instead of `any`/`never`: + * expectTypeOf<{u: unknown}>().branded.inspect<{findType: 'unknown'}>({foundProps: {'.u': 'unknown'}}) + * ``` + */ + inspect: = DeepBrandPropNotesOptionsDefaults>(params: { + foundProps: DeepBrandPropNotes; + }) => true; + configure(): Branded; +} +/** + * Represents the negative expectation type for the {@linkcode Actual} type. + */ +export interface NegativeExpectTypeOf extends BaseExpectTypeOf { + /** + * Similar to jest's `expect(...).toMatchObject(...)` but for types. + * Deeply "picks" the properties of the actual type based on the expected type, then performs a strict check to make sure the types match `Expected`. + * + * **Note**: optional properties on the {@linkcode Expected | expected type} are not allowed to be missing on the {@linkcode Actual | actual type}. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchObjectType<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toMatchObjectType<{ a: number; c?: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toMatchObjectType: (...MISMATCH: MismatchArgs, Expected>, false>) => true; + /** + * Check if your type extends the expected type + * + * A less strict version of {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} that allows for extra properties. + * This is roughly equivalent to an `extends` constraint in a function type argument. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toExtend<{ a: number }>()] + * + * expectTypeOf({ a: 1 }).not.toExtend<{ b: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toExtend(...MISMATCH: MismatchArgs, false>): true; + toEqualTypeOf: { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (value: Expected & AValue, ...MISMATCH: MismatchArgs, false>): true; + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (...MISMATCH: MismatchArgs, false>): true; + }; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + */ + toMatchTypeOf: { + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of + * {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, false>): true; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of + * {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (...MISMATCH: MismatchArgs, false>): true; + }; + /** + * Checks whether an object has a given property. + * + * @example + * check that properties exist + * ```ts + * const obj = { a: 1, b: '' } + * + * expectTypeOf(obj).toHaveProperty('a') + * + * expectTypeOf(obj).not.toHaveProperty('c') + * ``` + * + * @param key - The property key to check for. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toHaveProperty: (key: KeyType, ...MISMATCH: MismatchArgs, false>) => true; +} +/** + * Represents a conditional type that selects either + * {@linkcode PositiveExpectTypeOf} or {@linkcode NegativeExpectTypeOf} based + * on the value of the `positive` property in the {@linkcode Options} type. + */ +export type ExpectTypeOf = Options['positive'] extends true ? PositiveExpectTypeOf : NegativeExpectTypeOf; +/** + * Represents the base interface for the + * {@linkcode expectTypeOf()} function. + * Provides a set of assertion methods to perform type checks on a value. + */ +export interface BaseExpectTypeOf { + /** + * Checks whether the type of the value is `any`. + */ + toBeAny: Scolder, Options>; + /** + * Checks whether the type of the value is `unknown`. + */ + toBeUnknown: Scolder, Options>; + /** + * Checks whether the type of the value is `never`. + */ + toBeNever: Scolder, Options>; + /** + * Checks whether the type of the value is `function`. + */ + toBeFunction: Scolder, Options>; + /** + * Checks whether the type of the value is `object`. + */ + toBeObject: Scolder, Options>; + /** + * Checks whether the type of the value is an {@linkcode Array}. + */ + toBeArray: Scolder, Options>; + /** + * Checks whether the type of the value is `number`. + */ + toBeNumber: Scolder, Options>; + /** + * Checks whether the type of the value is `string`. + */ + toBeString: Scolder, Options>; + /** + * Checks whether the type of the value is `boolean`. + */ + toBeBoolean: Scolder, Options>; + /** + * Checks whether the type of the value is `void`. + */ + toBeVoid: Scolder, Options>; + /** + * Checks whether the type of the value is `symbol`. + */ + toBeSymbol: Scolder, Options>; + /** + * Checks whether the type of the value is `null`. + */ + toBeNull: Scolder, Options>; + /** + * Checks whether the type of the value is `undefined`. + */ + toBeUndefined: Scolder, Options>; + /** + * Checks whether the type of the value is `null` or `undefined`. + */ + toBeNullable: Scolder, Options>; + /** + * Transform that type of the value via a callback. + * + * @param fn - A callback that transforms the input value. Note that this function is not actually called - it's only used for type inference. + * @returns A new type which can be used for further assertions. + */ + map: (fn: (value: Actual) => T) => ExpectTypeOf; + /** + * Checks whether the type of the value is **`bigint`**. + * + * @example + * #### Distinguish between **`number`** and **`bigint`** + * + * ```ts + * import { expectTypeOf } from 'expect-type' + * + * const aVeryBigInteger = 10n ** 100n + * + * expectTypeOf(aVeryBigInteger).not.toBeNumber() + * + * expectTypeOf(aVeryBigInteger).toBeBigInt() + * ``` + * + * @since 1.1.0 + */ + toBeBigInt: Scolder, Options>; + /** + * Checks whether a function is callable with the given parameters. + * + * __Note__: You cannot negate this assertion with + * {@linkcode PositiveExpectTypeOf.not | .not}, you need to use + * `ts-expect-error` instead. + * + * @example + * ```ts + * const f = (a: number) => [a, a] + * + * expectTypeOf(f).toBeCallableWith(1) + * ``` + * + * __Known Limitation__: This assertion will likely fail if you try to use it + * with a generic function or an overload. + * @see {@link https://github.com/mmkal/expect-type/issues/50 | This issue} for an example and a workaround. + * + * @param args - The arguments to check for callability. + * @returns `true`. + */ + toBeCallableWith: Options['positive'] extends true ? >(...args: Args) => ExpectTypeOf, Options> : never; + /** + * Checks whether a class is constructible with the given parameters. + * + * @example + * ```ts + * expectTypeOf(Date).toBeConstructibleWith('1970') + * + * expectTypeOf(Date).toBeConstructibleWith(0) + * + * expectTypeOf(Date).toBeConstructibleWith(new Date()) + * + * expectTypeOf(Date).toBeConstructibleWith() + * ``` + * + * @param args - The arguments to check for constructibility. + * @returns `true`. + */ + toBeConstructibleWith: Options['positive'] extends true ? >(...args: Args) => true : never; + /** + * Equivalent to the {@linkcode Extract} utility type. + * Helps narrow down complex union types. + * + * @example + * ```ts + * type ResponsiveProp = T | T[] | { xs?: T; sm?: T; md?: T } + * + * interface CSSProperties { + * margin?: string + * padding?: string + * } + * + * function getResponsiveProp(_props: T): ResponsiveProp { + * return {} + * } + * + * const cssProperties: CSSProperties = { margin: '1px', padding: '2px' } + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .extract<{ xs?: any }>() // extracts the last type from a union + * .toEqualTypeOf<{ + * xs?: CSSProperties + * sm?: CSSProperties + * md?: CSSProperties + * }>() + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .extract() // extracts an array from a union + * .toEqualTypeOf() + * ``` + * + * __Note__: If no type is found in the union, it will return `never`. + * + * @param v - The type to extract from the union. + * @returns The type after extracting the type from the union. + */ + extract: (v?: V) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Exclude} utility type. + * Removes types from a union. + * + * @example + * ```ts + * type ResponsiveProp = T | T[] | { xs?: T; sm?: T; md?: T } + * + * interface CSSProperties { + * margin?: string + * padding?: string + * } + * + * function getResponsiveProp(_props: T): ResponsiveProp { + * return {} + * } + * + * const cssProperties: CSSProperties = { margin: '1px', padding: '2px' } + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .exclude() + * .exclude<{ xs?: unknown }>() // or just `.exclude()` + * .toEqualTypeOf() + * ``` + */ + exclude: (v?: V) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Pick} utility type. + * Helps select a subset of properties from an object type. + * + * @example + * ```ts + * interface Person { + * name: string + * age: number + * } + * + * expectTypeOf() + * .pick<'name'>() + * .toEqualTypeOf<{ name: string }>() + * ``` + * + * @param keyToPick - The property key to pick. + * @returns The type after picking the property. + */ + pick: (keyToPick?: KeyToPick) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Omit} utility type. + * Helps remove a subset of properties from an object type. + * + * @example + * ```ts + * interface Person { + * name: string + * age: number + * } + * + * expectTypeOf().omit<'name'>().toEqualTypeOf<{ age: number }>() + * ``` + * + * @param keyToOmit - The property key to omit. + * @returns The type after omitting the property. + */ + omit: )>(keyToOmit?: KeyToOmit) => ExpectTypeOf, Options>; + /** + * Extracts a certain function argument with `.parameter(number)` call to + * perform other assertions on it. + * + * @example + * ```ts + * function foo(a: number, b: string) { + * return [a, b] + * } + * + * expectTypeOf(foo).parameter(0).toBeNumber() + * + * expectTypeOf(foo).parameter(1).toBeString() + * ``` + * + * @param index - The index of the parameter to extract. + * @returns The extracted parameter type. + */ + parameter: (index: Index) => ExpectTypeOf[Index], Options>; + /** + * Equivalent to the {@linkcode Parameters} utility type. + * Extracts function parameters to perform assertions on its value. + * Parameters are returned as an array. + * + * @example + * ```ts + * function noParam() {} + * + * function hasParam(s: string) {} + * + * expectTypeOf(noParam).parameters.toEqualTypeOf<[]>() + * + * expectTypeOf(hasParam).parameters.toEqualTypeOf<[string]>() + * ``` + */ + parameters: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode ConstructorParameters} utility type. + * Extracts constructor parameters as an array of values and + * perform assertions on them with this method. + * + * For overloaded constructors it will return a union of all possible parameter-tuples. + * + * @example + * ```ts + * expectTypeOf(Date).constructorParameters.toEqualTypeOf< + * [] | [string | number | Date] + * >() + * ``` + */ + constructorParameters: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode ThisParameterType} utility type. + * Extracts the `this` parameter of a function to + * perform assertions on its value. + * + * @example + * ```ts + * function greet(this: { name: string }, message: string) { + * return `Hello ${this.name}, here's your message: ${message}` + * } + * + * expectTypeOf(greet).thisParameter.toEqualTypeOf<{ name: string }>() + * ``` + */ + thisParameter: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode InstanceType} utility type. + * Extracts the instance type of a class to perform assertions on. + * + * @example + * ```ts + * expectTypeOf(Date).instance.toHaveProperty('toISOString') + * ``` + */ + instance: Actual extends new (...args: any[]) => infer I ? ExpectTypeOf : never; + /** + * Equivalent to the {@linkcode ReturnType} utility type. + * Extracts the return type of a function. + * + * @example + * ```ts + * expectTypeOf(() => {}).returns.toBeVoid() + * + * expectTypeOf((a: number) => [a, a]).returns.toEqualTypeOf([1, 2]) + * ``` + */ + returns: Actual extends Function ? ExpectTypeOf, Options> : never; + /** + * Extracts resolved value of a Promise, + * so you can perform other assertions on it. + * + * @example + * ```ts + * async function asyncFunc() { + * return 123 + * } + * + * expectTypeOf(asyncFunc).returns.resolves.toBeNumber() + * + * expectTypeOf(Promise.resolve('string')).resolves.toBeString() + * ``` + * + * Type Equivalent: + * ```ts + * type Resolves = PromiseType extends PromiseLike + * ? ResolvedType + * : never + * ``` + */ + resolves: Actual extends PromiseLike ? ExpectTypeOf : never; + /** + * Extracts array item type to perform assertions on. + * + * @example + * ```ts + * expectTypeOf([1, 2, 3]).items.toEqualTypeOf() + * + * expectTypeOf([1, 2, 3]).items.not.toEqualTypeOf() + * ``` + * + * __Type Equivalent__: + * ```ts + * type Items = ArrayType extends ArrayLike + * ? ItemType + * : never + * ``` + */ + items: Actual extends ArrayLike ? ExpectTypeOf : never; + /** + * Extracts the type guarded by a function to perform assertions on. + * + * @example + * ```ts + * function isString(v: any): v is string { + * return typeof v === 'string' + * } + * + * expectTypeOf(isString).guards.toBeString() + * ``` + */ + guards: Actual extends (v: any, ...args: any[]) => v is infer T ? ExpectTypeOf : never; + /** + * Extracts the type asserted by a function to perform assertions on. + * + * @example + * ```ts + * function assertNumber(v: any): asserts v is number { + * if (typeof v !== 'number') + * throw new TypeError('Nope !') + * } + * + * expectTypeOf(assertNumber).asserts.toBeNumber() + * ``` + */ + asserts: Actual extends (v: any, ...args: any[]) => asserts v is infer T ? unknown extends T ? never : ExpectTypeOf : never; +} +/** + * Represents a function that allows asserting the expected type of a value. + */ +export type _ExpectTypeOf = { + /** + * Asserts the expected type of a value. + * + * @param actual - The actual value being asserted. + * @returns An object representing the expected type assertion. + */ + (actual: Actual): ExpectTypeOf; + /** + * Asserts the expected type of a value without providing an actual value. + * + * @returns An object representing the expected type assertion. + */ + (): ExpectTypeOf; +}; +/** + * Similar to Jest's `expect`, but with type-awareness. + * Gives you access to a number of type-matchers that let you make assertions about the + * form of a reference or generic type parameter. + * + * @example + * ```ts + * import { foo, bar } from '../foo' + * import { expectTypeOf } from 'expect-type' + * + * test('foo types', () => { + * // make sure `foo` has type { a: number } + * expectTypeOf(foo).toMatchTypeOf({ a: 1 }) + * expectTypeOf(foo).toHaveProperty('a').toBeNumber() + * + * // make sure `bar` is a function taking a string: + * expectTypeOf(bar).parameter(0).toBeString() + * expectTypeOf(bar).returns.not.toBeAny() + * }) + * ``` + * + * @description + * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples. + */ +export declare const expectTypeOf: _ExpectTypeOf; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.js b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.js new file mode 100644 index 00000000..f74db8ce --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/index.js @@ -0,0 +1,106 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.expectTypeOf = void 0; +__exportStar(require("./branding"), exports); // backcompat, consider removing in next major version +__exportStar(require("./messages"), exports); // backcompat, consider removing in next major version +__exportStar(require("./overloads"), exports); +__exportStar(require("./utils"), exports); // backcompat, consider removing in next major version +const fn = () => true; +/** + * Similar to Jest's `expect`, but with type-awareness. + * Gives you access to a number of type-matchers that let you make assertions about the + * form of a reference or generic type parameter. + * + * @example + * ```ts + * import { foo, bar } from '../foo' + * import { expectTypeOf } from 'expect-type' + * + * test('foo types', () => { + * // make sure `foo` has type { a: number } + * expectTypeOf(foo).toMatchTypeOf({ a: 1 }) + * expectTypeOf(foo).toHaveProperty('a').toBeNumber() + * + * // make sure `bar` is a function taking a string: + * expectTypeOf(bar).parameter(0).toBeString() + * expectTypeOf(bar).returns.not.toBeAny() + * }) + * ``` + * + * @description + * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples. + */ +const expectTypeOf = (_actual) => { + const nonFunctionProperties = [ + 'parameters', + 'returns', + 'resolves', + 'not', + 'items', + 'constructorParameters', + 'thisParameter', + 'instance', + 'guards', + 'asserts', + ]; + /* eslint-disable @typescript-eslint/no-unsafe-assignment */ + function createBranded() { + return { + inspect: () => true, + configure: () => createBranded(), + toEqualTypeOf: fn, + }; + } + const obj = { + toBeAny: fn, + toBeUnknown: fn, + toBeNever: fn, + toBeFunction: fn, + toBeObject: fn, + toBeArray: fn, + toBeString: fn, + toBeNumber: fn, + toBeBoolean: fn, + toBeVoid: fn, + toBeSymbol: fn, + toBeNull: fn, + toBeUndefined: fn, + toBeNullable: fn, + toBeBigInt: fn, + toMatchTypeOf: fn, + toEqualTypeOf: fn, + toBeConstructibleWith: fn, + toMatchObjectType: fn, + toExtend: fn, + map: exports.expectTypeOf, + toBeCallableWith: exports.expectTypeOf, + extract: exports.expectTypeOf, + exclude: exports.expectTypeOf, + pick: exports.expectTypeOf, + omit: exports.expectTypeOf, + toHaveProperty: exports.expectTypeOf, + parameter: exports.expectTypeOf, + get branded() { + return createBranded(); + }, + }; + /* eslint-enable @typescript-eslint/no-unsafe-assignment */ + const getterProperties = nonFunctionProperties; + getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) })); + return obj; +}; +exports.expectTypeOf = expectTypeOf; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.d.ts b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.d.ts new file mode 100644 index 00000000..6f8a03dc --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.d.ts @@ -0,0 +1,168 @@ +import { DeepBrandOptions, DeepBrandOptionsDefaults, StrictEqualUsingBranding } from './branding'; +import type { And, Extends, ExtendsExcludingAnyOrNever, IsAny, IsNever, IsUnknown, Not, OptionalKeys, StrictEqualUsingTSInternalIdenticalToOperator, UsefulKeys } from './utils'; +/** + * Determines the printable type representation for a given type. + */ +export type PrintType = IsUnknown extends true ? 'unknown' : IsNever extends true ? 'never' : IsAny extends true ? never : boolean extends T ? 'boolean' : T extends boolean ? `literal boolean: ${T}` : string extends T ? 'string' : T extends string ? `literal string: ${T}` : number extends T ? 'number' : T extends number ? `literal number: ${T}` : bigint extends T ? 'bigint' : T extends bigint ? `literal bigint: ${T}` : T extends null ? 'null' : T extends undefined ? 'undefined' : T extends (...args: any[]) => any ? 'function' : '...'; +/** + * Helper for showing end-user a hint why their type assertion is failing. + * This swaps "leaf" types with a literal message about what the actual and + * expected types are. Needs to check for `Not>` because + * otherwise `LeafTypeOf` returns `never`, which extends everything 🤔 + */ +export type MismatchInfo = And<[Extends, '...'>, Not>]> extends true ? And<[Extends, Extends]> extends true ? Array[number], Extract[number], Options>> : Optionalify<{ + [K in UsefulKeys | UsefulKeys]: MismatchInfo; +}, OptionalKeys> : StrictEqualUsingBranding extends true ? Actual : `Expected: ${PrintType}, Actual: ${PrintType>}`; +/** + * Helper for making some keys of a type optional. Only useful so far for `MismatchInfo` - it makes sure we + * don't get bogus errors about optional properties mismatching, when actually it's something else that's wrong. + * + * - Note: this helper is a no-op if there are no optional keys in the type. + */ +export type Optionalify = [TOptionalKeys] extends [never] ? T : ({ + [K in Exclude]: T[K]; +} & { + [K in Extract]?: T[K]; +}) extends infer X ? { + [K in keyof X]: X[K]; +} : never; +/** + * @internal + */ +declare const inverted: unique symbol; +/** + * @internal + */ +type Inverted = { + [inverted]: T; +}; +/** + * @internal + */ +declare const expectNull: unique symbol; +export type ExpectNull = { + [expectNull]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectUndefined: unique symbol; +export type ExpectUndefined = { + [expectUndefined]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectNumber: unique symbol; +export type ExpectNumber = { + [expectNumber]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectString: unique symbol; +export type ExpectString = { + [expectString]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectBoolean: unique symbol; +export type ExpectBoolean = { + [expectBoolean]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectVoid: unique symbol; +export type ExpectVoid = { + [expectVoid]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectFunction: unique symbol; +export type ExpectFunction = { + [expectFunction]: T; + result: ExtendsExcludingAnyOrNever any>; +}; +/** + * @internal + */ +declare const expectObject: unique symbol; +export type ExpectObject = { + [expectObject]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectArray: unique symbol; +export type ExpectArray = { + [expectArray]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectSymbol: unique symbol; +export type ExpectSymbol = { + [expectSymbol]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectAny: unique symbol; +export type ExpectAny = { + [expectAny]: T; + result: IsAny; +}; +/** + * @internal + */ +declare const expectUnknown: unique symbol; +export type ExpectUnknown = { + [expectUnknown]: T; + result: IsUnknown; +}; +/** + * @internal + */ +declare const expectNever: unique symbol; +export type ExpectNever = { + [expectNever]: T; + result: IsNever; +}; +/** + * @internal + */ +declare const expectNullable: unique symbol; +export type ExpectNullable = { + [expectNullable]: T; + result: Not>>; +}; +/** + * @internal + */ +declare const expectBigInt: unique symbol; +export type ExpectBigInt = { + [expectBigInt]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * Checks if the result of an expecter matches the specified options, and + * resolves to a fairly readable error message if not. + */ +export type Scolder = Expecter['result'] extends Options['positive'] ? () => true : Options['positive'] extends true ? Expecter : Inverted; +export {}; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.js b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.js new file mode 100644 index 00000000..ff4e0ae9 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/messages.js @@ -0,0 +1,66 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * @internal + */ +const inverted = Symbol('inverted'); +/** + * @internal + */ +const expectNull = Symbol('expectNull'); +/** + * @internal + */ +const expectUndefined = Symbol('expectUndefined'); +/** + * @internal + */ +const expectNumber = Symbol('expectNumber'); +/** + * @internal + */ +const expectString = Symbol('expectString'); +/** + * @internal + */ +const expectBoolean = Symbol('expectBoolean'); +/** + * @internal + */ +const expectVoid = Symbol('expectVoid'); +/** + * @internal + */ +const expectFunction = Symbol('expectFunction'); +/** + * @internal + */ +const expectObject = Symbol('expectObject'); +/** + * @internal + */ +const expectArray = Symbol('expectArray'); +/** + * @internal + */ +const expectSymbol = Symbol('expectSymbol'); +/** + * @internal + */ +const expectAny = Symbol('expectAny'); +/** + * @internal + */ +const expectUnknown = Symbol('expectUnknown'); +/** + * @internal + */ +const expectNever = Symbol('expectNever'); +/** + * @internal + */ +const expectNullable = Symbol('expectNullable'); +/** + * @internal + */ +const expectBigInt = Symbol('expectBigInt'); diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.d.ts b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.d.ts new file mode 100644 index 00000000..cf305924 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.d.ts @@ -0,0 +1,394 @@ +import type { StrictEqualUsingTSInternalIdenticalToOperator, IsNever, UnionToIntersection, UnionToTuple } from './utils'; +/** + * The simple(ish) way to get overload info from a function + * {@linkcode FunctionType}. Recent versions of TypeScript will match any + * function against a generic 10-overload type, filling in slots with + * duplicates of the function. So, we can just match against a single type + * and get all the overloads. + * + * For older versions of TypeScript, we'll need to painstakingly do + * ten separate matches. + */ +export type TSPost53OverloadsInfoUnion = FunctionType extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; + (...args: infer A10): infer R10; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : never; +/** + * A function with `unknown` parameters and return type. + */ +export type UnknownFunction = (...args: unknown[]) => unknown; +/** + * `true` iff {@linkcode FunctionType} is + * equivalent to `(...args: unknown[]) => unknown`, + * which is what an overload variant looks like for a non-existent overload. + * This is useful because older versions of TypeScript end up with + * 9 "useless" overloads and one real one for parameterless/generic functions. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type IsUselessOverloadInfo = StrictEqualUsingTSInternalIdenticalToOperator; +/** + * Old versions of TypeScript can sometimes seem to refuse to separate out + * union members unless you put them each in a pointless tuple and add an + * extra `infer X` expression. There may be a better way to work around this + * problem, but since it's not a problem in newer versions of TypeScript, + * it's not a priority right now. + */ +export type Tuplify = Union extends infer X ? [X] : never; +/** + * For older versions of TypeScript, we need two separate workarounds + * to get overload info. First, we need need to use + * {@linkcode DecreasingOverloadsInfoUnion} to get the overload info for + * functions with 1-10 overloads. Then, we need to filter out the + * "useless" overloads that are present in older versions of TypeScript, + * for parameterless functions. To do this we use + * {@linkcode IsUselessOverloadInfo} to remove useless overloads. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type TSPre53OverloadsInfoUnion = Tuplify> extends infer Tup ? Tup extends [infer Fn] ? IsUselessOverloadInfo extends true ? never : Fn : never : never; +/** + * For versions of TypeScript below 5.3, we need to check for 10 overloads, + * then 9, then 8, etc., to get a union of the overload variants. + */ +export type DecreasingOverloadsInfoUnion = F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; + (...args: infer A10): infer R10; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) : F extends (...args: infer A1) => infer R1 ? ((...p: A1) => R1) : never; +/** + * Get a union of overload variants for a function {@linkcode FunctionType}. + * Does a check for whether we can do the one-shot + * 10-overload matcher (which works for ts\>5.3), and if not, + * falls back to the more complicated utility. + */ +export type OverloadsInfoUnion = IsNever 2>> extends true ? TSPre53OverloadsInfoUnion : TSPost53OverloadsInfoUnion; +/** + * Allows inferring any function using the `infer` keyword. + */ +export type InferFunctionType any> = FunctionType; +/** + * A union type of the parameters allowed for any + * overload of function {@linkcode FunctionType}. + */ +export type OverloadParameters = OverloadsInfoUnion extends InferFunctionType ? Parameters : never; +/** + * A union type of the return types for any overload of + * function {@linkcode FunctionType}. + */ +export type OverloadReturnTypes = OverloadsInfoUnion extends InferFunctionType ? ReturnType : never; +/** + * Like {@linkcode TSPost53OverloadsInfoUnion} but extracts only the + * `this` parameter types, using `(this: infer T, ...)` to preserve `this` + * before it gets stripped. + * + * @template FunctionType - the function type to extract `this` parameter types from. + */ +export type TSPost53OverloadThisParameterTypes = FunctionType extends { + (this: infer T1, ...args: any[]): any; + (this: infer T2, ...args: any[]): any; + (this: infer T3, ...args: any[]): any; + (this: infer T4, ...args: any[]): any; + (this: infer T5, ...args: any[]): any; + (this: infer T6, ...args: any[]): any; + (this: infer T7, ...args: any[]): any; + (this: infer T8, ...args: any[]): any; + (this: infer T9, ...args: any[]): any; + (this: infer T10, ...args: any[]): any; +} ? T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10 : never; +/** + * Like {@linkcode DecreasingOverloadsInfoUnion} but preserves the + * `this` parameter in each extracted function variant so that it can be + * used for filtering and `this` type extraction. + * + * @template FunctionType - the function type to extract overload info from. + */ +export type DecreasingOverloadsInfoUnionWithThis = FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; + (this: infer T6, ...args: infer A6): infer R6; + (this: infer T7, ...args: infer A7): infer R7; + (this: infer T8, ...args: infer A8): infer R8; + (this: infer T9, ...args: infer A9): infer R9; + (this: infer T10, ...args: infer A10): infer R10; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) | ((this: T9, ...args: A9) => R9) | ((this: T10, ...args: A10) => R10) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; + (this: infer T6, ...args: infer A6): infer R6; + (this: infer T7, ...args: infer A7): infer R7; + (this: infer T8, ...args: infer A8): infer R8; + (this: infer T9, ...args: infer A9): infer R9; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) | ((this: T9, ...args: A9) => R9) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; + (this: infer T6, ...args: infer A6): infer R6; + (this: infer T7, ...args: infer A7): infer R7; + (this: infer T8, ...args: infer A8): infer R8; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) | ((this: T8, ...args: A8) => R8) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; + (this: infer T6, ...args: infer A6): infer R6; + (this: infer T7, ...args: infer A7): infer R7; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) | ((this: T7, ...args: A7) => R7) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; + (this: infer T6, ...args: infer A6): infer R6; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) | ((this: T6, ...args: A6) => R6) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; + (this: infer T5, ...args: infer A5): infer R5; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) | ((this: T5, ...args: A5) => R5) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; + (this: infer T4, ...args: infer A4): infer R4; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) | ((this: T4, ...args: A4) => R4) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; + (this: infer T3, ...args: infer A3): infer R3; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) | ((this: T3, ...args: A3) => R3) : FunctionType extends { + (this: infer T1, ...args: infer A1): infer R1; + (this: infer T2, ...args: infer A2): infer R2; +} ? ((this: T1, ...args: A1) => R1) | ((this: T2, ...args: A2) => R2) : FunctionType extends (this: infer T1, ...args: infer A1) => infer R1 ? (this: T1, ...args: A1) => R1 : never; +/** + * Like {@linkcode TSPre53OverloadsInfoUnion} but extracts the + * `this` parameter types, using + * {@linkcode DecreasingOverloadsInfoUnionWithThis} to preserve `this` + * through the filtering step. + * + * @template FunctionType - the function type to extract `this` parameter types from. + */ +export type TSPre53OverloadThisParameterTypes = Tuplify> extends infer TupleType ? TupleType extends [infer OverloadedFunctionType] ? IsUselessOverloadInfo extends true ? never : OverloadedFunctionType extends (this: infer InferredThisType, ...args: any[]) => any ? InferredThisType : never : never : never; +/** + * A union type of the `this` parameter types for any overload of + * function {@linkcode FunctionType}. + * + * @template FunctionType - the function type to extract `this` parameter types from. + */ +export type OverloadThisParameterTypes = FunctionType extends (...args: any[]) => any ? IsNever 2>> extends true ? TSPre53OverloadThisParameterTypes : TSPost53OverloadThisParameterTypes : ThisParameterType; +/** + * Takes an overload variants {@linkcode Union}, + * produced from {@linkcode OverloadsInfoUnion} and rejects + * the ones incompatible with parameters {@linkcode Args}. + */ +export type SelectOverloadsInfo = Union extends InferFunctionType ? (Args extends Parameters ? Fn : never) : never; +/** + * Creates a new overload (an intersection type) from an existing one, + * which only includes variant(s) which can accept + * {@linkcode Args} as parameters. + */ +export type OverloadsNarrowedByParameters> = UnionToIntersection, Args>>; +/** + * The simple(ish) way to get overload info from a constructor + * {@linkcode ConstructorType}. Recent versions of TypeScript will match any + * constructor against a generic 10-overload type, filling in slots with + * duplicates of the constructor. So, we can just match against a single type + * and get all the overloads. + * + * For older versions of TypeScript, + * we'll need to painstakingly do ten separate matches. + */ +export type TSPost53ConstructorOverloadsInfoUnion = ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; + new (...args: infer A10): infer R10; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : never; +/** + * A constructor function with `unknown` parameters and return type. + */ +export type UnknownConstructor = new (...args: unknown[]) => unknown; +/** + * Same as {@linkcode IsUselessOverloadInfo}, but for constructors. + */ +export type IsUselessConstructorOverloadInfo = StrictEqualUsingTSInternalIdenticalToOperator; +/** + * For older versions of TypeScript, we need two separate workarounds to + * get constructor overload info. First, we need need to use + * {@linkcode DecreasingConstructorOverloadsInfoUnion} to get the overload + * info for constructors with 1-10 overloads. Then, we need to filter out the + * "useless" overloads that are present in older versions of TypeScript, + * for parameterless constructors. To do this we use + * {@linkcode IsUselessConstructorOverloadInfo} to remove useless overloads. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type TSPre53ConstructorOverloadsInfoUnion = Tuplify> extends infer Tup ? Tup extends [infer Ctor] ? IsUselessConstructorOverloadInfo extends true ? never : Ctor : never : never; +/** + * For versions of TypeScript below 5.3, we need to check for 10 overloads, + * then 9, then 8, etc., to get a union of the overload variants. + */ +export type DecreasingConstructorOverloadsInfoUnion = ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; + new (...args: infer A10): infer R10; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) : ConstructorType extends new (...args: infer A1) => infer R1 ? (new (...p: A1) => R1) : never; +/** + * Get a union of overload variants for a constructor + * {@linkcode ConstructorType}. Does a check for whether we can do the + * one-shot 10-overload matcher (which works for ts\>5.3), and if not, + * falls back to the more complicated utility. + */ +export type ConstructorOverloadsUnion = IsNever any>> extends true ? TSPre53ConstructorOverloadsInfoUnion : TSPost53ConstructorOverloadsInfoUnion; +/** + * Allows inferring any constructor using the `infer` keyword. + */ +export type InferConstructor any> = ConstructorType; +/** + * A union type of the parameters allowed for any overload + * of constructor {@linkcode ConstructorType}. + */ +export type ConstructorOverloadParameters = ConstructorOverloadsUnion extends InferConstructor ? ConstructorParameters : never; +/** + * Calculates the number of overloads for a given function type. + */ +export type NumOverloads = UnionToTuple>['length']; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.js b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.js new file mode 100644 index 00000000..c8ad2e54 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/overloads.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.d.ts b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.d.ts new file mode 100644 index 00000000..74fcd4e0 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.d.ts @@ -0,0 +1,210 @@ +/** + * Negates a boolean type. + */ +export type Not = T extends true ? false : true; +/** + * Returns `true` if at least one of the types in the + * {@linkcode Types} array is `true`, otherwise returns `false`. + */ +export type Or = Types[number] extends false ? false : true; +/** + * Checks if all the boolean types in the {@linkcode Types} array are `true`. + */ +export type And = Types[number] extends true ? true : false; +/** + * Represents an equality type that returns {@linkcode Right} if + * {@linkcode Left} is `true`, + * otherwise returns the negation of {@linkcode Right}. + */ +export type Eq = Left extends true ? Right : Not; +/** + * Represents the exclusive OR operation on a tuple of boolean types. + * Returns `true` if exactly one of the boolean types is `true`, + * otherwise returns `false`. + */ +export type Xor = Not>; +/** + * @internal + */ +declare const secret: unique symbol; +/** + * @internal + */ +type Secret = typeof secret; +/** + * Checks if the given type is `never`. + */ +export type IsNever = [T] extends [never] ? true : false; +/** + * Checks if the given type is `any`. + */ +export type IsAny = [T] extends [Secret] ? Not> : false; +/** + * Determines if the given type is `unknown`. + */ +export type IsUnknown = [unknown] extends [T] ? Not> : false; +/** + * Determines if a type is either `never` or `any`. + */ +export type IsNeverOrAny = Or<[IsNever, IsAny]>; +/** + * Subjective "useful" keys from a type. For objects it's just `keyof` but for + * tuples/arrays it's the number keys. + * + * @example + * ```ts + * UsefulKeys<{ a: 1; b: 2 }> // 'a' | 'b' + * + * UsefulKeys<['a', 'b']> // '0' | '1' + * + * UsefulKeys // number + * ``` + */ +export type UsefulKeys = T extends any[] ? { + [K in keyof T]: K; +}[number] : keyof T; +/** + * Extracts the keys from a type that are required (not optional). + */ +export type RequiredKeys = Extract<{ + [K in keyof T]-?: {} extends Pick ? never : K; +}[keyof T], keyof T>; +/** + * Gets the keys of an object type that are optional. + */ +export type OptionalKeys = Exclude>; +/** + * Extracts the keys from a type that are not `readonly`. + */ +export type ReadonlyKeys = Extract<{ + [K in keyof T]-?: ReadonlyEquivalent<{ + [_K in K]: T[K]; + }, { + -readonly [_K in K]: T[K]; + }> extends true ? never : K; +}[keyof T], keyof T>; +/** + * Determines if two types, are equivalent in a `readonly` manner. + * + * @internal + */ +type ReadonlyEquivalent = Extends<(() => T extends X ? true : false), (() => T extends Y ? true : false)>; +/** + * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because: + * 1. If either type is `never`, the result is `true` iff the other type is also `never`. + * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends` => `false | true` => `boolean`. + */ +export type Extends = IsNever extends true ? IsNever : [Left] extends [Right] ? true : false; +/** + * Checks if the {@linkcode Left} type extends the {@linkcode Right} type, + * excluding `any` or `never`. + */ +export type ExtendsExcludingAnyOrNever = IsAny extends true ? IsAny : Extends; +/** + * Checks if two types are strictly equal using + * the TypeScript internal identical-to operator. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/55188#issuecomment-1656328122 | much history} + */ +export type StrictEqualUsingTSInternalIdenticalToOperator = (() => T extends (L & T) | T ? true : false) extends () => T extends (R & T) | T ? true : false ? IsNever extends IsNever ? true : false : false; +/** + * Checks that {@linkcode Left} and {@linkcode Right} extend each other. + * Not quite the same as an equality check since `any` can make it resolve + * to `true`. So should only be used when {@linkcode Left} and + * {@linkcode Right} are known to avoid `any`. + */ +export type MutuallyExtends = And<[Extends, Extends]>; +/** + * @internal + */ +declare const mismatch: unique symbol; +/** + * @internal + */ +type Mismatch = { + [mismatch]: 'mismatch'; +}; +/** + * A type which should match anything passed as a value but *doesn't* + * match {@linkcode Mismatch}. It helps TypeScript select the right overload + * for {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} and + * {@linkcode PositiveExpectTypeOf.toMatchTypeOf | .toMatchTypeOf()}. + * + * @internal + */ +declare const avalue: unique symbol; +/** + * Represents a value that can be of various types. + */ +export type AValue = { + [avalue]?: undefined; +} | string | number | boolean | symbol | bigint | null | undefined | void; +/** + * Represents the type of mismatched arguments between + * the actual result and the expected result. + * + * If {@linkcode ActualResult} and {@linkcode ExpectedResult} are equivalent, + * the type resolves to an empty tuple `[]`, indicating no mismatch. + * If they are not equivalent, it resolves to a tuple containing the element + * {@linkcode Mismatch}, signifying a discrepancy between + * the expected and actual results. + */ +export type MismatchArgs = Eq extends true ? [] : [Mismatch]; +/** + * Represents the options for the {@linkcode ExpectTypeOf} function. + */ +export interface ExpectTypeOfOptions { + positive: boolean; + branded: boolean; +} +/** + * Convert a union to an intersection. + * `A | B | C` -\> `A & B & C` + */ +export type UnionToIntersection = (Union extends any ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : never; +/** + * Get the last element of a union. + * First, converts to a union of `() => T` functions, + * then uses {@linkcode UnionToIntersection} to get the last one. + */ +export type LastOf = UnionToIntersection Union : never> extends () => infer R ? R : never; +/** + * Intermediate type for {@linkcode UnionToTuple} which pushes the + * "last" union member to the end of a tuple, and recursively prepends + * the remainder of the union. + */ +export type TuplifyUnion> = IsNever extends true ? [] : [...TuplifyUnion>, LastElement]; +/** + * Convert a union like `1 | 2 | 3` to a tuple like `[1, 2, 3]`. + */ +export type UnionToTuple = TuplifyUnion; +/** The numbers between 0 and 9 that you learned in school */ +export type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'; +/** + * e.g. `['a', 'b']` -> `{ 0: 'a', 1: 'b' }` + * Looks at the keys to see which look digit-like, so could do the wrong thing for types like + * `['a', 'b'] & {'1foo': string}` + */ +export type TupleToRecord = { + [K in keyof T as `${Extract}`]: T[K]; +}; +/** `true` iff `T` is a tuple, as opposed to an indeterminate-length array */ +export type IsTuple = number extends T['length'] ? false : true; +/** `true` iff `T` is a record accepting any string keys, or accepting any number keys */ +export type IsRecord = Or<[Extends, Extends]>; +export type IsUnion = Not['length'], 1>>; +/** + * A recursive version of `Pick` that selects properties from the left type that are present in the right type. + * The "leaf" types from `Left` are used - only the keys of `Right` are considered. + * + * @example + * ```ts + * const user = {email: 'a@b.com', name: 'John Doe', address: {street: '123 2nd St', city: 'New York', zip: '10001', state: 'NY', country: 'USA'}} + * + * type Result = DeepPickMatchingProps // {name: string, address: {city: string}} + * ``` + */ +export type DeepPickMatchingProps = Left extends Record ? Pick<{ + [K in keyof Left]: K extends keyof Right ? DeepPickMatchingProps : never; +}, Extract> : Left; +export {}; diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.js b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.js new file mode 100644 index 00000000..43407cf4 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/dist/utils.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * @internal + */ +const secret = Symbol('secret'); +/** + * @internal + */ +const mismatch = Symbol('mismatch'); +/** + * A type which should match anything passed as a value but *doesn't* + * match {@linkcode Mismatch}. It helps TypeScript select the right overload + * for {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} and + * {@linkcode PositiveExpectTypeOf.toMatchTypeOf | .toMatchTypeOf()}. + * + * @internal + */ +const avalue = Symbol('avalue'); diff --git a/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/package.json b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/package.json new file mode 100644 index 00000000..48ea2155 --- /dev/null +++ b/backend/node_modules/.pnpm/expect-type@1.4.0/node_modules/expect-type/package.json @@ -0,0 +1,50 @@ +{ + "name": "expect-type", + "version": "1.4.0", + "engines": { + "node": ">=12.0.0" + }, + "keywords": [ + "typescript", + "type-check", + "assert", + "types", + "typings", + "test", + "testing" + ], + "homepage": "https://github.com/mmkal/expect-type#readme", + "repository": { + "type": "git", + "url": "https://github.com/mmkal/expect-type.git" + }, + "license": "Apache-2.0", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "dist", + "*.md" + ], + "devDependencies": { + "@arethetypeswrong/cli": "0.18.3", + "@types/node": "^24.0.0", + "@typescript/native-preview": "7.0.0-dev.20260609.1", + "@vitest/ui": "^4.0.0", + "eslint": "^8.57.0", + "eslint-plugin-mmkal": "0.9.0", + "np": "^11.0.0", + "pkg-pr-new": "0.0.75", + "strip-ansi": "7.2.0", + "ts-morph": "27.0.2", + "typescript": "5.9.3", + "vitest": "^4.0.0" + }, + "scripts": { + "eslint": "eslint --max-warnings 0", + "lint": "tsc && pnpm eslint .", + "type-check": "tsc", + "build": "tsc -p tsconfig.lib.json", + "arethetypeswrong": "attw --pack", + "test": "vitest run" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/LICENSE b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/LICENSE new file mode 100644 index 00000000..e739abce --- /dev/null +++ b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Pooya Parsa + +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/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/README.md b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/README.md new file mode 100644 index 00000000..b3af4838 --- /dev/null +++ b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/README.md @@ -0,0 +1,258 @@ +# jiti + + + +[![npm version](https://img.shields.io/npm/v/jiti?color=F0DB4F)](https://npmjs.com/package/jiti) +[![npm downloads](https://img.shields.io/npm/dm/jiti?color=F0DB4F)](https://npmjs.com/package/jiti) +[![bundle size](https://img.shields.io/bundlephobia/minzip/jiti?color=F0DB4F)](https://bundlephobia.com/package/jiti) + + + +> This is the active development branch. Check out [jiti/v1](https://github.com/unjs/jiti/tree/v1) for legacy v1 docs and code. + +## 🌟 Used in + +[Docusaurus](https://docusaurus.io/), [ESLint](https://github.com/eslint/eslint), [FormKit](https://formkit.com/), [Histoire](https://histoire.dev/), [Knip](https://knip.dev/), [Nitro](https://nitro.unjs.io/), [Nuxt](https://nuxt.com/), [PostCSS loader](https://github.com/webpack-contrib/postcss-loader), [Rsbuild](https://rsbuild.dev/), [Size Limit](https://github.com/ai/size-limit), [Slidev](https://sli.dev/), [Tailwindcss](https://tailwindcss.com/), [Tokenami](https://github.com/tokenami/tokenami), [UnoCSS](https://unocss.dev/), [WXT](https://wxt.dev/), [Winglang](https://www.winglang.io/), [Graphql code generator](https://the-guild.dev/graphql/codegen), [Lingui](https://lingui.dev/), [Scaffdog](https://scaff.dog/), [Storybook](https://storybook.js.org), [...UnJS ecosystem](https://unjs.io/), [...60M+ npm monthly downloads](https://npm.chart.dev/jiti), [...6M+ public repositories](https://github.com/unjs/jiti/network/dependents). + +## ✅ Features + +- Seamless TypeScript and ESM syntax support for Node.js +- Seamless interoperability between ESM and CommonJS +- Asynchronous API to replace `import()` +- Synchronous API to replace `require()` (deprecated) +- Super slim and zero dependency +- Custom resolve aliases +- Smart syntax detection to avoid extra transforms +- Node.js native `require.cache` integration +- Filesystem transpile with hard disk caches +- ESM Loader support +- JSX support (opt-in) + +> [!IMPORTANT] +> To enhance compatibility, jiti `>=2.1` enabled [`interopDefault`](#interopdefault) using a new Proxy method. If you migrated to `2.0.0` earlier, this might have caused behavior changes. In case of any issues during the upgrade, please [report](https://github.com/unjs/jiti/issues) so we can investigate to solve them. 🙏🏼 + +## 💡 Usage + +### CLI + +You can use `jiti` CLI to quickly run any script with TypeScript and native ESM support! + +```bash +npx jiti ./index.ts +``` + +### Programmatic + +Initialize a jiti instance: + +```js +// ESM +import { createJiti } from "jiti"; +const jiti = createJiti(import.meta.url); + +// CommonJS (deprecated) +const { createJiti } = require("jiti"); +const jiti = createJiti(__filename); +``` + +Import (async) and resolve with ESM compatibility: + +```js +// jiti.import(id) is similar to import(id) +const mod = await jiti.import("./path/to/file.ts"); + +// jiti.esmResolve(id) is similar to import.meta.resolve(id) +const resolvedPath = jiti.esmResolve("./src"); +``` + +If you need the default export of module, you can use `jiti.import(id, { default: true })` as shortcut to `mod?.default ?? mod`. + +```js +// shortcut to mod?.default ?? mod +const modDefault = await jiti.import("./path/to/file.ts", { default: true }); +``` + +CommonJS (sync & deprecated): + +```js +// jiti() is similar to require(id) +const mod = jiti("./path/to/file.ts"); + +// jiti.resolve() is similar to require.resolve(id) +const resolvedPath = jiti.resolve("./src"); +``` + +You can also pass options as the second argument: + +```js +const jiti = createJiti(import.meta.url, { debug: true }); +``` + +### Register global ESM loader + +You can globally register jiti using [global hooks](https://nodejs.org/api/module.html#initialize). (Important: Requires Node.js > 20) + +```js +import "jiti/register"; +``` + +Or: + +```bash +node --import jiti/register index.ts +``` + +## 🎈 `jiti/native` + +You can alias `jiti` to `jiti/native` to directly depend on runtime's [`import.meta.resolve`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta/resolve) and dynamic [`import()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) support. This allows easing up the ecosystem transition to runtime native support by giving the same API of jiti. + +## ⚙️ Options + +### `debug` + +- Type: Boolean +- Default: `false` +- Environment variable: `JITI_DEBUG` + +Enable verbose logging. You can use `JITI_DEBUG=1 ` to enable it. + +### `fsCache` + +- Type: Boolean | String +- Default: `true` +- Environment variable: `JITI_FS_CACHE` + +Filesystem source cache (enabled by default) + +By default (when is `true`), jiti uses `node_modules/.cache/jiti` (if exists) or `{TMP_DIR}/jiti`. + +**Note:** It is recommended that this option be enabled for better performance. + +### `rebuildFsCache` + +- Type: Boolean +- Default: `false` +- Environment variable: `JITI_REBUILD_FS_CACHE` + +Rebuild filesystem source cache created by `fsCache`. + +### `moduleCache` + +- Type: String +- Default: `true` +- Environment variable: `JITI_MODULE_CACHE` + +Runtime module cache (enabled by default). + +Disabling allows editing code and importing the same module multiple times. + +When enabled, jiti integrates with Node.js native CommonJS cache-store. + +### `transform` + +- Type: Function +- Default: Babel (lazy loaded) + +Transform function. See [src/babel](./src/babel.ts) for more details + +### `sourceMaps` + +- Type: Boolean +- Default `false` +- Environment variable: `JITI_SOURCE_MAPS` + +Add inline source map to transformed source for better debugging. + +### `interopDefault` + +- Type: Boolean +- Default: `true` +- Environment variable: `JITI_INTEROP_DEFAULT` + +Jiti combines module exports with the `default` export using an internal Proxy to improve compatibility with mixed CJS/ESM usage. You can check the current implementation [here](https://github.com/unjs/jiti/blob/main/src/utils.ts#L105). + +> [!WARNING] +> This option wraps **all imported modules** in a Proxy, which adds ~25-50ns overhead per property access. For performance-critical hot paths where you access module exports very frequently, consider setting `interopDefault: false` or `JITI_INTEROP_DEFAULT=false`. + +### `alias` + +- Type: Object +- Default: - +- Environment variable: `JITI_ALIAS` + +You can also pass an object to the environment variable for inline config. Example: `JITI_ALIAS='{"~/*": "./src/*"}' jiti ...`. + +Custom alias map used to resolve IDs. + +### `tsconfigPaths` + +- Type: Boolean | String +- Default: `false` +- Environment variable: `JITI_TSCONFIG_PATHS` + +Enable TypeScript [`paths`](https://www.typescriptlang.org/tsconfig/#paths) resolution using [`get-tsconfig`](https://github.com/privatenumber/get-tsconfig). + +- `true`: Auto-discover `tsconfig.json` by walking up from the jiti instance's parent path. +- `string`: Explicit path to a `tsconfig.json` file. +- `false` (default): Disabled. + +### `nativeModules` + +- Type: Array +- Default: ['typescript'] +- Environment variable: `JITI_NATIVE_MODULES` + +List of modules (within `node_modules`) to always use native `require()` for them. + +### `transformModules` + +- Type: Array +- Default: [] +- Environment variable: `JITI_TRANSFORM_MODULES` + +List of modules (within `node_modules`) to transform them regardless of syntax. + +### `importMeta` + +Parent module's [`import.meta`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta) context to use for ESM resolution. (only used for `jiti/native` import). + +### `tryNative` + +- Type: Boolean +- Default: Enabled if bun is detected +- Environment variable: `JITI_TRY_NATIVE` + +Try to use native require and import without jiti transformations first. + +### `jsx` + +- Type: Boolean | {options} +- Default: `false` +- Environment Variable: `JITI_JSX` + +Enable JSX support using [`@babel/plugin-transform-react-jsx`](https://babeljs.io/docs/babel-plugin-transform-react-jsx). + +See [`test/fixtures/jsx`](./test/fixtures/jsx) for framework integration examples. + +## Development + +- Clone this repository +- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable` +- Install dependencies using `pnpm install` +- Run `pnpm dev` +- Run `pnpm jiti ./test/path/to/file.ts` + +## License + + + +Published under the [MIT](https://github.com/unjs/jiti/blob/main/LICENSE) license. +Made by [@pi0](https://github.com/pi0) and [community](https://github.com/unjs/jiti/graphs/contributors) 💛 +

+ + + + + + + diff --git a/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/dist/babel.cjs b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/dist/babel.cjs new file mode 100644 index 00000000..1e6b684f --- /dev/null +++ b/backend/node_modules/.pnpm/jiti@2.7.0/node_modules/jiti/dist/babel.cjs @@ -0,0 +1,257 @@ +(()=>{var e={"./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files lazy recursive"(e){function webpackEmptyAsyncContext(e){return Promise.resolve().then(function(){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t})}webpackEmptyAsyncContext.keys=()=>[],webpackEmptyAsyncContext.resolve=webpackEmptyAsyncContext,webpackEmptyAsyncContext.id="./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files lazy recursive",e.exports=webpackEmptyAsyncContext},"./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files sync recursive"(e){function webpackEmptyContext(e){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}webpackEmptyContext.keys=()=>[],webpackEmptyContext.resolve=webpackEmptyContext,webpackEmptyContext.id="./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files sync recursive",e.exports=webpackEmptyContext},"./node_modules/.pnpm/@babel+plugin-syntax-class-properties@7.12.13_@babel+core@7.29.0/node_modules/@babel/plugin-syntax-class-properties/lib/index.js"(e,t,r){"use strict";t.A=void 0;var n=(0,r("./node_modules/.pnpm/@babel+helper-plugin-utils@7.28.6/node_modules/@babel/helper-plugin-utils/lib/index.js").declare)(e=>(e.assertVersion(7),{name:"syntax-class-properties",manipulateOptions(e,t){t.plugins.push("classProperties","classPrivateProperties","classPrivateMethods")}}));t.A=n},"./node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"(e,t,r){var n;!function(e,t,r){"use strict";var n=Object.create,s=Object.defineProperty,i=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,a=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,__commonJS=(e,t)=>function(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/sourcemap-codec"(e,r){r.exports=t}}),c=__commonJS({"umd:@jridgewell/trace-mapping"(e,t){t.exports=r}}),u={};__export(u,{GenMapping:()=>E,addMapping:()=>addMapping,addSegment:()=>addSegment,allMappings:()=>allMappings,fromMap:()=>fromMap,maybeAddMapping:()=>maybeAddMapping,maybeAddSegment:()=>maybeAddSegment,setIgnore:()=>setIgnore,setSourceContent:()=>setSourceContent,toDecodedMap:()=>toDecodedMap,toEncodedMap:()=>toEncodedMap}),e.exports=__toCommonJS(u);var d=class{constructor(){this._indexes={__proto__:null},this.array=[]}};function cast(e){return e}function get(e,t){return cast(e)._indexes[t]}function put(e,t){const r=get(e,t);if(void 0!==r)return r;const{array:n,_indexes:s}=cast(e),i=n.push(t);return s[t]=i-1}function remove(e,t){const r=get(e,t);if(void 0===r)return;const{array:n,_indexes:s}=cast(e);for(let e=r+1;eaddSegmentInternal(!0,e,t,r,n,s,i,o,a),maybeAddMapping=(e,t)=>addMappingInternal(!0,e,t);function setSourceContent(e,t,r){const{_sources:n,_sourcesContent:s}=cast2(e);s[put(n,t)]=r}function setIgnore(e,t,r=!0){const{_sources:n,_sourcesContent:s,_ignoreList:i}=cast2(e),o=put(n,t);o===s.length&&(s[o]=null),r?put(i,o):remove(i,o)}function toDecodedMap(e){const{_mappings:t,_sources:r,_sourcesContent:n,_names:s,_ignoreList:i}=cast2(e);return removeEmptyFinalLines(t),{version:3,file:e.file||void 0,names:s.array,sourceRoot:e.sourceRoot||void 0,sources:r.array,sourcesContent:n,mappings:t,ignoreList:i.array}}function toEncodedMap(e){const t=toDecodedMap(e);return Object.assign({},t,{mappings:(0,h.encode)(t.mappings)})}function fromMap(e){const t=new m.TraceMap(e),r=new E({file:t.file,sourceRoot:t.sourceRoot});return putAll(cast2(r)._names,t.names),putAll(cast2(r)._sources,t.sources),cast2(r)._sourcesContent=t.sourcesContent||t.sources.map(()=>null),cast2(r)._mappings=(0,m.decodedMappings)(t),t.ignoreList&&putAll(cast2(r)._ignoreList,t.ignoreList),r}function allMappings(e){const t=[],{_mappings:r,_sources:n,_names:s}=cast2(e);for(let e=0;e=0&&!(t>=e[n][f]);r=n--);return r}function insert(e,t,r){for(let r=e.length;r>t;r--)e[r]=e[r-1];e[t]=r}function removeEmptyFinalLines(e){const{length:t}=e;let r=t;for(let t=r-1;t>=0&&!(e[t].length>0);r=t,t--);rfunction(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/trace-mapping"(e,t){t.exports=r}}),c=__commonJS({"umd:@jridgewell/gen-mapping"(e,r){r.exports=t}}),u={};__export(u,{default:()=>remapping}),e.exports=__toCommonJS(u);var d=__toESM(p()),h=__toESM(c()),m=__toESM(p()),f=SegmentObject("",-1,-1,"",null,!1),y=[];function SegmentObject(e,t,r,n,s,i){return{source:e,line:t,column:r,name:n,content:s,ignore:i}}function Source(e,t,r,n,s){return{map:e,sources:t,source:r,content:n,ignore:s}}function MapSource(e,t){return Source(e,t,"",null,!1)}function OriginalSource(e,t,r){return Source(null,y,e,t,r)}function traceMappings(e){const t=new h.GenMapping({file:e.map.file}),{sources:r,map:n}=e,s=n.names,i=(0,m.decodedMappings)(n);for(let e=0;enew d.TraceMap(e,"")),n=r.pop();for(let e=0;e1)throw new Error(`Transformation map ${e} must have exactly one source file.\nDid you specify these with the most recent transformation maps first?`);let s=build(n,t,"",0);for(let e=r.length-1;e>=0;e--)s=MapSource(r[e],[s]);return s}function build(e,t,r,n){const{resolvedSources:s,sourcesContent:i,ignoreList:o}=e,a=n+1;return MapSource(e,s.map((e,n)=>{const s={importer:r,depth:a,source:e||"",content:void 0,ignore:void 0},l=t(s.source,s),{source:p,content:c,ignore:u}=s;return l?build(new d.TraceMap(l,p),t,p,a):OriginalSource(p,void 0!==c?c:i?i[n]:null,void 0!==u?u:!!o&&o.includes(n))}))}var b=__toESM(c()),g=class{constructor(e,t){const r=t.decodedMappings?(0,b.toDecodedMap)(e):(0,b.toEncodedMap)(e);this.version=r.version,this.file=r.file,this.mappings=r.mappings,this.names=r.names,this.ignoreList=r.ignoreList,this.sourceRoot=r.sourceRoot,this.sources=r.sources,t.excludeContent||(this.sourcesContent=r.sourcesContent)}toString(){return JSON.stringify(this)}};function remapping(e,t,r){const n="object"==typeof r?r:{excludeContent:!!r,decodedMappings:!1},s=buildSourceMapTree(e,t);return new g(traceMappings(s),n)}}(e=r.nmd(e),r("./node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"),r("./node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js")),e.exports="default"in(n=e).exports?n.exports.default:n.exports},"./node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(e){e.exports=function(){"use strict";const e=/^[\w+.-]+:\/\//,t=/^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/,r=/^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;function isAbsoluteUrl(t){return e.test(t)}function isSchemeRelativeUrl(e){return e.startsWith("//")}function isAbsolutePath(e){return e.startsWith("/")}function isFileUrl(e){return e.startsWith("file:")}function isRelative(e){return/^[.?#]/.test(e)}function parseAbsoluteUrl(e){const r=t.exec(e);return makeUrl(r[1],r[2]||"",r[3],r[4]||"",r[5]||"/",r[6]||"",r[7]||"")}function parseFileUrl(e){const t=r.exec(e),n=t[2];return makeUrl("file:","",t[1]||"","",isAbsolutePath(n)?n:"/"+n,t[3]||"",t[4]||"")}function makeUrl(e,t,r,n,s,i,o){return{scheme:e,user:t,host:r,port:n,path:s,query:i,hash:o,type:7}}function parseUrl(e){if(isSchemeRelativeUrl(e)){const t=parseAbsoluteUrl("http:"+e);return t.scheme="",t.type=6,t}if(isAbsolutePath(e)){const t=parseAbsoluteUrl("http://foo.com"+e);return t.scheme="",t.host="",t.type=5,t}if(isFileUrl(e))return parseFileUrl(e);if(isAbsoluteUrl(e))return parseAbsoluteUrl(e);const t=parseAbsoluteUrl("http://foo.com/"+e);return t.scheme="",t.host="",t.type=e?e.startsWith("?")?3:e.startsWith("#")?2:4:1,t}function stripPathFilename(e){if(e.endsWith("/.."))return e;const t=e.lastIndexOf("/");return e.slice(0,t+1)}function mergePaths(e,t){normalizePath(t,t.type),"/"===e.path?e.path=t.path:e.path=stripPathFilename(t.path)+e.path}function normalizePath(e,t){const r=t<=4,n=e.path.split("/");let s=1,i=0,o=!1;for(let e=1;en&&(n=s)}normalizePath(r,n);const s=r.query+r.hash;switch(n){case 2:case 3:return s;case 4:{const n=r.path.slice(1);return n?isRelative(t||e)&&!isRelative(n)?"./"+n+s:n+s:s||"."}case 5:return r.path+s;default:return r.scheme+"//"+r.user+r.host+r.port+r.path+s}}return resolve}()},"./node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(e,t,r){var n;!function(e){"use strict";var t=Object.defineProperty,r=Object.getOwnPropertyDescriptor,n=Object.getOwnPropertyNames,s=Object.prototype.hasOwnProperty,__copyProps=(e,i,o,a)=>{if(i&&"object"==typeof i||"function"==typeof i)for(let l of n(i))s.call(e,l)||l===o||t(e,l,{get:()=>i[l],enumerable:!(a=r(i,l))||a.enumerable});return e},__toCommonJS=e=>__copyProps(t({},"__esModule",{value:!0}),e),i={};((e,r)=>{for(var n in r)t(e,n,{get:r[n],enumerable:!0})})(i,{decode:()=>decode,decodeGeneratedRanges:()=>decodeGeneratedRanges,decodeOriginalScopes:()=>decodeOriginalScopes,encode:()=>encode,encodeGeneratedRanges:()=>encodeGeneratedRanges,encodeOriginalScopes:()=>encodeOriginalScopes}),e.exports=__toCommonJS(i);var o=",".charCodeAt(0),a=";".charCodeAt(0),l="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p=new Uint8Array(64),c=new Uint8Array(128);for(let e=0;e>>=1,i&&(r=-2147483648|-r),t+r}function encodeInteger(e,t,r){let n=t-r;n=n<0?-n<<1|1:n<<1;do{let t=31&n;n>>>=5,n>0&&(t|=32),e.write(p[t])}while(n>0);return t}function hasMoreVlq(e,t){return!(e.pos>=t)&&e.peek()!==o}var u=16384,d="undefined"!=typeof TextDecoder?new TextDecoder:"undefined"!=typeof Buffer?{decode:e=>Buffer.from(e.buffer,e.byteOffset,e.byteLength).toString()}:{decode(e){let t="";for(let r=0;r0?t+d.decode(e.subarray(0,r)):t}},m=class{constructor(e){this.pos=0,this.buffer=e}next(){return this.buffer.charCodeAt(this.pos++)}peek(){return this.buffer.charCodeAt(this.pos)}indexOf(e){const{buffer:t,pos:r}=this,n=t.indexOf(e,r);return-1===n?t.length:n}},f=[];function decodeOriginalScopes(e){const{length:t}=e,r=new m(e),n=[],s=[];let i=0;for(;r.pos0&&r.write(o),n[0]=encodeInteger(r,i,n[0]),encodeInteger(r,a,0),encodeInteger(r,c,0),encodeInteger(r,6===s.length?1:0,0),6===s.length&&encodeInteger(r,s[5],0);for(const e of u)encodeInteger(r,e,0);for(t++;tl||i===l&&o>=p)break;t=_encodeOriginalScopes(e,t,r,n)}return r.write(o),n[0]=encodeInteger(r,l,n[0]),encodeInteger(r,p,0),t}function decodeGeneratedRanges(e){const{length:t}=e,r=new m(e),n=[],s=[];let i=0,o=0,a=0,l=0,p=0,c=0,u=0,d=0;do{const e=r.indexOf(";");let t=0;for(;r.pose;t--){const e=u;u=decodeInteger(r,u),d=decodeInteger(r,u===e?d:0);const t=decodeInteger(r,0);n.push([t,u,d])}}else n=[[e]];x.push(n)}while(hasMoreVlq(r,e))}b.bindings=x,n.push(b),s.push(b)}i++,r.pos=e+1}while(r.pos0&&r.write(o),n[1]=encodeInteger(r,s[1],n[1]),encodeInteger(r,(6===s.length?1:0)|(u?2:0)|(c?4:0),0),6===s.length){const{4:e,5:t}=s;e!==n[2]&&(n[3]=0),n[2]=encodeInteger(r,e,n[2]),n[3]=encodeInteger(r,t,n[3])}if(u){const{0:e,1:t,2:i}=s.callsite;e!==n[4]?(n[5]=0,n[6]=0):t!==n[5]&&(n[6]=0),n[4]=encodeInteger(r,e,n[4]),n[5]=encodeInteger(r,t,n[5]),n[6]=encodeInteger(r,i,n[6])}if(d)for(const e of d){e.length>1&&encodeInteger(r,-e.length,0),encodeInteger(r,e[0][0],0);let t=i,n=a;for(let s=1;sl||i===l&&o>=p)break;t=_encodeGeneratedRanges(e,t,r,n)}return n[0]0&&t.write(a),0===p.length)continue;let c=0;for(let e=0;e0&&t.write(o),c=encodeInteger(t,a[0],c),1!==a.length&&(r=encodeInteger(t,a[1],r),n=encodeInteger(t,a[2],n),s=encodeInteger(t,a[3],s),4!==a.length&&(i=encodeInteger(t,a[4],i)))}}return t.flush()}}(e=r.nmd(e)),e.exports="default"in(n=e).exports?n.exports.default:n.exports},"./node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(e,t,r){var n;!function(e,t,r){"use strict";var n=Object.create,s=Object.defineProperty,i=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,a=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,__commonJS=(e,t)=>function(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/sourcemap-codec"(e,t){t.exports=r}}),c=__commonJS({"umd:@jridgewell/resolve-uri"(e,r){r.exports=t}}),u={};__export(u,{AnyMap:()=>FlattenMap,FlattenMap:()=>FlattenMap,GREATEST_LOWER_BOUND:()=>_,LEAST_UPPER_BOUND:()=>P,TraceMap:()=>A,allGeneratedPositionsFor:()=>allGeneratedPositionsFor,decodedMap:()=>decodedMap,decodedMappings:()=>decodedMappings,eachMapping:()=>eachMapping,encodedMap:()=>encodedMap,encodedMappings:()=>encodedMappings,generatedPositionFor:()=>generatedPositionFor,isIgnored:()=>isIgnored,originalPositionFor:()=>originalPositionFor,presortedDecodedMap:()=>presortedDecodedMap,sourceContentFor:()=>sourceContentFor,traceSegment:()=>traceSegment}),e.exports=__toCommonJS(u);var d=__toESM(p()),h=__toESM(c());function stripFilename(e){if(!e)return"";const t=e.lastIndexOf("/");return e.slice(0,t+1)}function resolver(e,t){const r=stripFilename(e),n=t?t+"/":"";return e=>(0,h.default)(n+(e||""),r)}var m=0,f=1,y=2,b=3,g=4,x=1,v=2;function maybeSort(e,t){const r=nextUnsortedSegmentLine(e,0);if(r===e.length)return e;t||(e=e.slice());for(let n=r;n[]);for(let t=0;t>1),i=e[s][m]-t;if(0===i)return E=!0,s;i<0?r=s+1:n=s-1}return E=!1,r-1}function upperBound(e,t,r){for(let n=r+1;n=0&&e[n][m]===t;r=n--);return r}function memoizedState(){return{lastKey:-1,lastNeedle:-1,lastIndex:-1}}function memoizedBinarySearch(e,t,r,n){const{lastKey:s,lastNeedle:i,lastIndex:o}=r;let a=0,l=e.length-1;if(n===s){if(t===i)return E=-1!==o&&e[o][m]===t,o;t>=i?a=-1===o?0:o:l=o}return r.lastKey=n,r.lastNeedle=t,r.lastIndex=binarySearch(e,t,a,l)}function parse(e){return"string"==typeof e?JSON.parse(e):e}var FlattenMap=function(e,t){const r=parse(e);if(!("sections"in r))return new A(r,t);const n=[],s=[],i=[],o=[],a=[];return recurse(r,t,n,s,i,o,a,0,0,1/0,1/0),presortedDecodedMap({version:3,file:r.file,names:o,sources:s,sourcesContent:i,mappings:n,ignoreList:a})};function recurse(e,t,r,n,s,i,o,a,l,p,c){const{sections:u}=e;for(let e=0;ep)return;const n=getLine(r,t),s=0===e?l:0,i=v[e];for(let e=0;e=c)return;if(1===r.length){n.push([o]);continue}const a=h+r[f],l=r[y],u=r[b];n.push(4===r.length?[o,a,l,u]:[o,a,l,u,x+r[g]])}}}function append(e,t){for(let r=0;r=n.length)return null;const s=n[t],i=traceSegmentInternal(s,cast(e)._decodedMemo,t,r,_);return-1===i?null:s[i]}function originalPositionFor(e,t){let{line:r,column:n,bias:s}=t;if(r--,r<0)throw new Error(T);if(n<0)throw new Error(S);const i=decodedMappings(e);if(r>=i.length)return OMapping(null,null,null,null);const o=i[r],a=traceSegmentInternal(o,cast(e)._decodedMemo,r,n,s||_);if(-1===a)return OMapping(null,null,null,null);const l=o[a];if(1===l.length)return OMapping(null,null,null,null);const{names:p,resolvedSources:c}=e;return OMapping(c[l[f]],l[y]+1,l[b],5===l.length?p[l[g]]:null)}function generatedPositionFor(e,t){const{source:r,line:n,column:s,bias:i}=t;return generatedPosition(e,r,n,s,i||_,!1)}function allGeneratedPositionsFor(e,t){const{source:r,line:n,column:s,bias:i}=t;return generatedPosition(e,r,n,s,i||P,!0)}function eachMapping(e,t){const r=decodedMappings(e),{names:n,resolvedSources:s}=e;for(let e=0;e{"%%"!==e&&(n++,"%c"===e&&(s=n))}),t.splice(s,0,r)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")||t.storage.getItem("DEBUG")}catch(e){}!e&&"undefined"!=typeof process&&"env"in process&&(e=process.env.DEBUG);return e},t.useColors=function(){if("undefined"!=typeof window&&window.process&&("renderer"===window.process.type||window.process.__nwjs))return!0;if("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))return!1;let e;return"undefined"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)},t.storage=function(){try{return localStorage}catch(e){}}(),t.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))}})(),t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=r("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(t);const{formatters:n}=e.exports;n.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}},"./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(e,t,r){e.exports=function(e){function createDebug(e){let t,r,n,s=null;function debug(...e){if(!debug.enabled)return;const r=debug,n=Number(new Date),s=n-(t||n);r.diff=s,r.prev=t,r.curr=n,t=n,e[0]=createDebug.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let i=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,(t,n)=>{if("%%"===t)return"%";i++;const s=createDebug.formatters[n];if("function"==typeof s){const n=e[i];t=s.call(r,n),e.splice(i,1),i--}return t}),createDebug.formatArgs.call(r,e);(r.log||createDebug.log).apply(r,e)}return debug.namespace=e,debug.useColors=createDebug.useColors(),debug.color=createDebug.selectColor(e),debug.extend=extend,debug.destroy=createDebug.destroy,Object.defineProperty(debug,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==s?s:(r!==createDebug.namespaces&&(r=createDebug.namespaces,n=createDebug.enabled(e)),n),set:e=>{s=e}}),"function"==typeof createDebug.init&&createDebug.init(debug),debug}function extend(e,t){const r=createDebug(this.namespace+(void 0===t?":":t)+e);return r.log=this.log,r}function matchesTemplate(e,t){let r=0,n=0,s=-1,i=0;for(;r"-"+e)].join(",");return createDebug.enable(""),e},createDebug.enable=function(e){createDebug.save(e),createDebug.namespaces=e,createDebug.names=[],createDebug.skips=[];const t=("string"==typeof e?e:"").trim().replace(/\s+/g,",").split(",").filter(Boolean);for(const e of t)"-"===e[0]?createDebug.skips.push(e.slice(1)):createDebug.names.push(e)},createDebug.enabled=function(e){for(const t of createDebug.skips)if(matchesTemplate(e,t))return!1;for(const t of createDebug.names)if(matchesTemplate(e,t))return!0;return!1},createDebug.humanize=r("./node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"),createDebug.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach(t=>{createDebug[t]=e[t]}),createDebug.names=[],createDebug.skips=[],createDebug.formatters={},createDebug.selectColor=function(e){let t=0;for(let r=0;r{},"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."),t.colors=[6,2,3,4,5,1];try{const e=r("./node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js");e&&(e.stderr||e).level>=2&&(t.colors=[20,21,26,27,32,33,38,39,40,41,42,43,44,45,56,57,62,63,68,69,74,75,76,77,78,79,80,81,92,93,98,99,112,113,128,129,134,135,148,149,160,161,162,163,164,165,166,167,168,169,170,171,172,173,178,179,184,185,196,197,198,199,200,201,202,203,204,205,206,207,208,209,214,215,220,221])}catch(e){}t.inspectOpts=Object.keys(process.env).filter(e=>/^debug_/i.test(e)).reduce((e,t)=>{const r=t.substring(6).toLowerCase().replace(/_([a-z])/g,(e,t)=>t.toUpperCase());let n=process.env[t];return n=!!/^(yes|on|true|enabled)$/i.test(n)||!/^(no|off|false|disabled)$/i.test(n)&&("null"===n?null:Number(n)),e[r]=n,e},{}),e.exports=r("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(t);const{formatters:i}=e.exports;i.o=function(e){return this.inspectOpts.colors=this.useColors,s.inspect(e,this.inspectOpts).split("\n").map(e=>e.trim()).join(" ")},i.O=function(e){return this.inspectOpts.colors=this.useColors,s.inspect(e,this.inspectOpts)}},"./node_modules/.pnpm/gensync@1.0.0-beta.2/node_modules/gensync/index.js"(e){"use strict";const t=Symbol.for("gensync:v1:start"),r=Symbol.for("gensync:v1:suspend"),n="GENSYNC_OPTIONS_ERROR",s="GENSYNC_RACE_NONEMPTY",i="GENSYNC_ERRBACK_NO_CALLBACK";function assertTypeof(e,t,r,s){if(typeof r===e||s&&void 0===r)return;let i;throw i=s?`Expected opts.${t} to be either a ${e}, or undefined.`:`Expected opts.${t} to be a ${e}.`,makeError(i,n)}function makeError(e,t){return Object.assign(new Error(e),{code:t})}function buildOperation({name:e,arity:n,sync:s,async:i}){return setFunctionMetadata(e,n,function*(...e){const n=yield t;if(!n){return s.call(this,e)}let o;try{i.call(this,e,e=>{o||(o={value:e},n())},e=>{o||(o={err:e},n())})}catch(e){o={err:e},n()}if(yield r,o.hasOwnProperty("err"))throw o.err;return o.value})}function evaluateSync(e){let t;for(;!({value:t}=e.next()).done;)assertStart(t,e);return t}function evaluateAsync(e,t,r){!function step(){try{let r;for(;!({value:r}=e.next()).done;){assertStart(r,e);let t=!0,n=!1;const s=e.next(()=>{t?n=!0:step()});if(t=!1,assertSuspend(s,e),!n)return}return t(r)}catch(e){return r(e)}}()}function assertStart(e,r){e!==t&&throwError(r,makeError(`Got unexpected yielded value in gensync generator: ${JSON.stringify(e)}. Did you perhaps mean to use 'yield*' instead of 'yield'?`,"GENSYNC_EXPECTED_START"))}function assertSuspend({value:e,done:t},n){(t||e!==r)&&throwError(n,makeError(t?"Unexpected generator completion. If you get this, it is probably a gensync bug.":`Expected GENSYNC_SUSPEND, got ${JSON.stringify(e)}. If you get this, it is probably a gensync bug.`,"GENSYNC_EXPECTED_SUSPEND"))}function throwError(e,t){throw e.throw&&e.throw(t),t}function setFunctionMetadata(e,t,r){if("string"==typeof e){const t=Object.getOwnPropertyDescriptor(r,"name");t&&!t.configurable||Object.defineProperty(r,"name",Object.assign(t||{},{configurable:!0,value:e}))}if("number"==typeof t){const e=Object.getOwnPropertyDescriptor(r,"length");e&&!e.configurable||Object.defineProperty(r,"length",Object.assign(e||{},{configurable:!0,value:t}))}return r}e.exports=Object.assign(function(e){let t=e;return t="function"!=typeof e?function({name:e,arity:t,sync:r,async:s,errback:i}){if(assertTypeof("string","name",e,!0),assertTypeof("number","arity",t,!0),assertTypeof("function","sync",r),assertTypeof("function","async",s,!0),assertTypeof("function","errback",i,!0),s&&i)throw makeError("Expected one of either opts.async or opts.errback, but got _both_.",n);if("string"!=typeof e){let t;i&&i.name&&"errback"!==i.name&&(t=i.name),s&&s.name&&"async"!==s.name&&(t=s.name.replace(/Async$/,"")),r&&r.name&&"sync"!==r.name&&(t=r.name.replace(/Sync$/,"")),"string"==typeof t&&(e=t)}"number"!=typeof t&&(t=r.length);return buildOperation({name:e,arity:t,sync:function(e){return r.apply(this,e)},async:function(e,t,n){s?s.apply(this,e).then(t,n):i?i.call(this,...e,(e,r)=>{null==e?t(r):n(e)}):t(r.apply(this,e))}})}(e):function(e){return setFunctionMetadata(e.name,e.length,function(...t){return e.apply(this,t)})}(e),Object.assign(t,function(e){const t={sync:function(...t){return evaluateSync(e.apply(this,t))},async:function(...t){return new Promise((r,n)=>{evaluateAsync(e.apply(this,t),r,n)})},errback:function(...t){const r=t.pop();if("function"!=typeof r)throw makeError("Asynchronous function called without callback",i);let n;try{n=e.apply(this,t)}catch(e){return void r(e)}evaluateAsync(n,e=>r(void 0,e),e=>r(e))}};return t}(t))},{all:buildOperation({name:"all",arity:1,sync:function(e){return Array.from(e[0]).map(e=>evaluateSync(e))},async:function(e,t,r){const n=Array.from(e[0]);if(0===n.length)return void Promise.resolve().then(()=>t([]));let s=0;const i=n.map(()=>{});n.forEach((e,n)=>{evaluateAsync(e,e=>{i[n]=e,s+=1,s===i.length&&t(i)},r)})}}),race:buildOperation({name:"race",arity:1,sync:function(e){const t=Array.from(e[0]);if(0===t.length)throw makeError("Must race at least 1 item",s);return evaluateSync(t[0])},async:function(e,t,r){const n=Array.from(e[0]);if(0===n.length)throw makeError("Must race at least 1 item",s);for(const e of n)evaluateAsync(e,t,r)}})})},"./node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(e){"use strict";e.exports=(e,t=process.argv)=>{const r=e.startsWith("-")?"":1===e.length?"-":"--",n=t.indexOf(r+e),s=t.indexOf("--");return-1!==n&&(-1===s||n{for(const n in e)r.call(e,n)&&t(n,e[n])},fourHexEscape=e=>"\\u"+("0000"+e).slice(-4),hexadecimal=(e,t)=>{let r=e.toString(16);return t?r:r.toUpperCase()},n=t.toString,s=Array.isArray,isBigInt=e=>"bigint"==typeof e,i={"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"},o=/[\\\b\f\n\r\t]/,a=/[0-9]/,l=/[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/,p=/([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^]/g,c=/([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^ !#-&\(-\[\]-_a-~]/g,jsesc=(e,t)=>{const increaseIndentation=()=>{g=b,++t.indentLevel,b=t.indent.repeat(t.indentLevel)},r={escapeEverything:!1,minimal:!1,isScriptContext:!1,quotes:"single",wrap:!1,es6:!1,json:!1,compact:!0,lowercaseHex:!1,numbers:"decimal",indent:"\t",indentLevel:0,__inline1__:!1,__inline2__:!1},u=t&&t.json;var d,h;u&&(r.quotes="double",r.wrap=!0),d=r,"single"!=(t=(h=t)?(forOwn(h,(e,t)=>{d[e]=t}),d):d).quotes&&"double"!=t.quotes&&"backtick"!=t.quotes&&(t.quotes="single");const m="double"==t.quotes?'"':"backtick"==t.quotes?"`":"'",f=t.compact,y=t.lowercaseHex;let b=t.indent.repeat(t.indentLevel),g="";const x=t.__inline1__,v=t.__inline2__,E=f?"":"\n";let T,S=!0;const P="binary"==t.numbers,_="octal"==t.numbers,A="decimal"==t.numbers,C="hexadecimal"==t.numbers;if(u&&e&&(e=>"function"==typeof e)(e.toJSON)&&(e=e.toJSON()),!(e=>"string"==typeof e||"[object String]"==n.call(e))(e)){if((e=>"[object Map]"==n.call(e))(e))return 0==e.size?"new Map()":(f||(t.__inline1__=!0,t.__inline2__=!1),"new Map("+jsesc(Array.from(e),t)+")");if((e=>"[object Set]"==n.call(e))(e))return 0==e.size?"new Set()":"new Set("+jsesc(Array.from(e),t)+")";if((e=>"function"==typeof Buffer&&Buffer.isBuffer(e))(e))return 0==e.length?"Buffer.from([])":"Buffer.from("+jsesc(Array.from(e),t)+")";if(s(e))return T=[],t.wrap=!0,x&&(t.__inline1__=!1,t.__inline2__=!0),v||increaseIndentation(),((e,t)=>{const r=e.length;let n=-1;for(;++n{S=!1,v&&(t.__inline2__=!1),T.push((f||v?"":b)+jsesc(e,t))}),S?"[]":v?"["+T.join(", ")+"]":"["+E+T.join(","+E)+E+(f?"":g)+"]";if((e=>"number"==typeof e||"[object Number]"==n.call(e))(e)||isBigInt(e)){if(u)return JSON.stringify(Number(e));let t;if(A)t=String(e);else if(C){let r=e.toString(16);y||(r=r.toUpperCase()),t="0x"+r}else P?t="0b"+e.toString(2):_&&(t="0o"+e.toString(8));return isBigInt(e)?t+"n":t}return isBigInt(e)?u?JSON.stringify(Number(e)):e+"n":(e=>"[object Object]"==n.call(e))(e)?(T=[],t.wrap=!0,increaseIndentation(),forOwn(e,(e,r)=>{S=!1,T.push((f?"":b)+jsesc(e,t)+":"+(f?"":" ")+jsesc(r,t))}),S?"{}":"{"+E+T.join(","+E)+E+(f?"":g)+"}"):u?JSON.stringify(e)||"null":String(e)}const w=t.escapeEverything?p:c;return T=e.replace(w,(e,r,n,s,p,c)=>{if(r){if(t.minimal)return r;const e=r.charCodeAt(0),n=r.charCodeAt(1);if(t.es6){return"\\u{"+hexadecimal(1024*(e-55296)+n-56320+65536,y)+"}"}return fourHexEscape(hexadecimal(e,y))+fourHexEscape(hexadecimal(n,y))}if(n)return fourHexEscape(hexadecimal(n.charCodeAt(0),y));if("\0"==e&&!u&&!a.test(c.charAt(p+1)))return"\\0";if(s)return s==m||t.escapeEverything?"\\"+s:s;if(o.test(e))return i[e];if(t.minimal&&!l.test(e))return e;const d=hexadecimal(e.charCodeAt(0),y);return u||d.length>2?fourHexEscape(d):"\\x"+("00"+d).slice(-2)}),"`"==m&&(T=T.replace(/\$\{/g,"\\${")),t.isScriptContext&&(T=T.replace(/<\/(script|style)/gi,"<\\/$1").replace(/ + +- ✨ Minimal footprint + - 1.50 kB minified + gzipped (plain) + - 1.48 kB minified + gzipped (browser) + - 1.73 kB minified + gzipped (ansi) +- 📦 Zero dependencies +- 📝 Full TypeScript support +- 🚀 Native ESM compatibility +- 🌐 Optimized for modern runtimes + - ES2015+ browsers + - Modern Node.js versions +- 🎨 Customizable formatting + +## Installation + +```bash +npm install obug +``` + +### Runtime entries + +The default npm entry selects an implementation through conditional exports: + +| Runtime | Entry | Output | +| ----------------------------------------------- | ------ | ----------------------------------- | +| Node.js, Bun, Deno | `obug` | ANSI output to `stderr` | +| React Native / Expo | `obug` | React Native console output | +| Cloudflare Workers, Vercel Edge, Fastly Compute | `obug` | Plain console output | +| Browsers | `obug` | Browser-style output to the console | + +Use an explicit entry when a bundler does not provide the appropriate export condition: + +```ts +import { createDebug } from 'obug/ansi' // terminal / ANSI output +import { createDebug } from 'obug/browser' // browser-style console output +import { createDebug } from 'obug/plain' // plain console output +``` + +JSR does not provide conditional exports. Its default entry remains the ANSI implementation, and the existing `node` subpath is retained as an alias. Use explicit subpaths for browser or plain console output: + +```ts +import { createDebug } from 'jsr:@sxzz/obug' // terminal / ANSI output +import { createDebug } from 'jsr:@sxzz/obug/browser' // browser-style console output +import { createDebug } from 'jsr:@sxzz/obug/plain' // plain console output +``` + +## Usage + +```ts +import { createDebug, disable, enable, enabled, namespaces } from 'obug' + +// Get the currently enabled namespaces +console.log(namespaces()) + +const debug = createDebug('my-namespace', { + // All options are optional + + useColors: true, // false, true, undefined for auto-detect + color: 2, // custom color + // custom formatArgs + formatArgs(args) {}, + formatters: {}, + // Node.js only + inspectOpts: {}, + + // custom log + log: console.log, +}) + +debug('This is a debug message') +console.log( + debug.namespace, // 'my-namespace' + debug.enabled, // Check if enabled + debug.useColors, // true + debug.color, // 2 + debug.formatArgs, // custom formatArgs + debug.formatters, // {} + debug.inspectOpts, // {} + debug.log, // implemented log function +) + +// Create a sub-namespace, and it will inherit options from the parent debugger +const sub = debug.extend('sub-namespace') +sub('This is a sub-namespace debug message') +console.log(sub.namespace) // 'my-namespace:sub-namespace' +``` + +## How to use + +### Enabling debug output + +obug picks up enabled namespaces from the `DEBUG` environment variable in Node.js, or from `localStorage.debug` in browsers. + +In Node.js: + +```bash +DEBUG=app:* node app.js +``` + +On Windows (CMD): + +```cmd +set DEBUG=app:* & node app.js +``` + +On Windows (PowerShell): + +```powershell +$env:DEBUG='app:*'; node app.js +``` + +In the browser, set the value in DevTools and refresh the page: + +```js +localStorage.debug = 'app:*' +``` + +### Wildcards and exclusion + +The `*` character is a wildcard. Suppose your library has debuggers named `connect:bodyParser`, `connect:compress`, and `connect:session` — instead of listing each one, use `DEBUG=connect:*`. Use `DEBUG=*` to enable everything. + +Exclude namespaces by prefixing them with `-`: + +```bash +DEBUG=*,-connect:* node app.js +``` + +### Namespace conventions + +If you're using obug in a library, prefix your namespaces with the library name and use `:` to separate features (e.g. `connect:bodyParser`). This lets users opt into the parts they care about without guessing names. + +### Extending a namespace + +Use `.extend()` to create a sub-namespace that inherits options from its parent: + +```ts +const log = createDebug('auth') +const logSign = log.extend('sign') // 'auth:sign' +const logLogin = log.extend('login') // 'auth:login' + +log('hello') // auth hello +logSign('hello') // auth:sign hello +logLogin('hello') // auth:login hello +``` + +### Formatters + +obug uses [printf-style](https://wikipedia.org/wiki/Printf_format_string) formatting. Built-in formatters: + +| Formatter | Representation | +| --------- | -------------------------------------------------- | +| `%O` | Pretty-print an Object on multiple lines. | +| `%o` | Pretty-print an Object all on a single line. | +| `%%` | Single percent sign. Does not consume an argument. | + +Other format specifiers supported by Node's `util.format` (`%s`, `%d`, `%j`, …) and the browser console pass through to the underlying logger. + +#### Custom formatters + +Register custom formatters via the `formatters` option. For example, to render a `Buffer` as hex with `%h`: + +```ts +const debug = createDebug('foo', { + formatters: { + h: (v) => v.toString('hex'), + }, +}) + +debug('this is hex: %h', Buffer.from('hello world')) +// foo this is hex: 68656c6c6f20776f726c64 +0ms +``` + +### Dynamic enable / disable + +You can toggle namespaces at runtime: + +```ts +import { disable, enable, enabled, namespaces } from 'obug' + +enable('app:*') +console.log(enabled('app:server')) // true + +const previous = disable() +console.log(enabled('app:server')) // false + +// Restore later +enable(previous) +``` + +`namespaces()` returns the string of currently enabled namespaces. Note that calling `enable()` overrides the value initially read from `DEBUG`. + +### Checking whether a debugger is enabled + +Guard expensive work behind the `enabled` property: + +```ts +const debug = createDebug('http') + +if (debug.enabled) { + // expensive computation only when enabled +} +``` + +You can also force the state by assigning to `debug.enabled` directly. + +### Custom output + +By default, obug writes to `stderr` in Node.js and to the console in browsers. Override the `log` option to redirect output per-namespace: + +```ts +const log = createDebug('app:log', { + log: console.log, +}) + +const error = createDebug('app:error') // still goes to stderr +``` + +### Environment variables (Node.js) + +| Name | Purpose | +| ------------------- | ----------------------------------------------- | +| `DEBUG` | Enables/disables specific debugging namespaces. | +| `DEBUG_HIDE_DATE` | Hide date from debug output (non-TTY). | +| `DEBUG_COLORS` | Whether to use colors in the debug output. | +| `DEBUG_DEPTH` | Object inspection depth. | +| `DEBUG_SHOW_HIDDEN` | Shows hidden properties on inspected objects. | + +Variables prefixed with `DEBUG_` are converted to camelCase keys on the options object passed to Node's [`util.inspect()`](https://nodejs.org/api/util.html#util_util_inspect_object_options) for the `%o` / `%O` formatters. + +## Original Authors + +As obug is a fork of debug with significant modifications, we would like to acknowledge the original authors: + +- TJ Holowaychuk +- Nathan Rajlich +- Andrew Rhyne +- Josh Junon + +## Sponsors + +

+ + + +

+ +## License + +[MIT](./LICENSE) License © 2025-PRESENT [Kevin Deng](https://github.com/sxzz) + +[The MIT License](./LICENSE) Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca> + +[The MIT License](./LICENSE) Copyright (c) 2018-2021 Josh Junon + + + +[npm-version-src]: https://img.shields.io/npm/v/obug.svg +[npm-version-href]: https://npmjs.com/package/obug +[npm-downloads-src]: https://img.shields.io/npm/dm/obug +[npm-downloads-href]: https://www.npmcharts.com/compare/obug?interval=30 +[unit-test-src]: https://github.com/sxzz/obug/actions/workflows/unit-test.yml/badge.svg +[unit-test-href]: https://github.com/sxzz/obug/actions/workflows/unit-test.yml +[jsr-badge-src]: https://jsr.io/badges/@sxzz/obug +[jsr-badge-href]: https://jsr.io/@sxzz/obug diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.d.ts b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.d.ts new file mode 100644 index 00000000..31a0258e --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.d.ts @@ -0,0 +1,10 @@ +import { a as Debugger, i as DebugOptions, n as enabled, o as Formatters, r as namespaces, s as InspectOptions, t as disable } from "./core.js"; +//#region src/ansi.d.ts +export declare function createDebug(namespace: string, options?: DebugOptions): Debugger; +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + */ +declare function enable(namespaces: string): void; +//#endregion +export { type DebugOptions, type Debugger, type Formatters, type InspectOptions, disable, enable, enabled, namespaces }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.js b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.js new file mode 100644 index 00000000..ac590bf5 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/ansi.js @@ -0,0 +1,174 @@ +import { a as namespaces, i as enabled, n as disable, o as humanize, r as enable$1, s as selectColor, t as createDebug$1 } from "./core.js"; +import { isatty } from "node:tty"; +import { formatWithOptions, inspect } from "node:util"; +//#region src/ansi.ts +let env = {}; +try { + process.env.DEBUG; + env = process.env; +} catch (_unused) {} +const colors = process.stderr.getColorDepth && process.stderr.getColorDepth(env) > 2 ? [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 +] : [ + 6, + 2, + 3, + 4, + 5, + 1 +]; +const inspectOpts = Object.keys(env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => { + const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase()); + let value = env[key]; + const lowerCase = typeof value === "string" && value.toLowerCase(); + if (value === "null") value = null; + else if (lowerCase === "yes" || lowerCase === "on" || lowerCase === "true" || lowerCase === "enabled") value = true; + else if (lowerCase === "no" || lowerCase === "off" || lowerCase === "false" || lowerCase === "disabled") value = false; + else value = Number(value); + obj[prop] = value; + return obj; +}, Object.create(null)); +/** +* Is stdout a TTY? Colored output is enabled when `true`. +*/ +function useColors() { + return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : isatty(process.stderr.fd); +} +function getDate() { + if (inspectOpts.hideDate) return ""; + return `${(/* @__PURE__ */ new Date()).toISOString()} `; +} +/** +* Adds ANSI color escape codes if enabled. +*/ +function formatArgs(diff, args) { + const { namespace: name, useColors } = this; + if (useColors) { + const c = this.color; + const colorCode = `\u{1B}[3${c < 8 ? c : `8;5;${c}`}`; + const prefix = ` ${colorCode};1m${name} \u{1B}[0m`; + args[0] = prefix + args[0].split("\n").join(`\n${prefix}`); + args.push(`${colorCode}m+${this.humanize(diff)}\u{1B}[0m`); + } else args[0] = `${getDate()}${name} ${args[0]}`; +} +function log(...args) { + process.stderr.write(`${formatWithOptions(this.inspectOpts, ...args)}\n`); +} +const defaultOptions = { + useColors: useColors(), + formatArgs, + formatters: { + /** + * Map %o to `util.inspect()`, all on a single line. + */ + o(v) { + this.inspectOpts.colors = this.useColors; + return inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" "); + }, + /** + * Map %O to `util.inspect()`, allowing multiple lines if needed. + */ + O(v) { + this.inspectOpts.colors = this.useColors; + return inspect(v, this.inspectOpts); + } + }, + inspectOpts, + log, + humanize +}; +function createDebug(namespace, options) { + var _ref; + const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace); + return createDebug$1(namespace, Object.assign(defaultOptions, { color }, options)); +} +function save(namespaces) { + if (namespaces) env.DEBUG = namespaces; + else delete env.DEBUG; +} +/** +* Enables a debug mode by namespaces. This can include modes +* separated by a colon and wildcards. +*/ +function enable(namespaces) { + save(namespaces); + enable$1(namespaces); +} +enable$1(env.DEBUG || ""); +//#endregion +export { createDebug, disable, enable, enabled, namespaces }; diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.d.ts b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.d.ts new file mode 100644 index 00000000..975901c0 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.d.ts @@ -0,0 +1,10 @@ +import { a as Debugger, i as DebugOptions, n as enabled, o as Formatters, r as namespaces, s as InspectOptions, t as disable } from "./core.js"; +//#region src/browser.d.ts +export declare function createDebug(namespace: string, options?: DebugOptions): Debugger; +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + */ +declare function enable(namespaces: string): void; +//#endregion +export { type DebugOptions, type Debugger, type Formatters, type InspectOptions, disable, enable, enabled, namespaces }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.js b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.js new file mode 100644 index 00000000..beaee009 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.js @@ -0,0 +1,146 @@ +import { a as namespaces, i as enabled, n as disable, o as humanize, r as enable$1, s as selectColor, t as createDebug$1 } from "./core.js"; +//#region src/browser.ts +const colors = [ + "#0000CC", + "#0000FF", + "#0033CC", + "#0033FF", + "#0066CC", + "#0066FF", + "#0099CC", + "#0099FF", + "#00CC00", + "#00CC33", + "#00CC66", + "#00CC99", + "#00CCCC", + "#00CCFF", + "#3300CC", + "#3300FF", + "#3333CC", + "#3333FF", + "#3366CC", + "#3366FF", + "#3399CC", + "#3399FF", + "#33CC00", + "#33CC33", + "#33CC66", + "#33CC99", + "#33CCCC", + "#33CCFF", + "#6600CC", + "#6600FF", + "#6633CC", + "#6633FF", + "#66CC00", + "#66CC33", + "#9900CC", + "#9900FF", + "#9933CC", + "#9933FF", + "#99CC00", + "#99CC33", + "#CC0000", + "#CC0033", + "#CC0066", + "#CC0099", + "#CC00CC", + "#CC00FF", + "#CC3300", + "#CC3333", + "#CC3366", + "#CC3399", + "#CC33CC", + "#CC33FF", + "#CC6600", + "#CC6633", + "#CC9900", + "#CC9933", + "#CCCC00", + "#CCCC33", + "#FF0000", + "#FF0033", + "#FF0066", + "#FF0099", + "#FF00CC", + "#FF00FF", + "#FF3300", + "#FF3333", + "#FF3366", + "#FF3399", + "#FF33CC", + "#FF33FF", + "#FF6600", + "#FF6633", + "#FF9900", + "#FF9933", + "#FFCC00", + "#FFCC33" +]; +/** +* Colorize log arguments if enabled. +*/ +function formatArgs(diff, args) { + const { useColors } = this; + args[0] = `${(useColors ? "%c" : "") + this.namespace + (useColors ? " %c" : " ") + args[0] + (useColors ? "%c " : " ")}+${this.humanize(diff)}`; + if (!useColors) return; + const c = `color: ${this.color}`; + args.splice(1, 0, c, "color: inherit"); + let index = 0; + let lastC = 0; + args[0].replace(/%[a-z%]/gi, (match) => { + if (match === "%%") return; + index++; + if (match === "%c") lastC = index; + }); + args.splice(lastC, 0, c); +} +const defaultOptions = { + useColors: true, + formatArgs, + formatters: { + /** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ +j(v) { + try { + return JSON.stringify(v); + } catch (error) { + return `[UnexpectedJSONParseError]: ${error.message}`; + } + } }, + inspectOpts: {}, + humanize, + log: console.debug || console.log || (() => {}) +}; +function createDebug(namespace, options) { + var _ref; + const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace); + return createDebug$1(namespace, Object.assign(defaultOptions, { color }, options)); +} +function load() { + let r; + try { + r = localStorage.getItem("debug") || localStorage.getItem("DEBUG"); + } catch (_unused) {} + if (!r && typeof process !== "undefined" && "env" in process) r = process.env.DEBUG; + return r || ""; +} +function save(namespaces) { + try { + if (namespaces) localStorage.setItem("debug", namespaces); + else localStorage.removeItem("debug"); + } catch (_unused2) {} +} +/** +* Enables a debug mode by namespaces. This can include modes +* separated by a colon and wildcards. +*/ +function enable(namespaces) { + save(namespaces); + enable$1(namespaces); +} +enable$1(load()); +//#endregion +export { createDebug, disable, enable, enabled, namespaces }; diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.min.js b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.min.js new file mode 100644 index 00000000..77332cf8 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/browser.min.js @@ -0,0 +1 @@ +function e(e){return e instanceof Error?e.stack||e.message:e}function t(e,t){let n=0;for(let e=0;e=1e3?`${(e/1e3).toFixed(1)}s`:`${e}ms`}let i=``;function a(){return i}function o(t,n){let r,a,s,c,l=((...t)=>{if(!l.enabled)return;let i=Date.now(),a=i-(r||i);r=i,t[0]=e(t[0]),typeof t[0]!=`string`&&t.unshift(`%O`);let o=0;t[0]=t[0].replace(/%([a-z%])/gi,(e,r)=>{if(e===`%%`)return`%`;o++;let i=n.formatters[r];if(typeof i==`function`){let n=t[o];e=i.call(l,n),t.splice(o,1),o--}return e}),n.formatArgs.call(l,a,t),l.log(...t)});return l.extend=function(e,t=`:`){return o(this.namespace+t+e,{useColors:this.useColors,color:this.color,formatArgs:this.formatArgs,formatters:this.formatters,inspectOpts:this.inspectOpts,log:this.log,humanize:this.humanize})},Object.assign(l,n),l.namespace=t,Object.defineProperty(l,"enabled",{enumerable:!0,configurable:!1,get:()=>a==null?(s!==i&&(s=i,c=d(t)),c):a,set:e=>{a=e}}),l}let s=[],c=[];function l(e){i=e,s=[],c=[];let t=i.trim().replace(/\s+/g,`,`).split(`,`).filter(Boolean);for(let e of t)e[0]===`-`?c.push(e.slice(1)):s.push(e)}function u(){let e=[...s,...c.map(e=>`-${e}`)].join(`,`);return l(``),e}function d(e){for(let t of c)if(n(e,t))return!1;for(let t of s)if(n(e,t))return!0;return!1}const f=`#0000CC.#0000FF.#0033CC.#0033FF.#0066CC.#0066FF.#0099CC.#0099FF.#00CC00.#00CC33.#00CC66.#00CC99.#00CCCC.#00CCFF.#3300CC.#3300FF.#3333CC.#3333FF.#3366CC.#3366FF.#3399CC.#3399FF.#33CC00.#33CC33.#33CC66.#33CC99.#33CCCC.#33CCFF.#6600CC.#6600FF.#6633CC.#6633FF.#66CC00.#66CC33.#9900CC.#9900FF.#9933CC.#9933FF.#99CC00.#99CC33.#CC0000.#CC0033.#CC0066.#CC0099.#CC00CC.#CC00FF.#CC3300.#CC3333.#CC3366.#CC3399.#CC33CC.#CC33FF.#CC6600.#CC6633.#CC9900.#CC9933.#CCCC00.#CCCC33.#FF0000.#FF0033.#FF0066.#FF0099.#FF00CC.#FF00FF.#FF3300.#FF3333.#FF3366.#FF3399.#FF33CC.#FF33FF.#FF6600.#FF6633.#FF9900.#FF9933.#FFCC00.#FFCC33`.split(`.`);function p(e,t){let{useColors:n}=this;if(t[0]=`${(n?`%c`:``)+this.namespace+(n?` %c`:` `)+t[0]+(n?`%c `:` `)}+${this.humanize(e)}`,!n)return;let r=`color: ${this.color}`;t.splice(1,0,r,`color: inherit`);let i=0,a=0;t[0].replace(/%[a-z%]/gi,e=>{e!==`%%`&&(i++,e===`%c`&&(a=i))}),t.splice(a,0,r)}const m={useColors:!0,formatArgs:p,formatters:{j(e){try{return JSON.stringify(e)}catch(e){return`[UnexpectedJSONParseError]: ${e.message}`}}},inspectOpts:{},humanize:r,log:console.debug||console.log||(()=>{})};function h(e,n){var r;let i=(r=n&&n.color)==null?t(f,e):r;return o(e,Object.assign(m,{color:i},n))}function g(){let e;try{e=localStorage.getItem(`debug`)||localStorage.getItem(`DEBUG`)}catch(e){}return!e&&typeof process<`u`&&`env`in process&&(e=process.env.DEBUG),e||``}function _(e){try{e?localStorage.setItem(`debug`,e):localStorage.removeItem(`debug`)}catch(e){}}function v(e){_(e),l(e)}l(g());export{h as createDebug,u as disable,v as enable,d as enabled,a as namespaces}; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.d.ts b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.d.ts new file mode 100644 index 00000000..b71f635d --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.d.ts @@ -0,0 +1,46 @@ +import { InspectOptions } from "node:util"; +//#region src/types.d.ts +interface InspectOptions$1 extends InspectOptions { + hideDate?: boolean; +} +/** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ +interface Formatters { + [formatter: string]: (this: Debugger, v: any) => string; +} +interface Debugger extends Required { + (formatter: any, ...args: any[]): void; + namespace: string; + enabled: boolean; + extend: (namespace: string, delimiter?: string) => Debugger; +} +interface DebugOptions { + useColors?: boolean; + color?: string | number; + formatArgs?: (this: Debugger, diff: number, args: [string, ...any[]]) => void; + formatters?: Formatters; + /** Node.js only */ + inspectOpts?: InspectOptions$1; + /** Humanize a duration in milliseconds */ + humanize?: (value: number) => string; + log?: (this: Debugger, ...args: any[]) => void; +} +//#endregion +//#region src/core.d.ts +/** + * Returns a string of the currently enabled debug namespaces. + */ +declare function namespaces(): string; +/** + * Disable debug output. + */ +declare function disable(): string; +/** + * Returns true if the given mode name is enabled, false otherwise. + */ +declare function enabled(name: string): boolean; +//#endregion +export { Debugger as a, DebugOptions as i, enabled as n, Formatters as o, namespaces as r, InspectOptions$1 as s, disable as t }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.js b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.js new file mode 100644 index 00000000..0828422d --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/core.js @@ -0,0 +1,145 @@ +//#region src/utils.ts +/** +* Coerce `value`. +*/ +function coerce(value) { + if (value instanceof Error) return value.stack || value.message; + return value; +} +/** +* Selects a color for a debug namespace +* @return An ANSI color code for the given namespace +*/ +function selectColor(colors, namespace) { + let hash = 0; + for (let i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; + } + return colors[Math.abs(hash) % colors.length]; +} +/** +* Checks if the given string matches a namespace template, honoring +* asterisks as wildcards. +*/ +function matchesTemplate(search, template) { + let searchIndex = 0; + let templateIndex = 0; + let starIndex = -1; + let matchIndex = 0; + while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) { + if (template[templateIndex] === "*") { + starIndex = templateIndex; + matchIndex = searchIndex; + templateIndex++; + } else { + searchIndex++; + templateIndex++; + } + } else if (starIndex !== -1) { + templateIndex = starIndex + 1; + matchIndex++; + searchIndex = matchIndex; + } else return false; + while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++; + return templateIndex === template.length; +} +function humanize(value) { + if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`; + return `${value}ms`; +} +//#endregion +//#region src/core.ts +let globalNamespaces = ""; +/** +* Returns a string of the currently enabled debug namespaces. +*/ +function namespaces() { + return globalNamespaces; +} +function createDebug(namespace, options) { + let prevTime; + let enableOverride; + let namespacesCache; + let enabledCache; + const debug = ((...args) => { + if (!debug.enabled) return; + const curr = Date.now(); + const diff = curr - (prevTime || curr); + prevTime = curr; + args[0] = coerce(args[0]); + if (typeof args[0] !== "string") args.unshift("%O"); + let index = 0; + args[0] = args[0].replace(/%([a-z%])/gi, (match, format) => { + if (match === "%%") return "%"; + index++; + const formatter = options.formatters[format]; + if (typeof formatter === "function") { + const value = args[index]; + match = formatter.call(debug, value); + args.splice(index, 1); + index--; + } + return match; + }); + options.formatArgs.call(debug, diff, args); + debug.log(...args); + }); + debug.extend = function(namespace, delimiter = ":") { + return createDebug(this.namespace + delimiter + namespace, { + useColors: this.useColors, + color: this.color, + formatArgs: this.formatArgs, + formatters: this.formatters, + inspectOpts: this.inspectOpts, + log: this.log, + humanize: this.humanize + }); + }; + Object.assign(debug, options); + debug.namespace = namespace; + Object.defineProperty(debug, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride != null) return enableOverride; + if (namespacesCache !== globalNamespaces) { + namespacesCache = globalNamespaces; + enabledCache = enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + return debug; +} +let names = []; +let skips = []; +function enable(namespaces) { + globalNamespaces = namespaces; + names = []; + skips = []; + const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean); + for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1)); + else names.push(ns); +} +/** +* Disable debug output. +*/ +function disable() { + const namespaces = [...names, ...skips.map((namespace) => `-${namespace}`)].join(","); + enable(""); + return namespaces; +} +/** +* Returns true if the given mode name is enabled, false otherwise. +*/ +function enabled(name) { + for (const skip of skips) if (matchesTemplate(name, skip)) return false; + for (const ns of names) if (matchesTemplate(name, ns)) return true; + return false; +} +//#endregion +export { namespaces as a, enabled as i, disable as n, humanize as o, enable as r, selectColor as s, createDebug as t }; diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.d.ts b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.d.ts new file mode 100644 index 00000000..48e10c35 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.d.ts @@ -0,0 +1,6 @@ +import { a as Debugger, i as DebugOptions, n as enabled, o as Formatters, r as namespaces, s as InspectOptions, t as disable } from "./core.js"; +import { enable } from "./browser.js"; +//#region src/plain.d.ts +export declare function createDebug(namespace: string, options?: DebugOptions): Debugger; +//#endregion +export { type DebugOptions, type Debugger, type Formatters, type InspectOptions, disable, enable, enabled, namespaces }; \ No newline at end of file diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.js b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.js new file mode 100644 index 00000000..0f537f28 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/dist/plain.js @@ -0,0 +1,8 @@ +import { a as namespaces, i as enabled, n as disable } from "./core.js"; +import { createDebug as createDebug$1, enable } from "./browser.js"; +//#region src/plain.ts +function createDebug(namespace, options) { + return createDebug$1(namespace, Object.assign({}, options, { useColors: false })); +} +//#endregion +export { createDebug, disable, enable, enabled, namespaces }; diff --git a/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/package.json b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/package.json new file mode 100644 index 00000000..b3ea0176 --- /dev/null +++ b/backend/node_modules/.pnpm/obug@2.2.1/node_modules/obug/package.json @@ -0,0 +1,90 @@ +{ + "name": "obug", + "type": "module", + "version": "2.2.1", + "description": "A lightweight JavaScript debugging utility, forked from debug, featuring TypeScript and ESM support.", + "author": "Kevin Deng ", + "license": "MIT", + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "homepage": "https://github.com/sxzz/obug#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/sxzz/obug.git" + }, + "bugs": { + "url": "https://github.com/sxzz/obug/issues" + }, + "sideEffects": false, + "exports": { + ".": { + "workerd": "./dist/plain.js", + "edge-light": "./dist/plain.js", + "fastly": "./dist/plain.js", + "browser": "./dist/browser.js", + "react-native": "./dist/plain.js", + "node": "./dist/ansi.js", + "default": "./dist/browser.js" + }, + "./ansi": "./dist/ansi.js", + "./browser": "./dist/browser.js", + "./plain": "./dist/plain.js", + "./package.json": "./package.json" + }, + "main": "./dist/ansi.js", + "module": "./dist/ansi.js", + "unpkg": "./dist/browser.min.js", + "jsdelivr": "./dist/browser.min.js", + "react-native": "./dist/plain.js", + "types": "./dist/browser.d.ts", + "files": [ + "dist" + ], + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=12.20.0" + }, + "devEngines": { + "packageManager": { + "name": "pnpm", + "version": "12.3.4", + "onFail": "download" + } + }, + "devDependencies": { + "@sxzz/eslint-config": "^8.6.0", + "@sxzz/prettier-config": "^2.3.2", + "@types/debug": "^4.1.13", + "@types/node": "^26.5.0", + "@typescript/native-preview": "7.0.0-dev.20260707.2", + "@vitest/browser-playwright": "^5.0.0", + "@vitest/coverage-v8": "^5.0.0", + "bumpp": "^12.3.0", + "debug": "^4.4.3", + "eslint": "^10.10.0", + "playwright": "^1.63.0", + "prettier": "^3.9.6", + "tsdown": "^0.23.0", + "typescript": "^6.0.3", + "vite": "^8.2.2", + "vitest": "^5.0.0" + }, + "prettier": "@sxzz/prettier-config", + "scripts": { + "lint": "eslint --cache .", + "lint:fix": "pnpm run lint --fix", + "build": "tsdown", + "size": "node scripts/bundle-size.ts", + "dev": "tsdown --watch", + "test": "vitest", + "test:coverage": "vitest --project node --coverage", + "play": "vite playground", + "typecheck": "tsgo --noEmit", + "format": "prettier --cache --write .", + "release": "bumpp" + } +} \ No newline at end of file diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/LICENSE b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/LICENSE new file mode 100644 index 00000000..46c9b95d --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/README.md b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/README.md new file mode 100644 index 00000000..8e47aa8e --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/README.md @@ -0,0 +1,21 @@ +# picocolors + +The tiniest and the fastest library for terminal output formatting with ANSI colors. + +```javascript +import pc from "picocolors" + +console.log( + pc.green(`How are ${pc.italic(`you`)} doing?`) +) +``` + +- **No dependencies.** +- **14 times** smaller and **2 times** faster than chalk. +- Used by popular tools like PostCSS, SVGO, Stylelint, and Browserslist. +- Node.js v6+ & browsers support. Support for both CJS and ESM projects. +- TypeScript type declarations included. +- [`NO_COLOR`](https://no-color.org/) friendly. + +## Docs +Read **[full docs](https://github.com/alexeyraspopov/picocolors#readme)** on GitHub. diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/package.json b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/package.json new file mode 100644 index 00000000..372d4b64 --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/package.json @@ -0,0 +1,25 @@ +{ + "name": "picocolors", + "version": "1.1.1", + "main": "./picocolors.js", + "types": "./picocolors.d.ts", + "browser": { + "./picocolors.js": "./picocolors.browser.js" + }, + "sideEffects": false, + "description": "The tiniest and the fastest library for terminal output formatting with ANSI colors", + "files": [ + "picocolors.*", + "types.d.ts" + ], + "keywords": [ + "terminal", + "colors", + "formatting", + "cli", + "console" + ], + "author": "Alexey Raspopov", + "repository": "alexeyraspopov/picocolors", + "license": "ISC" +} diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js new file mode 100644 index 00000000..9dcf637c --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js @@ -0,0 +1,4 @@ +var x=String; +var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}}; +module.exports=create(); +module.exports.createColors = create; diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.d.ts b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.d.ts new file mode 100644 index 00000000..94e146a8 --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.d.ts @@ -0,0 +1,5 @@ +import { Colors } from "./types" + +declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors } + +export = picocolors diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js new file mode 100644 index 00000000..e32df854 --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js @@ -0,0 +1,75 @@ +let p = process || {}, argv = p.argv || [], env = p.env || {} +let isColorSupported = + !(!!env.NO_COLOR || argv.includes("--no-color")) && + (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI) + +let formatter = (open, close, replace = open) => + input => { + let string = "" + input, index = string.indexOf(close, open.length) + return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close + } + +let replaceClose = (string, close, replace, index) => { + let result = "", cursor = 0 + do { + result += string.substring(cursor, index) + replace + cursor = index + close.length + index = string.indexOf(close, cursor) + } while (~index) + return result + string.substring(cursor) +} + +let createColors = (enabled = isColorSupported) => { + let f = enabled ? formatter : () => String + return { + isColorSupported: enabled, + reset: f("\x1b[0m", "\x1b[0m"), + bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"), + dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"), + italic: f("\x1b[3m", "\x1b[23m"), + underline: f("\x1b[4m", "\x1b[24m"), + inverse: f("\x1b[7m", "\x1b[27m"), + hidden: f("\x1b[8m", "\x1b[28m"), + strikethrough: f("\x1b[9m", "\x1b[29m"), + + black: f("\x1b[30m", "\x1b[39m"), + red: f("\x1b[31m", "\x1b[39m"), + green: f("\x1b[32m", "\x1b[39m"), + yellow: f("\x1b[33m", "\x1b[39m"), + blue: f("\x1b[34m", "\x1b[39m"), + magenta: f("\x1b[35m", "\x1b[39m"), + cyan: f("\x1b[36m", "\x1b[39m"), + white: f("\x1b[37m", "\x1b[39m"), + gray: f("\x1b[90m", "\x1b[39m"), + + bgBlack: f("\x1b[40m", "\x1b[49m"), + bgRed: f("\x1b[41m", "\x1b[49m"), + bgGreen: f("\x1b[42m", "\x1b[49m"), + bgYellow: f("\x1b[43m", "\x1b[49m"), + bgBlue: f("\x1b[44m", "\x1b[49m"), + bgMagenta: f("\x1b[45m", "\x1b[49m"), + bgCyan: f("\x1b[46m", "\x1b[49m"), + bgWhite: f("\x1b[47m", "\x1b[49m"), + + blackBright: f("\x1b[90m", "\x1b[39m"), + redBright: f("\x1b[91m", "\x1b[39m"), + greenBright: f("\x1b[92m", "\x1b[39m"), + yellowBright: f("\x1b[93m", "\x1b[39m"), + blueBright: f("\x1b[94m", "\x1b[39m"), + magentaBright: f("\x1b[95m", "\x1b[39m"), + cyanBright: f("\x1b[96m", "\x1b[39m"), + whiteBright: f("\x1b[97m", "\x1b[39m"), + + bgBlackBright: f("\x1b[100m", "\x1b[49m"), + bgRedBright: f("\x1b[101m", "\x1b[49m"), + bgGreenBright: f("\x1b[102m", "\x1b[49m"), + bgYellowBright: f("\x1b[103m", "\x1b[49m"), + bgBlueBright: f("\x1b[104m", "\x1b[49m"), + bgMagentaBright: f("\x1b[105m", "\x1b[49m"), + bgCyanBright: f("\x1b[106m", "\x1b[49m"), + bgWhiteBright: f("\x1b[107m", "\x1b[49m"), + } +} + +module.exports = createColors() +module.exports.createColors = createColors diff --git a/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/types.d.ts b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/types.d.ts new file mode 100644 index 00000000..cd1aec46 --- /dev/null +++ b/backend/node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/types.d.ts @@ -0,0 +1,51 @@ +export type Formatter = (input: string | number | null | undefined) => string + +export interface Colors { + isColorSupported: boolean + + reset: Formatter + bold: Formatter + dim: Formatter + italic: Formatter + underline: Formatter + inverse: Formatter + hidden: Formatter + strikethrough: Formatter + + black: Formatter + red: Formatter + green: Formatter + yellow: Formatter + blue: Formatter + magenta: Formatter + cyan: Formatter + white: Formatter + gray: Formatter + + bgBlack: Formatter + bgRed: Formatter + bgGreen: Formatter + bgYellow: Formatter + bgBlue: Formatter + bgMagenta: Formatter + bgCyan: Formatter + bgWhite: Formatter + + blackBright: Formatter + redBright: Formatter + greenBright: Formatter + yellowBright: Formatter + blueBright: Formatter + magentaBright: Formatter + cyanBright: Formatter + whiteBright: Formatter + + bgBlackBright: Formatter + bgRedBright: Formatter + bgGreenBright: Formatter + bgYellowBright: Formatter + bgBlueBright: Formatter + bgMagentaBright: Formatter + bgCyanBright: Formatter + bgWhiteBright: Formatter +} diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/nanoid b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/nanoid new file mode 120000 index 00000000..52f16d9c --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/nanoid @@ -0,0 +1 @@ +../../nanoid@3.3.19/node_modules/nanoid \ No newline at end of file diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/picocolors b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/picocolors new file mode 120000 index 00000000..e301a8d8 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/picocolors @@ -0,0 +1 @@ +../../picocolors@1.1.1/node_modules/picocolors \ No newline at end of file diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/LICENSE b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/LICENSE new file mode 100644 index 00000000..c2314d53 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright 2013 Andrey Sitnik + +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/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/README.md b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/README.md new file mode 100644 index 00000000..6c8de01f --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/README.md @@ -0,0 +1,27 @@ +# PostCSS + +Philosopher’s stone, logo of PostCSS + +PostCSS is a tool for transforming styles with JS plugins. +These plugins can lint your CSS, support variables and mixins, +transpile future CSS syntax, inline images, and more. + +PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba, +and JetBrains. The [Autoprefixer] and [Stylelint] PostCSS plugins are some of the most popular CSS tools. + +--- + +  PostCSS is built by Evil Martians, an American design and engineering consultancy for developer tools, AI, and cybersecurity startups. + +--- + +[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree +[Evil Martians]: https://evilmartians.com/?utm_source=postcss +[Autoprefixer]: https://github.com/postcss/autoprefixer +[Stylelint]: https://stylelint.io/ +[plugins]: https://github.com/postcss/postcss#plugins + +## Docs +Read full docs **[here](https://postcss.org/)**. diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.d.ts new file mode 100644 index 00000000..703e3999 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.d.ts @@ -0,0 +1,139 @@ +import Container, { + ContainerProps, + ContainerWithChildren +} from './container.js' + +declare namespace AtRule { + export interface AtRuleRaws extends Record { + /** + * The space symbols after the last child of the node to the end of the node. + */ + after?: string + + /** + * The space between the at-rule name and its parameters. + */ + afterName?: string + + /** + * The space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + */ + before?: string + + /** + * The symbols between the last parameter and `{` for rules. + */ + between?: string + + /** + * The rule’s selector with comments. + */ + params?: { + raw: string + value: string + } + + /** + * Contains `true` if the last child has an (optional) semicolon. + */ + semicolon?: boolean + } + + export interface AtRuleProps extends ContainerProps { + /** Name of the at-rule. */ + name: string + /** Parameters following the name of the at-rule. */ + params?: number | string + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: AtRuleRaws + } + + export { AtRule_ as default } +} + +/** + * Represents an at-rule. + * + * ```js + * Once (root, { AtRule }) { + * let media = new AtRule({ name: 'media', params: 'print' }) + * media.append(…) + * root.append(media) + * } + * ``` + * + * If it’s followed in the CSS by a `{}` block, this node will have + * a nodes property representing its children. + * + * ```js + * const root = postcss.parse('@charset "UTF-8"; @media print {}') + * + * const charset = root.first + * charset.type //=> 'atrule' + * charset.nodes //=> undefined + * + * const media = root.last + * media.nodes //=> [] + * ``` + */ +declare class AtRule_ extends Container { + /** + * An array containing the layer’s children. + * + * ```js + * const root = postcss.parse('@layer example { a { color: black } }') + * const layer = root.first + * layer.nodes.length //=> 1 + * layer.nodes[0].selector //=> 'a' + * ``` + * + * Can be `undefinded` if the at-rule has no body. + * + * ```js + * const root = postcss.parse('@layer a, b, c;') + * const layer = root.first + * layer.nodes //=> undefined + * ``` + */ + nodes: Container['nodes'] | undefined + parent: ContainerWithChildren | undefined + + raws: AtRule.AtRuleRaws + type: 'atrule' + /** + * The at-rule’s name immediately follows the `@`. + * + * ```js + * const root = postcss.parse('@media print {}') + * const media = root.first + * media.name //=> 'media' + * ``` + */ + get name(): string + set name(value: string) + + /** + * The at-rule’s parameters, the values that follow the at-rule’s name + * but precede any `{}` block. + * + * ```js + * const root = postcss.parse('@media print, screen {}') + * const media = root.first + * media.params //=> 'print, screen' + * ``` + */ + get params(): string + + set params(value: string) + + constructor(defaults?: AtRule.AtRuleProps) + assign(overrides: AtRule.AtRuleProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class AtRule extends AtRule_ {} + +export = AtRule diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.js new file mode 100644 index 00000000..9486447b --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.js @@ -0,0 +1,25 @@ +'use strict' + +let Container = require('./container') + +class AtRule extends Container { + constructor(defaults) { + super(defaults) + this.type = 'atrule' + } + + append(...children) { + if (!this.proxyOf.nodes) this.nodes = [] + return super.append(...children) + } + + prepend(...children) { + if (!this.proxyOf.nodes) this.nodes = [] + return super.prepend(...children) + } +} + +module.exports = AtRule +AtRule.default = AtRule + +Container.registerAtRule(AtRule) diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.d.ts new file mode 100644 index 00000000..f764109b --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.d.ts @@ -0,0 +1,67 @@ +import Container from './container.js' +import Node, { NodeProps } from './node.js' + +declare namespace Comment { + export interface CommentRaws extends Record { + /** + * The space symbols before the node. + */ + before?: string + + /** + * The space symbols between `/*` and the comment’s text. + */ + left?: string + + /** + * The space symbols between the comment’s text. + */ + right?: string + } + + export interface CommentProps extends NodeProps { + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: CommentRaws + /** Content of the comment. */ + text: string + } + + export { Comment_ as default } +} + +/** + * It represents a class that handles + * [CSS comments](https://developer.mozilla.org/en-US/docs/Web/CSS/Comments) + * + * ```js + * Once (root, { Comment }) { + * const note = new Comment({ text: 'Note: …' }) + * root.append(note) + * } + * ``` + * + * Remember that CSS comments inside selectors, at-rule parameters, + * or declaration values will be stored in the `raws` properties + * explained above. + */ +declare class Comment_ extends Node { + parent: Container | undefined + raws: Comment.CommentRaws + type: 'comment' + /** + * The comment's text. + */ + get text(): string + + set text(value: string) + + constructor(defaults?: Comment.CommentProps) + assign(overrides: Comment.CommentProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class Comment extends Comment_ {} + +export = Comment diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.js new file mode 100644 index 00000000..c5665064 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.js @@ -0,0 +1,13 @@ +'use strict' + +let Node = require('./node') + +class Comment extends Node { + constructor(defaults) { + super(defaults) + this.type = 'comment' + } +} + +module.exports = Comment +Comment.default = Comment diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.d.ts new file mode 100644 index 00000000..a2edcdad --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.d.ts @@ -0,0 +1,474 @@ +import AtRule from './at-rule.js' +import Comment from './comment.js' +import Declaration from './declaration.js' +import Node, { ChildNode, ChildProps, NodeProps } from './node.js' +import { Root } from './postcss.js' +import Rule from './rule.js' + +declare namespace Container { + export type ContainerWithChildren = { + nodes: Child[] + } & (AtRule | Root | Rule) + + export interface ValueOptions { + /** + * String that’s used to narrow down values and speed up the regexp search. + */ + fast?: string + + /** + * An array of property names. + */ + props?: readonly string[] + } + + export interface ContainerProps extends NodeProps { + nodes?: readonly (ChildProps | Node)[] + } + + /** + * All types that can be passed into container methods to create or add a new + * child node. + */ + export type NewChild = + | ChildProps + | Node + | readonly ChildProps[] + | readonly Node[] + | readonly string[] + | string + | undefined + + export { Container_ as default } +} + +/** + * The `Root`, `AtRule`, and `Rule` container nodes + * inherit some common methods to help work with their children. + * + * Note that all containers can store any content. If you write a rule inside + * a rule, PostCSS will parse it. + */ +declare abstract class Container_ extends Node { + /** + * An array containing the container’s children. + * + * ```js + * const root = postcss.parse('a { color: black }') + * root.nodes.length //=> 1 + * root.nodes[0].selector //=> 'a' + * root.nodes[0].nodes[0].prop //=> 'color' + * ``` + */ + nodes: Child[] | undefined + + /** + * The container’s first child. + * + * ```js + * rule.first === rules.nodes[0] + * ``` + */ + get first(): Child | undefined + + /** + * The container’s last child. + * + * ```js + * rule.last === rule.nodes[rule.nodes.length - 1] + * ``` + */ + get last(): Child | undefined + /** + * Inserts new nodes to the end of the container. + * + * ```js + * const decl1 = new Declaration({ prop: 'color', value: 'black' }) + * const decl2 = new Declaration({ prop: 'background-color', value: 'white' }) + * rule.append(decl1, decl2) + * + * root.append({ name: 'charset', params: '"UTF-8"' }) // at-rule + * root.append({ selector: 'a' }) // rule + * rule.append({ prop: 'color', value: 'black' }) // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}') + * root.first.append('color: black; z-index: 1') + * ``` + * + * @param nodes New nodes. + * @return This node for methods chain. + */ + append(...nodes: Container.NewChild[]): this + assign(overrides: Container.ContainerProps | object): this + clone(overrides?: Partial): this + + cloneAfter(overrides?: Partial): this + + cloneBefore(overrides?: Partial): this + /** + * Iterates through the container’s immediate children, + * calling `callback` for each child. + * + * Returning `false` in the callback will break iteration. + * + * This method only iterates through the container’s immediate children. + * If you need to recursively iterate through all the container’s descendant + * nodes, use `Container#walk`. + * + * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe + * if you are mutating the array of child nodes during iteration. + * PostCSS will adjust the current index to match the mutations. + * + * ```js + * const root = postcss.parse('a { color: black; z-index: 1 }') + * const rule = root.first + * + * for (const decl of rule.nodes) { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }) + * // Cycle will be infinite, because cloneBefore moves the current node + * // to the next index + * } + * + * rule.each(decl => { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }) + * // Will be executed only for color and z-index + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + each( + callback: (node: Child, index: number) => false | void + ): false | undefined + + /** + * Returns `true` if callback returns `true` + * for all of the container’s children. + * + * ```js + * const noPrefixes = rule.every(i => i.prop[0] !== '-') + * ``` + * + * @param condition Iterator returns true or false. + * @return Is every child pass condition. + */ + every( + condition: (node: Child, index: number, nodes: Child[]) => boolean + ): boolean + /** + * Returns a `child`’s index within the `Container#nodes` array. + * + * ```js + * rule.index( rule.nodes[2] ) //=> 2 + * ``` + * + * @param child Child of the current container. + * @return Child index. + */ + index(child: Child | number): number + + /** + * Insert new node after old node within the container. + * + * @param oldNode Child or child’s index. + * @param newNode New node. + * @return This node for methods chain. + */ + insertAfter(oldNode: Child | number, newNode: Container.NewChild): this + + /** + * Insert new node before old node within the container. + * + * ```js + * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop })) + * ``` + * + * @param oldNode Child or child’s index. + * @param newNode New node. + * @return This node for methods chain. + */ + insertBefore(oldNode: Child | number, newNode: Container.NewChild): this + /** + * Inserts new nodes to the start of the container. + * + * ```js + * const decl1 = new Declaration({ prop: 'color', value: 'black' }) + * const decl2 = new Declaration({ prop: 'background-color', value: 'white' }) + * rule.prepend(decl1, decl2) + * + * root.append({ name: 'charset', params: '"UTF-8"' }) // at-rule + * root.append({ selector: 'a' }) // rule + * rule.append({ prop: 'color', value: 'black' }) // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}') + * root.first.append('color: black; z-index: 1') + * ``` + * + * @param nodes New nodes. + * @return This node for methods chain. + */ + prepend(...nodes: Container.NewChild[]): this + + /** + * Add child to the end of the node. + * + * ```js + * rule.push(new Declaration({ prop: 'color', value: 'black' })) + * ``` + * + * @param child New node. + * @return This node for methods chain. + */ + push(child: Child): this + + /** + * Removes all children from the container + * and cleans their parent properties. + * + * ```js + * rule.removeAll() + * rule.nodes.length //=> 0 + * ``` + * + * @return This node for methods chain. + */ + removeAll(): this + + /** + * Removes node from the container and cleans the parent properties + * from the node and its children. + * + * ```js + * rule.nodes.length //=> 5 + * rule.removeChild(decl) + * rule.nodes.length //=> 4 + * decl.parent //=> undefined + * ``` + * + * @param child Child or child’s index. + * @return This node for methods chain. + */ + removeChild(child: Child | number): this + + replaceValues( + pattern: RegExp | string, + replaced: { (substring: string, ...args: any[]): string } | string + ): this + /** + * Passes all declaration values within the container that match pattern + * through callback, replacing those values with the returned result + * of callback. + * + * This method is useful if you are using a custom unit or function + * and need to iterate through all values. + * + * ```js + * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => { + * return 15 * parseInt(string) + 'px' + * }) + * ``` + * + * @param pattern Replace pattern. + * @param {object} options Options to speed up the search. + * @param replaced String to replace pattern or callback + * that returns a new value. The callback + * will receive the same arguments + * as those passed to a function parameter + * of `String#replace`. + * @return This node for methods chain. + */ + replaceValues( + pattern: RegExp | string, + options: Container.ValueOptions, + replaced: { (substring: string, ...args: any[]): string } | string + ): this + + /** + * Returns `true` if callback returns `true` for (at least) one + * of the container’s children. + * + * ```js + * const hasPrefix = rule.some(i => i.prop[0] === '-') + * ``` + * + * @param condition Iterator returns true or false. + * @return Is some child pass condition. + */ + some( + condition: (node: Child, index: number, nodes: Child[]) => boolean + ): boolean + + /** + * Traverses the container’s descendant nodes, calling callback + * for each node. + * + * Like container.each(), this method is safe to use + * if you are mutating arrays during iteration. + * + * If you only need to iterate through the container’s immediate children, + * use `Container#each`. + * + * ```js + * root.walk(node => { + * // Traverses all descendant nodes. + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walk( + callback: (node: ChildNode, index: number) => false | void + ): false | undefined + + /** + * Traverses the container’s descendant nodes, calling callback + * for each at-rule node. + * + * If you pass a filter, iteration will only happen over at-rules + * that have matching names. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * root.walkAtRules(rule => { + * if (isOld(rule.name)) rule.remove() + * }) + * + * let first = false + * root.walkAtRules('charset', rule => { + * if (!first) { + * first = true + * } else { + * rule.remove() + * } + * }) + * ``` + * + * @param name String or regular expression to filter at-rules by name. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkAtRules( + nameFilter: RegExp | string, + callback: (atRule: AtRule, index: number) => false | void + ): false | undefined + walkAtRules( + callback: (atRule: AtRule, index: number) => false | void + ): false | undefined + + /** + * Traverses the container’s descendant nodes, calling callback + * for each comment node. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * root.walkComments(comment => { + * comment.remove() + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkComments( + callback: (comment: Comment, indexed: number) => false | void + ): false | undefined + + /** + * Traverses the container’s descendant nodes, calling callback + * for each declaration node. + * + * If you pass a filter, iteration will only happen over declarations + * with matching properties. + * + * ```js + * root.walkDecls(decl => { + * checkPropertySupport(decl.prop) + * }) + * + * root.walkDecls('border-radius', decl => { + * decl.remove() + * }) + * + * root.walkDecls(/^background/, decl => { + * decl.value = takeFirstColorFromGradient(decl.value) + * }) + * ``` + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param prop String or regular expression to filter declarations + * by property name. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkDecls( + propFilter: RegExp | string, + callback: (decl: Declaration, index: number) => false | void + ): false | undefined + walkDecls( + callback: (decl: Declaration, index: number) => false | void + ): false | undefined + /** + * Traverses the container’s descendant nodes, calling callback + * for each rule node. + * + * If you pass a filter, iteration will only happen over rules + * with matching selectors. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * const selectors = [] + * root.walkRules(rule => { + * selectors.push(rule.selector) + * }) + * console.log(`Your CSS uses ${ selectors.length } selectors`) + * ``` + * + * @param selector String or regular expression to filter rules by selector. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkRules( + selectorFilter: RegExp | string, + callback: (rule: Rule, index: number) => false | void + ): false | undefined + walkRules( + callback: (rule: Rule, index: number) => false | void + ): false | undefined + /** + * An internal method that converts a {@link NewChild} into a list of actual + * child nodes that can then be added to this container. + * + * This ensures that the nodes' parent is set to this container, that they use + * the correct prototype chain, and that they're marked as dirty. + * + * @param mnodes The new node or nodes to add. + * @param sample A node from whose raws the new node's `before` raw should be + * taken. + * @param type This should be set to `'prepend'` if the new nodes will be + * inserted at the beginning of the container. + * @hidden + */ + protected normalize( + nodes: Container.NewChild, + sample: Node | undefined, + type?: 'prepend' | false + ): Child[] +} + +declare class Container< + Child extends Node = ChildNode +> extends Container_ {} + +export = Container diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.js new file mode 100644 index 00000000..cd3b65b6 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.js @@ -0,0 +1,494 @@ +'use strict' + +let Comment = require('./comment') +let Declaration = require('./declaration') +let Node = require('./node') +let { isClean, my } = require('./symbols') + +let AtRule, parse, Root, Rule + +function cleanSource(nodes) { + let stack = nodes.slice() + while (stack.length > 0) { + let node = stack.pop() + delete node.source + if (node.nodes) { + node.nodes = node.nodes.slice() + for (let i of node.nodes) stack.push(i) + } + } + return nodes.slice() +} + +function markTreeDirty(node) { + let stack = [node] + while (stack.length > 0) { + let next = stack.pop() + next[isClean] = false + if (next.proxyOf.nodes) { + for (let i of next.proxyOf.nodes) stack.push(i) + } + } +} + +class Container extends Node { + get first() { + if (!this.proxyOf.nodes) return undefined + return this.proxyOf.nodes[0] + } + + get last() { + if (!this.proxyOf.nodes) return undefined + return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] + } + + append(...children) { + for (let child of children) { + let nodes = this.normalize(child, this.last) + for (let node of nodes) this.proxyOf.nodes.push(node) + } + + this.markDirty() + + return this + } + + cleanRaws(keepBetween) { + let stack = [this] + while (stack.length > 0) { + let node = stack.pop() + if (node !== this && node.cleanRaws !== Container.prototype.cleanRaws) { + // Subclass with own logic; let it handle its subtree + node.cleanRaws(keepBetween) + continue + } + Node.prototype.cleanRaws.call(node, keepBetween) + if (node.nodes) { + for (let child of node.nodes) stack.push(child) + } + } + } + + each(callback) { + if (!this.proxyOf.nodes) return undefined + let iterator = this.getIterator() + + let index, result + while (this.indexes[iterator] < this.proxyOf.nodes.length) { + index = this.indexes[iterator] + result = callback(this.proxyOf.nodes[index], index) + if (result === false) break + + this.indexes[iterator] += 1 + } + + delete this.indexes[iterator] + return result + } + + every(condition) { + return this.nodes.every(condition) + } + + getIterator() { + if (!this.lastEach) this.lastEach = 0 + if (!this.indexes) this.indexes = {} + + this.lastEach += 1 + let iterator = this.lastEach + this.indexes[iterator] = 0 + + return iterator + } + + getProxyProcessor() { + return { + get(node, prop) { + if (prop === 'proxyOf') { + return node + } else if (!node[prop]) { + return node[prop] + } else if ( + prop === 'each' || + (typeof prop === 'string' && prop.startsWith('walk')) + ) { + return (...args) => { + return node[prop]( + ...args.map(i => { + if (typeof i === 'function') { + return (child, index) => i(child.toProxy(), index) + } else { + return i + } + }) + ) + } + } else if (prop === 'every' || prop === 'some') { + return cb => { + return node[prop]((child, ...other) => + cb(child.toProxy(), ...other) + ) + } + } else if (prop === 'root') { + return () => node.root().toProxy() + } else if (prop === 'nodes') { + return node.nodes.map(i => i.toProxy()) + } else if (prop === 'first' || prop === 'last') { + return node[prop].toProxy() + } else { + return node[prop] + } + }, + + set(node, prop, value) { + if (node[prop] === value) return true + node[prop] = value + if (prop === 'name' || prop === 'params' || prop === 'selector') { + node.markDirty() + } + return true + } + } + } + + index(child) { + if (typeof child === 'number') return child + if (child.proxyOf) child = child.proxyOf + return this.proxyOf.nodes.indexOf(child) + } + + insertAfter(exist, add) { + let existIndex = this.index(exist) + let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse() + existIndex = this.index(exist) + for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (existIndex < index) { + this.indexes[id] = index + nodes.length + } + } + + this.markDirty() + + return this + } + + insertBefore(exist, add) { + let existIndex = this.index(exist) + let type = existIndex === 0 ? 'prepend' : false + let nodes = this.normalize( + add, + this.proxyOf.nodes[existIndex], + type + ).reverse() + existIndex = this.index(exist) + for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (existIndex <= index) { + this.indexes[id] = index + nodes.length + } + } + + this.markDirty() + + return this + } + + normalize(nodes, sample) { + if (typeof nodes === 'string') { + nodes = cleanSource(parse(nodes).nodes) + } else if (typeof nodes === 'undefined') { + nodes = [] + } else if (Array.isArray(nodes)) { + nodes = nodes.slice(0) + for (let i of nodes) { + if (i.parent) i.parent.removeChild(i, 'ignore') + } + } else if (nodes.type === 'root' && this.type !== 'document') { + nodes = nodes.nodes.slice(0) + for (let i of nodes) { + if (i.parent) i.parent.removeChild(i, 'ignore') + } + } else if (nodes.type) { + nodes = [nodes] + } else if (nodes.prop) { + if (typeof nodes.value === 'undefined') { + throw new Error('Value field is missed in node creation') + } else if (typeof nodes.value !== 'string') { + nodes.value = String(nodes.value) + } + nodes = [new Declaration(nodes)] + } else if (nodes.selector || nodes.selectors) { + nodes = [new Rule(nodes)] + } else if (nodes.name) { + nodes = [new AtRule(nodes)] + } else if (nodes.text) { + nodes = [new Comment(nodes)] + } else { + throw new Error('Unknown node type in node creation') + } + + let processed = nodes.map(i => { + /* c8 ignore next */ + if (!i[my]) Container.rebuild(i) + i = i.proxyOf + if (i.parent) i.parent.removeChild(i) + if (i[isClean]) markTreeDirty(i) + + if (!i.raws) i.raws = {} + if (typeof i.raws.before === 'undefined') { + if (sample && typeof sample.raws.before !== 'undefined') { + i.raws.before = sample.raws.before.replace(/\S/g, '') + } + } + i.parent = this.proxyOf + return i + }) + + return processed + } + + prepend(...children) { + children = children.reverse() + for (let child of children) { + let nodes = this.normalize(child, this.first, 'prepend').reverse() + for (let node of nodes) this.proxyOf.nodes.unshift(node) + for (let id in this.indexes) { + this.indexes[id] = this.indexes[id] + nodes.length + } + } + + this.markDirty() + + return this + } + + push(child) { + child.parent = this + this.proxyOf.nodes.push(child) + return this + } + + removeAll() { + for (let node of this.proxyOf.nodes) node.parent = undefined + this.proxyOf.nodes = [] + + this.markDirty() + + return this + } + + removeChild(child) { + child = this.index(child) + this.proxyOf.nodes[child].parent = undefined + this.proxyOf.nodes.splice(child, 1) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (index >= child) { + this.indexes[id] = index - 1 + } + } + + this.markDirty() + + return this + } + + replaceValues(pattern, opts, callback) { + if (!callback) { + callback = opts + opts = {} + } + + this.walkDecls(decl => { + if (opts.props && !opts.props.includes(decl.prop)) return + if (opts.fast && !decl.value.includes(opts.fast)) return + + decl.value = decl.value.replace(pattern, callback) + }) + + this.markDirty() + + return this + } + + some(condition) { + return this.nodes.some(condition) + } + + walk(callback) { + if (!this.proxyOf.nodes) return undefined + + // An explicit stack instead of recursive `each()` calls to survive + // deeply nested trees. Each frame keeps a live `indexes` slot, so + // insertion and removal during the walk behave like `each()`: the + // slot stays at the current child until its subtree is finished. + let stack = [{ iterator: this.getIterator(), node: this.proxyOf }] + + while (stack.length > 0) { + let { iterator, node } = stack[stack.length - 1] + let index = node.indexes[iterator] + + if (index >= node.proxyOf.nodes.length) { + delete node.indexes[iterator] + stack.pop() + let parent = stack[stack.length - 1] + // Finish the parent’s step for the child subtree we just left + if (parent) parent.node.indexes[parent.iterator] += 1 + continue + } + + let child = node.proxyOf.nodes[index] + let result + try { + result = callback(child, index) + } catch (e) { + throw child.addToError(e) + } + if (result === false) { + for (let opened of stack) { + delete opened.node.indexes[opened.iterator] + } + return false + } + if (child.walk && child.proxyOf.nodes) { + stack.push({ iterator: child.getIterator(), node: child }) + } else { + node.indexes[iterator] += 1 + } + } + + return undefined + } + + walkAtRules(name, callback) { + if (!callback) { + callback = name + return this.walk((child, i) => { + if (child.type === 'atrule') { + return callback(child, i) + } + }) + } + if (name instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'atrule' && name.test(child.name)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'atrule' && child.name === name) { + return callback(child, i) + } + }) + } + + walkComments(callback) { + return this.walk((child, i) => { + if (child.type === 'comment') { + return callback(child, i) + } + }) + } + + walkDecls(prop, callback) { + if (!callback) { + callback = prop + return this.walk((child, i) => { + if (child.type === 'decl') { + return callback(child, i) + } + }) + } + if (prop instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'decl' && prop.test(child.prop)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'decl' && child.prop === prop) { + return callback(child, i) + } + }) + } + + walkRules(selector, callback) { + if (!callback) { + callback = selector + + return this.walk((child, i) => { + if (child.type === 'rule') { + return callback(child, i) + } + }) + } + if (selector instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'rule' && selector.test(child.selector)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'rule' && child.selector === selector) { + return callback(child, i) + } + }) + } +} + +Container.registerParse = dependant => { + parse = dependant +} + +Container.registerRule = dependant => { + Rule = dependant +} + +Container.registerAtRule = dependant => { + AtRule = dependant +} + +Container.registerRoot = dependant => { + Root = dependant +} + +module.exports = Container +Container.default = Container + +/* c8 ignore start */ +Container.rebuild = node => { + let stack = [node] + while (stack.length > 0) { + let next = stack.pop() + if (next.type === 'atrule') { + Object.setPrototypeOf(next, AtRule.prototype) + } else if (next.type === 'rule') { + Object.setPrototypeOf(next, Rule.prototype) + } else if (next.type === 'decl') { + Object.setPrototypeOf(next, Declaration.prototype) + } else if (next.type === 'comment') { + Object.setPrototypeOf(next, Comment.prototype) + } else if (next.type === 'root') { + Object.setPrototypeOf(next, Root.prototype) + } + + next[my] = true + + if (next.nodes) { + for (let child of next.nodes) stack.push(child) + } + } +} +/* c8 ignore stop */ diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.d.ts new file mode 100644 index 00000000..03d9ed17 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.d.ts @@ -0,0 +1,247 @@ +import { FilePosition } from './input.js' + +declare namespace CssSyntaxError { + /** + * A position that is part of a range. + */ + export interface RangePosition { + /** + * The column number in the input. + */ + column: number + + /** + * The line number in the input. + */ + line: number + } + + export { CssSyntaxError_ as default } +} + +/** + * The CSS parser throws this error for broken CSS. + * + * Custom parsers can throw this error for broken custom syntax using + * the `Node#error` method. + * + * PostCSS will use the input source map to detect the original error location. + * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS, + * PostCSS will show the original position in the Sass file. + * + * If you need the position in the PostCSS input + * (e.g., to debug the previous compiler), use `error.input.file`. + * + * ```js + * // Raising error from plugin + * throw node.error('Unknown variable', { plugin: 'postcss-vars' }) + * ``` + * + * ```js + * // Catching and checking syntax error + * try { + * postcss.parse('a{') + * } catch (error) { + * if (error.name === 'CssSyntaxError') { + * error //=> CssSyntaxError + * } + * } + * ``` + */ +declare class CssSyntaxError_ extends Error { + /** + * Source column of the error. + * + * ```js + * error.column //=> 1 + * error.input.column //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.column`. + */ + column?: number + + /** + * Source column of the error's end, exclusive. Provided if the error pertains + * to a range. + * + * ```js + * error.endColumn //=> 1 + * error.input.endColumn //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.endColumn`. + */ + endColumn?: number + + /** + * Source line of the error's end, exclusive. Provided if the error pertains + * to a range. + * + * ```js + * error.endLine //=> 3 + * error.input.endLine //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.endLine`. + */ + endLine?: number + + /** + * Absolute path to the broken file. + * + * ```js + * error.file //=> 'a.sass' + * error.input.file //=> 'a.css' + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.file`. + */ + file?: string + + /** + * Input object with PostCSS internal information + * about input file. If input has source map + * from previous tool, PostCSS will use origin + * (for example, Sass) source. You can use this + * object to get PostCSS input source. + * + * ```js + * error.input.file //=> 'a.css' + * error.file //=> 'a.sass' + * ``` + */ + input?: FilePosition + + /** + * Source line of the error. + * + * ```js + * error.line //=> 2 + * error.input.line //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.line`. + */ + line?: number + + /** + * Full error text in the GNU error format + * with plugin, file, line and column. + * + * ```js + * error.message //=> 'a.css:1:1: Unclosed block' + * ``` + */ + message: string + + /** + * Always equal to `'CssSyntaxError'`. You should always check error type + * by `error.name === 'CssSyntaxError'` + * instead of `error instanceof CssSyntaxError`, + * because npm could have several PostCSS versions. + * + * ```js + * if (error.name === 'CssSyntaxError') { + * error //=> CssSyntaxError + * } + * ``` + */ + name: 'CssSyntaxError' + + /** + * Plugin name, if error came from plugin. + * + * ```js + * error.plugin //=> 'postcss-vars' + * ``` + */ + plugin?: string + + /** + * Error message. + * + * ```js + * error.message //=> 'Unclosed block' + * ``` + */ + reason: string + + /** + * Source code of the broken file. + * + * ```js + * error.source //=> 'a { b {} }' + * error.input.source //=> 'a b { }' + * ``` + */ + source?: string + + stack: string + + /** + * Instantiates a CSS syntax error. Can be instantiated for a single position + * or for a range. + * @param message Error message. + * @param lineOrStartPos If for a single position, the line number, or if for + * a range, the inclusive start position of the error. + * @param columnOrEndPos If for a single position, the column number, or if for + * a range, the exclusive end position of the error. + * @param source Source code of the broken file. + * @param file Absolute path to the broken file. + * @param plugin PostCSS plugin name, if error came from plugin. + */ + constructor( + message: string, + lineOrStartPos?: CssSyntaxError.RangePosition | number, + columnOrEndPos?: CssSyntaxError.RangePosition | number, + source?: string, + file?: string, + plugin?: string + ) + + /** + * Returns a few lines of CSS source that caused the error. + * + * If the CSS has an input source map without `sourceContent`, + * this method will return an empty string. + * + * ```js + * error.showSourceCode() //=> " 4 | } + * // 5 | a { + * // > 6 | bad + * // | ^ + * // 7 | } + * // 8 | b {" + * ``` + * + * @param color Whether arrow will be colored red by terminal + * color codes. By default, PostCSS will detect + * color support by `process.stdout.isTTY` + * and `process.env.NODE_DISABLE_COLORS`. + * @return Few lines of CSS source that caused the error. + */ + showSourceCode(color?: boolean): string + + /** + * Returns error position, message and source code of the broken part. + * + * ```js + * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block + * // > 1 | a { + * // | ^" + * ``` + * + * @return Error position, message and source code. + */ + toString(): string +} + +declare class CssSyntaxError extends CssSyntaxError_ {} + +export = CssSyntaxError diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.js new file mode 100644 index 00000000..275a4f64 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.js @@ -0,0 +1,133 @@ +'use strict' + +let pico = require('picocolors') + +let terminalHighlight = require('./terminal-highlight') + +class CssSyntaxError extends Error { + constructor(message, line, column, source, file, plugin) { + super(message) + this.name = 'CssSyntaxError' + this.reason = message + + if (file) { + this.file = file + } + if (source) { + this.source = source + } + if (plugin) { + this.plugin = plugin + } + if (typeof line !== 'undefined' && typeof column !== 'undefined') { + if (typeof line === 'number') { + this.line = line + this.column = column + } else { + this.line = line.line + this.column = line.column + this.endLine = column.line + this.endColumn = column.column + } + } + + this.setMessage() + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CssSyntaxError) + } + } + + setMessage() { + this.message = this.plugin ? this.plugin + ': ' : '' + this.message += this.file ? this.file : '' + if (typeof this.line !== 'undefined') { + this.message += ':' + this.line + ':' + this.column + } + this.message += ': ' + this.reason + } + + showSourceCode(color) { + if (!this.source) return '' + + let css = this.source + if (color == null) color = pico.isColorSupported + + let aside = text => text + let mark = text => text + let highlight = text => text + if (color) { + let { bold, gray, red } = pico.createColors(true) + mark = text => bold(red(text)) + aside = text => gray(text) + if (terminalHighlight) { + highlight = text => terminalHighlight(text) + } + } + + let lines = css.split(/\r?\n/) + let start = Math.max(this.line - 3, 0) + let end = Math.min(this.line + 2, lines.length) + let maxWidth = String(end).length + + return lines + .slice(start, end) + .map((line, index) => { + let number = start + 1 + index + let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ' + if (number === this.line) { + if (line.length > 160) { + let padding = 20 + let subLineStart = Math.max(0, this.column - padding) + let subLineEnd = Math.max( + this.column + padding, + this.endColumn + padding + ) + let subLine = line.slice(subLineStart, subLineEnd) + + let spacing = + aside(gutter.replace(/\d/g, ' ')) + + line + .slice(0, Math.min(this.column - 1, padding - 1)) + .replace(/[^\t]/g, ' ') + + return ( + mark('>') + + aside(gutter) + + highlight(subLine) + + '\n ' + + spacing + + mark('^') + ) + } + + let spacing = + aside(gutter.replace(/\d/g, ' ')) + + line.slice(0, this.column - 1).replace(/[^\t]/g, ' ') + + return ( + mark('>') + + aside(gutter) + + highlight(line) + + '\n ' + + spacing + + mark('^') + ) + } + + return ' ' + aside(gutter) + highlight(line) + }) + .join('\n') + } + + toString() { + let code = this.showSourceCode() + if (code) { + code = '\n\n' + code + '\n' + } + return this.name + ': ' + this.message + code + } +} + +module.exports = CssSyntaxError +CssSyntaxError.default = CssSyntaxError diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.d.ts new file mode 100644 index 00000000..35c0e5be --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.d.ts @@ -0,0 +1,150 @@ +import { ContainerWithChildren } from './container.js' +import Node, { NodeProps } from './node.js' + +declare namespace Declaration { + export interface DeclarationRaws extends Record { + /** + * The space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + */ + before?: string + + /** + * The symbols between the property and value for declarations. + */ + between?: string + + /** + * The content of the important statement, if it is not just `!important`. + */ + important?: string + + /** + * Declaration value with comments. + */ + value?: { + raw: string + value: string + } + } + + export interface DeclarationProps extends NodeProps { + /** Whether the declaration has an `!important` annotation. */ + important?: boolean + /** Name of the declaration. */ + prop: string + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: DeclarationRaws + /** Value of the declaration. */ + value: string + } + + export { Declaration_ as default } +} + +/** + * It represents a class that handles + * [CSS declarations](https://developer.mozilla.org/en-US/docs/Web/CSS/Syntax#css_declarations) + * + * ```js + * Once (root, { Declaration }) { + * const color = new Declaration({ prop: 'color', value: 'black' }) + * root.append(color) + * } + * ``` + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first?.first + * + * decl.type //=> 'decl' + * decl.toString() //=> ' color: black' + * ``` + */ +declare class Declaration_ extends Node { + parent: ContainerWithChildren | undefined + raws: Declaration.DeclarationRaws + + type: 'decl' + + /** + * It represents a specificity of the declaration. + * + * If true, the CSS declaration will have an + * [important](https://developer.mozilla.org/en-US/docs/Web/CSS/important) + * specifier. + * + * ```js + * const root = postcss.parse('a { color: black !important; color: red }') + * + * root.first.first.important //=> true + * root.first.last.important //=> undefined + * ``` + */ + get important(): boolean + set important(value: boolean) + + /** + * The property name for a CSS declaration. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first.first + * + * decl.prop //=> 'color' + * ``` + */ + get prop(): string + + set prop(value: string) + + /** + * The property value for a CSS declaration. + * + * Any CSS comments inside the value string will be filtered out. + * CSS comments present in the source value will be available in + * the `raws` property. + * + * Assigning new `value` would ignore the comments in `raws` + * property while compiling node to string. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first.first + * + * decl.value //=> 'black' + * ``` + */ + get value(): string + set value(value: string) + + /** + * It represents a getter that returns `true` if a declaration starts with + * `--` or `$`, which are used to declare variables in CSS and SASS/SCSS. + * + * ```js + * const root = postcss.parse(':root { --one: 1 }') + * const one = root.first.first + * + * one.variable //=> true + * ``` + * + * ```js + * const root = postcss.parse('$one: 1') + * const one = root.first + * + * one.variable //=> true + * ``` + */ + get variable(): boolean + constructor(defaults?: Declaration.DeclarationProps) + + assign(overrides: Declaration.DeclarationProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class Declaration extends Declaration_ {} + +export = Declaration diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.js new file mode 100644 index 00000000..65a03aa9 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.js @@ -0,0 +1,24 @@ +'use strict' + +let Node = require('./node') + +class Declaration extends Node { + get variable() { + return this.prop.startsWith('--') || this.prop[0] === '$' + } + + constructor(defaults) { + if ( + defaults && + typeof defaults.value !== 'undefined' && + typeof defaults.value !== 'string' + ) { + defaults = { ...defaults, value: String(defaults.value) } + } + super(defaults) + this.type = 'decl' + } +} + +module.exports = Declaration +Declaration.default = Declaration diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.d.ts new file mode 100644 index 00000000..67194dd9 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.d.ts @@ -0,0 +1,68 @@ +import Container, { ContainerProps } from './container.js' +import { ProcessOptions } from './postcss.js' +import Result from './result.js' +import Root from './root.js' + +declare namespace Document { + export interface DocumentProps extends ContainerProps { + nodes?: readonly Root[] + + /** + * Information to generate byte-to-byte equal node string as it was + * in the origin input. + * + * Every parser saves its own properties. + */ + raws?: Record + } + + export { Document_ as default } +} + +/** + * Represents a file and contains all its parsed nodes. + * + * **Experimental:** some aspects of this node could change within minor + * or patch version releases. + * + * ```js + * const document = htmlParser( + * '' + * ) + * document.type //=> 'document' + * document.nodes.length //=> 2 + * ``` + */ +declare class Document_ extends Container { + nodes: Root[] + parent: undefined + type: 'document' + + constructor(defaults?: Document.DocumentProps) + + assign(overrides: Document.DocumentProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this + + /** + * Returns a `Result` instance representing the document’s CSS roots. + * + * ```js + * const root1 = postcss.parse(css1, { from: 'a.css' }) + * const root2 = postcss.parse(css2, { from: 'b.css' }) + * const document = postcss.document() + * document.append(root1) + * document.append(root2) + * const result = document.toResult({ to: 'all.css', map: true }) + * ``` + * + * @param opts Options. + * @return Result with current document’s CSS. + */ + toResult(options?: ProcessOptions): Result +} + +declare class Document extends Document_ {} + +export = Document diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.js new file mode 100644 index 00000000..44689917 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.js @@ -0,0 +1,33 @@ +'use strict' + +let Container = require('./container') + +let LazyResult, Processor + +class Document extends Container { + constructor(defaults) { + // type needs to be passed to super, otherwise child roots won't be normalized correctly + super({ type: 'document', ...defaults }) + + if (!this.nodes) { + this.nodes = [] + } + } + + toResult(opts = {}) { + let lazy = new LazyResult(new Processor(), this, opts) + + return lazy.stringify() + } +} + +Document.registerLazyResult = dependant => { + LazyResult = dependant +} + +Document.registerProcessor = dependant => { + Processor = dependant +} + +module.exports = Document +Document.default = Document diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.d.ts new file mode 100644 index 00000000..3a0c5b85 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.d.ts @@ -0,0 +1,9 @@ +import { JSONHydrator } from './postcss.js' + +interface FromJSON extends JSONHydrator { + default: FromJSON +} + +declare let fromJSON: FromJSON + +export = fromJSON diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.js new file mode 100644 index 00000000..c1a9509b --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.js @@ -0,0 +1,107 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Input = require('./input') +let PreviousMap = require('./previous-map') +let Root = require('./root') +let Rule = require('./rule') + +function hydrateInputs(json, inputs) { + if (!json.inputs) return inputs + return json.inputs.map(input => { + let inputHydrated = { ...input, __proto__: Input.prototype } + if (inputHydrated.map) { + inputHydrated.map = { + ...inputHydrated.map, + __proto__: PreviousMap.prototype + } + } + return inputHydrated + }) +} + +function constructNode(json, inputs, children) { + let defaults = { ...json } + delete defaults.inputs + delete defaults.nodes + if (defaults.source) { + let { inputId, ...source } = defaults.source + defaults.source = source + if (inputId != null) { + defaults.source.input = inputs[inputId] + } + } + + let node + if (defaults.type === 'root') { + node = new Root(defaults) + } else if (defaults.type === 'decl') { + node = new Declaration(defaults) + } else if (defaults.type === 'rule') { + node = new Rule(defaults) + } else if (defaults.type === 'comment') { + node = new Comment(defaults) + } else if (defaults.type === 'atrule') { + node = new AtRule(defaults) + } else { + throw new Error('Unknown node type: ' + json.type) + } + + // Rehydrated children are attached after construction. Passing them + // through the container constructor would re-run insertion spacing + // normalization and overwrite each child's own `raws.before`. + if (children) { + node.nodes = children + for (let child of children) child.parent = node + } + + return node +} + +function fromJSON(json, inputs) { + if (Array.isArray(json)) return json.map(n => fromJSON(n)) + + // An explicit stack instead of recursive calls to survive deeply + // nested trees. Children are rehydrated before their parent node + // is constructed. + let result + let stack = [ + { childIndex: 0, children: [], inputs: hydrateInputs(json, inputs), json } + ] + + while (stack.length > 0) { + let frame = stack[stack.length - 1] + let jsonNodes = frame.json.nodes + + if (jsonNodes && frame.childIndex < jsonNodes.length) { + let childJson = jsonNodes[frame.childIndex] + frame.childIndex += 1 + stack.push({ + childIndex: 0, + children: [], + inputs: hydrateInputs(childJson, frame.inputs), + json: childJson + }) + continue + } + + stack.pop() + let node = constructNode( + frame.json, + frame.inputs, + jsonNodes ? frame.children : undefined + ) + if (stack.length > 0) { + stack[stack.length - 1].children.push(node) + } else { + result = node + } + } + + return result +} + +module.exports = fromJSON +fromJSON.default = fromJSON diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.d.ts new file mode 100644 index 00000000..ca2d26bf --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.d.ts @@ -0,0 +1,226 @@ +import { CssSyntaxError, ProcessOptions } from './postcss.js' +import PreviousMap from './previous-map.js' + +declare namespace Input { + export interface FilePosition { + /** + * Column of inclusive start position in source file. + */ + column: number + + /** + * Column of exclusive end position in source file. + */ + endColumn?: number + + /** + * Line of exclusive end position in source file. + */ + endLine?: number + + /** + * Offset of exclusive end position in source file. + */ + endOffset?: number + + /** + * Absolute path to the source file. + */ + file?: string + + /** + * Line of inclusive start position in source file. + */ + line: number + + /** + * Offset of inclusive start position in source file. + */ + offset: number + + /** + * Source code. + */ + source?: string + + /** + * URL for the source file. + */ + url: string + } + + export { Input_ as default } +} + +/** + * Represents the source CSS. + * + * ```js + * const root = postcss.parse(css, { from: file }) + * const input = root.source.input + * ``` + */ +declare class Input_ { + /** + * Input CSS source. + * + * ```js + * const input = postcss.parse('a{}', { from: file }).input + * input.css //=> "a{}" + * ``` + */ + css: string + + /** + * Input source with support for non-CSS documents. + * + * ```js + * const input = postcss.parse('a{}', { from: file, document: '' }).input + * input.document //=> "" + * input.css //=> "a{}" + * ``` + */ + document: string + + /** + * The absolute path to the CSS source file defined + * with the `from` option. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.file //=> '/home/ai/a.css' + * ``` + */ + file?: string + + /** + * The flag to indicate whether or not the source code has Unicode BOM. + */ + hasBOM: boolean + + /** + * The unique ID of the CSS source. It will be created if `from` option + * is not provided (because PostCSS does not know the file path). + * + * ```js + * const root = postcss.parse(css) + * root.source.input.file //=> undefined + * root.source.input.id //=> "" + * ``` + */ + id?: string + + /** + * The input source map passed from a compilation step before PostCSS + * (for example, from Sass compiler). + * + * ```js + * root.source.input.map.consumer().sources //=> ['a.sass'] + * ``` + */ + map: PreviousMap + + /** + * The CSS source identifier. Contains `Input#file` if the user + * set the `from` option, or `Input#id` if they did not. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.from //=> "/home/ai/a.css" + * + * const root = postcss.parse(css) + * root.source.input.from //=> "" + * ``` + */ + get from(): string + + /** + * @param css Input CSS source. + * @param opts Process options. + */ + constructor(css: string, opts?: ProcessOptions) + + /** + * Returns `CssSyntaxError` with information about the error and its position. + */ + error( + message: string, + start: + | { + column: number + line: number + } + | { + offset: number + }, + end: + | { + column: number + line: number + } + | { + offset: number + }, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + line: number, + column: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + offset: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + + /** + * Converts source line and column to offset. + * + * @param line Source line. + * @param column Source column. + * @return Source offset. + */ + fromLineAndColumn(line: number, column: number): number + + /** + * Converts source offset to line and column. + * + * @param offset Source offset. + */ + fromOffset(offset: number): { col: number; line: number } | null + + /** + * Reads the input source map and returns a symbol position + * in the input source (e.g., in a Sass file that was compiled + * to CSS before being passed to PostCSS). Optionally takes an + * end position, exclusive. + * + * ```js + * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 } + * root.source.input.origin(1, 1, 1, 4) + * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 } + * ``` + * + * @param line Line for inclusive start position in input CSS. + * @param column Column for inclusive start position in input CSS. + * @param endLine Line for exclusive end position in input CSS. + * @param endColumn Column for exclusive end position in input CSS. + * + * @return Position in input source. + */ + origin( + line: number, + column: number, + endLine?: number, + endColumn?: number + ): false | Input.FilePosition + + /** Converts this to a JSON-friendly object representation. */ + toJSON(): object +} + +declare class Input extends Input_ {} + +export = Input diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.js new file mode 100644 index 00000000..defe395f --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.js @@ -0,0 +1,282 @@ +'use strict' + +let { nanoid } = require('nanoid/non-secure') +let { isAbsolute, resolve } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { fileURLToPath, pathToFileURL } = require('url') + +let CssSyntaxError = require('./css-syntax-error') +let PreviousMap = require('./previous-map') +let terminalHighlight = require('./terminal-highlight') + +let lineToIndexCache = Symbol('lineToIndexCache') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(resolve && isAbsolute) + +function getLineToIndex(input) { + if (input[lineToIndexCache]) return input[lineToIndexCache] + let lines = input.css.split('\n') + let lineToIndex = new Array(lines.length) + let prevIndex = 0 + + for (let i = 0, l = lines.length; i < l; i++) { + lineToIndex[i] = prevIndex + prevIndex += lines[i].length + 1 + } + + input[lineToIndexCache] = lineToIndex + return lineToIndex +} + +class Input { + get from() { + return this.file || this.id + } + + constructor(css, opts = {}) { + if ( + css === null || + typeof css === 'undefined' || + (typeof css === 'object' && !css.toString) + ) { + throw new Error(`PostCSS received ${css} instead of CSS string`) + } + + this.css = css.toString() + + if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { + this.hasBOM = true + this.css = this.css.slice(1) + } else { + this.hasBOM = false + } + + this.document = this.css + if (opts.document) this.document = opts.document.toString() + + if (opts.from) { + if ( + !pathAvailable || + /^\w+:\/\//.test(opts.from) || + isAbsolute(opts.from) + ) { + this.file = opts.from + } else { + this.file = resolve(opts.from) + } + } + + if (pathAvailable && sourceMapAvailable) { + let map = new PreviousMap(this.css, opts) + if (map.text) { + this.map = map + let file = map.consumer().file + if (!this.file && file) this.file = this.mapResolve(file) + } + } + + if (!this.file) { + this.id = '' + } + if (this.map) this.map.file = this.from + } + + error(message, line, column, opts = {}) { + let endColumn, endLine, endOffset, offset, result + + if (line && typeof line === 'object') { + let start = line + let end = column + if (typeof start.offset === 'number') { + offset = start.offset + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + line = start.line + column = start.column + offset = this.fromLineAndColumn(line, column) + } + if (typeof end.offset === 'number') { + endOffset = end.offset + let pos = this.fromOffset(endOffset) + endLine = pos.line + endColumn = pos.col + } else { + endLine = end.line + endColumn = end.column + endOffset = this.fromLineAndColumn(end.line, end.column) + } + } else if (!column) { + offset = line + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + offset = this.fromLineAndColumn(line, column) + } + + let origin = this.origin(line, column, endLine, endColumn) + if (origin) { + result = new CssSyntaxError( + message, + origin.endLine === undefined + ? origin.line + : { column: origin.column, line: origin.line }, + origin.endLine === undefined + ? origin.column + : { column: origin.endColumn, line: origin.endLine }, + origin.source, + origin.file, + opts.plugin + ) + } else { + result = new CssSyntaxError( + message, + endLine === undefined ? line : { column, line }, + endLine === undefined ? column : { column: endColumn, line: endLine }, + this.css, + this.file, + opts.plugin + ) + } + + result.input = { + column, + endColumn, + endLine, + endOffset, + line, + offset, + source: this.css + } + if (this.file) { + if (pathToFileURL) { + result.input.url = pathToFileURL(this.file).toString() + } + result.input.file = this.file + } + + return result + } + + fromLineAndColumn(line, column) { + let lineToIndex = getLineToIndex(this) + let index = lineToIndex[line - 1] + return index + column - 1 + } + + fromOffset(offset) { + let lineToIndex = getLineToIndex(this) + let lastLine = lineToIndex[lineToIndex.length - 1] + + let min = 0 + if (offset >= lastLine) { + min = lineToIndex.length - 1 + } else { + let max = lineToIndex.length - 2 + let mid + while (min < max) { + mid = min + ((max - min) >> 1) + if (offset < lineToIndex[mid]) { + max = mid - 1 + } else if (offset >= lineToIndex[mid + 1]) { + min = mid + 1 + } else { + min = mid + break + } + } + } + return { + col: offset - lineToIndex[min] + 1, + line: min + 1 + } + } + + mapResolve(file) { + if (/^\w+:\/\//.test(file)) { + return file + } + return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) + } + + origin(line, column, endLine, endColumn) { + if (!this.map) return false + let consumer = this.map.consumer() + + let from = consumer.originalPositionFor({ column: column - 1, line }) + if (!from.source) return false + + let to + if (typeof endLine === 'number') { + let toPosition = consumer.originalPositionFor({ + column: endColumn - 1, + line: endLine + }) + // The source map may not have a mapping that covers the end position + // (`originalPositionFor()` then returns `null` for `line`/`column` + // instead of omitting them). Treat that the same as not requesting + // an end position at all, so `endLine`/`endColumn` stay a consistent + // `undefined` pair instead of a mix of `null` and a bogus number. + if (toPosition.source) to = toPosition + } + + let fromUrl + + if (isAbsolute(from.source)) { + fromUrl = pathToFileURL(from.source) + } else { + fromUrl = new URL( + from.source, + this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) + ) + } + + let result = { + column: from.column + 1, + endColumn: to && to.column + 1, + endLine: to && to.line, + line: from.line, + url: fromUrl.toString() + } + + if (fromUrl.protocol === 'file:') { + if (fileURLToPath) { + result.file = fileURLToPath(fromUrl) + } else { + /* c8 ignore next 2 */ + throw new Error(`file: protocol is not available in this PostCSS build`) + } + } + + let source = consumer.sourceContentFor(from.source) + if (source) result.source = source + + return result + } + + toJSON() { + let json = {} + for (let name of ['hasBOM', 'css', 'file', 'id']) { + if (this[name] != null) { + json[name] = this[name] + } + } + if (this.map) { + json.map = { ...this.map } + if (json.map.consumerCache) { + json.map.consumerCache = undefined + } + } + return json + } +} + +module.exports = Input +Input.default = Input + +if (terminalHighlight && terminalHighlight.registerInput) { + terminalHighlight.registerInput(Input) +} diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.d.ts new file mode 100644 index 00000000..599a614b --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.d.ts @@ -0,0 +1,189 @@ +import Document from './document.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace LazyResult { + export { LazyResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * + * A `LazyResult` instance is returned by `Processor#process`. + * + * ```js + * const lazy = postcss([autoprefixer]).process(css) + * ``` + */ +declare class LazyResult_ implements PromiseLike< + Result +> { + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onRejected for each error thrown in any plugin. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).then(result => { + * console.log(result.css) + * }).catch(error => { + * console.error(error) + * }) + * ``` + */ + catch: Promise>['catch'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onFinally on any error or when all plugins will finish work. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).finally(() => { + * console.log('processing ended') + * }) + * ``` + */ + finally: Promise>['finally'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls `onFulfilled` with a Result instance. If a plugin throws + * an error, the `onRejected` callback will be executed. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => { + * console.log(result.css) + * }) + * ``` + */ + then: Promise>['then'] + + /** + * An alias for the `css` property. Use it with syntaxes + * that generate non-CSS output. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get content(): string + + /** + * Processes input CSS through synchronous plugins, converts `Root` + * to a CSS string and returns `Result#css`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get css(): string + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#map`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get map(): SourceMap + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#messages`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get messages(): Message[] + + /** + * Options from the `Processor#process` call. + */ + get opts(): ResultOptions + + /** + * Returns a `Processor` instance, which will be used + * for CSS transformations. + */ + get processor(): Processor + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#root`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get root(): RootNode + + /** + * Returns the default string description of an object. + * Required to implement the Promise interface. + */ + get [Symbol.toStringTag](): string + + /** + * @param processor Processor used for this transformation. + * @param css CSS to parse and transform. + * @param opts Options from the `Processor#process` or `Root#toResult`. + */ + constructor(processor: Processor, css: string, opts: ResultOptions) + + /** + * Run plugin in async way and return `Result`. + * + * @return Result with output content. + */ + async(): Promise> + + /** + * Run plugin in sync way and return `Result`. + * + * @return Result with output content. + */ + sync(): Result + + /** + * Alias for the `LazyResult#css` property. + * + * ```js + * lazy + '' === lazy.css + * ``` + * + * @return Output CSS. + */ + toString(): string + + /** + * Processes input CSS through synchronous plugins + * and calls `Result#warnings`. + * + * @return Warnings from plugins. + */ + warnings(): Warning[] +} + +declare class LazyResult< + RootNode = Document | Root +> extends LazyResult_ {} + +export = LazyResult diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.js new file mode 100644 index 00000000..be695b29 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.js @@ -0,0 +1,626 @@ +'use strict' + +let Container = require('./container') +let Document = require('./document') +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let Root = require('./root') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') +let warnOnce = require('./warn-once') + +const TYPE_TO_CLASS_NAME = { + atrule: 'AtRule', + comment: 'Comment', + decl: 'Declaration', + document: 'Document', + root: 'Root', + rule: 'Rule' +} + +const PLUGIN_PROPS = { + AtRule: true, + AtRuleExit: true, + Comment: true, + CommentExit: true, + Declaration: true, + DeclarationExit: true, + Document: true, + DocumentExit: true, + Once: true, + OnceExit: true, + postcssPlugin: true, + prepare: true, + Root: true, + RootExit: true, + Rule: true, + RuleExit: true +} + +const NOT_VISITORS = { + Once: true, + postcssPlugin: true, + prepare: true +} + +const CHILDREN = 0 + +function isPromise(obj) { + return typeof obj === 'object' && typeof obj.then === 'function' +} + +function getEvents(node) { + let key = false + let type = TYPE_TO_CLASS_NAME[node.type] + if (node.type === 'decl') { + key = node.prop.toLowerCase() + } else if (node.type === 'atrule') { + key = node.name.toLowerCase() + } + + if (key && node.append) { + return [ + type, + type + '-' + key, + CHILDREN, + type + 'Exit', + type + 'Exit-' + key + ] + } else if (key) { + return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] + } else if (node.append) { + return [type, CHILDREN, type + 'Exit'] + } else { + return [type, type + 'Exit'] + } +} + +function toStack(node) { + let events + if (node.type === 'document') { + events = ['Document', CHILDREN, 'DocumentExit'] + } else if (node.type === 'root') { + events = ['Root', CHILDREN, 'RootExit'] + } else { + events = getEvents(node) + } + + return { + eventIndex: 0, + events, + iterator: 0, + node, + visitorIndex: 0, + visitors: [] + } +} + +function cleanMarks(node) { + let stack = [node] + while (stack.length > 0) { + let next = stack.pop() + next[isClean] = false + if (next.nodes) { + for (let i of next.nodes) stack.push(i) + } + } + return node +} + +let postcss = {} + +class LazyResult { + get content() { + return this.stringify().content + } + + get css() { + return this.stringify().css + } + + get map() { + return this.stringify().map + } + + get messages() { + return this.sync().messages + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + return this.sync().root + } + + get [Symbol.toStringTag]() { + return 'LazyResult' + } + + constructor(processor, css, opts) { + this.stringified = false + this.processed = false + + let root + if ( + typeof css === 'object' && + css !== null && + (css.type === 'root' || css.type === 'document') + ) { + root = cleanMarks(css) + } else if (css instanceof LazyResult || css instanceof Result) { + root = cleanMarks(css.root) + if (css.map) { + if (typeof opts.map === 'undefined') opts.map = {} + if (!opts.map.inline) opts.map.inline = false + opts.map.prev = css.map + } + } else { + let parser = parse + if (opts.syntax) parser = opts.syntax.parse + if (opts.parser) parser = opts.parser + if (parser.parse) parser = parser.parse + + try { + root = parser(css, opts) + } catch (error) { + this.processed = true + this.error = error + } + + if (root && !root[my]) { + /* c8 ignore next 2 */ + Container.rebuild(root) + } + } + + this.result = new Result(processor, root, opts) + this.helpers = { ...postcss, postcss, result: this.result } + this.plugins = this.processor.plugins.map(plugin => { + if (typeof plugin === 'object' && plugin.prepare) { + return { ...plugin, ...plugin.prepare(this.result) } + } else { + return plugin + } + }) + } + + async() { + if (this.error) return Promise.reject(this.error) + if (this.processed) return Promise.resolve(this.result) + if (!this.processing) { + this.processing = this.runAsync() + } + return this.processing + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + getAsyncError() { + throw new Error('Use process(css).then(cb) to work with async plugins') + } + + handleError(error, node) { + let plugin = this.result.lastPlugin + try { + if (node) node.addToError(error) + this.error = error + if (error.name === 'CssSyntaxError' && !error.plugin) { + error.plugin = plugin.postcssPlugin + error.setMessage() + } else if (plugin.postcssVersion) { + if (process.env.NODE_ENV !== 'production') { + let pluginName = plugin.postcssPlugin + let pluginVer = plugin.postcssVersion + let runtimeVer = this.result.processor.version + let a = pluginVer.split('.') + let b = runtimeVer.split('.') + + if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) { + // eslint-disable-next-line no-console + console.error( + 'Unknown error from PostCSS plugin. Your current PostCSS ' + + 'version is ' + + runtimeVer + + ', but ' + + pluginName + + ' uses ' + + pluginVer + + '. Perhaps this is the source of the error below.' + ) + } + } + } + } catch (err) { + /* c8 ignore next 3 */ + // eslint-disable-next-line no-console + if (console && console.error) console.error(err) + } + return error + } + + prepareVisitors() { + this.listeners = {} + let add = (plugin, type, cb) => { + if (!this.listeners[type]) this.listeners[type] = [] + this.listeners[type].push([plugin, cb]) + } + for (let plugin of this.plugins) { + if (typeof plugin === 'object') { + for (let event in plugin) { + if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { + throw new Error( + `Unknown event ${event} in ${plugin.postcssPlugin}. ` + + `Try to update PostCSS (${this.processor.version} now).` + ) + } + if (!NOT_VISITORS[event]) { + if (typeof plugin[event] === 'object') { + for (let filter in plugin[event]) { + if (filter === '*') { + add(plugin, event, plugin[event][filter]) + } else { + add( + plugin, + event + '-' + filter.toLowerCase(), + plugin[event][filter] + ) + } + } + } else if (typeof plugin[event] === 'function') { + add(plugin, event, plugin[event]) + } + } + } + } + } + this.hasListener = Object.keys(this.listeners).length > 0 + } + + async runAsync() { + this.plugin = 0 + for (let i = 0; i < this.plugins.length; i++) { + let plugin = this.plugins[i] + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + try { + await promise + } catch (error) { + throw this.handleError(error) + } + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + let stack = [toStack(root)] + while (stack.length > 0) { + let promise = this.visitTick(stack) + if (isPromise(promise)) { + try { + await promise + } catch (e) { + let node = stack[stack.length - 1].node + throw this.handleError(e, node) + } + } + } + } + + if (this.listeners.OnceExit) { + for (let [plugin, visitor] of this.listeners.OnceExit) { + this.result.lastPlugin = plugin + try { + if (root.type === 'document') { + let roots = root.nodes.map(subRoot => + visitor(subRoot, this.helpers) + ) + + await Promise.all(roots) + } else { + await visitor(root, this.helpers) + } + } catch (e) { + throw this.handleError(e) + } + } + } + } + + this.processed = true + return this.stringify() + } + + runOnRoot(plugin) { + this.result.lastPlugin = plugin + try { + if (typeof plugin === 'object' && plugin.Once) { + if (this.result.root.type === 'document') { + let roots = this.result.root.nodes.map(root => + plugin.Once(root, this.helpers) + ) + + if (isPromise(roots[0])) { + return Promise.all(roots) + } + + return roots + } + + return plugin.Once(this.result.root, this.helpers) + } else if (typeof plugin === 'function') { + return plugin(this.result.root, this.result) + } + } catch (error) { + throw this.handleError(error) + } + } + + stringify() { + if (this.error) throw this.error + if (this.stringified) return this.result + this.stringified = true + + this.sync() + + let opts = this.result.opts + let str = stringify + if (opts.syntax) str = opts.syntax.stringify + if (opts.stringifier) str = opts.stringifier + if (str.stringify) str = str.stringify + + let rootSource = this.result.root.source + if ( + opts.map === undefined && + !(rootSource && rootSource.input && rootSource.input.map) + ) { + let result = '' + str(this.result.root, i => { + result += i + }) + this.result.css = result + return this.result + } + + let map = new MapGenerator(str, this.result.root, this.result.opts) + let data = map.generate() + this.result.css = data[0] + this.result.map = data[1] + + return this.result + } + + sync() { + if (this.error) throw this.error + if (this.processed) return this.result + this.processed = true + + if (this.processing) { + throw this.getAsyncError() + } + + for (let plugin of this.plugins) { + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + this.walkSync(root) + } + if (this.listeners.OnceExit) { + if (root.type === 'document') { + for (let subRoot of root.nodes) { + this.visitSync(this.listeners.OnceExit, subRoot) + } + } else { + this.visitSync(this.listeners.OnceExit, root) + } + } + } + + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this.opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this.css + } + + visitSync(visitors, node) { + for (let [plugin, visitor] of visitors) { + this.result.lastPlugin = plugin + let promise + try { + promise = visitor(node, this.helpers) + } catch (e) { + throw this.handleError(e, node.proxyOf) + } + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + return true + } + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + } + + visitTick(stack) { + let visit = stack[stack.length - 1] + let { node, visitors } = visit + + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + stack.pop() + return + } + + if (visitors.length > 0 && visit.visitorIndex < visitors.length) { + let [plugin, visitor] = visitors[visit.visitorIndex] + visit.visitorIndex += 1 + if (visit.visitorIndex === visitors.length) { + visit.visitors = [] + visit.visitorIndex = 0 + } + this.result.lastPlugin = plugin + try { + return visitor(node.toProxy(), this.helpers) + } catch (e) { + throw this.handleError(e, node) + } + } + + if (visit.iterator !== 0) { + let iterator = visit.iterator + // Advance past the child we just finished visiting. Like + // `Container#each`, the index is incremented only after a child has + // been fully processed, so a node inserted right after the current + // child is not skipped by the `existIndex < index` adjustment in + // `Container#insertAfter()` (which would fire exit events too early). + if (visit.descending) { + visit.descending = false + node.indexes[iterator] += 1 + } + let child + while ((child = node.nodes[node.indexes[iterator]])) { + if (!child[isClean]) { + child[isClean] = true + visit.descending = true + stack.push(toStack(child)) + return + } + node.indexes[iterator] += 1 + } + visit.iterator = 0 + delete node.indexes[iterator] + } + + let events = visit.events + while (visit.eventIndex < events.length) { + let event = events[visit.eventIndex] + visit.eventIndex += 1 + if (event === CHILDREN) { + if (node.nodes && node.nodes.length) { + node[isClean] = true + visit.iterator = node.getIterator() + } + return + } else if (this.listeners[event]) { + visit.visitors = this.listeners[event] + return + } + } + stack.pop() + } + + walkSync(node) { + // An explicit stack like in async `visitTick()` to survive deeply + // nested trees. Unlike `visitTick()`, nodes are marked clean only + // on entering, so a node dirtied by its own visitors is revisited + // on the next pass. + node[isClean] = true + let stack = [{ eventIndex: 0, events: getEvents(node), iterator: 0, node }] + + while (stack.length > 0) { + let visit = stack[stack.length - 1] + let visitNode = visit.node + + if (visit.iterator !== 0) { + let iterator = visit.iterator + // Advance past the child we just finished visiting. Like + // `Container#each`, the index is incremented only after a child has + // been fully processed. Incrementing before (as this loop used to) + // makes a node inserted right after the current child get skipped by + // the `existIndex < index` adjustment in `Container#insertAfter()`, + // which fires exit events before those new siblings are visited. + if (visit.descending) { + visit.descending = false + visitNode.indexes[iterator] += 1 + } + let child + let descended = false + while ((child = visitNode.nodes[visitNode.indexes[iterator]])) { + if (!child[isClean]) { + child[isClean] = true + visit.descending = true + stack.push({ + eventIndex: 0, + events: getEvents(child), + iterator: 0, + node: child + }) + descended = true + break + } + visitNode.indexes[iterator] += 1 + } + if (descended) continue + visit.iterator = 0 + delete visitNode.indexes[iterator] + } + + if (visit.eventIndex < visit.events.length) { + let event = visit.events[visit.eventIndex] + visit.eventIndex += 1 + if (event === CHILDREN) { + if (visitNode.nodes && visitNode.nodes.length) { + visit.iterator = visitNode.getIterator() + } + } else { + let visitors = this.listeners[event] + if (visitors) { + if (this.visitSync(visitors, visitNode.toProxy())) stack.pop() + } + } + continue + } + + stack.pop() + } + } + + warnings() { + return this.sync().warnings() + } +} + +LazyResult.registerPostcss = dependant => { + postcss = dependant +} + +module.exports = LazyResult +LazyResult.default = LazyResult + +Root.registerLazyResult(LazyResult) +Document.registerLazyResult(LazyResult) diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.d.ts new file mode 100644 index 00000000..119624e8 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.d.ts @@ -0,0 +1,60 @@ +declare namespace list { + type List = { + /** + * Safely splits comma-separated values (such as those for `transition-*` + * and `background` properties). + * + * ```js + * Once (root, { list }) { + * list.comma('black, linear-gradient(white, black)') + * //=> ['black', 'linear-gradient(white, black)'] + * } + * ``` + * + * @param str Comma-separated values. + * @return Split values. + */ + comma(str: string): string[] + + default: List + + /** + * Safely splits space-separated values (such as those for `background`, + * `border-radius`, and other shorthand properties). + * + * ```js + * Once (root, { list }) { + * list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param str Space-separated values. + * @return Split values. + */ + space(str: string): string[] + + /** + * Safely splits values. + * + * ```js + * Once (root, { list }) { + * list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param string separated values. + * @param separators array of separators. + * @param last boolean indicator. + * @return Split values. + */ + split( + string: string, + separators: readonly string[], + last: boolean + ): string[] + } +} + +declare let list: list.List + +export = list diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.js new file mode 100644 index 00000000..2a963a8b --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.js @@ -0,0 +1,61 @@ +'use strict' + +let list = { + comma(string) { + return list.split(string, [','], true) + }, + + space(string) { + let spaces = [' ', '\n', '\t'] + return list.split(string, spaces) + }, + + split(string, separators, last) { + if (typeof string !== 'string') return [] + let array = [] + let current = '' + let split = false + + let func = 0 + let inQuote = false + let prevQuote = '' + let escape = false + + for (let letter of string) { + if (escape) { + escape = false + } else if (letter === '\\') { + escape = true + } else if (inQuote) { + if (letter === prevQuote) { + inQuote = false + } + } else if (letter === '"' || letter === "'") { + inQuote = true + prevQuote = letter + } else if (letter === '(') { + func += 1 + } else if (letter === ')') { + if (func > 0) func -= 1 + } else if (func === 0) { + if (separators.includes(letter)) split = true + } + + if (split) { + let value = current.trim() + if (last || value !== '') array.push(value) + current = '' + split = false + } else { + current += letter + } + } + + let value = current.trim() + if (last || value !== '') array.push(value) + return array + } +} + +module.exports = list +list.default = list diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/map-generator.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/map-generator.js new file mode 100644 index 00000000..13f883e5 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/map-generator.js @@ -0,0 +1,377 @@ +'use strict' + +let { dirname, relative, resolve, sep } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { pathToFileURL } = require('url') + +let Input = require('./input') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(dirname && resolve && relative && sep) + +class MapGenerator { + constructor(stringify, root, opts, cssString) { + this.stringify = stringify + this.mapOpts = opts.map || {} + this.root = root + this.opts = opts + this.css = cssString + this.originalCSS = cssString + this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute + + this.memoizedFileURLs = new Map() + this.memoizedPaths = new Map() + this.memoizedURLs = new Map() + } + + addAnnotation() { + let content + + if (this.isInline()) { + content = + 'data:application/json;base64,' + this.toBase64(this.map.toString()) + } else if (typeof this.mapOpts.annotation === 'string') { + content = this.mapOpts.annotation + } else if (typeof this.mapOpts.annotation === 'function') { + content = this.mapOpts.annotation(this.opts.to, this.root) + } else { + content = this.outputFile() + '.map' + } + let eol = '\n' + if (this.css.includes('\r\n')) eol = '\r\n' + + this.css += eol + '/*# sourceMappingURL=' + content + ' */' + } + + applyPrevMaps() { + for (let prev of this.previous()) { + let from = this.toUrl(this.path(prev.file)) + let root = prev.root || dirname(prev.file) + let map + + if (this.mapOpts.sourcesContent === false) { + map = new SourceMapConsumer(prev.text) + if (map.sourcesContent) { + map.sourcesContent = null + } + } else { + map = prev.consumer() + } + + this.map.applySourceMap(map, from, this.toUrl(this.path(root))) + } + } + + clearAnnotation() { + if (this.mapOpts.annotation === false) return + + if (this.root) { + let node + for (let i = this.root.nodes.length - 1; i >= 0; i--) { + node = this.root.nodes[i] + if (node.type !== 'comment') continue + if (node.text.startsWith('# sourceMappingURL=')) { + this.root.removeChild(i) + } + } + } else if (this.css) { + let annotation = '/*# sourceMappingURL=' + let startIndex + while ((startIndex = this.css.lastIndexOf(annotation)) !== -1) { + let endIndex = this.css.indexOf('*/', startIndex + annotation.length) + if (endIndex === -1) break + while (startIndex > 0 && this.css[startIndex - 1] === '\n') { + startIndex-- + } + this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2) + } + } + } + + generate() { + this.clearAnnotation() + if (pathAvailable && sourceMapAvailable && this.isMap()) { + return this.generateMap() + } else { + let result = '' + this.stringify(this.root, i => { + result += i + }) + return [result] + } + } + + generateMap() { + if (this.root) { + this.generateString() + } else if (this.previous().length === 1) { + let prev = this.previous()[0].consumer() + prev.file = this.outputFile() + this.map = SourceMapGenerator.fromSourceMap(prev, { + ignoreInvalidMapping: true + }) + } else { + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + this.map.addMapping({ + generated: { column: 0, line: 1 }, + original: { column: 0, line: 1 }, + source: this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + }) + } + + if (this.isSourcesContent()) this.setSourcesContent() + if (this.root && this.previous().length > 0) this.applyPrevMaps() + if (this.isAnnotation()) this.addAnnotation() + + if (this.isInline()) { + return [this.css] + } else { + return [this.css, this.map] + } + } + + generateString() { + this.css = '' + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + + let line = 1 + let column = 1 + + let noSource = '' + let mapping = { + generated: { column: 0, line: 0 }, + original: { column: 0, line: 0 }, + source: '' + } + + let last, lines + this.stringify(this.root, (str, node, type) => { + this.css += str + + if (node && type !== 'end') { + mapping.generated.line = line + mapping.generated.column = column - 1 + if (node.source && node.source.start) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.start.line + mapping.original.column = node.source.start.column - 1 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + this.map.addMapping(mapping) + } + } + + lines = str.match(/\n/g) + if (lines) { + line += lines.length + last = str.lastIndexOf('\n') + column = str.length - last + } else { + column += str.length + } + + if (node && type !== 'start') { + let p = node.parent || { raws: {} } + let childless = + node.type === 'decl' || (node.type === 'atrule' && !node.nodes) + if (!childless || node !== p.last || p.raws.semicolon) { + if (node.source && node.source.end) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.end.line + mapping.original.column = node.source.end.column - 1 + mapping.generated.line = line + mapping.generated.column = column - 2 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + mapping.generated.line = line + mapping.generated.column = column - 1 + this.map.addMapping(mapping) + } + } + } + }) + } + + isAnnotation() { + if (this.isInline()) { + return true + } + if (typeof this.mapOpts.annotation !== 'undefined') { + return this.mapOpts.annotation + } + if (this.previous().length) { + return this.previous().some(i => i.annotation) + } + return true + } + + isInline() { + if (typeof this.mapOpts.inline !== 'undefined') { + return this.mapOpts.inline + } + + let annotation = this.mapOpts.annotation + if (typeof annotation !== 'undefined' && annotation !== true) { + return false + } + + if (this.previous().length) { + return this.previous().some(i => i.inline) + } + return true + } + + isMap() { + if (typeof this.opts.map !== 'undefined') { + return !!this.opts.map + } + return this.previous().length > 0 + } + + isSourcesContent() { + if (typeof this.mapOpts.sourcesContent !== 'undefined') { + return this.mapOpts.sourcesContent + } + if (this.previous().length) { + return this.previous().some(i => i.withContent()) + } + return true + } + + outputFile() { + if (this.opts.to) { + return this.path(this.opts.to) + } else if (this.opts.from) { + return this.path(this.opts.from) + } else { + return 'to.css' + } + } + + path(file) { + if (this.mapOpts.absolute) return file + if (file.charCodeAt(0) === 60 /* `<` */) return file + if (/^\w+:\/\//.test(file)) return file + let cached = this.memoizedPaths.get(file) + if (cached) return cached + + let from = this.opts.to ? dirname(this.opts.to) : '.' + + if (typeof this.mapOpts.annotation === 'string') { + from = dirname(resolve(from, this.mapOpts.annotation)) + } + + let path = relative(from, file) + this.memoizedPaths.set(file, path) + + return path + } + + previous() { + if (!this.previousMaps) { + this.previousMaps = [] + if (this.root) { + this.root.walk(node => { + if (node.source && node.source.input.map) { + let map = node.source.input.map + if (!this.previousMaps.includes(map)) { + this.previousMaps.push(map) + } + } + }) + } else { + let input = new Input(this.originalCSS, this.opts) + if (input.map) this.previousMaps.push(input.map) + } + } + + return this.previousMaps + } + + setSourcesContent() { + let already = {} + if (this.root) { + this.root.walk(node => { + if (node.source) { + let from = node.source.input.from + if (from && !already[from]) { + already[from] = true + let fromUrl = this.usesFileUrls + ? this.toFileUrl(from) + : this.toUrl(this.path(from)) + this.map.setSourceContent(fromUrl, node.source.input.css) + } + } + }) + } else if (this.css) { + let from = this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + this.map.setSourceContent(from, this.css) + } + } + + sourcePath(node) { + if (this.mapOpts.from) { + return this.toUrl(this.mapOpts.from) + } else if (this.usesFileUrls) { + return this.toFileUrl(node.source.input.from) + } else { + return this.toUrl(this.path(node.source.input.from)) + } + } + + toBase64(str) { + if (Buffer) { + return Buffer.from(str).toString('base64') + } else { + return window.btoa(unescape(encodeURIComponent(str))) + } + } + + toFileUrl(path) { + let cached = this.memoizedFileURLs.get(path) + if (cached) return cached + + if (pathToFileURL) { + let fileURL = pathToFileURL(path).toString() + this.memoizedFileURLs.set(path, fileURL) + + return fileURL + } else { + throw new Error( + '`map.absolute` option is not available in this PostCSS build' + ) + } + } + + toUrl(path) { + let cached = this.memoizedURLs.get(path) + if (cached) return cached + + if (sep === '\\') { + path = path.replace(/\\/g, '/') + } + + let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent) + this.memoizedURLs.set(path, url) + + return url + } +} + +module.exports = MapGenerator diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.d.ts new file mode 100644 index 00000000..fa9d2848 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.d.ts @@ -0,0 +1,45 @@ +import LazyResult from './lazy-result.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace NoWorkResult { + export { NoWorkResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root` + * are accessed. See the example below for details. + * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined. + * + * ```js + * const noWorkResult = postcss().process(css) // No plugins are defined. + * // CSS is not parsed + * let root = noWorkResult.root // now css is parsed because we accessed the root + * ``` + */ +declare class NoWorkResult_ implements LazyResult { + catch: Promise>['catch'] + finally: Promise>['finally'] + then: Promise>['then'] + get content(): string + get css(): string + get map(): SourceMap + get messages(): Message[] + get opts(): ResultOptions + get processor(): Processor + get root(): Root + get [Symbol.toStringTag](): string + constructor(processor: Processor, css: string, opts: ResultOptions) + async(): Promise> + sync(): Result + toString(): string + warnings(): Warning[] +} + +declare class NoWorkResult extends NoWorkResult_ {} + +export = NoWorkResult diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.js new file mode 100644 index 00000000..7ec1a742 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.js @@ -0,0 +1,137 @@ +'use strict' + +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let stringify = require('./stringify') +let warnOnce = require('./warn-once') + +class NoWorkResult { + get content() { + return this.result.css + } + + get css() { + return this.result.css + } + + get map() { + return this.result.map + } + + get messages() { + return [] + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + if (this._root) { + return this._root + } + + let root + let parser = parse + + try { + root = parser(this._css, this._opts) + } catch (error) { + this.error = error + } + + if (this.error) { + throw this.error + } else { + this._root = root + return root + } + } + + get [Symbol.toStringTag]() { + return 'NoWorkResult' + } + + constructor(processor, css, opts) { + css = css.toString() + this.stringified = false + + this._processor = processor + this._css = css + this._opts = opts + this._map = undefined + + let str = stringify + this.result = new Result(this._processor, undefined, this._opts) + this.result.css = css + + let self = this + Object.defineProperty(this.result, 'root', { + get() { + return self.root + } + }) + + let map = new MapGenerator(str, undefined, this._opts, css) + if (map.isMap()) { + let [generatedCSS, generatedMap] = map.generate() + if (generatedCSS) { + this.result.css = generatedCSS + } + if (generatedMap) { + this.result.map = generatedMap + } + } else { + map.clearAnnotation() + this.result.css = map.css + } + } + + async() { + if (this.error) return Promise.reject(this.error) + return Promise.resolve(this.result) + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + sync() { + if (this.error) throw this.error + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this._opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this._css + } + + warnings() { + return [] + } +} + +module.exports = NoWorkResult +NoWorkResult.default = NoWorkResult diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.d.ts new file mode 100644 index 00000000..e93ce5ba --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.d.ts @@ -0,0 +1,555 @@ +import AtRule = require('./at-rule.js') +import { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document from './document.js' +import Input from './input.js' +import { Stringifier, Syntax } from './postcss.js' +import Result from './result.js' +import Root from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +declare namespace Node { + export type ChildNode = AtRule.default | Comment | Declaration | Rule + + export type AnyNode = + | AtRule.default + | Comment + | Declaration + | Document + | Root + | Rule + + export type ChildProps = + | AtRuleProps + | CommentProps + | DeclarationProps + | RuleProps + + export interface Position { + /** + * Source column in file. It starts from 1. + */ + column: number + + /** + * Source line in file. It starts from 1. + */ + line: number + + /** + * Source offset in file. It starts from 0. + */ + offset: number + } + + export interface Range { + /** + * End position, exclusive. + */ + end: Position + + /** + * Start position, inclusive. + */ + start: Position + } + + /** + * Source represents an interface for the {@link Node.source} property. + */ + export interface Source { + /** + * The inclusive ending position for the source + * code of a node. + * + * However, `end.offset` of a non `Root` node is the exclusive position. + * See https://github.com/postcss/postcss/pull/1879 for details. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const a = root.first + * const color = a.first + * + * // The offset of `Root` node is the inclusive position + * css.source.end // { line: 1, column: 19, offset: 18 } + * + * // The offset of non `Root` node is the exclusive position + * a.source.end // { line: 1, column: 18, offset: 18 } + * color.source.end // { line: 1, column: 16, offset: 16 } + * ``` + */ + end?: Position + + /** + * The source file from where a node has originated. + */ + input: Input + + /** + * The inclusive starting position for the source + * code of a node. + */ + start?: Position + } + + /** + * Interface represents an interface for an object received + * as parameter by Node class constructor. + */ + export interface NodeProps { + source?: Source + } + + export interface NodeErrorOptions { + /** + * An ending index inside a node's string that should be highlighted as + * source of error. + */ + endIndex?: number + /** + * An index inside a node's string that should be highlighted as source + * of error. + */ + index?: number + /** + * Plugin name that created this error. PostCSS will set it automatically. + */ + plugin?: string + /** + * A word inside a node's string, that should be highlighted as source + * of error. + */ + word?: string + } + + class Node extends Node_ {} + export { Node as default } +} + +/** + * It represents an abstract class that handles common + * methods for other CSS abstract syntax tree nodes. + * + * Any node that represents CSS selector or value should + * not extend the `Node` class. + */ +declare abstract class Node_ { + /** + * It represents parent of the current node. + * + * ```js + * root.nodes[0].parent === root //=> true + * ``` + */ + parent: Container | Document | undefined + + /** + * It represents unnecessary whitespace and characters present + * in the css source code. + * + * Information to generate byte-to-byte equal node string as it was + * in the origin input. + * + * The properties of the raws object are decided by parser, + * the default parser uses the following properties: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * * `afterName`: the space between the at-rule name and its parameters. + * * `left`: the space symbols between `/*` and the comment’s text. + * * `right`: the space symbols between the comment’s text + * and */. + * - `important`: the content of the important statement, + * if it is not just `!important`. + * + * PostCSS filters out the comments inside selectors, declaration values + * and at-rule parameters but it stores the origin content in raws. + * + * ```js + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '\n ', between: ':' } + * ``` + */ + raws: any + + /** + * It represents information related to origin of a node and is required + * for generating source maps. + * + * The nodes that are created manually using the public APIs + * provided by PostCSS will have `source` undefined and + * will be absent in the source map. + * + * For this reason, the plugin developer should consider + * duplicating nodes as the duplicate node will have the + * same source as the original node by default or assign + * source to a node created manually. + * + * ```js + * decl.source.input.from //=> '/home/ai/source.css' + * decl.source.start //=> { line: 10, column: 2 } + * decl.source.end //=> { line: 10, column: 12 } + * ``` + * + * ```js + * // Incorrect method, source not specified! + * const prefixed = postcss.decl({ + * prop: '-moz-' + decl.prop, + * value: decl.value + * }) + * + * // Correct method, source is inherited when duplicating. + * const prefixed = decl.clone({ + * prop: '-moz-' + decl.prop + * }) + * ``` + * + * ```js + * if (atrule.name === 'add-link') { + * const rule = postcss.rule({ + * selector: 'a', + * source: atrule.source + * }) + * + * atrule.parent.insertBefore(atrule, rule) + * } + * ``` + */ + source?: Node.Source + + /** + * It represents type of a node in + * an abstract syntax tree. + * + * A type of node helps in identification of a node + * and perform operation based on it's type. + * + * ```js + * const declaration = new Declaration({ + * prop: 'color', + * value: 'black' + * }) + * + * declaration.type //=> 'decl' + * ``` + */ + type: string + + constructor(defaults?: object) + + /** + * Insert new node after current node to current node’s parent. + * + * Just alias for `node.parent.insertAfter(node, add)`. + * + * ```js + * decl.after('color: black') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + after( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * It assigns properties to an existing node instance. + * + * ```js + * decl.assign({ prop: 'word-wrap', value: 'break-word' }) + * ``` + * + * @param overrides New properties to override the node. + * + * @return `this` for method chaining. + */ + assign(overrides: object): this + + /** + * Insert new node before current node to current node’s parent. + * + * Just alias for `node.parent.insertBefore(node, add)`. + * + * ```js + * decl.before('content: ""') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + before( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * Clear the code style properties for the node and its children. + * + * ```js + * node.raws.before //=> ' ' + * node.cleanRaws() + * node.raws.before //=> undefined + * ``` + * + * @param keepBetween Keep the `raws.between` symbols. + */ + cleanRaws(keepBetween?: boolean): void + + /** + * It creates clone of an existing node, which includes all the properties + * and their values, that includes `raws` but not `type`. + * + * ```js + * decl.raws.before //=> "\n " + * const cloned = decl.clone({ prop: '-moz-' + decl.prop }) + * cloned.raws.before //=> "\n " + * cloned.toString() //=> -moz-transform: scale(0) + * ``` + * + * @param overrides New properties to override in the clone. + * + * @return Duplicate of the node instance. + */ + clone(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * after the current node. + * + * @param overrides New properties to override in the clone. + * @return New node. + */ + cloneAfter(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * before the current node. + * + * ```js + * decl.cloneBefore({ prop: '-moz-' + decl.prop }) + * ``` + * + * @param overrides Mew properties to override in the clone. + * + * @return New node + */ + cloneBefore(overrides?: object): this + + /** + * It creates an instance of the class `CssSyntaxError` and parameters passed + * to this method are assigned to the error instance. + * + * The error instance will have description for the + * error, original position of the node in the + * source, showing line and column number. + * + * If any previous map is present, it would be used + * to get original position of the source. + * + * The Previous Map here is referred to the source map + * generated by previous compilation, example: Less, + * Stylus and Sass. + * + * This method returns the error instance instead of + * throwing it. + * + * ```js + * if (!variables[name]) { + * throw decl.error(`Unknown variable ${name}`, { word: name }) + * // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black + * // color: $black + * // a + * // ^ + * // background: white + * } + * ``` + * + * @param message Description for the error instance. + * @param options Options for the error instance. + * + * @return Error instance is returned. + */ + error(message: string, options?: Node.NodeErrorOptions): CssSyntaxError + + /** + * Returns the next child of the node’s parent. + * Returns `undefined` if the current node is the last child. + * + * ```js + * if (comment.text === 'delete next') { + * const next = comment.next() + * if (next) { + * next.remove() + * } + * } + * ``` + * + * @return Next node. + */ + next(): Node.ChildNode | undefined + + /** + * Get the position for a word or an index inside the node. + * + * @param opts Options. + * @return Position. + */ + positionBy(opts?: Pick): Node.Position + + /** + * Convert string index to line/column. + * + * @param index The symbol number in the node’s string. + * @return Symbol position in file. + */ + positionInside(index: number): Node.Position + + /** + * Returns the previous child of the node’s parent. + * Returns `undefined` if the current node is the first child. + * + * ```js + * const annotation = decl.prev() + * if (annotation.type === 'comment') { + * readAnnotation(annotation.text) + * } + * ``` + * + * @return Previous node. + */ + prev(): Node.ChildNode | undefined + + /** + * Get the range for a word or start and end index inside the node. + * The start index is inclusive; the end index is exclusive. + * + * @param opts Options. + * @return Range. + */ + rangeBy( + opts?: Pick + ): Node.Range + + /** + * Returns a `raws` value. If the node is missing + * the code style property (because the node was manually built or cloned), + * PostCSS will try to autodetect the code style property by looking + * at other nodes in the tree. + * + * ```js + * const root = postcss.parse('a { background: white }') + * root.nodes[0].append({ prop: 'color', value: 'black' }) + * root.nodes[0].nodes[1].raws.before //=> undefined + * root.nodes[0].nodes[1].raw('before') //=> ' ' + * ``` + * + * @param prop Name of code style property. + * @param defaultType Name of default value, it can be missed + * if the value is the same as prop. + * @return {string} Code style value. + */ + raw(prop: string, defaultType?: string): string + + /** + * It removes the node from its parent and deletes its parent property. + * + * ```js + * if (decl.prop.match(/^-webkit-/)) { + * decl.remove() + * } + * ``` + * + * @return `this` for method chaining. + */ + remove(): this + + /** + * Inserts node(s) before the current node and removes the current node. + * + * ```js + * AtRule: { + * mixin: atrule => { + * atrule.replaceWith(mixinRules[atrule.params]) + * } + * } + * ``` + * + * @param nodes Mode(s) to replace current one. + * @return Current node to methods chain. + */ + replaceWith(...nodes: NewChild[]): this + + /** + * Finds the Root instance of the node’s tree. + * + * ```js + * root.nodes[0].nodes[0].root() === root + * ``` + * + * @return Root parent. + */ + root(): Root + + /** + * Fix circular links on `JSON.stringify()`. + * + * @return Cleaned object. + */ + toJSON(): object + + /** + * It compiles the node to browser readable cascading style sheets string + * depending on it's type. + * + * ```js + * new Rule({ selector: 'a' }).toString() //=> "a {}" + * ``` + * + * @param stringifier A syntax to use in string generation. + * @return CSS string of this node. + */ + toString(stringifier?: Stringifier | Syntax): string + + /** + * It is a wrapper for {@link Result#warn}, providing convenient + * way of generating warnings. + * + * ```js + * Declaration: { + * bad: (decl, { result }) => { + * decl.warn(result, 'Deprecated property: bad') + * } + * } + * ``` + * + * @param result The `Result` instance that will receive the warning. + * @param message Description for the warning. + * @param options Options for the warning. + * + * @return `Warning` instance is returned + */ + warn(result: Result, message: string, options?: WarningOptions): Warning + + /** + * If this node isn't already dirty, marks it and its ancestors as such. This + * indicates to the LazyResult processor that the {@link Root} has been + * modified by the current plugin and may need to be processed again by other + * plugins. + */ + protected markDirty(): void +} + +declare class Node extends Node_ {} + +export = Node diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.js new file mode 100644 index 00000000..a298d365 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.js @@ -0,0 +1,494 @@ +'use strict' + +let CssSyntaxError = require('./css-syntax-error') +let Stringifier = require('./stringifier') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') + +function cloneNode(obj, parent) { + let cloned = new obj.constructor() + // An explicit stack instead of recursive calls to survive deeply + // nested trees. Each entry is [source, its clone, clone's parent]. + let stack = [[obj, cloned, parent]] + + while (stack.length > 0) { + let [source, target, targetParent] = stack.pop() + for (let i in source) { + if (!Object.prototype.hasOwnProperty.call(source, i)) { + /* c8 ignore next 2 */ + continue + } + if (i === 'proxyCache') continue + let value = source[i] + let type = typeof value + + if (i === 'parent' && type === 'object') { + if (targetParent) target[i] = targetParent + } else if (i === 'source') { + target[i] = value + } else if (Array.isArray(value)) { + let children = [] + target[i] = children + for (let j of value) { + let childClone = new j.constructor() + children.push(childClone) + stack.push([j, childClone, target]) + } + } else { + if (type === 'object' && value !== null) { + let valueClone = new value.constructor() + stack.push([value, valueClone, undefined]) + value = valueClone + } + target[i] = value + } + } + } + + return cloned +} + +function sourceOffset(inputCSS, position) { + // Not all custom syntaxes support `offset` in `source.start` and `source.end` + if (position && typeof position.offset !== 'undefined') { + return position.offset + } + + let column = 1 + let line = 1 + let offset = 0 + + for (let i = 0; i < inputCSS.length; i++) { + if (line === position.line && column === position.column) { + offset = i + break + } + + if (inputCSS[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return offset +} + +class Node { + get proxyOf() { + return this + } + + constructor(defaults = {}) { + this.raws = {} + this[isClean] = false + this[my] = true + + for (let name of Object.keys(defaults)) { + if (name === '__proto__') continue + if (name === 'nodes') { + this.nodes = [] + for (let node of defaults[name]) { + // Clone only nodes that already belong to another tree, so passing a + // freshly created (parent-less) node adopts that instance instead of + // a copy and keeps the caller's reference usable. See #1987. + if (typeof node.clone === 'function' && node.parent) { + this.append(node.clone()) + } else { + this.append(node) + } + } + } else { + this[name] = defaults[name] + } + } + } + + addToError(error) { + error.postcssNode = this + if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { + let s = this.source + error.stack = error.stack.replace( + /\n\s{4}at /, + `$&${s.input.from}:${s.start.line}:${s.start.column}$&` + ) + } + return error + } + + after(add) { + this.parent.insertAfter(this, add) + return this + } + + assign(overrides = {}) { + for (let name in overrides) { + this[name] = overrides[name] + } + return this + } + + before(add) { + this.parent.insertBefore(this, add) + return this + } + + cleanRaws(keepBetween) { + delete this.raws.before + delete this.raws.after + if (!keepBetween) delete this.raws.between + } + + clone(overrides = {}) { + let cloned = cloneNode(this) + for (let name in overrides) { + cloned[name] = overrides[name] + } + return cloned + } + + cloneAfter(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertAfter(this, cloned) + return cloned + } + + cloneBefore(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertBefore(this, cloned) + return cloned + } + + error(message, opts = {}) { + if (this.source) { + let { end, start } = this.rangeBy(opts) + return this.source.input.error( + message, + { column: start.column, line: start.line }, + { column: end.column, line: end.line }, + opts + ) + } + return new CssSyntaxError(message) + } + + getProxyProcessor() { + return { + get(node, prop) { + if (prop === 'proxyOf') { + return node + } else if (prop === 'root') { + return () => node.root().toProxy() + } else { + return node[prop] + } + }, + + set(node, prop, value) { + if (node[prop] === value) return true + node[prop] = value + if ( + prop === 'prop' || + prop === 'value' || + prop === 'name' || + prop === 'params' || + prop === 'important' || + /* c8 ignore next */ + prop === 'text' + ) { + node.markDirty() + } + return true + } + } + } + + /* c8 ignore next 3 */ + markClean() { + this[isClean] = true + } + + markDirty() { + if (this[isClean]) { + this[isClean] = false + let next = this + while ((next = next.parent)) { + next[isClean] = false + } + } + } + + next() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index + 1] + } + + positionBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let pos = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + if (opts.index) { + pos = this.positionInside(opts.index) + } else if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) pos = this.positionInside(index) + } + return pos + } + + positionInside(index) { + let column = this.source.start.column + let line = this.source.start.line + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let offset = sourceOffset(inputString, this.source.start) + let end = offset + index + + for (let i = offset; i < end; i++) { + if (inputString[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return { column, line, offset: end } + } + + prev() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index - 1] + } + + rangeBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let start = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + let end = this.source.end + ? { + column: this.source.end.column + 1, + line: this.source.end.line, + offset: + typeof this.source.end.offset === 'number' + ? // `source.end.offset` is exclusive, so we don't need to add 1 + this.source.end.offset + : // Since line/column in this.source.end is inclusive, + // the `sourceOffset(... , this.source.end)` returns an inclusive offset. + // So, we add 1 to convert it to exclusive. + sourceOffset(inputString, this.source.end) + 1 + } + : { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + + if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) { + start = this.positionInside(index) + end = this.positionInside(index + opts.word.length) + } + } else { + if (opts.start) { + start = { + column: opts.start.column, + line: opts.start.line, + offset: sourceOffset(inputString, opts.start) + } + } else if (typeof opts.index === 'number') { + start = this.positionInside(opts.index) + } + + if (opts.end) { + end = { + column: opts.end.column, + line: opts.end.line, + offset: sourceOffset(inputString, opts.end) + } + } else if (typeof opts.endIndex === 'number') { + end = this.positionInside(opts.endIndex) + } else if (typeof opts.index === 'number') { + end = this.positionInside(opts.index + 1) + } + } + + if ( + end.line < start.line || + (end.line === start.line && end.column <= start.column) + ) { + end = { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + } + + return { end, start } + } + + raw(prop, defaultType) { + let str = new Stringifier() + return str.raw(this, prop, defaultType) + } + + remove() { + if (this.parent) { + this.parent.removeChild(this) + } + this.parent = undefined + return this + } + + replaceWith(...nodes) { + if (this.parent) { + let bookmark = this + let foundSelf = false + for (let node of nodes) { + if (node === this) { + foundSelf = true + } else if (foundSelf) { + this.parent.insertAfter(bookmark, node) + bookmark = node + } else { + this.parent.insertBefore(bookmark, node) + } + } + + if (!foundSelf) { + this.remove() + } + } + + return this + } + + root() { + let result = this + while (result.parent && result.parent.type !== 'document') { + result = result.parent + } + return result + } + + toJSON(_, inputs) { + let emitInputs = inputs == null + inputs = inputs || new Map() + + // A worklist instead of recursive `toJSON()` calls to survive deeply + // nested trees. Each entry converts one node and writes the result + // into the already converted parent by [holder, key]. + let holderOfRoot = [] + let queue = [[this, holderOfRoot, 0]] + + for (let step = 0; step < queue.length; step++) { + let [node, holder, key] = queue[step] + let fixed = {} + holder[key] = fixed + + for (let name in node) { + if (!Object.prototype.hasOwnProperty.call(node, name)) { + /* c8 ignore next 2 */ + continue + } + if (name === 'parent' || name === 'proxyCache') continue + let value = node[name] + + if (Array.isArray(value)) { + let fixedArray = [] + fixed[name] = fixedArray + for (let i = 0; i < value.length; i++) { + let item = value[i] + if (typeof item === 'object' && item.toJSON) { + if (item.toJSON === Node.prototype.toJSON) { + queue.push([item, fixedArray, i]) + } else { + fixedArray[i] = item.toJSON(null, inputs) + } + } else { + fixedArray[i] = item + } + } + } else if (typeof value === 'object' && value.toJSON) { + if (value.toJSON === Node.prototype.toJSON) { + queue.push([value, fixed, name]) + } else { + fixed[name] = value.toJSON(null, inputs) + } + } else if (name === 'source') { + if (value == null) continue + let inputId = inputs.get(value.input) + if (inputId == null) { + inputId = inputs.size + inputs.set(value.input, inputId) + } + fixed[name] = { + end: value.end, + inputId, + start: value.start + } + } else { + fixed[name] = value + } + } + } + + let fixed = holderOfRoot[0] + if (emitInputs) { + fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) + } + + return fixed + } + + toProxy() { + if (!this.proxyCache) { + this.proxyCache = new Proxy(this, this.getProxyProcessor()) + } + return this.proxyCache + } + + toString(stringifier = stringify) { + if (stringifier.stringify) stringifier = stringifier.stringify + let result = '' + stringifier(this, i => { + result += i + }) + return result + } + + warn(result, text, opts = {}) { + let data = { node: this } + for (let i in opts) data[i] = opts[i] + return result.warn(text, data) + } +} + +module.exports = Node +Node.default = Node diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.d.ts new file mode 100644 index 00000000..ffe35b43 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.d.ts @@ -0,0 +1,9 @@ +import { Parser } from './postcss.js' + +interface Parse extends Parser { + default: Parse +} + +declare let parse: Parse + +export = parse diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.js new file mode 100644 index 00000000..00a1037a --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.js @@ -0,0 +1,42 @@ +'use strict' + +let Container = require('./container') +let Input = require('./input') +let Parser = require('./parser') + +function parse(css, opts) { + let input = new Input(css, opts) + let parser = new Parser(input) + try { + parser.parse() + } catch (e) { + if (process.env.NODE_ENV !== 'production') { + if (e.name === 'CssSyntaxError' && opts && opts.from) { + if (/\.scss$/i.test(opts.from)) { + e.message += + '\nYou tried to parse SCSS with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-scss parser' + } else if (/\.sass/i.test(opts.from)) { + e.message += + '\nYou tried to parse Sass with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-sass parser' + } else if (/\.less$/i.test(opts.from)) { + e.message += + '\nYou tried to parse Less with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-less parser' + } + } + } + throw e + } + + return parser.root +} + +module.exports = parse +parse.default = parse + +Container.registerParse(parse) diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parser.js b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parser.js new file mode 100644 index 00000000..f549f56d --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parser.js @@ -0,0 +1,621 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Root = require('./root') +let Rule = require('./rule') +let tokenizer = require('./tokenize') + +const SAFE_COMMENT_NEIGHBOR = { + empty: true, + space: true +} + +function findLastWithPosition(tokens) { + for (let i = tokens.length - 1; i >= 0; i--) { + let token = tokens[i] + let pos = token[3] || token[2] + if (pos) return pos + } +} + +function tokensToString(tokens, from, to) { + let result = '' + for (let i = from; i < to; i++) result += tokens[i][1] + return result +} + +class Parser { + constructor(input) { + this.input = input + + this.root = new Root() + this.current = this.root + this.spaces = '' + this.semicolon = false + + this.createTokenizer() + this.root.source = { input, start: { column: 1, line: 1, offset: 0 } } + } + + atrule(token) { + let node = new AtRule() + node.name = token[1].slice(1) + if (node.name === '') { + this.unnamedAtrule(node, token) + } + this.init(node, token[2]) + + let type + let prev + let shift + let last = false + let open = false + let params = [] + let brackets = [] + + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + type = token[0] + + if (type === '(' || type === '[') { + brackets.push(type === '(' ? ')' : ']') + } else if (type === '{' && brackets.length > 0) { + brackets.push('}') + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + } + + if (brackets.length === 0) { + if (type === ';') { + node.source.end = this.getPosition(token[2]) + node.source.end.offset++ + this.semicolon = true + break + } else if (type === '{') { + open = true + break + } else if (type === '}') { + if (params.length > 0) { + shift = params.length - 1 + prev = params[shift] + while (prev && prev[0] === 'space') { + prev = params[--shift] + } + if (prev) { + node.source.end = this.getPosition(prev[3] || prev[2]) + node.source.end.offset++ + } + } + this.end(token) + break + } else { + params.push(token) + } + } else { + params.push(token) + } + + if (this.tokenizer.endOfFile()) { + last = true + break + } + } + + node.raws.between = this.spacesAndCommentsFromEnd(params) + if (params.length) { + node.raws.afterName = this.spacesAndCommentsFromStart(params) + this.raw(node, 'params', params) + if (last) { + token = params[params.length - 1] + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + this.spaces = node.raws.between + node.raws.between = '' + } + } else { + node.raws.afterName = '' + node.params = '' + } + + if (open) { + node.nodes = [] + this.current = node + } + } + + checkMissedSemicolon(tokens) { + let colon = this.colon(tokens) + if (colon === false) return + + let founded = 0 + let token + for (let j = colon - 1; j >= 0; j--) { + token = tokens[j] + if (token[0] !== 'space') { + founded += 1 + if (founded === 2) break + } + } + // If the token is a word, e.g. `!important`, `red` or any other valid + // property's value. Then we need to return the colon after that word + // token. [3] is the "end" colon of that word. And because we need it + // after that one we do +1 to get the next one. + throw this.input.error( + 'Missed semicolon', + token[0] === 'word' ? token[3] + 1 : token[2] + ) + } + + colon(tokens) { + let brackets = 0 + let prev, token, type + for (let [i, element] of tokens.entries()) { + token = element + type = token[0] + + if (type === '(') { + brackets += 1 + } + if (type === ')') { + brackets -= 1 + } + if (brackets === 0 && type === ':') { + if (!prev) { + this.doubleColon(token) + } else if (prev[0] === 'word' && prev[1] === 'progid') { + continue + } else { + return i + } + } + + prev = token + } + return false + } + + comment(token) { + let node = new Comment() + this.init(node, token[2]) + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + + let text = token[1].slice(2, -2) + if (!text.trim()) { + node.text = '' + node.raws.left = text + node.raws.right = '' + } else { + let match = text.match(/^(\s*)([^]*\S)(\s*)$/) + node.text = match[2] + node.raws.left = match[1] + node.raws.right = match[3] + } + } + + createTokenizer() { + this.tokenizer = tokenizer(this.input) + } + + decl(tokens, customProperty) { + let node = new Declaration() + this.init(node, tokens[0][2]) + + let last = tokens[tokens.length - 1] + if (last[0] === ';') { + this.semicolon = true + tokens.pop() + } + + node.source.end = this.getPosition( + last[3] || last[2] || findLastWithPosition(tokens) + ) + node.source.end.offset++ + + let start = 0 + while (tokens[start][0] !== 'word') { + if (start === tokens.length - 1) this.unknownWord([tokens[start]]) + start++ + } + node.raws.before += tokensToString(tokens, 0, start) + node.source.start = this.getPosition(tokens[start][2]) + + let propStart = start + while (start < tokens.length) { + let type = tokens[start][0] + if (type === ':' || type === 'space' || type === 'comment') { + break + } + start++ + } + node.prop = tokensToString(tokens, propStart, start) + + let betweenStart = start + let token + while (start < tokens.length) { + token = tokens[start] + start++ + if (token[0] === ':') break + if (token[0] === 'word' && /\w/.test(token[1])) { + this.unknownWord([token]) + } + } + node.raws.between = tokensToString(tokens, betweenStart, start) + + if (node.prop[0] === '_' || node.prop[0] === '*') { + node.raws.before += node.prop[0] + node.prop = node.prop.slice(1) + } + + let firstSpacesStart = start + while (start < tokens.length) { + let next = tokens[start][0] + if (next !== 'space' && next !== 'comment') break + start++ + } + let firstSpaces = tokens.slice(firstSpacesStart, start) + + tokens = tokens.slice(start) + + this.precheckMissedSemicolon(tokens) + + for (let i = tokens.length - 1; i >= 0; i--) { + token = tokens[i] + if (token[1].toLowerCase() === '!important') { + node.important = true + let string = this.stringFrom(tokens, i) + string = this.spacesFromEnd(tokens) + string + if (string !== ' !important') node.raws.important = string + break + } else if (token[1].toLowerCase() === 'important') { + let cache = tokens.slice(0) + let str = '' + for (let j = i; j > 0; j--) { + let type = cache[j][0] + if (str.trim().startsWith('!') && type !== 'space') { + break + } + str = cache.pop()[1] + str + } + if (str.trim().startsWith('!')) { + node.important = true + node.raws.important = str + tokens = cache + } + } + + if (token[0] !== 'space' && token[0] !== 'comment') { + break + } + } + + let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') + + if (hasWord) { + node.raws.between += firstSpaces.map(i => i[1]).join('') + firstSpaces = [] + } + this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) + + if (node.value.includes(':') && !customProperty) { + this.checkMissedSemicolon(tokens) + } + } + + doubleColon(token) { + throw this.input.error( + 'Double colon', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } + + emptyRule(token) { + let node = new Rule() + this.init(node, token[2]) + node.selector = '' + node.raws.between = '' + this.current = node + } + + end(token) { + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.semicolon = false + + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.spaces = '' + + if (this.current.parent) { + this.current.source.end = this.getPosition(token[2]) + this.current.source.end.offset++ + this.current = this.current.parent + } else { + this.unexpectedClose(token) + } + } + + endFile() { + if (this.current.parent) this.unclosedBlock() + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.root.source.end = this.getPosition(this.tokenizer.position()) + } + + freeSemicolon(token) { + this.spaces += token[1] + if (this.current.nodes) { + let prev = this.current.nodes[this.current.nodes.length - 1] + if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { + prev.raws.ownSemicolon = this.spaces + this.spaces = '' + // `ownSemicolon` also holds the spaces before the semicolon, but + // the position above is the semicolon itself, so the node ends + // right after it. + prev.source.end = this.getPosition(token[2]) + prev.source.end.offset++ + } + } + } + + // Helpers + + getPosition(offset) { + let pos = this.input.fromOffset(offset) + return { + column: pos.col, + line: pos.line, + offset + } + } + + init(node, offset) { + this.current.push(node) + node.source = { + input: this.input, + start: this.getPosition(offset) + } + node.raws.before = this.spaces + this.spaces = '' + if (node.type !== 'comment') this.semicolon = false + } + + other(start) { + let end = false + let type = null + let colon = false + let bracket = null + let brackets = [] + let customProperty = start[1].startsWith('--') + + let tokens = [] + let token = start + while (token) { + type = token[0] + tokens.push(token) + + if (type === '(' || type === '[') { + if (!bracket) bracket = token + brackets.push(type === '(' ? ')' : ']') + } else if (customProperty && colon && type === '{') { + if (!bracket) bracket = token + brackets.push('}') + } else if (brackets.length === 0) { + if (type === ';') { + if (colon) { + this.decl(tokens, customProperty) + return + } else { + break + } + } else if (type === '{') { + this.rule(tokens) + return + } else if (type === '}') { + this.tokenizer.back(tokens.pop()) + end = true + break + } else if (type === ':') { + colon = true + } + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + if (brackets.length === 0) bracket = null + } + + token = this.tokenizer.nextToken() + } + + if (this.tokenizer.endOfFile()) end = true + if (brackets.length > 0) this.unclosedBracket(bracket) + + if (end && colon) { + if (!customProperty) { + while (tokens.length) { + token = tokens[tokens.length - 1][0] + if (token !== 'space' && token !== 'comment') break + this.tokenizer.back(tokens.pop()) + } + } + this.decl(tokens, customProperty) + } else { + this.unknownWord(tokens) + } + } + + parse() { + let token + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + + switch (token[0]) { + case 'space': + this.spaces += token[1] + break + + case ';': + this.freeSemicolon(token) + break + + case '}': + this.end(token) + break + + case 'comment': + this.comment(token) + break + + case 'at-word': + this.atrule(token) + break + + case '{': + this.emptyRule(token) + break + + default: + this.other(token) + break + } + } + this.endFile() + } + + precheckMissedSemicolon(/* tokens */) { + // Hook for Safe Parser + } + + raw(node, prop, tokens, customProperty) { + let token, type + let length = tokens.length + let value = '' + let clean = true + let next, prev + + for (let i = 0; i < length; i += 1) { + token = tokens[i] + type = token[0] + if (type === 'space' && i === length - 1 && !customProperty) { + clean = false + } else if (type === 'comment') { + prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' + next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' + if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { + if (value.slice(-1) === ',') { + clean = false + } else { + value += token[1] + } + } else { + clean = false + } + } else { + value += token[1] + } + } + if (!clean) { + let raw = tokens.reduce((all, i) => all + i[1], '') + node.raws[prop] = { raw, value } + } + node[prop] = value + } + + rule(tokens) { + tokens.pop() + + let node = new Rule() + this.init(node, tokens[0][2]) + + node.raws.between = this.spacesAndCommentsFromEnd(tokens) + this.raw(node, 'selector', tokens) + this.current = node + } + + spacesAndCommentsFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space' && lastTokenType !== 'comment') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + // Errors + + spacesAndCommentsFromStart(tokens) { + let next + let spaces = '' + while (tokens.length) { + next = tokens[0][0] + if (next !== 'space' && next !== 'comment') break + spaces += tokens.shift()[1] + } + return spaces + } + + spacesFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + stringFrom(tokens, from) { + let result = '' + for (let i = from; i < tokens.length; i++) { + result += tokens[i][1] + } + tokens.splice(from, tokens.length - from) + return result + } + + unclosedBlock() { + let pos = this.current.source.start + throw this.input.error('Unclosed block', pos.line, pos.column) + } + + unclosedBracket(bracket) { + throw this.input.error( + 'Unclosed bracket', + { offset: bracket[2] }, + { offset: bracket[2] + 1 } + ) + } + + unexpectedClose(token) { + throw this.input.error( + 'Unexpected }', + { offset: token[2] }, + { offset: token[2] + 1 } + ) + } + + unknownWord(tokens) { + throw this.input.error( + 'Unknown word ' + tokens[0][1], + { offset: tokens[0][2] }, + { offset: tokens[0][2] + tokens[0][1].length } + ) + } + + unnamedAtrule(node, token) { + throw this.input.error( + 'At-rule without name', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } +} + +module.exports = Parser diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.mts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.mts new file mode 100644 index 00000000..eaec8681 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.mts @@ -0,0 +1,66 @@ +export { + // Type-only exports + AcceptedPlugin, + AnyNode, + atRule, + AtRule, + AtRuleProps, + Builder, + ChildNode, + ChildProps, + comment, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + decl, + Declaration, + DeclarationProps, + // postcss function / namespace + default, + document, + Document, + DocumentProps, + FilePosition, + fromJSON, + Helpers, + Input, + JSONHydrator, + // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here. + type LazyResult, + list, + Message, + Node, + NodeErrorOptions, + NodeProps, + OldPlugin, + parse, + Parser, + // @ts-expect-error This value exists, but it’s untyped. + plugin, + Plugin, + PluginCreator, + Position, + Postcss, + ProcessOptions, + Processor, + Result, + root, + Root, + RootProps, + rule, + Rule, + RuleProps, + Source, + SourceMap, + SourceMapOptions, + Stringifier, + // Value exports from postcss.mjs + stringify, + Syntax, + TransformCallback, + Transformer, + Warning, + WarningOptions +} from './postcss.js' diff --git a/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.ts b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.ts new file mode 100644 index 00000000..41bf40f9 --- /dev/null +++ b/backend/node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.d.ts @@ -0,0 +1,464 @@ +import { RawSourceMap, SourceMapGenerator } from 'source-map-js' + +import AtRule, { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { ContainerProps, NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document, { DocumentProps } from './document.js' +import Input, { FilePosition } from './input.js' +import LazyResult from './lazy-result.js' +import list from './list.js' +import Node, { + AnyNode, + ChildNode, + ChildProps, + NodeErrorOptions, + NodeProps, + Position, + Source +} from './node.js' +import Processor from './processor.js' +import Result, { Message } from './result.js' +import Root, { RootProps } from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +type DocumentProcessor = ( + document: Document, + helper: postcss.Helpers +) => Promise | void +type RootProcessor = ( + root: Root, + helper: postcss.Helpers +) => Promise | void +type DeclarationProcessor = ( + decl: Declaration, + helper: postcss.Helpers +) => Promise | void +type RuleProcessor = ( + rule: Rule, + helper: postcss.Helpers +) => Promise | void +type AtRuleProcessor = ( + atRule: AtRule, + helper: postcss.Helpers +) => Promise | void +type CommentProcessor = ( + comment: Comment, + helper: postcss.Helpers +) => Promise | void + +interface Processors { + /** + * Will be called on all`AtRule` nodes. + * + * Will be called again on node or children changes. + */ + AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `AtRule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + AtRuleExit?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `Comment` nodes. + * + * Will be called again on node or children changes. + */ + Comment?: CommentProcessor + + /** + * Will be called on all `Comment` nodes after listeners + * for `Comment` event. + * + * Will be called again on node or children changes. + */ + CommentExit?: CommentProcessor + + /** + * Will be called on all `Declaration` nodes after listeners + * for `Declaration` event. + * + * Will be called again on node or children changes. + */ + Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor + + /** + * Will be called on all `Declaration` nodes. + * + * Will be called again on node or children changes. + */ + DeclarationExit?: + | { [prop: string]: DeclarationProcessor } + | DeclarationProcessor + + /** + * Will be called on `Document` node. + * + * Will be called again on children changes. + */ + Document?: DocumentProcessor + + /** + * Will be called on `Document` node, when all children will be processed. + * + * Will be called again on children changes. + */ + DocumentExit?: DocumentProcessor + + /** + * Will be called on `Root` node once. + */ + Once?: RootProcessor + + /** + * Will be called on `Root` node once, when all children will be processed. + */ + OnceExit?: RootProcessor + + /** + * Will be called on `Root` node. + * + * Will be called again on children changes. + */ + Root?: RootProcessor + + /** + * Will be called on `Root` node, when all children will be processed. + * + * Will be called again on children changes. + */ + RootExit?: RootProcessor + + /** + * Will be called on all `Rule` nodes. + * + * Will be called again on node or children changes. + */ + Rule?: RuleProcessor + + /** + * Will be called on all `Rule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + RuleExit?: RuleProcessor +} + +declare namespace postcss { + export { + AnyNode, + AtRule, + AtRuleProps, + ChildNode, + ChildProps, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + Declaration, + DeclarationProps, + Document, + DocumentProps, + FilePosition, + Input, + LazyResult, + list, + Message, + NewChild, + Node, + NodeErrorOptions, + NodeProps, + Position, + Processor, + Result, + Root, + RootProps, + Rule, + RuleProps, + Source, + Warning, + WarningOptions + } + + export type SourceMap = { + toJSON(): RawSourceMap + } & SourceMapGenerator + + export type Helpers = { postcss: Postcss; result: Result } & Postcss + + export interface Plugin extends Processors { + postcssPlugin: string + prepare?: (result: Result) => Processors + } + + export interface PluginCreator { + (opts?: PluginOptions): Plugin | Processor + postcss: true + } + + export interface Transformer extends TransformCallback { + postcssPlugin: string + postcssVersion: string + } + + export interface TransformCallback { + (root: Root, result: Result): Promise | void + } + + export interface OldPlugin extends Transformer { + (opts?: T): Transformer + postcss: Transformer + } + + export type AcceptedPlugin = + | { + postcss: Processor | TransformCallback + } + | OldPlugin + | Plugin + | PluginCreator + | Processor + | TransformCallback + + export interface Parser { + ( + css: { toString(): string } | string, + opts?: Pick + ): RootNode + } + + export interface Builder { + (part: string, node?: AnyNode, type?: 'end' | 'start'): void + } + + export interface Stringifier { + (node: AnyNode, builder: Builder): void + } + + export interface JSONHydrator { + (data: object): Node + (data: object[]): Node[] + } + + export interface Syntax { + /** + * Function to generate AST by string. + */ + parse?: Parser + + /** + * Class to generate string by AST. + */ + stringify?: Stringifier + } + + export interface SourceMapOptions { + /** + * Use absolute path in generated source map. + */ + absolute?: boolean + + /** + * Indicates that PostCSS should add annotation comments to the CSS. + * By default, PostCSS will always add a comment with a path + * to the source map. PostCSS will not add annotations to CSS files + * that do not contain any comments. + * + * By default, PostCSS presumes that you want to save the source map as + * `opts.to + '.map'` and will use this path in the annotation comment. + * A different path can be set by providing a string value for annotation. + * + * If you have set `inline: true`, annotation cannot be disabled. + */ + annotation?: ((file: string, root: Root) => string) | boolean | string + + /** + * Override `from` in map’s sources. + */ + from?: string + + /** + * Indicates that the source map should be embedded in the output CSS + * as a Base64-encoded comment. By default, it is `true`. + * But if all previous maps are external, not inline, PostCSS will not embed + * the map even if you do not set this option. + * + * If you have an inline source map, the result.map property will be empty, + * as the source map will be contained within the text of `result.css`. + */ + inline?: boolean + + /** + * Source map content from a previous processing step (e.g., Sass). + * + * PostCSS will try to read the previous source map + * automatically (based on comments within the source CSS), but you can use + * this option to identify it manually. + * + * If desired, you can omit the previous map with prev: `false`. + */ + prev?: ((file: string) => string) | boolean | object | string + + /** + * Indicates that PostCSS should set the origin content (e.g., Sass source) + * of the source map. By default, it is true. But if all previous maps do not + * contain sources content, PostCSS will also leave it out even if you + * do not set this option. + */ + sourcesContent?: boolean + } + + export interface ProcessOptions { + /** + * Input file if it is not simple CSS file, but HTML with + + `; +} +//#endregion +//#region src/node/server/middlewares/indexHtml.ts +function createDevHtmlTransformFn(config) { + const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(config.plugins); + const transformHooks = [ + preImportMapHook(config), + injectCspNonceMetaTagHook(config), + ...preHooks, + htmlEnvHook(config), + devHtmlHook, + ...normalHooks, + ...postHooks, + injectNonceAttributeTagHook(config), + postImportMapHook(config) + ]; + const pluginContext = new BasicMinimalPluginContext({ + ...basePluginContextMeta, + watchMode: true + }, config.logger); + return (server, url, html, originalUrl) => { + return applyHtmlTransforms(html, transformHooks, pluginContext, { + path: url, + filename: getHtmlFilename(url, server), + server, + originalUrl + }); + }; +} +function getHtmlFilename(url, server) { + if (url.startsWith(FS_PREFIX)) return decodeURIComponent(fsPathFromId(url)); + else return decodeURIComponent(normalizePath(path.join(server.config.root, url.slice(1)))); +} +function shouldPreTransform(url, config) { + return !checkPublicFile(url, config) && (isJSRequest(url) || isCSSRequest(url)); +} +const wordCharRE = /\w/; +function isBareRelative(url) { + return wordCharRE.test(url[0]) && !url.includes(":"); +} +function getHtmlDirnameForRelativeUrl(htmlPath) { + return htmlPath.endsWith("/") ? htmlPath : path.posix.dirname(htmlPath); +} +const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, server, isClassicScriptLink) => { + const replacer = (url) => { + if (url[0] === "/" && url[1] !== "/" || (url[0] === "." || isBareRelative(url)) && originalUrl && originalUrl !== "/" && htmlPath === "/index.html") url = path.posix.join(config.base, url); + let preTransformUrl; + if (!isClassicScriptLink && shouldPreTransform(url, config)) { + if (url[0] === "/" && url[1] !== "/") preTransformUrl = url; + else if (url[0] === "." || isBareRelative(url)) preTransformUrl = path.posix.join(config.base, getHtmlDirnameForRelativeUrl(htmlPath), url); + } + if (server) { + const mod = server.environments.client.moduleGraph.urlToModuleMap.get(stripBase(preTransformUrl || url, config.decodedBase)); + if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`); + } + if (server && preTransformUrl) { + try { + preTransformUrl = decodeURI(preTransformUrl); + } catch { + return url; + } + preTransformRequest(server, preTransformUrl, config.decodedBase); + } + return url; + }; + return useSrcSetReplacer ? processSrcSetSync(url, ({ url }) => replacer(url)) : replacer(url); +}; +const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => { + const { config, watcher } = server; + const base = config.base || "/"; + const decodedBase = config.decodedBase || "/"; + let proxyModulePath; + let proxyModuleUrl; + const trailingSlash = htmlPath.endsWith("/"); + if (!trailingSlash && fs.existsSync(filename)) { + proxyModulePath = htmlPath.startsWith(FS_PREFIX) ? filename : htmlPath; + proxyModuleUrl = htmlPath; + } else { + proxyModulePath = `\0${`${htmlPath}${trailingSlash ? "index.html" : ""}`}`; + proxyModuleUrl = wrapId(proxyModulePath); + } + proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl); + const s = new MagicString(html); + let inlineModuleIndex = -1; + const proxyCacheUrl = decodeURI(cleanUrl(proxyModulePath).replace(normalizePath(config.root), "")); + const styleUrl = []; + const inlineStyles = []; + const inlineModulePaths = []; + const addInlineModule = (node, ext) => { + inlineModuleIndex++; + const contentNode = node.childNodes[0]; + const code = contentNode.value; + let map; + if (proxyModulePath[0] !== "\0") { + map = new MagicString(html).snip(contentNode.sourceCodeLocation.startOffset, contentNode.sourceCodeLocation.endOffset).generateMap({ hires: "boundary" }); + map.sources = [filename]; + map.file = filename; + } + addToHTMLProxyCache(config, proxyCacheUrl, inlineModuleIndex, { + code, + map + }); + const modulePath = `${proxyModuleUrl}?html-proxy&index=${inlineModuleIndex}.${ext}`; + inlineModulePaths.push(modulePath); + s.update(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset, `