first

node_modules/@babel/parser/lib/parse-error/credentials.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instantiate = exports.ParseErrorCode = void 0;
+var ParseErrorCode = {
+  SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
+  SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
+};
+exports.ParseErrorCode = ParseErrorCode;
+const reflect = (keys, last = keys.length - 1) => ({
+  get() {
+    return keys.reduce((object, key) => object[key], this);
+  },
+  set(value) {
+    keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this);
+  }
+});
+const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? {
+  value: descriptor,
+  enumerable: false
+} : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({
+  configurable: true
+}, descriptor)), Object.assign(new constructor(), properties));
+exports.instantiate = instantiate;
+
+//# sourceMappingURL=credentials.js.map

node_modules/@babel/parser/lib/parse-error/credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ParseErrorCode","SyntaxError","SourceTypeModuleError","exports","reflect","keys","last","length","get","reduce","object","key","set","value","item","i","instantiate","constructor","properties","descriptors","Object","map","filter","descriptor","enumerable","assign","split","instance","defineProperty","configurable"],"sources":["../../src/parse-error/credentials.ts"],"sourcesContent":["export const enum ParseErrorCode {\n  SyntaxError = \"BABEL_PARSER_SYNTAX_ERROR\",\n  SourceTypeModuleError = \"BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED\",\n}\n\nexport type SyntaxPlugin =\n  | \"flow\"\n  | \"typescript\"\n  | \"jsx\"\n  | \"pipelineOperator\"\n  | \"placeholders\";\n\nexport type ToMessage<ErrorDetails> = (self: ErrorDetails) => string;\n\nexport type ParseErrorCredentials<ErrorDetails> = {\n  code: ParseErrorCode;\n  reasonCode: string;\n  syntaxPlugin?: SyntaxPlugin;\n  toMessage: ToMessage<ErrorDetails>;\n};\n\nconst reflect = (keys: string[], last = keys.length - 1) => ({\n  get(this: unknown): unknown {\n    return keys.reduce(\n      (object, key) =>\n        // @ts-expect-error key should index object\n        object[key],\n      this,\n    );\n  },\n  set(this: unknown, value: unknown) {\n    keys.reduce(\n      // @ts-expect-error key should index item\n      (item, key, i) => (i === last ? (item[key] = value) : item[key]),\n      this,\n    );\n  },\n});\n\nconst instantiate = <T>(\n  constructor: new () => T,\n  properties: any,\n  descriptors: any,\n) =>\n  Object.keys(descriptors)\n    .map(key => [key, descriptors[key]])\n    .filter(([, descriptor]) => !!descriptor)\n    .map(([key, descriptor]) => [\n      key,\n      typeof descriptor === \"function\"\n        ? { value: descriptor, enumerable: false }\n        : typeof descriptor.reflect === \"string\"\n        ? { ...descriptor, ...reflect(descriptor.reflect.split(\".\")) }\n        : descriptor,\n    ])\n    .reduce(\n      (instance, [key, descriptor]) =>\n        Object.defineProperty(instance, key, {\n          configurable: true,\n          ...descriptor,\n        }),\n      Object.assign(new constructor(), properties),\n    );\n\nexport { instantiate };\n"],"mappings":";;;;;;IAAkBA,cAAc;EAAAC,WAAA;EAAAC,qBAAA;AAAA;AAAAC,OAAA,CAAAH,cAAA,GAAAA,cAAA;AAqBhC,MAAMI,OAAO,GAAGA,CAACC,IAAc,EAAEC,IAAI,GAAGD,IAAI,CAACE,MAAM,GAAG,CAAC,MAAM;EAC3DC,GAAGA,CAAA,EAAyB;IAC1B,OAAOH,IAAI,CAACI,MAAM,CAChB,CAACC,MAAM,EAAEC,GAAG,KAEVD,MAAM,CAACC,GAAG,CAAC,EACb,IACF,CAAC;EACH,CAAC;EACDC,GAAGA,CAAgBC,KAAc,EAAE;IACjCR,IAAI,CAACI,MAAM,CAET,CAACK,IAAI,EAAEH,GAAG,EAAEI,CAAC,KAAMA,CAAC,KAAKT,IAAI,GAAIQ,IAAI,CAACH,GAAG,CAAC,GAAGE,KAAK,GAAIC,IAAI,CAACH,GAAG,CAAE,EAChE,IACF,CAAC;EACH;AACF,CAAC,CAAC;AAEF,MAAMK,WAAW,GAAGA,CAClBC,WAAwB,EACxBC,UAAe,EACfC,WAAgB,KAEhBC,MAAM,CAACf,IAAI,CAACc,WAAW,CAAC,CACrBE,GAAG,CAACV,GAAG,IAAI,CAACA,GAAG,EAAEQ,WAAW,CAACR,GAAG,CAAC,CAAC,CAAC,CACnCW,MAAM,CAAC,CAAC,GAAGC,UAAU,CAAC,KAAK,CAAC,CAACA,UAAU,CAAC,CACxCF,GAAG,CAAC,CAAC,CAACV,GAAG,EAAEY,UAAU,CAAC,KAAK,CAC1BZ,GAAG,EACH,OAAOY,UAAU,KAAK,UAAU,GAC5B;EAAEV,KAAK,EAAEU,UAAU;EAAEC,UAAU,EAAE;AAAM,CAAC,GACxC,OAAOD,UAAU,CAACnB,OAAO,KAAK,QAAQ,GAAAgB,MAAA,CAAAK,MAAA,KACjCF,UAAU,EAAKnB,OAAO,CAACmB,UAAU,CAACnB,OAAO,CAACsB,KAAK,CAAC,GAAG,CAAC,CAAC,IAC1DH,UAAU,CACf,CAAC,CACDd,MAAM,CACL,CAACkB,QAAQ,EAAE,CAAChB,GAAG,EAAEY,UAAU,CAAC,KAC1BH,MAAM,CAACQ,cAAc,CAACD,QAAQ,EAAEhB,GAAG,EAAAS,MAAA,CAAAK,MAAA;EACjCI,YAAY,EAAE;AAAI,GACfN,UAAU,CACd,CAAC,EACJH,MAAM,CAACK,MAAM,CAAC,IAAIR,WAAW,CAAC,CAAC,EAAEC,UAAU,CAC7C,CAAC;AAACf,OAAA,CAAAa,WAAA,GAAAA,WAAA"}

node_modules/@babel/parser/lib/parse-error/module-errors.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _parseError = require("../parse-error");
+var _default = {
+  ImportMetaOutsideModule: {
+    message: `import.meta may appear only with 'sourceType: "module"'`,
+    code: _parseError.ParseErrorCode.SourceTypeModuleError
+  },
+  ImportOutsideModule: {
+    message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
+    code: _parseError.ParseErrorCode.SourceTypeModuleError
+  }
+};
+exports.default = _default;
+
+//# sourceMappingURL=module-errors.js.map

node_modules/@babel/parser/lib/parse-error/module-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_parseError","require","_default","ImportMetaOutsideModule","message","code","ParseErrorCode","SourceTypeModuleError","ImportOutsideModule","exports","default"],"sources":["../../src/parse-error/module-errors.ts"],"sourcesContent":["import { ParseErrorCode } from \"../parse-error\";\n\nexport default {\n  ImportMetaOutsideModule: {\n    message: `import.meta may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n  ImportOutsideModule: {\n    message: `'import' and 'export' may appear only with 'sourceType: \"module\"'`,\n    code: ParseErrorCode.SourceTypeModuleError,\n  },\n};\n"],"mappings":";;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAgD,IAAAC,QAAA,GAEjC;EACbC,uBAAuB,EAAE;IACvBC,OAAO,EAAG,yDAAwD;IAClEC,IAAI,EAAEC,0BAAc,CAACC;EACvB,CAAC;EACDC,mBAAmB,EAAE;IACnBJ,OAAO,EAAG,mEAAkE;IAC5EC,IAAI,EAAEC,0BAAc,CAACC;EACvB;AACF,CAAC;AAAAE,OAAA,CAAAC,OAAA,GAAAR,QAAA"}

node_modules/@babel/parser/lib/parse-error/pipeline-operator-errors.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.UnparenthesizedPipeBodyDescriptions = void 0;
+var _toNodeDescription = require("./to-node-description");
+const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
+exports.UnparenthesizedPipeBodyDescriptions = UnparenthesizedPipeBodyDescriptions;
+var _default = {
+  PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
+  PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
+  PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
+  PipeTopicUnconfiguredToken: ({
+    token
+  }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
+  PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
+  PipeUnparenthesizedBody: ({
+    type
+  }) => `Hack-style pipe body cannot be an unparenthesized ${(0, _toNodeDescription.default)({
+    type
+  })}; please wrap it in parentheses.`,
+  PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
+  PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
+  PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
+  PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
+  PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
+  PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
+};
+exports.default = _default;
+
+//# sourceMappingURL=pipeline-operator-errors.js.map

node_modules/@babel/parser/lib/parse-error/pipeline-operator-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_toNodeDescription","require","UnparenthesizedPipeBodyDescriptions","Set","exports","_default","PipeBodyIsTighter","PipeTopicRequiresHackPipes","PipeTopicUnbound","PipeTopicUnconfiguredToken","token","PipeTopicUnused","PipeUnparenthesizedBody","type","toNodeDescription","PipelineBodyNoArrow","PipelineBodySequenceExpression","PipelineHeadSequenceExpression","PipelineTopicUnused","PrimaryTopicNotAllowed","PrimaryTopicRequiresSmartPipeline","default"],"sources":["../../src/parse-error/pipeline-operator-errors.ts"],"sourcesContent":["import toNodeDescription from \"./to-node-description\";\n\nexport const UnparenthesizedPipeBodyDescriptions = new Set([\n  \"ArrowFunctionExpression\",\n  \"AssignmentExpression\",\n  \"ConditionalExpression\",\n  \"YieldExpression\",\n] as const);\n\ntype GetSetMemberType<T extends Set<any>> = T extends Set<infer M>\n  ? M\n  : unknown;\n\ntype UnparenthesizedPipeBodyTypes = GetSetMemberType<\n  typeof UnparenthesizedPipeBodyDescriptions\n>;\n\nexport default {\n  // This error is only used by the smart-mix proposal\n  PipeBodyIsTighter:\n    \"Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.\",\n  PipeTopicRequiresHackPipes:\n    'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n  PipeTopicUnbound:\n    \"Topic reference is unbound; it must be inside a pipe body.\",\n  PipeTopicUnconfiguredToken: ({ token }: { token: string }) =>\n    `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { \"proposal\": \"hack\", \"topicToken\": \"${token}\" }.`,\n  PipeTopicUnused:\n    \"Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.\",\n  PipeUnparenthesizedBody: ({ type }: { type: UnparenthesizedPipeBodyTypes }) =>\n    `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({\n      type,\n    })}; please wrap it in parentheses.`,\n\n  // Messages whose codes start with “Pipeline” or “PrimaryTopic”\n  // are retained for backwards compatibility\n  // with the deprecated smart-mix pipe operator proposal plugin.\n  // They are subject to removal in a future major version.\n  PipelineBodyNoArrow:\n    'Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized.',\n  PipelineBodySequenceExpression:\n    \"Pipeline body may not be a comma-separated sequence expression.\",\n  PipelineHeadSequenceExpression:\n    \"Pipeline head should not be a comma-separated sequence expression.\",\n  PipelineTopicUnused:\n    \"Pipeline is in topic style but does not use topic reference.\",\n  PrimaryTopicNotAllowed:\n    \"Topic reference was used in a lexical context without topic binding.\",\n  PrimaryTopicRequiresSmartPipeline:\n    'Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.',\n};\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAEO,MAAMC,mCAAmC,GAAG,IAAIC,GAAG,CAAC,CACzD,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,CACT,CAAC;AAACC,OAAA,CAAAF,mCAAA,GAAAA,mCAAA;AAAA,IAAAG,QAAA,GAUG;EAEbC,iBAAiB,EACf,uJAAuJ;EACzJC,0BAA0B,EACxB,iHAAiH;EACnHC,gBAAgB,EACd,4DAA4D;EAC9DC,0BAA0B,EAAEA,CAAC;IAAEC;EAAyB,CAAC,KACtD,uBAAsBA,KAAM,qBAAoBA,KAAM,mHAAkHA,KAAM,MAAK;EACtLC,eAAe,EACb,yGAAyG;EAC3GC,uBAAuB,EAAEA,CAAC;IAAEC;EAA6C,CAAC,KACvE,qDAAoD,IAAAC,0BAAiB,EAAC;IACrED;EACF,CAAC,CAAE,kCAAiC;EAMtCE,mBAAmB,EACjB,mGAAmG;EACrGC,8BAA8B,EAC5B,iEAAiE;EACnEC,8BAA8B,EAC5B,oEAAoE;EACtEC,mBAAmB,EACjB,8DAA8D;EAChEC,sBAAsB,EACpB,sEAAsE;EACxEC,iCAAiC,EAC/B;AACJ,CAAC;AAAAhB,OAAA,CAAAiB,OAAA,GAAAhB,QAAA"}

node_modules/@babel/parser/lib/parse-error/standard-errors.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toNodeDescription = require("./to-node-description");
+var _default = {
+  AccessorIsGenerator: ({
+    kind
+  }) => `A ${kind}ter cannot be a generator.`,
+  ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
+  AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
+  AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
+  AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
+  AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
+  AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
+  AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
+  AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
+  BadGetterArity: "A 'get' accessor must not have any formal parameters.",
+  BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
+  BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
+  ConstructorClassField: "Classes may not have a field named 'constructor'.",
+  ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
+  ConstructorIsAccessor: "Class constructor may not be an accessor.",
+  ConstructorIsAsync: "Constructor can't be an async function.",
+  ConstructorIsGenerator: "Constructor can't be a generator.",
+  DeclarationMissingInitializer: ({
+    kind
+  }) => `Missing initializer in ${kind} declaration.`,
+  DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
+  DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
+  DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
+  DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
+  DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
+  DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
+  DecoratorStaticBlock: "Decorators can't be used with a static block.",
+  DeletePrivateField: "Deleting a private field is not allowed.",
+  DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
+  DuplicateConstructor: "Duplicate constructor in the same class.",
+  DuplicateDefaultExport: "Only one default export allowed per module.",
+  DuplicateExport: ({
+    exportName
+  }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
+  DuplicateProto: "Redefinition of __proto__ property.",
+  DuplicateRegExpFlags: "Duplicate regular expression flag.",
+  ElementAfterRest: "Rest element must be last element.",
+  EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
+  ExportBindingIsString: ({
+    localName,
+    exportName
+  }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
+  ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
+  ForInOfLoopInitializer: ({
+    type
+  }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
+  ForInUsing: "For-in loop may not start with 'using' declaration.",
+  ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
+  ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
+  GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
+  IllegalBreakContinue: ({
+    type
+  }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
+  IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
+  IllegalReturn: "'return' outside of function.",
+  ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
+  ImportBindingIsString: ({
+    importName
+  }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
+  ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
+  ImportCallArity: ({
+    maxArgumentCount
+  }) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
+  ImportCallNotNewExpression: "Cannot use new with import(...).",
+  ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
+  ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
+  ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
+  ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
+  IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
+  InvalidBigIntLiteral: "Invalid BigIntLiteral.",
+  InvalidCodePoint: "Code point out of bounds.",
+  InvalidCoverInitializedName: "Invalid shorthand property initializer.",
+  InvalidDecimal: "Invalid decimal.",
+  InvalidDigit: ({
+    radix
+  }) => `Expected number in radix ${radix}.`,
+  InvalidEscapeSequence: "Bad character escape sequence.",
+  InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
+  InvalidEscapedReservedWord: ({
+    reservedWord
+  }) => `Escape sequence in keyword ${reservedWord}.`,
+  InvalidIdentifier: ({
+    identifierName
+  }) => `Invalid identifier ${identifierName}.`,
+  InvalidLhs: ({
+    ancestor
+  }) => `Invalid left-hand side in ${(0, _toNodeDescription.default)(ancestor)}.`,
+  InvalidLhsBinding: ({
+    ancestor
+  }) => `Binding invalid left-hand side in ${(0, _toNodeDescription.default)(ancestor)}.`,
+  InvalidNumber: "Invalid number.",
+  InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
+  InvalidOrUnexpectedToken: ({
+    unexpected
+  }) => `Unexpected character '${unexpected}'.`,
+  InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
+  InvalidPrivateFieldResolution: ({
+    identifierName
+  }) => `Private name #${identifierName} is not defined.`,
+  InvalidPropertyBindingPattern: "Binding member expression.",
+  InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.",
+  InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
+  LabelRedeclaration: ({
+    labelName
+  }) => `Label '${labelName}' is already declared.`,
+  LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.",
+  LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
+  MalformedRegExpFlags: "Invalid regular expression flag.",
+  MissingClassName: "A class name is required.",
+  MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
+  MissingSemicolon: "Missing semicolon.",
+  MissingPlugin: ({
+    missingPlugin
+  }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
+  MissingOneOfPlugins: ({
+    missingPlugin
+  }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
+  MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
+  MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
+  ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.",
+  ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
+  ModuleAttributesWithDuplicateKeys: ({
+    key
+  }) => `Duplicate key "${key}" is not allowed in module attributes.`,
+  ModuleExportNameHasLoneSurrogate: ({
+    surrogateCharCode
+  }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
+  ModuleExportUndefined: ({
+    localName
+  }) => `Export '${localName}' is not defined.`,
+  MultipleDefaultsInSwitch: "Multiple default clauses.",
+  NewlineAfterThrow: "Illegal newline after throw.",
+  NoCatchOrFinally: "Missing catch or finally clause.",
+  NumberIdentifier: "Identifier directly after number.",
+  NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
+  ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
+  OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
+  OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
+  OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
+  ParamDupe: "Argument name clash.",
+  PatternHasAccessor: "Object pattern can't contain getter or setter.",
+  PatternHasMethod: "Object pattern can't contain methods.",
+  PrivateInExpectedIn: ({
+    identifierName
+  }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
+  PrivateNameRedeclaration: ({
+    identifierName
+  }) => `Duplicate private name #${identifierName}.`,
+  RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
+  RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
+  RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
+  RecordNoProto: "'__proto__' is not allowed in Record expressions.",
+  RestTrailingComma: "Unexpected trailing comma after rest element.",
+  SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
+  SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
+  StaticPrototype: "Classes may not have static property named prototype.",
+  SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
+  SuperPrivateField: "Private fields can't be accessed on super.",
+  TrailingDecorator: "Decorators must be attached to a class element.",
+  TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
+  TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
+  TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
+  UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
+  UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
+  UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
+  UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
+  UnexpectedKeyword: ({
+    keyword
+  }) => `Unexpected keyword '${keyword}'.`,
+  UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
+  UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
+  UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
+  UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
+  UnexpectedPrivateField: "Unexpected private name.",
+  UnexpectedReservedWord: ({
+    reservedWord
+  }) => `Unexpected reserved word '${reservedWord}'.`,
+  UnexpectedSuper: "'super' is only allowed in object methods and classes.",
+  UnexpectedToken: ({
+    expected,
+    unexpected
+  }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
+  UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
+  UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
+  UnsupportedBind: "Binding should be performed on object property.",
+  UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
+  UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
+  UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
+  UnsupportedMetaProperty: ({
+    target,
+    onlyValidPropertyName
+  }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
+  UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
+  UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
+  UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
+  UnterminatedComment: "Unterminated comment.",
+  UnterminatedRegExp: "Unterminated regular expression.",
+  UnterminatedString: "Unterminated string constant.",
+  UnterminatedTemplate: "Unterminated template.",
+  UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
+  VarRedeclaration: ({
+    identifierName
+  }) => `Identifier '${identifierName}' has already been declared.`,
+  YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
+  YieldInParameter: "Yield expression is not allowed in formal parameters.",
+  ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
+};
+exports.default = _default;
+
+//# sourceMappingURL=standard-errors.js.map

node_modules/@babel/parser/lib/parse-error/strict-mode-errors.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  StrictDelete: "Deleting local variable in strict mode.",
+  StrictEvalArguments: ({
+    referenceName
+  }) => `Assigning to '${referenceName}' in strict mode.`,
+  StrictEvalArgumentsBinding: ({
+    bindingName
+  }) => `Binding '${bindingName}' in strict mode.`,
+  StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
+  StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
+  StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
+  StrictWith: "'with' in strict mode."
+};
+exports.default = _default;
+
+//# sourceMappingURL=strict-mode-errors.js.map

node_modules/@babel/parser/lib/parse-error/strict-mode-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StrictDelete","StrictEvalArguments","referenceName","StrictEvalArgumentsBinding","bindingName","StrictFunction","StrictNumericEscape","StrictOctalLiteral","StrictWith","exports","default","_default"],"sources":["../../src/parse-error/strict-mode-errors.ts"],"sourcesContent":["export default {\n  StrictDelete: \"Deleting local variable in strict mode.\",\n\n  // `referenceName` is the StringValue[1] of an IdentifierReference[2], which\n  // is represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-IdentifierReference\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArguments: ({ referenceName }: { referenceName: string }) =>\n    `Assigning to '${referenceName}' in strict mode.`,\n\n  // `bindingName` is the StringValue[1] of a BindingIdentifier[2], which is\n  // represented as just an `Identifier`[3] in the Babel AST.\n  // 1. https://tc39.es/ecma262/#sec-static-semantics-stringvalue\n  // 2. https://tc39.es/ecma262/#prod-BindingIdentifier\n  // 3. https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md#identifier\n  StrictEvalArgumentsBinding: ({ bindingName }: { bindingName: string }) =>\n    `Binding '${bindingName}' in strict mode.`,\n\n  StrictFunction:\n    \"In strict mode code, functions can only be declared at top level or inside a block.\",\n\n  StrictNumericEscape: \"The only valid numeric escape in strict mode is '\\\\0'.\",\n\n  StrictOctalLiteral: \"Legacy octal literals are not allowed in strict mode.\",\n\n  StrictWith: \"'with' in strict mode.\",\n};\n"],"mappings":";;;;;;eAAe;EACbA,YAAY,EAAE,yCAAyC;EAOvDC,mBAAmB,EAAEA,CAAC;IAAEC;EAAyC,CAAC,KAC/D,iBAAgBA,aAAc,mBAAkB;EAOnDC,0BAA0B,EAAEA,CAAC;IAAEC;EAAqC,CAAC,KAClE,YAAWA,WAAY,mBAAkB;EAE5CC,cAAc,EACZ,qFAAqF;EAEvFC,mBAAmB,EAAE,wDAAwD;EAE7EC,kBAAkB,EAAE,uDAAuD;EAE3EC,UAAU,EAAE;AACd,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAC,QAAA"}

node_modules/@babel/parser/lib/parse-error/to-node-description.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const NodeDescriptions = {
+  ArrayPattern: "array destructuring pattern",
+  AssignmentExpression: "assignment expression",
+  AssignmentPattern: "assignment expression",
+  ArrowFunctionExpression: "arrow function expression",
+  ConditionalExpression: "conditional expression",
+  CatchClause: "catch clause",
+  ForOfStatement: "for-of statement",
+  ForInStatement: "for-in statement",
+  ForStatement: "for-loop",
+  FormalParameters: "function parameter list",
+  Identifier: "identifier",
+  ImportSpecifier: "import specifier",
+  ImportDefaultSpecifier: "import default specifier",
+  ImportNamespaceSpecifier: "import namespace specifier",
+  ObjectPattern: "object destructuring pattern",
+  ParenthesizedExpression: "parenthesized expression",
+  RestElement: "rest element",
+  UpdateExpression: {
+    true: "prefix operation",
+    false: "postfix operation"
+  },
+  VariableDeclarator: "variable declaration",
+  YieldExpression: "yield expression"
+};
+const toNodeDescription = ({
+  type,
+  prefix
+}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
+var _default = toNodeDescription;
+exports.default = _default;
+
+//# sourceMappingURL=to-node-description.js.map

node_modules/@babel/parser/lib/parse-error/to-node-description.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NodeDescriptions","ArrayPattern","AssignmentExpression","AssignmentPattern","ArrowFunctionExpression","ConditionalExpression","CatchClause","ForOfStatement","ForInStatement","ForStatement","FormalParameters","Identifier","ImportSpecifier","ImportDefaultSpecifier","ImportNamespaceSpecifier","ObjectPattern","ParenthesizedExpression","RestElement","UpdateExpression","true","false","VariableDeclarator","YieldExpression","toNodeDescription","type","prefix","String","_default","exports","default"],"sources":["../../src/parse-error/to-node-description.ts"],"sourcesContent":["const NodeDescriptions = {\n  ArrayPattern: \"array destructuring pattern\",\n  AssignmentExpression: \"assignment expression\",\n  AssignmentPattern: \"assignment expression\",\n  ArrowFunctionExpression: \"arrow function expression\",\n  ConditionalExpression: \"conditional expression\",\n  CatchClause: \"catch clause\",\n  ForOfStatement: \"for-of statement\",\n  ForInStatement: \"for-in statement\",\n  ForStatement: \"for-loop\",\n  FormalParameters: \"function parameter list\",\n  Identifier: \"identifier\",\n  ImportSpecifier: \"import specifier\",\n  ImportDefaultSpecifier: \"import default specifier\",\n  ImportNamespaceSpecifier: \"import namespace specifier\",\n  ObjectPattern: \"object destructuring pattern\",\n  ParenthesizedExpression: \"parenthesized expression\",\n  RestElement: \"rest element\",\n  UpdateExpression: {\n    true: \"prefix operation\",\n    false: \"postfix operation\",\n  },\n  VariableDeclarator: \"variable declaration\",\n  YieldExpression: \"yield expression\",\n};\n\ntype NodeTypesWithDescriptions = keyof Omit<\n  typeof NodeDescriptions,\n  \"UpdateExpression\"\n>;\n\ntype NodeWithDescription =\n  | {\n      type: \"UpdateExpression\";\n      prefix: boolean;\n    }\n  | {\n      type: NodeTypesWithDescriptions;\n    };\n\n// @ts-expect-error prefix is specified only when type is UpdateExpression\n// eslint-disable-next-line no-confusing-arrow\nconst toNodeDescription = ({ type, prefix }: NodeWithDescription) =>\n  type === \"UpdateExpression\"\n    ? NodeDescriptions.UpdateExpression[String(prefix) as \"true\" | \"false\"]\n    : NodeDescriptions[type];\n\nexport default toNodeDescription;\n"],"mappings":";;;;;;AAAA,MAAMA,gBAAgB,GAAG;EACvBC,YAAY,EAAE,6BAA6B;EAC3CC,oBAAoB,EAAE,uBAAuB;EAC7CC,iBAAiB,EAAE,uBAAuB;EAC1CC,uBAAuB,EAAE,2BAA2B;EACpDC,qBAAqB,EAAE,wBAAwB;EAC/CC,WAAW,EAAE,cAAc;EAC3BC,cAAc,EAAE,kBAAkB;EAClCC,cAAc,EAAE,kBAAkB;EAClCC,YAAY,EAAE,UAAU;EACxBC,gBAAgB,EAAE,yBAAyB;EAC3CC,UAAU,EAAE,YAAY;EACxBC,eAAe,EAAE,kBAAkB;EACnCC,sBAAsB,EAAE,0BAA0B;EAClDC,wBAAwB,EAAE,4BAA4B;EACtDC,aAAa,EAAE,8BAA8B;EAC7CC,uBAAuB,EAAE,0BAA0B;EACnDC,WAAW,EAAE,cAAc;EAC3BC,gBAAgB,EAAE;IAChBC,IAAI,EAAE,kBAAkB;IACxBC,KAAK,EAAE;EACT,CAAC;EACDC,kBAAkB,EAAE,sBAAsB;EAC1CC,eAAe,EAAE;AACnB,CAAC;AAkBD,MAAMC,iBAAiB,GAAGA,CAAC;EAAEC,IAAI;EAAEC;AAA4B,CAAC,KAC9DD,IAAI,KAAK,kBAAkB,GACvBxB,gBAAgB,CAACkB,gBAAgB,CAACQ,MAAM,CAACD,MAAM,CAAC,CAAqB,GACrEzB,gBAAgB,CAACwB,IAAI,CAAC;AAAC,IAAAG,QAAA,GAEdJ,iBAAiB;AAAAK,OAAA,CAAAC,OAAA,GAAAF,QAAA"}