Base UI

node_modules/@babel/generator/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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.

node_modules/@babel/generator/README.md

@@ -0,0 +1,19 @@
+# @babel/generator
+
+> Turns an AST into code.
+
+See our website [@babel/generator](https://babeljs.io/docs/babel-generator) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/generator
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/generator --dev
+```

node_modules/@babel/generator/lib/index.d.ts

@@ -0,0 +1,96 @@
+import * as t from '@babel/types';
+import { Opts } from 'jsesc';
+import { EncodedSourceMap, DecodedSourceMap, Mapping } from '@jridgewell/gen-mapping';
+
+interface GeneratorOptions {
+    /**
+     * Optional string to add as a block comment at the start of the output file.
+     */
+    auxiliaryCommentBefore?: string;
+    /**
+     * Optional string to add as a block comment at the end of the output file.
+     */
+    auxiliaryCommentAfter?: string;
+    /**
+     * Function that takes a comment (as a string) and returns true if the comment should be included in the output.
+     * By default, comments are included if `opts.comments` is `true` or if `opts.minified` is `false` and the comment
+     * contains `@preserve` or `@license`.
+     */
+    shouldPrintComment?(comment: string): boolean;
+    /**
+     * Preserve the input code format while printing the transformed code.
+     * This is experimental, and may have breaking changes in future
+     * patch releases. It will be removed in a future minor release,
+     * when it will graduate to stable.
+     */
+    experimental_preserveFormat?: boolean;
+    /**
+     * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces).
+     * Defaults to `false`.
+     */
+    retainLines?: boolean;
+    /**
+     * Retain parens around function expressions (could be used to change engine parsing behavior)
+     * Defaults to `false`.
+     */
+    retainFunctionParens?: boolean;
+    /**
+     * Should comments be included in output? Defaults to `true`.
+     */
+    comments?: boolean;
+    /**
+     * Set to true to avoid adding whitespace for formatting. Defaults to the value of `opts.minified`.
+     */
+    compact?: boolean | "auto";
+    /**
+     * Should the output be minified. Defaults to `false`.
+     */
+    minified?: boolean;
+    /**
+     * Set to true to reduce whitespace (but not as much as opts.compact). Defaults to `false`.
+     */
+    concise?: boolean;
+    /**
+     * Used in warning messages
+     */
+    filename?: string;
+    /**
+     * Enable generating source maps. Defaults to `false`.
+     */
+    sourceMaps?: boolean;
+    inputSourceMap?: any;
+    /**
+     * A root for all relative URLs in the source map.
+     */
+    sourceRoot?: string;
+    /**
+     * The filename for the source code (i.e. the code in the `code` argument).
+     * This will only be used if `code` is a string.
+     */
+    sourceFileName?: string;
+    /**
+     * Options for outputting jsesc representation.
+     */
+    jsescOption?: Opts;
+    /**
+     * For use with the Hack-style pipe operator.
+     * Changes what token is used for pipe bodies’ topic references.
+     */
+    topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+interface GeneratorResult {
+    code: string;
+    map: EncodedSourceMap | null;
+    decodedMap: DecodedSourceMap | undefined;
+    rawMappings: Mapping[] | undefined;
+}
+/**
+ * Turns an AST into code, maintaining sourcemaps, user preferences, and valid output.
+ * @param ast - the abstract syntax tree from which to generate output code.
+ * @param opts - used for specifying options for code generation.
+ * @param code - the original source code, used for source maps.
+ * @returns - an object containing the output code and source map.
+ */
+declare function generate(ast: t.Node, opts?: GeneratorOptions, code?: string | Record<string, string>): GeneratorResult;
+
+export { type GeneratorOptions, type GeneratorResult, generate as default, generate };

node_modules/@babel/generator/node_modules/.bin/parser

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+else 
+  exec node  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+fi

node_modules/@babel/generator/node_modules/.bin/parser.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\@babel\parser\bin\babel-parser.js" %*

node_modules/@babel/generator/node_modules/.bin/parser.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  } else {
+    & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/@babel/generator/node_modules/@babel/helper-string-parser/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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.

node_modules/@babel/generator/node_modules/@babel/helper-string-parser/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-string-parser
+
+> A utility package to parse strings
+
+See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-string-parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-string-parser
+```

node_modules/@babel/generator/node_modules/@babel/helper-string-parser/lib/index.d.ts

@@ -0,0 +1,41 @@
+type StringContentsErrorHandlers = EscapedCharErrorHandlers & {
+    unterminated(initialPos: number, initialLineStart: number, initialCurLine: number): void;
+};
+declare function readStringContents(type: "single" | "double" | "template", input: string, pos: number, lineStart: number, curLine: number, errors: StringContentsErrorHandlers): {
+    pos: number;
+    str: string;
+    firstInvalidLoc: {
+        pos: number;
+        lineStart: number;
+        curLine: number;
+    } | null;
+    lineStart: number;
+    curLine: number;
+};
+type EscapedCharErrorHandlers = HexCharErrorHandlers & CodePointErrorHandlers & {
+    strictNumericEscape(pos: number, lineStart: number, curLine: number): void;
+};
+type HexCharErrorHandlers = IntErrorHandlers & {
+    invalidEscapeSequence(pos: number, lineStart: number, curLine: number): void;
+};
+type IntErrorHandlers = {
+    numericSeparatorInEscapeSequence(pos: number, lineStart: number, curLine: number): void;
+    unexpectedNumericSeparator(pos: number, lineStart: number, curLine: number): void;
+    invalidDigit(pos: number, lineStart: number, curLine: number, radix: number): boolean;
+};
+declare function readInt(input: string, pos: number, lineStart: number, curLine: number, radix: number, len: number | undefined, forceLen: boolean, allowNumSeparator: boolean | "bail", errors: IntErrorHandlers, bailOnError: boolean): {
+    n: null;
+    pos: number;
+} | {
+    n: number;
+    pos: number;
+};
+type CodePointErrorHandlers = HexCharErrorHandlers & {
+    invalidCodePoint(pos: number, lineStart: number, curLine: number): void;
+};
+declare function readCodePoint(input: string, pos: number, lineStart: number, curLine: number, throwOnInvalid: boolean, errors: CodePointErrorHandlers): {
+    code: number | null;
+    pos: number;
+};
+
+export { type CodePointErrorHandlers, type IntErrorHandlers, type StringContentsErrorHandlers, readCodePoint, readInt, readStringContents };

node_modules/@babel/generator/node_modules/@babel/helper-string-parser/lib/index.js

@@ -0,0 +1,287 @@
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
+}
+
+export { readCodePoint, readInt, readStringContents };
+//# sourceMappingURL=index.js.map

node_modules/@babel/generator/node_modules/@babel/helper-string-parser/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-string-parser",
+  "version": "8.0.0",
+  "description": "A utility package to parse strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-string-parser"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "devDependencies": {
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module"
+}

node_modules/@babel/generator/node_modules/@babel/helper-validator-identifier/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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.

node_modules/@babel/generator/node_modules/@babel/helper-validator-identifier/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-validator-identifier
+
+> Validate identifier/keywords name
+
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-identifier
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-identifier
+```

node_modules/@babel/generator/node_modules/@babel/helper-validator-identifier/lib/index.d.ts

@@ -0,0 +1,28 @@
+declare function isIdentifierStart(code: number): boolean;
+declare function isIdentifierChar(code: number): boolean;
+declare function isIdentifierName(name: string): boolean;
+
+/**
+ * Checks if word is a reserved word in non-strict mode
+ */
+declare function isReservedWord(word: string, inModule: boolean): boolean;
+/**
+ * Checks if word is a reserved word in non-binding strict mode
+ *
+ * Includes non-strict reserved words
+ */
+declare function isStrictReservedWord(word: string, inModule: boolean): boolean;
+/**
+ * Checks if word is a reserved word in binding strict mode, but it is allowed as
+ * a normal identifier.
+ */
+declare function isStrictBindOnlyReservedWord(word: string): boolean;
+/**
+ * Checks if word is a reserved word in binding strict mode
+ *
+ * Includes non-strict reserved words and non-binding strict reserved words
+ */
+declare function isStrictBindReservedWord(word: string, inModule: boolean): boolean;
+declare function isKeyword(word: string): boolean;
+
+export { isIdentifierChar, isIdentifierName, isIdentifierStart, isKeyword, isReservedWord, isStrictBindOnlyReservedWord, isStrictBindReservedWord, isStrictReservedWord };

node_modules/@babel/generator/node_modules/@babel/helper-validator-identifier/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "8.0.2",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-17.0.0": "^1.6.10",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "module"
+}

node_modules/@babel/generator/node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 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.

node_modules/@babel/generator/node_modules/@babel/parser/README.md

@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```

node_modules/@babel/generator/node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { parse } from "..";
+import { readFileSync } from "node:fs";
+
+const filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  const file = readFileSync(filename, "utf8");
+  const ast = parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

node_modules/@babel/generator/node_modules/@babel/parser/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@babel/parser",
+  "version": "8.0.0",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
+  "dependencies": {
+    "@babel/types": "^8.0.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^8.0.0",
+    "@babel/helper-check-duplicate-nodes": "^8.0.0",
+    "@babel/helper-fixtures": "^8.0.0",
+    "@babel/helper-string-parser": "^8.0.0",
+    "@babel/helper-validator-identifier": "^8.0.0",
+    "charcodes": "^0.2.0",
+    "typescript": "6.0.2"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

node_modules/@babel/generator/node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -0,0 +1,620 @@
+import { File, Expression } from "@babel/types";
+
+// This file is auto-generated! Do not modify it directly.
+// Run `make bundle-babel-parser-dts` to re-generate it.
+/* eslint-disable @typescript-eslint/consistent-type-imports, @typescript-eslint/no-redundant-type-constituents */
+
+declare class Position {
+  line: number;
+  column: number;
+  index: number;
+  constructor(line: number, col: number, index?: number);
+}
+//# sourceMappingURL=module-errors.d.ts.map
+
+type LValAncestor =
+  | {
+      type: "UpdateExpression";
+      prefix: boolean;
+    }
+  | {
+      type:
+        | "ArrayPattern"
+        | "AssignmentExpression"
+        | "CatchClause"
+        | "ForOfStatement"
+        | "FormalParameters"
+        | "ForInStatement"
+        | "ForStatement"
+        | "ImportSpecifier"
+        | "ImportNamespaceSpecifier"
+        | "ImportDefaultSpecifier"
+        | "ParenthesizedExpression"
+        | "ObjectPattern"
+        | "RestElement"
+        | "VariableDeclarator";
+    };
+//# sourceMappingURL=bind-operator-errors.d.ts.map
+
+type Accessibility = "public" | "protected" | "private";
+type VarianceAnnotations = "in" | "out";
+
+type Plugin$1 =
+  | "asyncDoExpressions"
+  | "decorators"
+  | "decorators-legacy"
+  | "decoratorAutoAccessors"
+  | "deferredImportEvaluation"
+  | "destructuringPrivate"
+  | "doExpressions"
+  | "exportDefaultFrom"
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | "moduleBlocks"
+  | "placeholders"
+  | "sourcePhaseImports"
+  | "throwExpressions"
+  | "v8intrinsic"
+  | ParserPluginWithOptions[0];
+
+type ParserPluginWithOptions =
+  | ["discardBinding", { syntaxType: "void" }]
+  | ["estree", { classFeatures?: boolean }]
+  | ["optionalChainingAssign", { version: "2023-07" }]
+  | ["partialApplication", PartialApplicationPluginOptions]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+type PluginConfig = Plugin$1 | ParserPluginWithOptions;
+
+interface PartialApplicationPluginOptions {
+  version: "2018-07";
+}
+
+interface PipelineOperatorPluginOptions {
+  proposal: "fsharp" | "hack";
+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+
+interface FlowPluginOptions {
+  all?: boolean;
+}
+
+interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+type TsModifier =
+  | "readonly"
+  | "abstract"
+  | "declare"
+  | "static"
+  | "override"
+  | "const"
+  | Accessibility
+  | VarianceAnnotations;
+type EnumExplicitType = null | "boolean" | "number" | "string" | "symbol";
+
+type ParseError = SyntaxError & {
+  missingPlugin?: string | string[];
+  loc: Position;
+  pos: number;
+} & ErrorInfo;
+type __PatchMe = Decompress<ErrorInfoCompressed>;
+type ErrorInfo = __PatchMe | never;
+type ErrorInfoCompressed = {
+  ImportMetaOutsideModule: [object, "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"];
+  ImportOutsideModule: [object, "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"];
+  AccessorIsGenerator: [{ kind: "get" | "set" }];
+  ArgumentsInClass: [];
+  AsyncFunctionInSingleStatementContext: [];
+  AwaitBindingIdentifier: [];
+  AwaitBindingIdentifierInStaticBlock: [];
+  AwaitExpressionFormalParameter: [];
+  AwaitUsingNotInAsyncContext: [];
+  AwaitNotInAsyncContext: [];
+  BadGetterArity: [];
+  BadSetterArity: [];
+  BadSetterRestParameter: [];
+  ConstructorClassField: [];
+  ConstructorClassPrivateField: [];
+  ConstructorIsAccessor: [];
+  ConstructorIsAsync: [];
+  ConstructorIsGenerator: [];
+  DeclarationMissingInitializer: [
+    { kind: "await using" | "const" | "destructuring" | "using" },
+  ];
+  DecoratorArgumentsOutsideParentheses: [];
+  DecoratorsBeforeAfterExport: [];
+  DecoratorConstructor: [];
+  DecoratorSemicolon: [];
+  DecoratorStaticBlock: [];
+  DeferImportRequiresNamespace: [];
+  DeletePrivateField: [];
+  DestructureNamedImport: [];
+  DuplicateConstructor: [];
+  DuplicateDefaultExport: [];
+  DuplicateExport: [{ exportName: string }];
+  DuplicateProto: [];
+  DuplicateRegExpFlags: [];
+  ElementAfterRest: [];
+  EscapedCharNotAnIdentifier: [];
+  ExportBindingIsString: [{ localName: string; exportName: string }];
+  ExportDefaultFromAsIdentifier: [];
+  ForInOfLoopInitializer: [{ type: "ForInStatement" | "ForOfStatement" }];
+  ForInUsing: [];
+  ForOfAsync: [];
+  ForOfLet: [];
+  GeneratorInSingleStatementContext: [];
+  IllegalBreakContinue: [{ type: "BreakStatement" | "ContinueStatement" }];
+  IllegalLanguageModeDirective: [];
+  IllegalReturn: [];
+  ImportBindingIsString: [{ importName: string }];
+  ImportCallArity: [{ phase?: string | null | undefined }];
+  ImportCallNotNewExpression: [{ phase?: string | null | undefined }];
+  ImportCallSpreadArgument: [{ phase?: string | null | undefined }];
+  IncompatibleRegExpUVFlags: [];
+  InvalidBigIntLiteral: [];
+  InvalidCodePoint: [];
+  InvalidCoverDiscardElement: [];
+  InvalidCoverInitializedName: [];
+  InvalidDigit: [{ radix: number }];
+  InvalidEscapeSequence: [];
+  InvalidEscapeSequenceTemplate: [];
+  InvalidEscapedReservedWord: [{ reservedWord: string }];
+  InvalidIdentifier: [{ identifierName: string }];
+  InvalidLhs: [{ ancestor: LValAncestor }];
+  InvalidLhsBinding: [{ ancestor: LValAncestor }];
+  InvalidLhsOptionalChaining: [{ ancestor: LValAncestor }];
+  InvalidNumber: [];
+  InvalidOrMissingExponent: [];
+  InvalidOrUnexpectedToken: [{ unexpected: string }];
+  InvalidParenthesizedAssignment: [];
+  InvalidPrivateFieldResolution: [{ identifierName: string }];
+  InvalidPropertyBindingPattern: [];
+  InvalidRestAssignmentPattern: [];
+  LabelRedeclaration: [{ labelName: string }];
+  LetInLexicalBinding: [];
+  LineTerminatorBeforeArrow: [];
+  MalformedRegExpFlags: [];
+  MissingClassName: [];
+  MissingEqInAssignment: [];
+  MissingSemicolon: [];
+  MissingPlugin: [{ missingPlugin: [string] }];
+  MissingOneOfPlugins: [{ missingPlugin: string[] }];
+  MissingUnicodeEscape: [];
+  MixingCoalesceWithLogical: [];
+  ModuleAttributeInvalidValue: [];
+  ModuleAttributesWithDuplicateKeys: [{ key: string }];
+  ModuleExportNameHasLoneSurrogate: [{ surrogateCharCode: number }];
+  ModuleExportUndefined: [{ localName: string }];
+  MultipleDefaultsInSwitch: [];
+  NewlineAfterThrow: [];
+  NoCatchOrFinally: [];
+  NumberIdentifier: [];
+  NumericSeparatorInEscapeSequence: [];
+  ObsoleteAwaitStar: [];
+  OptionalChainingNoNew: [];
+  OptionalChainingNoTemplate: [];
+  OverrideOnConstructor: [];
+  ParamDupe: [];
+  PatternHasAccessor: [];
+  PatternHasMethod: [];
+  PrivateInExpectedIn: [{ identifierName: string }];
+  PrivateNameRedeclaration: [{ identifierName: string }];
+  RestTrailingComma: [];
+  SloppyFunction: [];
+  SloppyFunctionAnnexB: [];
+  SourcePhaseImportRequiresDefault: [];
+  StaticPrototype: [];
+  SuperCallNotNewExpression: [];
+  SuperNotAllowed: [];
+  SuperPrivateField: [];
+  TrailingDecorator: [];
+  UnexpectedArgumentPlaceholder: [];
+  UnexpectedDigitAfterHash: [];
+  UnexpectedImportExport: [];
+  UnexpectedKeyword: [{ keyword: string }];
+  UnexpectedLeadingDecorator: [];
+  UnexpectedLexicalDeclaration: [];
+  UnexpectedNewTarget: [];
+  UnexpectedNumericSeparator: [];
+  UnexpectedPrivateField: [];
+  UnexpectedReservedWord: [{ reservedWord: string }];
+  UnexpectedSuper: [];
+  UnexpectedTokenUnaryExponentiation: [];
+  UnexpectedUsingDeclaration: [];
+  UnexpectedVoidPattern: [];
+  UnsupportedDecoratorExport: [];
+  UnsupportedDefaultExport: [];
+  UnsupportedImport: [];
+  UnsupportedMetaProperty: [{ target: string; onlyValidPropertyName: string }];
+  UnsupportedParameterDecorator: [];
+  UnsupportedPropertyDecorator: [];
+  UnsupportedSuper: [];
+  UnterminatedComment: [];
+  UnterminatedRegExp: [];
+  UnterminatedString: [];
+  UnterminatedTemplate: [];
+  UsingDeclarationExport: [];
+  UsingDeclarationHasBindingPattern: [];
+  VarRedeclaration: [{ identifierName: string }];
+  VoidPatternCatchClauseParam: [];
+  VoidPatternInitializer: [];
+  YieldBindingIdentifier: [];
+  YieldInParameter: [];
+  YieldNotInGeneratorFunction: [];
+  ZeroDigitNumericSeparator: [];
+  StrictDelete: [];
+  StrictEvalArguments: [{ referenceName: string }];
+  StrictEvalArgumentsBinding: [{ bindingName: string }];
+  StrictFunction: [];
+  StrictNumericEscape: [];
+  StrictOctalLiteral: [];
+  StrictWith: [];
+  ParseExpressionEmptyInput: [];
+  ParseExpressionExpectsEOF: [{ unexpected: number }];
+  UnsupportedBind: [];
+  UnsupportedBindRHS: [];
+  PipeTopicRequiresHackPipes: [];
+  PipeTopicUnbound: [];
+  PipeTopicUnconfiguredToken: [{ token: string }];
+  PipeTopicUnused: [];
+  PipeUnparenthesizedBody: [
+    {
+      type:
+        | "AssignmentExpression"
+        | "ArrowFunctionExpression"
+        | "ConditionalExpression"
+        | "YieldExpression";
+    },
+  ];
+  PipelineUnparenthesized: [];
+  AbstractMethodHasImplementation: [{ methodName: string }];
+  AbstractPropertyHasInitializer: [{ propertyName: string }];
+  AccessorCannotBeOptional: [];
+  AccessorCannotDeclareThisParameter: [];
+  AccessorCannotHaveTypeParameters: [];
+  ClassMethodHasDeclare: [];
+  ClassMethodHasReadonly: [];
+  ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: [];
+  ConstructorHasTypeParameters: [];
+  DeclareAccessor: [{ kind: "get" | "set" }];
+  DeclareClassFieldHasInitializer: [];
+  DeclareFunctionHasImplementation: [];
+  DecoratorAbstractMethod: [
+    { kind: "abstract method" | "abstract field" | "declare field" },
+  ];
+  DuplicateAccessibilityModifier: [{ modifier: Accessibility }];
+  DuplicateModifier: [{ modifier: TsModifier }];
+  EmptyHeritageClauseType: [{ token: "extends" | "implements" }];
+  EmptyTypeArguments: [];
+  EmptyTypeParameters: [];
+  ExpectedAmbientAfterExportDeclare: [];
+  ExportAssignmentInTSNamespace: [];
+  ExportInTSNamespace: [];
+  ImportAliasHasImportType: [];
+  ImportInTSNamespace: [];
+  IncompatibleModifiers: [{ modifiers: [TsModifier, TsModifier] }];
+  IndexSignatureHasAbstract: [];
+  IndexSignatureHasAccessibility: [{ modifier: Accessibility }];
+  IndexSignatureHasDeclare: [];
+  IndexSignatureHasOverride: [];
+  IndexSignatureHasStatic: [];
+  InitializerNotAllowedInAmbientContext: [];
+  InlineModuleDeclarationMustUseString: [];
+  InvalidHeritageClauseType: [{ token: "extends" | "implements" }];
+  InvalidModifierOnAwaitUsingDeclaration: [
+    | "const"
+    | Accessibility
+    | "readonly"
+    | "abstract"
+    | "declare"
+    | "static"
+    | "override"
+    | VarianceAnnotations,
+  ];
+  InvalidModifierOnTypeMember: [{ modifier: TsModifier }];
+  InvalidModifierOnTypeParameter: [{ modifier: TsModifier }];
+  InvalidModifierOnTypeParameterPositions: [{ modifier: TsModifier }];
+  InvalidModifierOnUsingDeclaration: [
+    | "const"
+    | Accessibility
+    | "readonly"
+    | "abstract"
+    | "declare"
+    | "static"
+    | "override"
+    | VarianceAnnotations,
+  ];
+  InvalidModifiersOrder: [{ orderedModifiers: [TsModifier, TsModifier] }];
+  InvalidPropertyAccessAfterInstantiationExpression: [];
+  InvalidTupleMemberLabel: [];
+  MissingInterfaceName: [];
+  NamespaceExportInTSNamespace: [];
+  NonAbstractClassHasAbstractMethod: [];
+  NonClassMethodPropertyHasAbstractModifier: [];
+  OptionalTypeBeforeRequired: [];
+  OverrideNotInSubClass: [];
+  PrivateElementHasAbstract: [];
+  PrivateElementHasAccessibility: [{ modifier: Accessibility }];
+  ReadonlyForMethodSignature: [];
+  ReservedArrowTypeParam: [];
+  ReservedTypeAssertion: [];
+  SetAccessorCannotHaveOptionalParameter: [];
+  SetAccessorCannotHaveRestParameter: [];
+  SetAccessorCannotHaveReturnType: [];
+  SingleTypeParameterWithoutTrailingComma: [{ typeParameterName: string }];
+  StaticBlockCannotHaveModifier: [];
+  TupleOptionalAfterType: [];
+  TypeAnnotationAfterAssign: [];
+  TypeImportCannotSpecifyDefaultAndNamed: [];
+  TypeModifierIsUsedInTypeExports: [];
+  TypeModifierIsUsedInTypeImports: [];
+  UnexpectedParameterInitializer: [];
+  UnexpectedParameterModifier: [];
+  UnexpectedReadonly: [];
+  UnexpectedTypeAnnotation: [];
+  UnexpectedTypeCastInParameter: [];
+  UnexpectedTypeDeclaration: ["interface" | "type"];
+  UnsupportedImportTypeArgument: [];
+  UnsupportedParameterPropertyKind: [];
+  UnsupportedSignatureParameterKind: [{ type: string }];
+  UsingDeclarationInAmbientContext: ["await using" | "using"];
+  AmbiguousConditionalArrow: [];
+  AmbiguousDeclareModuleKind: [];
+  AssignReservedType: [{ reservedType: string }];
+  DeclareClassElement: [];
+  DeclareClassFieldInitializer: [];
+  DuplicateDeclareModuleExports: [];
+  EnumBooleanMemberNotInitialized: [{ memberName: string; enumName: string }];
+  EnumDuplicateMemberName: [{ memberName: string; enumName: string }];
+  EnumInconsistentMemberValues: [{ enumName: string }];
+  EnumInvalidExplicitType: [{ invalidEnumType: string; enumName: string }];
+  EnumInvalidExplicitTypeUnknownSupplied: [{ enumName: string }];
+  EnumInvalidMemberInitializerPrimaryType: [
+    { enumName: string; memberName: string; explicitType: EnumExplicitType },
+  ];
+  EnumInvalidMemberInitializerSymbolType: [
+    { enumName: string; memberName: string; explicitType: EnumExplicitType },
+  ];
+  EnumInvalidMemberInitializerUnknownType: [
+    { enumName: string; memberName: string; explicitType: EnumExplicitType },
+  ];
+  EnumInvalidMemberName: [
+    { enumName: string; memberName: string; suggestion: string },
+  ];
+  EnumNumberMemberNotInitialized: [{ enumName: string; memberName: string }];
+  EnumStringMemberInconsistentlyInitialized: [{ enumName: string }];
+  GetterMayNotHaveThisParam: [];
+  ImportTypeShorthandOnlyInPureImport: [];
+  InexactInsideExact: [];
+  InexactInsideNonObject: [];
+  InexactVariance: [];
+  InvalidNonTypeImportInDeclareModule: [];
+  MissingTypeParamDefault: [];
+  NestedDeclareModule: [];
+  NestedFlowComment: [];
+  SetterMayNotHaveThisParam: [];
+  SpreadVariance: [];
+  ThisParamAnnotationRequired: [];
+  ThisParamBannedInConstructor: [];
+  ThisParamMayNotBeOptional: [];
+  ThisParamMustBeFirst: [];
+  ThisParamNoDefault: [];
+  TypeBeforeInitializer: [];
+  TypeCastInPattern: [];
+  UnexpectedExplicitInexactInObject: [];
+  UnexpectedReservedType: [{ reservedType: string }];
+  UnexpectedReservedUnderscore: [];
+  UnexpectedSpaceBetweenModuloChecks: [];
+  UnexpectedSpreadType: [];
+  UnexpectedSubtractionOperand: [];
+  UnexpectedTokenAfterTypeParameter: [];
+  UnexpectedTypeParameterBeforeAsyncArrowFunction: [];
+  UnsupportedDeclareExportKind: [
+    { unsupportedExportKind: string; suggestion: string },
+  ];
+  UnsupportedStatementInDeclareModule: [];
+  UnterminatedFlowComment: [];
+  AttributeIsEmpty: [];
+  MissingClosingTagElement: [{ openingTagName: string }];
+  MissingClosingTagFragment: [];
+  UnexpectedSequenceExpression: [];
+  UnsupportedJsxValue: [];
+  UnterminatedJsxContent: [];
+  UnwrappedAdjacentJSXElements: [];
+  ClassNameIsRequired: [];
+  UnexpectedSpace: [];
+};
+type Decompress<T extends object> = {
+  [K in keyof T]: T[K] extends [infer Param, infer Code]
+    ? {
+        code: Code;
+        reasonCode: K;
+        details: Param;
+      }
+    : T[K] extends [infer Param]
+      ? {
+          code: "BABEL_PARSER_SYNTAX_ERROR";
+          reasonCode: K;
+          details: Param;
+        }
+      : T[K] extends []
+        ? {
+            code: "BABEL_PARSER_SYNTAX_ERROR";
+            reasonCode: K;
+            details: object;
+          }
+        : never;
+};
+
+type Plugin = PluginConfig;
+
+type SourceType = "script" | "commonjs" | "module" | "unambiguous";
+interface Options {
+  /**
+   * By default, import and export declarations can only appear at a program's top level.
+   * Setting this option to true allows them anywhere where a statement is allowed.
+   */
+  allowImportExportEverywhere?: boolean;
+  /**
+   * By default, await use is not allowed outside of an async function.
+   * Set this to true to accept such code.
+   */
+  allowAwaitOutsideFunction?: boolean;
+  /**
+   * By default, a return statement at the top level raises an error.
+   * Set this to true to accept such code.
+   */
+  allowReturnOutsideFunction?: boolean;
+  /**
+   * By default, new.target use is not allowed outside of a function or class.
+   * Set this to true to accept such code.
+   */
+  allowNewTargetOutsideFunction?: boolean;
+  /**
+   * By default, super calls are not allowed outside of a method.
+   * Set this to true to accept such code.
+   */
+  allowSuperOutsideMethod?: boolean;
+  /**
+   * By default, exported identifiers must refer to a declared variable.
+   * Set this to true to allow export statements to reference undeclared variables.
+   */
+  allowUndeclaredExports?: boolean;
+  /**
+   * By default, yield use is not allowed outside of a generator function.
+   * Set this to true to accept such code.
+   */
+  allowYieldOutsideFunction?: boolean;
+  /**
+   * By default, Babel parser JavaScript code according to Annex B syntax.
+   * Set this to `false` to disable such behavior.
+   */
+  annexB?: boolean;
+  /**
+   * By default, Babel attaches comments to adjacent AST nodes.
+   * When this option is set to false, comments are not attached.
+   * It can provide up to 30% performance improvement when the input code has many comments.
+   * @babel/eslint-parser will set it for you.
+   * It is not recommended to use attachComment: false with Babel transform,
+   * as doing so removes all the comments in output code, and renders annotations such as
+   * /* istanbul ignore next *\/ nonfunctional.
+   */
+  attachComment?: boolean;
+  /**
+   * By default, Babel always throws an error when it finds some invalid code.
+   * When this option is set to true, it will store the parsing error and
+   * try to continue parsing the invalid input file.
+   */
+  errorRecovery?: boolean;
+  /**
+   * Indicate the mode the code should be parsed in.
+   * Can be one of "script", "commonjs", "module", or "unambiguous". Defaults to "script".
+   * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+   * of ES6 import or export statements.
+   * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+   *
+   * Use "commonjs" to parse code that is intended to be run in a CommonJS environment such as Node.js.
+   */
+  sourceType?: SourceType;
+  /**
+   * Correlate output AST nodes with their source filename.
+   * Useful when generating code and source maps from the ASTs of multiple input files.
+   */
+  sourceFilename?: string;
+  /**
+   * By default, all source indexes start from 0.
+   * You can provide a start index to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startIndex?: number;
+  /**
+   * By default, the first line of code parsed is treated as line 1.
+   * You can provide a line number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startLine?: number;
+  /**
+   * By default, the parsed code is treated as if it starts from line 1, column 0.
+   * You can provide a column number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startColumn?: number;
+  /**
+   * Array containing the plugins that you want to enable.
+   */
+  plugins?: Plugin[];
+  /**
+   * Should the parser work in strict mode.
+   * Defaults to true if sourceType === 'module'. Otherwise, false.
+   */
+  strictMode?: boolean;
+  /**
+   * Adds a ranges property to each node: [node.start, node.end]
+   */
+  ranges?: boolean;
+  /**
+   * Adds a locations property to each node: [node.loc]
+   */
+  locations?: boolean;
+  /**
+   * Adds all parsed tokens to a tokens property on the File node.
+   */
+  tokens?: boolean;
+  /**
+   * By default, the parser adds information about parentheses by setting
+   * `extra.parenthesized` to `true` as needed.
+   * When this option is `true` the parser creates `ParenthesizedExpression`
+   * AST nodes instead of using the `extra` property.
+   */
+  createParenthesizedExpressions?: boolean;
+  /**
+   * By default, the parser parses import expressions as an `ImportExpression` node.
+   * Set this to false to parse it as `CallExpression(Import, [Identifier(foo)])`.
+   */
+  createImportExpressions?: boolean;
+}
+
+type ParserOptions = Partial<Options>;
+type ParseResult<Result extends File | Expression = File> = Result & {
+  comments: File["comments"];
+  errors: ParseError[];
+  tokens?: File["tokens"];
+};
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+declare function parse(
+  input: string,
+  options?: ParserOptions
+): ParseResult<File>;
+declare function parseExpression(
+  input: string,
+  options?: ParserOptions
+): ParseResult<Expression>;
+
+declare const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+export {
+  type FlowPluginOptions,
+  type ParseError,
+  type ParseResult,
+  type ParserOptions,
+  type PluginConfig as ParserPlugin,
+  type PipelineOperatorPluginOptions,
+  type TypeScriptPluginOptions,
+  parse,
+  parseExpression,
+  tokTypes,
+};

node_modules/@babel/generator/node_modules/@babel/types/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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.

node_modules/@babel/generator/node_modules/@babel/types/README.md

@@ -0,0 +1,19 @@
+# @babel/types
+
+> Babel Types is a Lodash-esque utility library for AST nodes
+
+See our website [@babel/types](https://babeljs.io/docs/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/types
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/types --dev
+```

node_modules/@babel/generator/node_modules/@babel/types/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@babel/types",
+  "version": "8.0.0",
+  "description": "Babel Types is a Lodash-esque utility library for AST nodes",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-types",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-types"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-string-parser": "^8.0.0",
+    "@babel/helper-validator-identifier": "^8.0.0"
+  },
+  "devDependencies": {
+    "@babel/generator": "^8.0.0",
+    "@babel/helper-fixtures": "^8.0.0",
+    "@babel/parser": "^8.0.0"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module"
+}

node_modules/@babel/generator/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@babel/generator",
+  "version": "8.0.0",
+  "description": "Turns an AST into code.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-generator"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-generator",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@babel/parser": "^8.0.0",
+    "@babel/types": "^8.0.0",
+    "@jridgewell/gen-mapping": "^0.3.12",
+    "@jridgewell/trace-mapping": "^0.3.28",
+    "@types/jsesc": "^2.5.0",
+    "jsesc": "^3.0.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^8.0.0",
+    "@babel/helper-fixtures": "^8.0.0",
+    "@babel/plugin-transform-typescript": "^8.0.0",
+    "@jridgewell/sourcemap-codec": "^1.5.3",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module"
+}