nv-js-err-tmpl

• nv-js-err-tmpl
• code from @babel/parser error
• for copy/paste in nvlang

install

• npm install nv-js-err-tmpl

usage

APIS

    {
      ErrorCodes: {
        SyntaxError: 'BABEL_PARSER_SYNTAX_ERROR',
        SourceTypeModuleError: 'BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED'
      },
      SourceTypeModuleErrorMessages: {
        ImportMetaOutsideModule: {
          code: 'BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED',
          reasonCode: 'ImportMetaOutsideModule',
          template: `import.meta may appear only with 'sourceType: "module"'`
        },
        ImportOutsideModule: {
          code: 'BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED',
          reasonCode: 'ImportOutsideModule',
          template: `'import' and 'export' may appear only with 'sourceType: "module"'`
        }
      },
      ErrorMessages: {
        AccessorIsGenerator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AccessorIsGenerator',
          template: 'A %0ter cannot be a generator.'
        },
        ArgumentsInClass: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ArgumentsInClass',
          template: "'arguments' is only allowed in functions and class methods."
        },
        AsyncFunctionInSingleStatementContext: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AsyncFunctionInSingleStatementContext',
          template: 'Async functions can only be declared at the top level or inside a block.'
        },
        AwaitBindingIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AwaitBindingIdentifier',
          template: "Can not use 'await' as identifier inside an async function."
        },
        AwaitBindingIdentifierInStaticBlock: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AwaitBindingIdentifierInStaticBlock',
          template: "Can not use 'await' as identifier inside a static block."
        },
        AwaitExpressionFormalParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AwaitExpressionFormalParameter',
          template: "'await' is not allowed in async function parameters."
        },
        AwaitNotInAsyncContext: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AwaitNotInAsyncContext',
          template: "'await' is only allowed within async functions and at the top levels of modules."
        },
        AwaitNotInAsyncFunction: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AwaitNotInAsyncFunction',
          template: "'await' is only allowed within async functions."
        },
        BadGetterArity: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'BadGetterArity',
          template: "A 'get' accesor must not have any formal parameters."
        },
        BadSetterArity: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'BadSetterArity',
          template: "A 'set' accesor must have exactly one formal parameter."
        },
        BadSetterRestParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'BadSetterRestParameter',
          template: "A 'set' accesor function argument must not be a rest parameter."
        },
        ConstructorClassField: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorClassField',
          template: "Classes may not have a field named 'constructor'."
        },
        ConstructorClassPrivateField: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorClassPrivateField',
          template: "Classes may not have a private field named '#constructor'."
        },
        ConstructorIsAccessor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorIsAccessor',
          template: 'Class constructor may not be an accessor.'
        },
        ConstructorIsAsync: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorIsAsync',
          template: "Constructor can't be an async function."
        },
        ConstructorIsGenerator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorIsGenerator',
          template: "Constructor can't be a generator."
        },
        DeclarationMissingInitializer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclarationMissingInitializer',
          template: "'%0' require an initialization value."
        },
        DecoratorBeforeExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DecoratorBeforeExport',
          template: "Decorators must be placed *before* the 'export' keyword. You can set the 'decoratorsBeforeExport' option to false to use the 'export @decorator class {}' syntax."
        },
        DecoratorConstructor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DecoratorConstructor',
          template: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?"
        },
        DecoratorExportClass: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DecoratorExportClass',
          template: 'Using the export keyword between a decorator and a class is not allowed. Please use `export @dec class` instead.'
        },
        DecoratorSemicolon: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DecoratorSemicolon',
          template: 'Decorators must not be followed by a semicolon.'
        },
        DecoratorStaticBlock: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DecoratorStaticBlock',
          template: "Decorators can't be used with a static block."
        },
        DeletePrivateField: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeletePrivateField',
          template: 'Deleting a private field is not allowed.'
        },
        DestructureNamedImport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DestructureNamedImport',
          template: 'ES2015 named imports do not destructure. Use another statement for destructuring after the import.'
        },
        DuplicateConstructor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateConstructor',
          template: 'Duplicate constructor in the same class.'
        },
        DuplicateDefaultExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateDefaultExport',
          template: 'Only one default export allowed per module.'
        },
        DuplicateExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateExport',
          template: '`%0` has already been exported. Exported identifiers must be unique.'
        },
        DuplicateProto: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateProto',
          template: 'Redefinition of __proto__ property.'
        },
        DuplicateRegExpFlags: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateRegExpFlags',
          template: 'Duplicate regular expression flag.'
        },
        ElementAfterRest: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ElementAfterRest',
          template: 'Rest element must be last element.'
        },
        EscapedCharNotAnIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EscapedCharNotAnIdentifier',
          template: 'Invalid Unicode escape.'
        },
        ExportBindingIsString: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ExportBindingIsString',
          template: 'A string literal cannot be used as an exported binding without `from`.\n' +
            "- Did you mean `export { '%0' as '%1' } from 'some-module'`?"
        },
        ExportDefaultFromAsIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ExportDefaultFromAsIdentifier',
          template: "'from' is not allowed as an identifier after 'export default'."
        },
        ForInOfLoopInitializer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ForInOfLoopInitializer',
          template: "'%0' loop variable declaration may not have an initializer."
        },
        ForOfAsync: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ForOfAsync',
          template: "The left-hand side of a for-of loop may not be 'async'."
        },
        ForOfLet: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ForOfLet',
          template: "The left-hand side of a for-of loop may not start with 'let'."
        },
        GeneratorInSingleStatementContext: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'GeneratorInSingleStatementContext',
          template: 'Generators can only be declared at the top level or inside a block.'
        },
        IllegalBreakContinue: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IllegalBreakContinue',
          template: 'Unsyntactic %0.'
        },
        IllegalLanguageModeDirective: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IllegalLanguageModeDirective',
          template: "Illegal 'use strict' directive in function with non-simple parameter list."
        },
        IllegalReturn: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IllegalReturn',
          template: "'return' outside of function."
        },
        ImportBindingIsString: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportBindingIsString',
          template: 'A string literal cannot be used as an imported binding.\n' +
            '- Did you mean `import { "%0" as foo }`?'
        },
        ImportCallArgumentTrailingComma: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportCallArgumentTrailingComma',
          template: 'Trailing comma is disallowed inside import(...) arguments.'
        },
        ImportCallArity: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportCallArity',
          template: '`import()` requires exactly %0.'
        },
        ImportCallNotNewExpression: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportCallNotNewExpression',
          template: 'Cannot use new with import(...).'
        },
        ImportCallSpreadArgument: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportCallSpreadArgument',
          template: '`...` is not allowed in `import()`.'
        },
        InvalidBigIntLiteral: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidBigIntLiteral',
          template: 'Invalid BigIntLiteral.'
        },
        InvalidCodePoint: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidCodePoint',
          template: 'Code point out of bounds.'
        },
        InvalidDecimal: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidDecimal',
          template: 'Invalid decimal.'
        },
        InvalidDigit: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidDigit',
          template: 'Expected number in radix %0.'
        },
        InvalidEscapeSequence: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidEscapeSequence',
          template: 'Bad character escape sequence.'
        },
        InvalidEscapeSequenceTemplate: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidEscapeSequenceTemplate',
          template: 'Invalid escape sequence in template.'
        },
        InvalidEscapedReservedWord: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidEscapedReservedWord',
          template: 'Escape sequence in keyword %0.'
        },
        InvalidIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidIdentifier',
          template: 'Invalid identifier %0.'
        },
        InvalidLhs: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidLhs',
          template: 'Invalid left-hand side in %0.'
        },
        InvalidLhsBinding: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidLhsBinding',
          template: 'Binding invalid left-hand side in %0.'
        },
        InvalidNumber: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidNumber',
          template: 'Invalid number.'
        },
        InvalidOrMissingExponent: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidOrMissingExponent',
          template: "Floating-point numbers require a valid exponent after the 'e'."
        },
        InvalidOrUnexpectedToken: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidOrUnexpectedToken',
          template: "Unexpected character '%0'."
        },
        InvalidParenthesizedAssignment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidParenthesizedAssignment',
          template: 'Invalid parenthesized assignment pattern.'
        },
        InvalidPrivateFieldResolution: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidPrivateFieldResolution',
          template: 'Private name #%0 is not defined.'
        },
        InvalidPropertyBindingPattern: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidPropertyBindingPattern',
          template: 'Binding member expression.'
        },
        InvalidRecordProperty: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidRecordProperty',
          template: 'Only properties and spread elements are allowed in record definitions.'
        },
        InvalidRestAssignmentPattern: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidRestAssignmentPattern',
          template: "Invalid rest operator's argument."
        },
        LabelRedeclaration: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'LabelRedeclaration',
          template: "Label '%0' is already declared."
        },
        LetInLexicalBinding: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'LetInLexicalBinding',
          template: "'let' is not allowed to be used as a name in 'let' or 'const' declarations."
        },
        LineTerminatorBeforeArrow: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'LineTerminatorBeforeArrow',
          template: "No line break is allowed before '=>'."
        },
        MalformedRegExpFlags: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MalformedRegExpFlags',
          template: 'Invalid regular expression flag.'
        },
        MissingClassName: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingClassName',
          template: 'A class name is required.'
        },
        MissingEqInAssignment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingEqInAssignment',
          template: "Only '=' operator can be used for specifying default value."
        },
        MissingSemicolon: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingSemicolon',
          template: 'Missing semicolon.'
        },
        MissingUnicodeEscape: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingUnicodeEscape',
          template: 'Expecting Unicode escape sequence \\uXXXX.'
        },
        MixingCoalesceWithLogical: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MixingCoalesceWithLogical',
          template: 'Nullish coalescing operator(??) requires parens when mixing with logical operators.'
        },
        ModuleAttributeDifferentFromType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ModuleAttributeDifferentFromType',
          template: 'The only accepted module attribute is `type`.'
        },
        ModuleAttributeInvalidValue: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ModuleAttributeInvalidValue',
          template: 'Only string literals are allowed as module attribute values.'
        },
        ModuleAttributesWithDuplicateKeys: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ModuleAttributesWithDuplicateKeys',
          template: 'Duplicate key "%0" is not allowed in module attributes.'
        },
        ModuleExportNameHasLoneSurrogate: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ModuleExportNameHasLoneSurrogate',
          template: "An export name cannot include a lone surrogate, found '\\u%0'."
        },
        ModuleExportUndefined: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ModuleExportUndefined',
          template: "Export '%0' is not defined."
        },
        MultipleDefaultsInSwitch: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MultipleDefaultsInSwitch',
          template: 'Multiple default clauses.'
        },
        NewlineAfterThrow: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NewlineAfterThrow',
          template: 'Illegal newline after throw.'
        },
        NoCatchOrFinally: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NoCatchOrFinally',
          template: 'Missing catch or finally clause.'
        },
        NumberIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NumberIdentifier',
          template: 'Identifier directly after number.'
        },
        NumericSeparatorInEscapeSequence: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NumericSeparatorInEscapeSequence',
          template: 'Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.'
        },
        ObsoleteAwaitStar: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ObsoleteAwaitStar',
          template: "'await*' has been removed from the async functions proposal. Use Promise.all() instead."
        },
        OptionalChainingNoNew: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OptionalChainingNoNew',
          template: 'Constructors in/after an Optional Chain are not allowed.'
        },
        OptionalChainingNoTemplate: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OptionalChainingNoTemplate',
          template: 'Tagged Template Literals are not allowed in optionalChain.'
        },
        OverrideOnConstructor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OverrideOnConstructor',
          template: "'override' modifier cannot appear on a constructor declaration."
        },
        ParamDupe: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ParamDupe',
          template: 'Argument name clash.'
        },
        PatternHasAccessor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PatternHasAccessor',
          template: "Object pattern can't contain getter or setter."
        },
        PatternHasMethod: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PatternHasMethod',
          template: "Object pattern can't contain methods."
        },
        PipelineBodyNoArrow: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PipelineBodyNoArrow',
          template: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.'
        },
        PipelineBodySequenceExpression: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PipelineBodySequenceExpression',
          template: 'Pipeline body may not be a comma-separated sequence expression.'
        },
        PipelineHeadSequenceExpression: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PipelineHeadSequenceExpression',
          template: 'Pipeline head should not be a comma-separated sequence expression.'
        },
        PipelineTopicUnused: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PipelineTopicUnused',
          template: 'Pipeline is in topic style but does not use topic reference.'
        },
        PrimaryTopicNotAllowed: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrimaryTopicNotAllowed',
          template: 'Topic reference was used in a lexical context without topic binding.'
        },
        PrimaryTopicRequiresSmartPipeline: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrimaryTopicRequiresSmartPipeline',
          template: "Primary Topic Reference found but pipelineOperator not passed 'smart' for 'proposal' option."
        },
        PrivateInExpectedIn: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrivateInExpectedIn',
          template: 'Private names are only allowed in property accesses (`obj.#%0`) or in `in` expressions (`#%0 in obj`).'
        },
        PrivateNameRedeclaration: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrivateNameRedeclaration',
          template: 'Duplicate private name #%0.'
        },
        RecordExpressionBarIncorrectEndSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'RecordExpressionBarIncorrectEndSyntaxType',
          template: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."
        },
        RecordExpressionBarIncorrectStartSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'RecordExpressionBarIncorrectStartSyntaxType',
          template: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."
        },
        RecordExpressionHashIncorrectStartSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'RecordExpressionHashIncorrectStartSyntaxType',
          template: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'."
        },
        RecordNoProto: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'RecordNoProto',
          template: "'__proto__' is not allowed in Record expressions."
        },
        RestTrailingComma: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'RestTrailingComma',
          template: 'Unexpected trailing comma after rest element.'
        },
        SloppyFunction: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SloppyFunction',
          template: '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: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StaticPrototype',
          template: 'Classes may not have static property named prototype.'
        },
        StrictDelete: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictDelete',
          template: 'Deleting local variable in strict mode.'
        },
        StrictEvalArguments: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictEvalArguments',
          template: "Assigning to '%0' in strict mode."
        },
        StrictEvalArgumentsBinding: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictEvalArgumentsBinding',
          template: "Binding '%0' in strict mode."
        },
        StrictFunction: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictFunction',
          template: 'In strict mode code, functions can only be declared at top level or inside a block.'
        },
        StrictNumericEscape: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictNumericEscape',
          template: "The only valid numeric escape in strict mode is '\\0'."
        },
        StrictOctalLiteral: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictOctalLiteral',
          template: 'Legacy octal literals are not allowed in strict mode.'
        },
        StrictWith: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StrictWith',
          template: "'with' in strict mode."
        },
        SuperNotAllowed: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SuperNotAllowed',
          template: "`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: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SuperPrivateField',
          template: "Private fields can't be accessed on super."
        },
        TrailingDecorator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TrailingDecorator',
          template: 'Decorators must be attached to a class element.'
        },
        TupleExpressionBarIncorrectEndSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TupleExpressionBarIncorrectEndSyntaxType',
          template: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."
        },
        TupleExpressionBarIncorrectStartSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TupleExpressionBarIncorrectStartSyntaxType',
          template: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'."
        },
        TupleExpressionHashIncorrectStartSyntaxType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TupleExpressionHashIncorrectStartSyntaxType',
          template: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'."
        },
        UnexpectedArgumentPlaceholder: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedArgumentPlaceholder',
          template: 'Unexpected argument placeholder.'
        },
        UnexpectedAwaitAfterPipelineBody: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedAwaitAfterPipelineBody',
          template: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.'
        },
        UnexpectedDigitAfterHash: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedDigitAfterHash',
          template: 'Unexpected digit after hash token.'
        },
        UnexpectedImportExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedImportExport',
          template: "'import' and 'export' may only appear at the top level."
        },
        UnexpectedKeyword: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedKeyword',
          template: "Unexpected keyword '%0'."
        },
        UnexpectedLeadingDecorator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedLeadingDecorator',
          template: 'Leading decorators must be attached to a class declaration.'
        },
        UnexpectedLexicalDeclaration: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedLexicalDeclaration',
          template: 'Lexical declaration cannot appear in a single-statement context.'
        },
        UnexpectedNewTarget: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedNewTarget',
          template: '`new.target` can only be used in functions or class properties.'
        },
        UnexpectedNumericSeparator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedNumericSeparator',
          template: 'A numeric separator is only allowed between two digits.'
        },
        UnexpectedPrivateField: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedPrivateField',
          template: 'Private names can only be used as the name of a class element (i.e. class C { #p = 42; #m() {} } )\n' +
            ' or a property of member expression (i.e. this.#p).'
        },
        UnexpectedReservedWord: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedReservedWord',
          template: "Unexpected reserved word '%0'."
        },
        UnexpectedSuper: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedSuper',
          template: "'super' is only allowed in object methods and classes."
        },
        UnexpectedToken: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedToken',
          template: "Unexpected token '%0'."
        },
        UnexpectedTokenUnaryExponentiation: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedTokenUnaryExponentiation',
          template: 'Illegal expression. Wrap left hand side or entire exponentiation in parentheses.'
        },
        UnsupportedBind: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedBind',
          template: 'Binding should be performed on object property.'
        },
        UnsupportedDecoratorExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedDecoratorExport',
          template: 'A decorated export must export a class declaration.'
        },
        UnsupportedDefaultExport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedDefaultExport',
          template: 'Only expressions, functions or classes are allowed as the `default` export.'
        },
        UnsupportedImport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedImport',
          template: '`import` can only be used in `import()` or `import.meta`.'
        },
        UnsupportedMetaProperty: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedMetaProperty',
          template: 'The only valid meta property for %0 is %0.%1.'
        },
        UnsupportedParameterDecorator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedParameterDecorator',
          template: 'Decorators cannot be used to decorate parameters.'
        },
        UnsupportedPropertyDecorator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedPropertyDecorator',
          template: 'Decorators cannot be used to decorate object literal properties.'
        },
        UnsupportedSuper: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedSuper',
          template: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop])."
        },
        UnterminatedComment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedComment',
          template: 'Unterminated comment.'
        },
        UnterminatedRegExp: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedRegExp',
          template: 'Unterminated regular expression.'
        },
        UnterminatedString: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedString',
          template: 'Unterminated string constant.'
        },
        UnterminatedTemplate: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedTemplate',
          template: 'Unterminated template.'
        },
        VarRedeclaration: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'VarRedeclaration',
          template: "Identifier '%0' has already been declared."
        },
        YieldBindingIdentifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'YieldBindingIdentifier',
          template: "Can not use 'yield' as identifier inside a generator."
        },
        YieldInParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'YieldInParameter',
          template: 'Yield expression is not allowed in formal parameters.'
        },
        ZeroDigitNumericSeparator: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ZeroDigitNumericSeparator',
          template: 'Numeric separator can not be used after leading 0.'
        }
      },
      FlowErrors: {
        AmbiguousConditionalArrow: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AmbiguousConditionalArrow',
          template: 'Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.'
        },
        AmbiguousDeclareModuleKind: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AmbiguousDeclareModuleKind',
          template: 'Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.'
        },
        AssignReservedType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AssignReservedType',
          template: 'Cannot overwrite reserved type %0.'
        },
        DeclareClassElement: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclareClassElement',
          template: 'The `declare` modifier can only appear on class fields.'
        },
        DeclareClassFieldInitializer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclareClassFieldInitializer',
          template: 'Initializers are not allowed in fields with the `declare` modifier.'
        },
        DuplicateDeclareModuleExports: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateDeclareModuleExports',
          template: 'Duplicate `declare module.exports` statement.'
        },
        EnumBooleanMemberNotInitialized: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumBooleanMemberNotInitialized',
          template: 'Boolean enum members need to be initialized. Use either `%0 = true,` or `%0 = false,` in enum `%1`.'
        },
        EnumDuplicateMemberName: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumDuplicateMemberName',
          template: 'Enum member names need to be unique, but the name `%0` has already been used before in enum `%1`.'
        },
        EnumInconsistentMemberValues: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInconsistentMemberValues',
          template: 'Enum `%0` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.'
        },
        EnumInvalidExplicitType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidExplicitType',
          template: 'Enum type `%1` is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.'
        },
        EnumInvalidExplicitTypeUnknownSupplied: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidExplicitTypeUnknownSupplied',
          template: 'Supplied enum type is not valid. Use one of `boolean`, `number`, `string`, or `symbol` in enum `%0`.'
        },
        EnumInvalidMemberInitializerPrimaryType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidMemberInitializerPrimaryType',
          template: 'Enum `%0` has type `%2`, so the initializer of `%1` needs to be a %2 literal.'
        },
        EnumInvalidMemberInitializerSymbolType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidMemberInitializerSymbolType',
          template: 'Symbol enum members cannot be initialized. Use `%1,` in enum `%0`.'
        },
        EnumInvalidMemberInitializerUnknownType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidMemberInitializerUnknownType',
          template: 'The enum member initializer for `%1` needs to be a literal (either a boolean, number, or string) in enum `%0`.'
        },
        EnumInvalidMemberName: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumInvalidMemberName',
          template: "Enum member names cannot start with lowercase 'a' through 'z'. Instead of using `%0`, consider using `%1`, in enum `%2`."
        },
        EnumNumberMemberNotInitialized: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumNumberMemberNotInitialized',
          template: 'Number enum members need to be initialized, e.g. `%1 = 1` in enum `%0`.'
        },
        EnumStringMemberInconsistentlyInitailized: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EnumStringMemberInconsistentlyInitailized',
          template: 'String enum members need to consistently either all use initializers, or use no initializers, in enum `%0`.'
        },
        GetterMayNotHaveThisParam: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'GetterMayNotHaveThisParam',
          template: 'A getter cannot have a `this` parameter.'
        },
        ImportTypeShorthandOnlyInPureImport: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportTypeShorthandOnlyInPureImport',
          template: 'The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.'
        },
        InexactInsideExact: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InexactInsideExact',
          template: 'Explicit inexact syntax cannot appear inside an explicit exact object type.'
        },
        InexactInsideNonObject: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InexactInsideNonObject',
          template: 'Explicit inexact syntax cannot appear in class or interface definitions.'
        },
        InexactVariance: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InexactVariance',
          template: 'Explicit inexact syntax cannot have variance.'
        },
        InvalidNonTypeImportInDeclareModule: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidNonTypeImportInDeclareModule',
          template: 'Imports within a `declare module` body must always be `import type` or `import typeof`.'
        },
        MissingTypeParamDefault: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingTypeParamDefault',
          template: 'Type parameter declaration needs a default, since a preceding type parameter declaration has a default.'
        },
        NestedDeclareModule: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NestedDeclareModule',
          template: '`declare module` cannot be used inside another `declare module`.'
        },
        NestedFlowComment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NestedFlowComment',
          template: 'Cannot have a flow comment inside another flow comment.'
        },
        OptionalBindingPattern: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OptionalBindingPattern',
          template: 'A binding pattern parameter cannot be optional in an implementation signature.'
        },
        SetterMayNotHaveThisParam: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SetterMayNotHaveThisParam',
          template: 'A setter cannot have a `this` parameter.'
        },
        SpreadVariance: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SpreadVariance',
          template: 'Spread properties cannot have variance.'
        },
        ThisParamAnnotationRequired: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ThisParamAnnotationRequired',
          template: 'A type annotation is required for the `this` parameter.'
        },
        ThisParamBannedInConstructor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ThisParamBannedInConstructor',
          template: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions."
        },
        ThisParamMayNotBeOptional: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ThisParamMayNotBeOptional',
          template: 'The `this` parameter cannot be optional.'
        },
        ThisParamMustBeFirst: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ThisParamMustBeFirst',
          template: 'The `this` parameter must be the first function parameter.'
        },
        ThisParamNoDefault: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ThisParamNoDefault',
          template: 'The `this` parameter may not have a default value.'
        },
        TypeBeforeInitializer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TypeBeforeInitializer',
          template: 'Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.'
        },
        TypeCastInPattern: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TypeCastInPattern',
          template: 'The type cast expression is expected to be wrapped with parenthesis.'
        },
        UnexpectedExplicitInexactInObject: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedExplicitInexactInObject',
          template: 'Explicit inexact syntax must appear at the end of an inexact object.'
        },
        UnexpectedReservedType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedReservedType',
          template: 'Unexpected reserved type %0.'
        },
        UnexpectedReservedUnderscore: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedReservedUnderscore',
          template: '`_` is only allowed as a type argument to call or new.'
        },
        UnexpectedSpaceBetweenModuloChecks: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedSpaceBetweenModuloChecks',
          template: 'Spaces between `%` and `checks` are not allowed here.'
        },
        UnexpectedSpreadType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedSpreadType',
          template: 'Spread operator cannot appear in class or interface definitions.'
        },
        UnexpectedSubtractionOperand: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedSubtractionOperand',
          template: 'Unexpected token, expected "number" or "bigint".'
        },
        UnexpectedTokenAfterTypeParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedTokenAfterTypeParameter',
          template: 'Expected an arrow function after this type parameter declaration.'
        },
        UnexpectedTypeParameterBeforeAsyncArrowFunction: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedTypeParameterBeforeAsyncArrowFunction',
          template: 'Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.'
        },
        UnsupportedDeclareExportKind: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedDeclareExportKind',
          template: '`declare export %0` is not supported. Use `%1` instead.'
        },
        UnsupportedStatementInDeclareModule: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedStatementInDeclareModule',
          template: 'Only declares and type imports are allowed inside declare module.'
        },
        UnterminatedFlowComment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedFlowComment',
          template: 'Unterminated flow-comment.'
        }
      },
      JsxErrors: {
        AttributeIsEmpty: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AttributeIsEmpty',
          template: 'JSX attributes must only be assigned a non-empty expression.'
        },
        MissingClosingTagElement: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingClosingTagElement',
          template: 'Expected corresponding JSX closing tag for <%0>.'
        },
        MissingClosingTagFragment: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MissingClosingTagFragment',
          template: 'Expected corresponding JSX closing tag for <>.'
        },
        UnexpectedSequenceExpression: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedSequenceExpression',
          template: 'Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?'
        },
        UnsupportedJsxValue: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedJsxValue',
          template: 'JSX value should be either an expression or a quoted JSX text.'
        },
        UnterminatedJsxContent: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnterminatedJsxContent',
          template: 'Unterminated JSX contents.'
        },
        UnwrappedAdjacentJSXElements: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnwrappedAdjacentJSXElements',
          template: 'Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?'
        }
      },
      TSErrors: {
        AbstractMethodHasImplementation: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AbstractMethodHasImplementation',
          template: "Method '%0' cannot have an implementation because it is marked abstract."
        },
        AccesorCannotDeclareThisParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AccesorCannotDeclareThisParameter',
          template: "'get' and 'set' accessors cannot declare 'this' parameters."
        },
        AccesorCannotHaveTypeParameters: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'AccesorCannotHaveTypeParameters',
          template: 'An accessor cannot have type parameters.'
        },
        ClassMethodHasDeclare: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ClassMethodHasDeclare',
          template: "Class methods cannot have the 'declare' modifier."
        },
        ClassMethodHasReadonly: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ClassMethodHasReadonly',
          template: "Class methods cannot have the 'readonly' modifier."
        },
        ConstructorHasTypeParameters: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ConstructorHasTypeParameters',
          template: 'Type parameters cannot appear on a constructor declaration.'
        },
        DeclareAccessor: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclareAccessor',
          template: "'declare' is not allowed in %0ters."
        },
        DeclareClassFieldHasInitializer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclareClassFieldHasInitializer',
          template: 'Initializers are not allowed in ambient contexts.'
        },
        DeclareFunctionHasImplementation: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DeclareFunctionHasImplementation',
          template: 'An implementation cannot be declared in ambient contexts.'
        },
        DuplicateAccessibilityModifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateAccessibilityModifier',
          template: 'Accessibility modifier already seen.'
        },
        DuplicateModifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'DuplicateModifier',
          template: "Duplicate modifier: '%0'."
        },
        EmptyHeritageClauseType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EmptyHeritageClauseType',
          template: "'%0' list cannot be empty."
        },
        EmptyTypeArguments: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EmptyTypeArguments',
          template: 'Type argument list cannot be empty.'
        },
        EmptyTypeParameters: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'EmptyTypeParameters',
          template: 'Type parameter list cannot be empty.'
        },
        ExpectedAmbientAfterExportDeclare: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ExpectedAmbientAfterExportDeclare',
          template: "'export declare' must be followed by an ambient declaration."
        },
        ImportAliasHasImportType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ImportAliasHasImportType',
          template: "An import alias can not use 'import type'."
        },
        IncompatibleModifiers: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IncompatibleModifiers',
          template: "'%0' modifier cannot be used with '%1' modifier."
        },
        IndexSignatureHasAbstract: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IndexSignatureHasAbstract',
          template: "Index signatures cannot have the 'abstract' modifier."
        },
        IndexSignatureHasAccessibility: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IndexSignatureHasAccessibility',
          template: "Index signatures cannot have an accessibility modifier ('%0')."
        },
        IndexSignatureHasDeclare: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IndexSignatureHasDeclare',
          template: "Index signatures cannot have the 'declare' modifier."
        },
        IndexSignatureHasOverride: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IndexSignatureHasOverride',
          template: "'override' modifier cannot appear on an index signature."
        },
        IndexSignatureHasStatic: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'IndexSignatureHasStatic',
          template: "Index signatures cannot have the 'static' modifier."
        },
        InvalidModifierOnTypeMember: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidModifierOnTypeMember',
          template: "'%0' modifier cannot appear on a type member."
        },
        InvalidModifiersOrder: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidModifiersOrder',
          template: "'%0' modifier must precede '%1' modifier."
        },
        InvalidTupleMemberLabel: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'InvalidTupleMemberLabel',
          template: 'Tuple members must be labeled with a simple identifier.'
        },
        MixedLabeledAndUnlabeledElements: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'MixedLabeledAndUnlabeledElements',
          template: 'Tuple members must all have names or all not have names.'
        },
        NonAbstractClassHasAbstractMethod: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NonAbstractClassHasAbstractMethod',
          template: 'Abstract methods can only appear within an abstract class.'
        },
        NonClassMethodPropertyHasAbstractModifer: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'NonClassMethodPropertyHasAbstractModifer',
          template: "'abstract' modifier can only appear on a class, method, or property declaration."
        },
        OptionalTypeBeforeRequired: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OptionalTypeBeforeRequired',
          template: 'A required element cannot follow an optional element.'
        },
        OverrideNotInSubClass: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'OverrideNotInSubClass',
          template: "This member cannot have an 'override' modifier because its containing class does not extend another class."
        },
        PatternIsOptional: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PatternIsOptional',
          template: 'A binding pattern parameter cannot be optional in an implementation signature.'
        },
        PrivateElementHasAbstract: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrivateElementHasAbstract',
          template: "Private elements cannot have the 'abstract' modifier."
        },
        PrivateElementHasAccessibility: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'PrivateElementHasAccessibility',
          template: "Private elements cannot have an accessibility modifier ('%0')."
        },
        ReadonlyForMethodSignature: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ReadonlyForMethodSignature',
          template: "'readonly' modifier can only appear on a property declaration or index signature."
        },
        SetAccesorCannotHaveOptionalParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SetAccesorCannotHaveOptionalParameter',
          template: "A 'set' accessor cannot have an optional parameter."
        },
        SetAccesorCannotHaveRestParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SetAccesorCannotHaveRestParameter',
          template: "A 'set' accessor cannot have rest parameter."
        },
        SetAccesorCannotHaveReturnType: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'SetAccesorCannotHaveReturnType',
          template: "A 'set' accessor cannot have a return type annotation."
        },
        StaticBlockCannotHaveModifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'StaticBlockCannotHaveModifier',
          template: 'Static class blocks cannot have any modifier.'
        },
        TypeAnnotationAfterAssign: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TypeAnnotationAfterAssign',
          template: 'Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.'
        },
        TypeImportCannotSpecifyDefaultAndNamed: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'TypeImportCannotSpecifyDefaultAndNamed',
          template: 'A type-only import can specify a default import or named bindings, but not both.'
        },
        UnexpectedParameterModifier: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedParameterModifier',
          template: 'A parameter property is only allowed in a constructor implementation.'
        },
        UnexpectedReadonly: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedReadonly',
          template: "'readonly' type modifier is only permitted on array and tuple literal types."
        },
        UnexpectedTypeAnnotation: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedTypeAnnotation',
          template: 'Did not expect a type annotation here.'
        },
        UnexpectedTypeCastInParameter: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnexpectedTypeCastInParameter',
          template: 'Unexpected type cast in parameter position.'
        },
        UnsupportedImportTypeArgument: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedImportTypeArgument',
          template: 'Argument in a type import must be a string literal.'
        },
        UnsupportedParameterPropertyKind: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedParameterPropertyKind',
          template: 'A parameter property may not be declared using a binding pattern.'
        },
        UnsupportedSignatureParameterKind: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'UnsupportedSignatureParameterKind',
          template: 'Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got %0.'
        }
      },
      PlaceHolderErrors: {
        ClassNameIsRequired: {
          code: 'BABEL_PARSER_SYNTAX_ERROR',
          reasonCode: 'ClassNameIsRequired',
          template: 'A class name is required.'
        }
      }
    }

LICENSE

• ISC