1.0.1 • Published 2 years ago
nv-js-err-tmpl v1.0.1
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
1.0.1
2 years ago