Source code
Revision control
Copy as Markdown
Other Tools
(function (factory) {
typeof define === 'function' && define.amd ? define(factory) :
factory();
})((function () { 'use strict';
(function() {
const env = {"NODE_ENV":"production"};
try {
if (process) {
process.env = Object.assign({}, process.env);
Object.assign(process.env, env);
return;
}
} catch (e) {} // avoid ReferenceError: process is not defined
globalThis.process = { env:env };
})();
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var lib$4 = {};
var isReactComponent$1 = {};
var buildMatchMemberExpression = {};
var matchesPattern = {};
var generated$3 = {};
var shallowEqual = {};
var hasRequiredShallowEqual;
function requireShallowEqual () {
if (hasRequiredShallowEqual) return shallowEqual;
hasRequiredShallowEqual = 1;
Object.defineProperty(shallowEqual, "__esModule", {
value: true
});
shallowEqual.default = shallowEqual$1;
function shallowEqual$1(actual, expected) {
const keys = Object.keys(expected);
for (const key of keys) {
if (actual[key] !== expected[key]) {
return false;
}
}
return true;
}
return shallowEqual;
}
var deprecationWarning = {};
var hasRequiredDeprecationWarning;
function requireDeprecationWarning () {
if (hasRequiredDeprecationWarning) return deprecationWarning;
hasRequiredDeprecationWarning = 1;
Object.defineProperty(deprecationWarning, "__esModule", {
value: true
});
deprecationWarning.default = deprecationWarning$1;
const warnings = new Set();
function deprecationWarning$1(oldName, newName, prefix = "") {
if (warnings.has(oldName)) return;
warnings.add(oldName);
const {
internal,
trace
} = captureShortStackTrace(1, 2);
if (internal) {
return;
}
console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`\n${trace}`);
}
function captureShortStackTrace(skip, length) {
const {
stackTraceLimit,
prepareStackTrace
} = Error;
let stackTrace;
Error.stackTraceLimit = 1 + skip + length;
Error.prepareStackTrace = function (err, stack) {
stackTrace = stack;
};
new Error().stack;
Error.stackTraceLimit = stackTraceLimit;
Error.prepareStackTrace = prepareStackTrace;
if (!stackTrace) return {
internal: false,
trace: ""
};
const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
return {
internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
trace: shortStackTrace.map(frame => ` at ${frame}`).join("\n")
};
}
return deprecationWarning;
}
var hasRequiredGenerated$3;
function requireGenerated$3 () {
if (hasRequiredGenerated$3) return generated$3;
hasRequiredGenerated$3 = 1;
Object.defineProperty(generated$3, "__esModule", {
value: true
});
generated$3.isAccessor = isAccessor;
generated$3.isAnyTypeAnnotation = isAnyTypeAnnotation;
generated$3.isArgumentPlaceholder = isArgumentPlaceholder;
generated$3.isArrayExpression = isArrayExpression;
generated$3.isArrayPattern = isArrayPattern;
generated$3.isArrayTypeAnnotation = isArrayTypeAnnotation;
generated$3.isArrowFunctionExpression = isArrowFunctionExpression;
generated$3.isAssignmentExpression = isAssignmentExpression;
generated$3.isAssignmentPattern = isAssignmentPattern;
generated$3.isAwaitExpression = isAwaitExpression;
generated$3.isBigIntLiteral = isBigIntLiteral;
generated$3.isBinary = isBinary;
generated$3.isBinaryExpression = isBinaryExpression;
generated$3.isBindExpression = isBindExpression;
generated$3.isBlock = isBlock;
generated$3.isBlockParent = isBlockParent;
generated$3.isBlockStatement = isBlockStatement;
generated$3.isBooleanLiteral = isBooleanLiteral;
generated$3.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
generated$3.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
generated$3.isBreakStatement = isBreakStatement;
generated$3.isCallExpression = isCallExpression;
generated$3.isCatchClause = isCatchClause;
generated$3.isClass = isClass;
generated$3.isClassAccessorProperty = isClassAccessorProperty;
generated$3.isClassBody = isClassBody;
generated$3.isClassDeclaration = isClassDeclaration;
generated$3.isClassExpression = isClassExpression;
generated$3.isClassImplements = isClassImplements;
generated$3.isClassMethod = isClassMethod;
generated$3.isClassPrivateMethod = isClassPrivateMethod;
generated$3.isClassPrivateProperty = isClassPrivateProperty;
generated$3.isClassProperty = isClassProperty;
generated$3.isCompletionStatement = isCompletionStatement;
generated$3.isConditional = isConditional;
generated$3.isConditionalExpression = isConditionalExpression;
generated$3.isContinueStatement = isContinueStatement;
generated$3.isDebuggerStatement = isDebuggerStatement;
generated$3.isDecimalLiteral = isDecimalLiteral;
generated$3.isDeclaration = isDeclaration;
generated$3.isDeclareClass = isDeclareClass;
generated$3.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
generated$3.isDeclareExportDeclaration = isDeclareExportDeclaration;
generated$3.isDeclareFunction = isDeclareFunction;
generated$3.isDeclareInterface = isDeclareInterface;
generated$3.isDeclareModule = isDeclareModule;
generated$3.isDeclareModuleExports = isDeclareModuleExports;
generated$3.isDeclareOpaqueType = isDeclareOpaqueType;
generated$3.isDeclareTypeAlias = isDeclareTypeAlias;
generated$3.isDeclareVariable = isDeclareVariable;
generated$3.isDeclaredPredicate = isDeclaredPredicate;
generated$3.isDecorator = isDecorator;
generated$3.isDirective = isDirective;
generated$3.isDirectiveLiteral = isDirectiveLiteral;
generated$3.isDoExpression = isDoExpression;
generated$3.isDoWhileStatement = isDoWhileStatement;
generated$3.isEmptyStatement = isEmptyStatement;
generated$3.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
generated$3.isEnumBody = isEnumBody;
generated$3.isEnumBooleanBody = isEnumBooleanBody;
generated$3.isEnumBooleanMember = isEnumBooleanMember;
generated$3.isEnumDeclaration = isEnumDeclaration;
generated$3.isEnumDefaultedMember = isEnumDefaultedMember;
generated$3.isEnumMember = isEnumMember;
generated$3.isEnumNumberBody = isEnumNumberBody;
generated$3.isEnumNumberMember = isEnumNumberMember;
generated$3.isEnumStringBody = isEnumStringBody;
generated$3.isEnumStringMember = isEnumStringMember;
generated$3.isEnumSymbolBody = isEnumSymbolBody;
generated$3.isExistsTypeAnnotation = isExistsTypeAnnotation;
generated$3.isExportAllDeclaration = isExportAllDeclaration;
generated$3.isExportDeclaration = isExportDeclaration;
generated$3.isExportDefaultDeclaration = isExportDefaultDeclaration;
generated$3.isExportDefaultSpecifier = isExportDefaultSpecifier;
generated$3.isExportNamedDeclaration = isExportNamedDeclaration;
generated$3.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
generated$3.isExportSpecifier = isExportSpecifier;
generated$3.isExpression = isExpression;
generated$3.isExpressionStatement = isExpressionStatement;
generated$3.isExpressionWrapper = isExpressionWrapper;
generated$3.isFile = isFile;
generated$3.isFlow = isFlow;
generated$3.isFlowBaseAnnotation = isFlowBaseAnnotation;
generated$3.isFlowDeclaration = isFlowDeclaration;
generated$3.isFlowPredicate = isFlowPredicate;
generated$3.isFlowType = isFlowType;
generated$3.isFor = isFor;
generated$3.isForInStatement = isForInStatement;
generated$3.isForOfStatement = isForOfStatement;
generated$3.isForStatement = isForStatement;
generated$3.isForXStatement = isForXStatement;
generated$3.isFunction = isFunction;
generated$3.isFunctionDeclaration = isFunctionDeclaration;
generated$3.isFunctionExpression = isFunctionExpression;
generated$3.isFunctionParent = isFunctionParent;
generated$3.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
generated$3.isFunctionTypeParam = isFunctionTypeParam;
generated$3.isGenericTypeAnnotation = isGenericTypeAnnotation;
generated$3.isIdentifier = isIdentifier;
generated$3.isIfStatement = isIfStatement;
generated$3.isImmutable = isImmutable;
generated$3.isImport = isImport;
generated$3.isImportAttribute = isImportAttribute;
generated$3.isImportDeclaration = isImportDeclaration;
generated$3.isImportDefaultSpecifier = isImportDefaultSpecifier;
generated$3.isImportExpression = isImportExpression;
generated$3.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
generated$3.isImportOrExportDeclaration = isImportOrExportDeclaration;
generated$3.isImportSpecifier = isImportSpecifier;
generated$3.isIndexedAccessType = isIndexedAccessType;
generated$3.isInferredPredicate = isInferredPredicate;
generated$3.isInterfaceDeclaration = isInterfaceDeclaration;
generated$3.isInterfaceExtends = isInterfaceExtends;
generated$3.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
generated$3.isInterpreterDirective = isInterpreterDirective;
generated$3.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
generated$3.isJSX = isJSX;
generated$3.isJSXAttribute = isJSXAttribute;
generated$3.isJSXClosingElement = isJSXClosingElement;
generated$3.isJSXClosingFragment = isJSXClosingFragment;
generated$3.isJSXElement = isJSXElement;
generated$3.isJSXEmptyExpression = isJSXEmptyExpression;
generated$3.isJSXExpressionContainer = isJSXExpressionContainer;
generated$3.isJSXFragment = isJSXFragment;
generated$3.isJSXIdentifier = isJSXIdentifier;
generated$3.isJSXMemberExpression = isJSXMemberExpression;
generated$3.isJSXNamespacedName = isJSXNamespacedName;
generated$3.isJSXOpeningElement = isJSXOpeningElement;
generated$3.isJSXOpeningFragment = isJSXOpeningFragment;
generated$3.isJSXSpreadAttribute = isJSXSpreadAttribute;
generated$3.isJSXSpreadChild = isJSXSpreadChild;
generated$3.isJSXText = isJSXText;
generated$3.isLVal = isLVal;
generated$3.isLabeledStatement = isLabeledStatement;
generated$3.isLiteral = isLiteral;
generated$3.isLogicalExpression = isLogicalExpression;
generated$3.isLoop = isLoop;
generated$3.isMemberExpression = isMemberExpression;
generated$3.isMetaProperty = isMetaProperty;
generated$3.isMethod = isMethod;
generated$3.isMiscellaneous = isMiscellaneous;
generated$3.isMixedTypeAnnotation = isMixedTypeAnnotation;
generated$3.isModuleDeclaration = isModuleDeclaration;
generated$3.isModuleExpression = isModuleExpression;
generated$3.isModuleSpecifier = isModuleSpecifier;
generated$3.isNewExpression = isNewExpression;
generated$3.isNoop = isNoop;
generated$3.isNullLiteral = isNullLiteral;
generated$3.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
generated$3.isNullableTypeAnnotation = isNullableTypeAnnotation;
generated$3.isNumberLiteral = isNumberLiteral;
generated$3.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
generated$3.isNumberTypeAnnotation = isNumberTypeAnnotation;
generated$3.isNumericLiteral = isNumericLiteral;
generated$3.isObjectExpression = isObjectExpression;
generated$3.isObjectMember = isObjectMember;
generated$3.isObjectMethod = isObjectMethod;
generated$3.isObjectPattern = isObjectPattern;
generated$3.isObjectProperty = isObjectProperty;
generated$3.isObjectTypeAnnotation = isObjectTypeAnnotation;
generated$3.isObjectTypeCallProperty = isObjectTypeCallProperty;
generated$3.isObjectTypeIndexer = isObjectTypeIndexer;
generated$3.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
generated$3.isObjectTypeProperty = isObjectTypeProperty;
generated$3.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
generated$3.isOpaqueType = isOpaqueType;
generated$3.isOptionalCallExpression = isOptionalCallExpression;
generated$3.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
generated$3.isOptionalMemberExpression = isOptionalMemberExpression;
generated$3.isParenthesizedExpression = isParenthesizedExpression;
generated$3.isPattern = isPattern;
generated$3.isPatternLike = isPatternLike;
generated$3.isPipelineBareFunction = isPipelineBareFunction;
generated$3.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
generated$3.isPipelineTopicExpression = isPipelineTopicExpression;
generated$3.isPlaceholder = isPlaceholder;
generated$3.isPrivate = isPrivate;
generated$3.isPrivateName = isPrivateName;
generated$3.isProgram = isProgram;
generated$3.isProperty = isProperty;
generated$3.isPureish = isPureish;
generated$3.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
generated$3.isRecordExpression = isRecordExpression;
generated$3.isRegExpLiteral = isRegExpLiteral;
generated$3.isRegexLiteral = isRegexLiteral;
generated$3.isRestElement = isRestElement;
generated$3.isRestProperty = isRestProperty;
generated$3.isReturnStatement = isReturnStatement;
generated$3.isScopable = isScopable;
generated$3.isSequenceExpression = isSequenceExpression;
generated$3.isSpreadElement = isSpreadElement;
generated$3.isSpreadProperty = isSpreadProperty;
generated$3.isStandardized = isStandardized;
generated$3.isStatement = isStatement;
generated$3.isStaticBlock = isStaticBlock;
generated$3.isStringLiteral = isStringLiteral;
generated$3.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
generated$3.isStringTypeAnnotation = isStringTypeAnnotation;
generated$3.isSuper = isSuper;
generated$3.isSwitchCase = isSwitchCase;
generated$3.isSwitchStatement = isSwitchStatement;
generated$3.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
generated$3.isTSAnyKeyword = isTSAnyKeyword;
generated$3.isTSArrayType = isTSArrayType;
generated$3.isTSAsExpression = isTSAsExpression;
generated$3.isTSBaseType = isTSBaseType;
generated$3.isTSBigIntKeyword = isTSBigIntKeyword;
generated$3.isTSBooleanKeyword = isTSBooleanKeyword;
generated$3.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
generated$3.isTSConditionalType = isTSConditionalType;
generated$3.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
generated$3.isTSConstructorType = isTSConstructorType;
generated$3.isTSDeclareFunction = isTSDeclareFunction;
generated$3.isTSDeclareMethod = isTSDeclareMethod;
generated$3.isTSEntityName = isTSEntityName;
generated$3.isTSEnumDeclaration = isTSEnumDeclaration;
generated$3.isTSEnumMember = isTSEnumMember;
generated$3.isTSExportAssignment = isTSExportAssignment;
generated$3.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
generated$3.isTSExternalModuleReference = isTSExternalModuleReference;
generated$3.isTSFunctionType = isTSFunctionType;
generated$3.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
generated$3.isTSImportType = isTSImportType;
generated$3.isTSIndexSignature = isTSIndexSignature;
generated$3.isTSIndexedAccessType = isTSIndexedAccessType;
generated$3.isTSInferType = isTSInferType;
generated$3.isTSInstantiationExpression = isTSInstantiationExpression;
generated$3.isTSInterfaceBody = isTSInterfaceBody;
generated$3.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
generated$3.isTSIntersectionType = isTSIntersectionType;
generated$3.isTSIntrinsicKeyword = isTSIntrinsicKeyword;
generated$3.isTSLiteralType = isTSLiteralType;
generated$3.isTSMappedType = isTSMappedType;
generated$3.isTSMethodSignature = isTSMethodSignature;
generated$3.isTSModuleBlock = isTSModuleBlock;
generated$3.isTSModuleDeclaration = isTSModuleDeclaration;
generated$3.isTSNamedTupleMember = isTSNamedTupleMember;
generated$3.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
generated$3.isTSNeverKeyword = isTSNeverKeyword;
generated$3.isTSNonNullExpression = isTSNonNullExpression;
generated$3.isTSNullKeyword = isTSNullKeyword;
generated$3.isTSNumberKeyword = isTSNumberKeyword;
generated$3.isTSObjectKeyword = isTSObjectKeyword;
generated$3.isTSOptionalType = isTSOptionalType;
generated$3.isTSParameterProperty = isTSParameterProperty;
generated$3.isTSParenthesizedType = isTSParenthesizedType;
generated$3.isTSPropertySignature = isTSPropertySignature;
generated$3.isTSQualifiedName = isTSQualifiedName;
generated$3.isTSRestType = isTSRestType;
generated$3.isTSSatisfiesExpression = isTSSatisfiesExpression;
generated$3.isTSStringKeyword = isTSStringKeyword;
generated$3.isTSSymbolKeyword = isTSSymbolKeyword;
generated$3.isTSThisType = isTSThisType;
generated$3.isTSTupleType = isTSTupleType;
generated$3.isTSType = isTSType;
generated$3.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
generated$3.isTSTypeAnnotation = isTSTypeAnnotation;
generated$3.isTSTypeAssertion = isTSTypeAssertion;
generated$3.isTSTypeElement = isTSTypeElement;
generated$3.isTSTypeLiteral = isTSTypeLiteral;
generated$3.isTSTypeOperator = isTSTypeOperator;
generated$3.isTSTypeParameter = isTSTypeParameter;
generated$3.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
generated$3.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
generated$3.isTSTypePredicate = isTSTypePredicate;
generated$3.isTSTypeQuery = isTSTypeQuery;
generated$3.isTSTypeReference = isTSTypeReference;
generated$3.isTSUndefinedKeyword = isTSUndefinedKeyword;
generated$3.isTSUnionType = isTSUnionType;
generated$3.isTSUnknownKeyword = isTSUnknownKeyword;
generated$3.isTSVoidKeyword = isTSVoidKeyword;
generated$3.isTaggedTemplateExpression = isTaggedTemplateExpression;
generated$3.isTemplateElement = isTemplateElement;
generated$3.isTemplateLiteral = isTemplateLiteral;
generated$3.isTerminatorless = isTerminatorless;
generated$3.isThisExpression = isThisExpression;
generated$3.isThisTypeAnnotation = isThisTypeAnnotation;
generated$3.isThrowStatement = isThrowStatement;
generated$3.isTopicReference = isTopicReference;
generated$3.isTryStatement = isTryStatement;
generated$3.isTupleExpression = isTupleExpression;
generated$3.isTupleTypeAnnotation = isTupleTypeAnnotation;
generated$3.isTypeAlias = isTypeAlias;
generated$3.isTypeAnnotation = isTypeAnnotation;
generated$3.isTypeCastExpression = isTypeCastExpression;
generated$3.isTypeParameter = isTypeParameter;
generated$3.isTypeParameterDeclaration = isTypeParameterDeclaration;
generated$3.isTypeParameterInstantiation = isTypeParameterInstantiation;
generated$3.isTypeScript = isTypeScript;
generated$3.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
generated$3.isUnaryExpression = isUnaryExpression;
generated$3.isUnaryLike = isUnaryLike;
generated$3.isUnionTypeAnnotation = isUnionTypeAnnotation;
generated$3.isUpdateExpression = isUpdateExpression;
generated$3.isUserWhitespacable = isUserWhitespacable;
generated$3.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
generated$3.isVariableDeclaration = isVariableDeclaration;
generated$3.isVariableDeclarator = isVariableDeclarator;
generated$3.isVariance = isVariance;
generated$3.isVoidTypeAnnotation = isVoidTypeAnnotation;
generated$3.isWhile = isWhile;
generated$3.isWhileStatement = isWhileStatement;
generated$3.isWithStatement = isWithStatement;
generated$3.isYieldExpression = isYieldExpression;
var _shallowEqual = requireShallowEqual();
var _deprecationWarning = requireDeprecationWarning();
function isArrayExpression(node, opts) {
if (!node) return false;
if (node.type !== "ArrayExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isAssignmentExpression(node, opts) {
if (!node) return false;
if (node.type !== "AssignmentExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBinaryExpression(node, opts) {
if (!node) return false;
if (node.type !== "BinaryExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isInterpreterDirective(node, opts) {
if (!node) return false;
if (node.type !== "InterpreterDirective") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDirective(node, opts) {
if (!node) return false;
if (node.type !== "Directive") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDirectiveLiteral(node, opts) {
if (!node) return false;
if (node.type !== "DirectiveLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBlockStatement(node, opts) {
if (!node) return false;
if (node.type !== "BlockStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBreakStatement(node, opts) {
if (!node) return false;
if (node.type !== "BreakStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isCallExpression(node, opts) {
if (!node) return false;
if (node.type !== "CallExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isCatchClause(node, opts) {
if (!node) return false;
if (node.type !== "CatchClause") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isConditionalExpression(node, opts) {
if (!node) return false;
if (node.type !== "ConditionalExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isContinueStatement(node, opts) {
if (!node) return false;
if (node.type !== "ContinueStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDebuggerStatement(node, opts) {
if (!node) return false;
if (node.type !== "DebuggerStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDoWhileStatement(node, opts) {
if (!node) return false;
if (node.type !== "DoWhileStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEmptyStatement(node, opts) {
if (!node) return false;
if (node.type !== "EmptyStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExpressionStatement(node, opts) {
if (!node) return false;
if (node.type !== "ExpressionStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFile(node, opts) {
if (!node) return false;
if (node.type !== "File") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isForInStatement(node, opts) {
if (!node) return false;
if (node.type !== "ForInStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isForStatement(node, opts) {
if (!node) return false;
if (node.type !== "ForStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunctionDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "FunctionDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunctionExpression(node, opts) {
if (!node) return false;
if (node.type !== "FunctionExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "Identifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isIfStatement(node, opts) {
if (!node) return false;
if (node.type !== "IfStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isLabeledStatement(node, opts) {
if (!node) return false;
if (node.type !== "LabeledStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStringLiteral(node, opts) {
if (!node) return false;
if (node.type !== "StringLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNumericLiteral(node, opts) {
if (!node) return false;
if (node.type !== "NumericLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNullLiteral(node, opts) {
if (!node) return false;
if (node.type !== "NullLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBooleanLiteral(node, opts) {
if (!node) return false;
if (node.type !== "BooleanLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isRegExpLiteral(node, opts) {
if (!node) return false;
if (node.type !== "RegExpLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isLogicalExpression(node, opts) {
if (!node) return false;
if (node.type !== "LogicalExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isMemberExpression(node, opts) {
if (!node) return false;
if (node.type !== "MemberExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNewExpression(node, opts) {
if (!node) return false;
if (node.type !== "NewExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isProgram(node, opts) {
if (!node) return false;
if (node.type !== "Program") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectExpression(node, opts) {
if (!node) return false;
if (node.type !== "ObjectExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectMethod(node, opts) {
if (!node) return false;
if (node.type !== "ObjectMethod") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isRestElement(node, opts) {
if (!node) return false;
if (node.type !== "RestElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isReturnStatement(node, opts) {
if (!node) return false;
if (node.type !== "ReturnStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSequenceExpression(node, opts) {
if (!node) return false;
if (node.type !== "SequenceExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isParenthesizedExpression(node, opts) {
if (!node) return false;
if (node.type !== "ParenthesizedExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSwitchCase(node, opts) {
if (!node) return false;
if (node.type !== "SwitchCase") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSwitchStatement(node, opts) {
if (!node) return false;
if (node.type !== "SwitchStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isThisExpression(node, opts) {
if (!node) return false;
if (node.type !== "ThisExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isThrowStatement(node, opts) {
if (!node) return false;
if (node.type !== "ThrowStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTryStatement(node, opts) {
if (!node) return false;
if (node.type !== "TryStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isUnaryExpression(node, opts) {
if (!node) return false;
if (node.type !== "UnaryExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isUpdateExpression(node, opts) {
if (!node) return false;
if (node.type !== "UpdateExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isVariableDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "VariableDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isVariableDeclarator(node, opts) {
if (!node) return false;
if (node.type !== "VariableDeclarator") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isWhileStatement(node, opts) {
if (!node) return false;
if (node.type !== "WhileStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isWithStatement(node, opts) {
if (!node) return false;
if (node.type !== "WithStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isAssignmentPattern(node, opts) {
if (!node) return false;
if (node.type !== "AssignmentPattern") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isArrayPattern(node, opts) {
if (!node) return false;
if (node.type !== "ArrayPattern") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isArrowFunctionExpression(node, opts) {
if (!node) return false;
if (node.type !== "ArrowFunctionExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassBody(node, opts) {
if (!node) return false;
if (node.type !== "ClassBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassExpression(node, opts) {
if (!node) return false;
if (node.type !== "ClassExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "ClassDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportAllDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "ExportAllDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportDefaultDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "ExportDefaultDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportNamedDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "ExportNamedDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ExportSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isForOfStatement(node, opts) {
if (!node) return false;
if (node.type !== "ForOfStatement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "ImportDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportDefaultSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ImportDefaultSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportNamespaceSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ImportNamespaceSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ImportSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportExpression(node, opts) {
if (!node) return false;
if (node.type !== "ImportExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isMetaProperty(node, opts) {
if (!node) return false;
if (node.type !== "MetaProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassMethod(node, opts) {
if (!node) return false;
if (node.type !== "ClassMethod") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectPattern(node, opts) {
if (!node) return false;
if (node.type !== "ObjectPattern") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSpreadElement(node, opts) {
if (!node) return false;
if (node.type !== "SpreadElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSuper(node, opts) {
if (!node) return false;
if (node.type !== "Super") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTaggedTemplateExpression(node, opts) {
if (!node) return false;
if (node.type !== "TaggedTemplateExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTemplateElement(node, opts) {
if (!node) return false;
if (node.type !== "TemplateElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTemplateLiteral(node, opts) {
if (!node) return false;
if (node.type !== "TemplateLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isYieldExpression(node, opts) {
if (!node) return false;
if (node.type !== "YieldExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isAwaitExpression(node, opts) {
if (!node) return false;
if (node.type !== "AwaitExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImport(node, opts) {
if (!node) return false;
if (node.type !== "Import") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBigIntLiteral(node, opts) {
if (!node) return false;
if (node.type !== "BigIntLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportNamespaceSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ExportNamespaceSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isOptionalMemberExpression(node, opts) {
if (!node) return false;
if (node.type !== "OptionalMemberExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isOptionalCallExpression(node, opts) {
if (!node) return false;
if (node.type !== "OptionalCallExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassAccessorProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassAccessorProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassPrivateProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassPrivateProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassPrivateMethod(node, opts) {
if (!node) return false;
if (node.type !== "ClassPrivateMethod") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPrivateName(node, opts) {
if (!node) return false;
if (node.type !== "PrivateName") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStaticBlock(node, opts) {
if (!node) return false;
if (node.type !== "StaticBlock") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isAnyTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "AnyTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isArrayTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ArrayTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBooleanTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "BooleanTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBooleanLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "BooleanLiteralTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNullLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NullLiteralTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClassImplements(node, opts) {
if (!node) return false;
if (node.type !== "ClassImplements") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareClass(node, opts) {
if (!node) return false;
if (node.type !== "DeclareClass") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareFunction(node, opts) {
if (!node) return false;
if (node.type !== "DeclareFunction") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareInterface(node, opts) {
if (!node) return false;
if (node.type !== "DeclareInterface") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareModule(node, opts) {
if (!node) return false;
if (node.type !== "DeclareModule") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareModuleExports(node, opts) {
if (!node) return false;
if (node.type !== "DeclareModuleExports") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareTypeAlias(node, opts) {
if (!node) return false;
if (node.type !== "DeclareTypeAlias") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareOpaqueType(node, opts) {
if (!node) return false;
if (node.type !== "DeclareOpaqueType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareVariable(node, opts) {
if (!node) return false;
if (node.type !== "DeclareVariable") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareExportDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "DeclareExportDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclareExportAllDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "DeclareExportAllDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclaredPredicate(node, opts) {
if (!node) return false;
if (node.type !== "DeclaredPredicate") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExistsTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ExistsTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunctionTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "FunctionTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunctionTypeParam(node, opts) {
if (!node) return false;
if (node.type !== "FunctionTypeParam") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isGenericTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "GenericTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isInferredPredicate(node, opts) {
if (!node) return false;
if (node.type !== "InferredPredicate") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isInterfaceExtends(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceExtends") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isInterfaceDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isInterfaceTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isIntersectionTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "IntersectionTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isMixedTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "MixedTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEmptyTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "EmptyTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNullableTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NullableTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNumberLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NumberLiteralTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNumberTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NumberTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeInternalSlot(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeInternalSlot") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeCallProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeCallProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeIndexer(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeIndexer") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectTypeSpreadProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeSpreadProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isOpaqueType(node, opts) {
if (!node) return false;
if (node.type !== "OpaqueType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isQualifiedTypeIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "QualifiedTypeIdentifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStringLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "StringLiteralTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStringTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "StringTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSymbolTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "SymbolTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isThisTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ThisTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTupleTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "TupleTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeofTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "TypeofTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeAlias(node, opts) {
if (!node) return false;
if (node.type !== "TypeAlias") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "TypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeCastExpression(node, opts) {
if (!node) return false;
if (node.type !== "TypeCastExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeParameter(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameter") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeParameterDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameterDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeParameterInstantiation(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameterInstantiation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isUnionTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "UnionTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isVariance(node, opts) {
if (!node) return false;
if (node.type !== "Variance") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isVoidTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "VoidTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "EnumDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumBooleanBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumBooleanBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumNumberBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumNumberBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumStringBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumStringBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumSymbolBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumSymbolBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumBooleanMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumBooleanMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumNumberMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumNumberMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumStringMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumStringMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumDefaultedMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumDefaultedMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isIndexedAccessType(node, opts) {
if (!node) return false;
if (node.type !== "IndexedAccessType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isOptionalIndexedAccessType(node, opts) {
if (!node) return false;
if (node.type !== "OptionalIndexedAccessType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXAttribute(node, opts) {
if (!node) return false;
if (node.type !== "JSXAttribute") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXClosingElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXClosingElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXEmptyExpression(node, opts) {
if (!node) return false;
if (node.type !== "JSXEmptyExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXExpressionContainer(node, opts) {
if (!node) return false;
if (node.type !== "JSXExpressionContainer") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXSpreadChild(node, opts) {
if (!node) return false;
if (node.type !== "JSXSpreadChild") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "JSXIdentifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXMemberExpression(node, opts) {
if (!node) return false;
if (node.type !== "JSXMemberExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXNamespacedName(node, opts) {
if (!node) return false;
if (node.type !== "JSXNamespacedName") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXOpeningElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXOpeningElement") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXSpreadAttribute(node, opts) {
if (!node) return false;
if (node.type !== "JSXSpreadAttribute") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXText(node, opts) {
if (!node) return false;
if (node.type !== "JSXText") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXFragment") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXOpeningFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXOpeningFragment") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSXClosingFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXClosingFragment") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNoop(node, opts) {
if (!node) return false;
if (node.type !== "Noop") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPlaceholder(node, opts) {
if (!node) return false;
if (node.type !== "Placeholder") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isV8IntrinsicIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "V8IntrinsicIdentifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isArgumentPlaceholder(node, opts) {
if (!node) return false;
if (node.type !== "ArgumentPlaceholder") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBindExpression(node, opts) {
if (!node) return false;
if (node.type !== "BindExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportAttribute(node, opts) {
if (!node) return false;
if (node.type !== "ImportAttribute") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDecorator(node, opts) {
if (!node) return false;
if (node.type !== "Decorator") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDoExpression(node, opts) {
if (!node) return false;
if (node.type !== "DoExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportDefaultSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ExportDefaultSpecifier") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isRecordExpression(node, opts) {
if (!node) return false;
if (node.type !== "RecordExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTupleExpression(node, opts) {
if (!node) return false;
if (node.type !== "TupleExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDecimalLiteral(node, opts) {
if (!node) return false;
if (node.type !== "DecimalLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isModuleExpression(node, opts) {
if (!node) return false;
if (node.type !== "ModuleExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTopicReference(node, opts) {
if (!node) return false;
if (node.type !== "TopicReference") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPipelineTopicExpression(node, opts) {
if (!node) return false;
if (node.type !== "PipelineTopicExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPipelineBareFunction(node, opts) {
if (!node) return false;
if (node.type !== "PipelineBareFunction") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPipelinePrimaryTopicReference(node, opts) {
if (!node) return false;
if (node.type !== "PipelinePrimaryTopicReference") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSParameterProperty(node, opts) {
if (!node) return false;
if (node.type !== "TSParameterProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSDeclareFunction(node, opts) {
if (!node) return false;
if (node.type !== "TSDeclareFunction") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSDeclareMethod(node, opts) {
if (!node) return false;
if (node.type !== "TSDeclareMethod") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSQualifiedName(node, opts) {
if (!node) return false;
if (node.type !== "TSQualifiedName") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSCallSignatureDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSCallSignatureDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSConstructSignatureDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSConstructSignatureDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSPropertySignature(node, opts) {
if (!node) return false;
if (node.type !== "TSPropertySignature") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSMethodSignature(node, opts) {
if (!node) return false;
if (node.type !== "TSMethodSignature") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSIndexSignature(node, opts) {
if (!node) return false;
if (node.type !== "TSIndexSignature") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSAnyKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSAnyKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSBooleanKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSBooleanKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSBigIntKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSBigIntKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSIntrinsicKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSIntrinsicKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNeverKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSNeverKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNullKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSNullKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNumberKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSNumberKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSObjectKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSObjectKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSStringKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSStringKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSSymbolKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSSymbolKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSUndefinedKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSUndefinedKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSUnknownKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSUnknownKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSVoidKeyword(node, opts) {
if (!node) return false;
if (node.type !== "TSVoidKeyword") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSThisType(node, opts) {
if (!node) return false;
if (node.type !== "TSThisType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSFunctionType(node, opts) {
if (!node) return false;
if (node.type !== "TSFunctionType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSConstructorType(node, opts) {
if (!node) return false;
if (node.type !== "TSConstructorType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeReference(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeReference") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypePredicate(node, opts) {
if (!node) return false;
if (node.type !== "TSTypePredicate") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeQuery(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeQuery") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeLiteral(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSArrayType(node, opts) {
if (!node) return false;
if (node.type !== "TSArrayType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTupleType(node, opts) {
if (!node) return false;
if (node.type !== "TSTupleType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSOptionalType(node, opts) {
if (!node) return false;
if (node.type !== "TSOptionalType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSRestType(node, opts) {
if (!node) return false;
if (node.type !== "TSRestType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNamedTupleMember(node, opts) {
if (!node) return false;
if (node.type !== "TSNamedTupleMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSUnionType(node, opts) {
if (!node) return false;
if (node.type !== "TSUnionType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSIntersectionType(node, opts) {
if (!node) return false;
if (node.type !== "TSIntersectionType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSConditionalType(node, opts) {
if (!node) return false;
if (node.type !== "TSConditionalType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSInferType(node, opts) {
if (!node) return false;
if (node.type !== "TSInferType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSParenthesizedType(node, opts) {
if (!node) return false;
if (node.type !== "TSParenthesizedType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeOperator(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeOperator") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSIndexedAccessType(node, opts) {
if (!node) return false;
if (node.type !== "TSIndexedAccessType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSMappedType(node, opts) {
if (!node) return false;
if (node.type !== "TSMappedType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSLiteralType(node, opts) {
if (!node) return false;
if (node.type !== "TSLiteralType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSExpressionWithTypeArguments(node, opts) {
if (!node) return false;
if (node.type !== "TSExpressionWithTypeArguments") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSInterfaceDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSInterfaceDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSInterfaceBody(node, opts) {
if (!node) return false;
if (node.type !== "TSInterfaceBody") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeAliasDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeAliasDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSInstantiationExpression(node, opts) {
if (!node) return false;
if (node.type !== "TSInstantiationExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSAsExpression(node, opts) {
if (!node) return false;
if (node.type !== "TSAsExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSSatisfiesExpression(node, opts) {
if (!node) return false;
if (node.type !== "TSSatisfiesExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeAssertion(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeAssertion") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSEnumDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSEnumDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSEnumMember(node, opts) {
if (!node) return false;
if (node.type !== "TSEnumMember") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSModuleDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSModuleDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSModuleBlock(node, opts) {
if (!node) return false;
if (node.type !== "TSModuleBlock") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSImportType(node, opts) {
if (!node) return false;
if (node.type !== "TSImportType") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSImportEqualsDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSImportEqualsDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSExternalModuleReference(node, opts) {
if (!node) return false;
if (node.type !== "TSExternalModuleReference") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNonNullExpression(node, opts) {
if (!node) return false;
if (node.type !== "TSNonNullExpression") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSExportAssignment(node, opts) {
if (!node) return false;
if (node.type !== "TSExportAssignment") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSNamespaceExportDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSNamespaceExportDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeAnnotation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeParameterInstantiation(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeParameterInstantiation") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeParameterDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeParameterDeclaration") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeParameter(node, opts) {
if (!node) return false;
if (node.type !== "TSTypeParameter") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStandardized(node, opts) {
if (!node) return false;
switch (node.type) {
case "ArrayExpression":
case "AssignmentExpression":
case "BinaryExpression":
case "InterpreterDirective":
case "Directive":
case "DirectiveLiteral":
case "BlockStatement":
case "BreakStatement":
case "CallExpression":
case "CatchClause":
case "ConditionalExpression":
case "ContinueStatement":
case "DebuggerStatement":
case "DoWhileStatement":
case "EmptyStatement":
case "ExpressionStatement":
case "File":
case "ForInStatement":
case "ForStatement":
case "FunctionDeclaration":
case "FunctionExpression":
case "Identifier":
case "IfStatement":
case "LabeledStatement":
case "StringLiteral":
case "NumericLiteral":
case "NullLiteral":
case "BooleanLiteral":
case "RegExpLiteral":
case "LogicalExpression":
case "MemberExpression":
case "NewExpression":
case "Program":
case "ObjectExpression":
case "ObjectMethod":
case "ObjectProperty":
case "RestElement":
case "ReturnStatement":
case "SequenceExpression":
case "ParenthesizedExpression":
case "SwitchCase":
case "SwitchStatement":
case "ThisExpression":
case "ThrowStatement":
case "TryStatement":
case "UnaryExpression":
case "UpdateExpression":
case "VariableDeclaration":
case "VariableDeclarator":
case "WhileStatement":
case "WithStatement":
case "AssignmentPattern":
case "ArrayPattern":
case "ArrowFunctionExpression":
case "ClassBody":
case "ClassExpression":
case "ClassDeclaration":
case "ExportAllDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
case "ExportSpecifier":
case "ForOfStatement":
case "ImportDeclaration":
case "ImportDefaultSpecifier":
case "ImportNamespaceSpecifier":
case "ImportSpecifier":
case "ImportExpression":
case "MetaProperty":
case "ClassMethod":
case "ObjectPattern":
case "SpreadElement":
case "Super":
case "TaggedTemplateExpression":
case "TemplateElement":
case "TemplateLiteral":
case "YieldExpression":
case "AwaitExpression":
case "Import":
case "BigIntLiteral":
case "ExportNamespaceSpecifier":
case "OptionalMemberExpression":
case "OptionalCallExpression":
case "ClassProperty":
case "ClassAccessorProperty":
case "ClassPrivateProperty":
case "ClassPrivateMethod":
case "PrivateName":
case "StaticBlock":
break;
case "Placeholder":
switch (node.expectedNode) {
case "Identifier":
case "StringLiteral":
case "BlockStatement":
case "ClassBody":
break;
default:
return false;
}
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExpression(node, opts) {
if (!node) return false;
switch (node.type) {
case "ArrayExpression":
case "AssignmentExpression":
case "BinaryExpression":
case "CallExpression":
case "ConditionalExpression":
case "FunctionExpression":
case "Identifier":
case "StringLiteral":
case "NumericLiteral":
case "NullLiteral":
case "BooleanLiteral":
case "RegExpLiteral":
case "LogicalExpression":
case "MemberExpression":
case "NewExpression":
case "ObjectExpression":
case "SequenceExpression":
case "ParenthesizedExpression":
case "ThisExpression":
case "UnaryExpression":
case "UpdateExpression":
case "ArrowFunctionExpression":
case "ClassExpression":
case "ImportExpression":
case "MetaProperty":
case "Super":
case "TaggedTemplateExpression":
case "TemplateLiteral":
case "YieldExpression":
case "AwaitExpression":
case "Import":
case "BigIntLiteral":
case "OptionalMemberExpression":
case "OptionalCallExpression":
case "TypeCastExpression":
case "JSXElement":
case "JSXFragment":
case "BindExpression":
case "DoExpression":
case "RecordExpression":
case "TupleExpression":
case "DecimalLiteral":
case "ModuleExpression":
case "TopicReference":
case "PipelineTopicExpression":
case "PipelineBareFunction":
case "PipelinePrimaryTopicReference":
case "TSInstantiationExpression":
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSNonNullExpression":
break;
case "Placeholder":
switch (node.expectedNode) {
case "Expression":
case "Identifier":
case "StringLiteral":
break;
default:
return false;
}
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBinary(node, opts) {
if (!node) return false;
switch (node.type) {
case "BinaryExpression":
case "LogicalExpression":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isScopable(node, opts) {
if (!node) return false;
switch (node.type) {
case "BlockStatement":
case "CatchClause":
case "DoWhileStatement":
case "ForInStatement":
case "ForStatement":
case "FunctionDeclaration":
case "FunctionExpression":
case "Program":
case "ObjectMethod":
case "SwitchStatement":
case "WhileStatement":
case "ArrowFunctionExpression":
case "ClassExpression":
case "ClassDeclaration":
case "ForOfStatement":
case "ClassMethod":
case "ClassPrivateMethod":
case "StaticBlock":
case "TSModuleBlock":
break;
case "Placeholder":
if (node.expectedNode === "BlockStatement") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBlockParent(node, opts) {
if (!node) return false;
switch (node.type) {
case "BlockStatement":
case "CatchClause":
case "DoWhileStatement":
case "ForInStatement":
case "ForStatement":
case "FunctionDeclaration":
case "FunctionExpression":
case "Program":
case "ObjectMethod":
case "SwitchStatement":
case "WhileStatement":
case "ArrowFunctionExpression":
case "ForOfStatement":
case "ClassMethod":
case "ClassPrivateMethod":
case "StaticBlock":
case "TSModuleBlock":
break;
case "Placeholder":
if (node.expectedNode === "BlockStatement") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isBlock(node, opts) {
if (!node) return false;
switch (node.type) {
case "BlockStatement":
case "Program":
case "TSModuleBlock":
break;
case "Placeholder":
if (node.expectedNode === "BlockStatement") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isStatement(node, opts) {
if (!node) return false;
switch (node.type) {
case "BlockStatement":
case "BreakStatement":
case "ContinueStatement":
case "DebuggerStatement":
case "DoWhileStatement":
case "EmptyStatement":
case "ExpressionStatement":
case "ForInStatement":
case "ForStatement":
case "FunctionDeclaration":
case "IfStatement":
case "LabeledStatement":
case "ReturnStatement":
case "SwitchStatement":
case "ThrowStatement":
case "TryStatement":
case "VariableDeclaration":
case "WhileStatement":
case "WithStatement":
case "ClassDeclaration":
case "ExportAllDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
case "ForOfStatement":
case "ImportDeclaration":
case "DeclareClass":
case "DeclareFunction":
case "DeclareInterface":
case "DeclareModule":
case "DeclareModuleExports":
case "DeclareTypeAlias":
case "DeclareOpaqueType":
case "DeclareVariable":
case "DeclareExportDeclaration":
case "DeclareExportAllDeclaration":
case "InterfaceDeclaration":
case "OpaqueType":
case "TypeAlias":
case "EnumDeclaration":
case "TSDeclareFunction":
case "TSInterfaceDeclaration":
case "TSTypeAliasDeclaration":
case "TSEnumDeclaration":
case "TSModuleDeclaration":
case "TSImportEqualsDeclaration":
case "TSExportAssignment":
case "TSNamespaceExportDeclaration":
break;
case "Placeholder":
switch (node.expectedNode) {
case "Statement":
case "Declaration":
case "BlockStatement":
break;
default:
return false;
}
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTerminatorless(node, opts) {
if (!node) return false;
switch (node.type) {
case "BreakStatement":
case "ContinueStatement":
case "ReturnStatement":
case "ThrowStatement":
case "YieldExpression":
case "AwaitExpression":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isCompletionStatement(node, opts) {
if (!node) return false;
switch (node.type) {
case "BreakStatement":
case "ContinueStatement":
case "ReturnStatement":
case "ThrowStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isConditional(node, opts) {
if (!node) return false;
switch (node.type) {
case "ConditionalExpression":
case "IfStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isLoop(node, opts) {
if (!node) return false;
switch (node.type) {
case "DoWhileStatement":
case "ForInStatement":
case "ForStatement":
case "WhileStatement":
case "ForOfStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isWhile(node, opts) {
if (!node) return false;
switch (node.type) {
case "DoWhileStatement":
case "WhileStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExpressionWrapper(node, opts) {
if (!node) return false;
switch (node.type) {
case "ExpressionStatement":
case "ParenthesizedExpression":
case "TypeCastExpression":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFor(node, opts) {
if (!node) return false;
switch (node.type) {
case "ForInStatement":
case "ForStatement":
case "ForOfStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isForXStatement(node, opts) {
if (!node) return false;
switch (node.type) {
case "ForInStatement":
case "ForOfStatement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunction(node, opts) {
if (!node) return false;
switch (node.type) {
case "FunctionDeclaration":
case "FunctionExpression":
case "ObjectMethod":
case "ArrowFunctionExpression":
case "ClassMethod":
case "ClassPrivateMethod":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFunctionParent(node, opts) {
if (!node) return false;
switch (node.type) {
case "FunctionDeclaration":
case "FunctionExpression":
case "ObjectMethod":
case "ArrowFunctionExpression":
case "ClassMethod":
case "ClassPrivateMethod":
case "StaticBlock":
case "TSModuleBlock":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPureish(node, opts) {
if (!node) return false;
switch (node.type) {
case "FunctionDeclaration":
case "FunctionExpression":
case "StringLiteral":
case "NumericLiteral":
case "NullLiteral":
case "BooleanLiteral":
case "RegExpLiteral":
case "ArrowFunctionExpression":
case "BigIntLiteral":
case "DecimalLiteral":
break;
case "Placeholder":
if (node.expectedNode === "StringLiteral") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isDeclaration(node, opts) {
if (!node) return false;
switch (node.type) {
case "FunctionDeclaration":
case "VariableDeclaration":
case "ClassDeclaration":
case "ExportAllDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
case "ImportDeclaration":
case "DeclareClass":
case "DeclareFunction":
case "DeclareInterface":
case "DeclareModule":
case "DeclareModuleExports":
case "DeclareTypeAlias":
case "DeclareOpaqueType":
case "DeclareVariable":
case "DeclareExportDeclaration":
case "DeclareExportAllDeclaration":
case "InterfaceDeclaration":
case "OpaqueType":
case "TypeAlias":
case "EnumDeclaration":
case "TSDeclareFunction":
case "TSInterfaceDeclaration":
case "TSTypeAliasDeclaration":
case "TSEnumDeclaration":
case "TSModuleDeclaration":
break;
case "Placeholder":
if (node.expectedNode === "Declaration") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPatternLike(node, opts) {
if (!node) return false;
switch (node.type) {
case "Identifier":
case "RestElement":
case "AssignmentPattern":
case "ArrayPattern":
case "ObjectPattern":
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSNonNullExpression":
break;
case "Placeholder":
switch (node.expectedNode) {
case "Pattern":
case "Identifier":
break;
default:
return false;
}
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isLVal(node, opts) {
if (!node) return false;
switch (node.type) {
case "Identifier":
case "MemberExpression":
case "RestElement":
case "AssignmentPattern":
case "ArrayPattern":
case "ObjectPattern":
case "TSParameterProperty":
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSNonNullExpression":
break;
case "Placeholder":
switch (node.expectedNode) {
case "Pattern":
case "Identifier":
break;
default:
return false;
}
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSEntityName(node, opts) {
if (!node) return false;
switch (node.type) {
case "Identifier":
case "TSQualifiedName":
break;
case "Placeholder":
if (node.expectedNode === "Identifier") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isLiteral(node, opts) {
if (!node) return false;
switch (node.type) {
case "StringLiteral":
case "NumericLiteral":
case "NullLiteral":
case "BooleanLiteral":
case "RegExpLiteral":
case "TemplateLiteral":
case "BigIntLiteral":
case "DecimalLiteral":
break;
case "Placeholder":
if (node.expectedNode === "StringLiteral") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImmutable(node, opts) {
if (!node) return false;
switch (node.type) {
case "StringLiteral":
case "NumericLiteral":
case "NullLiteral":
case "BooleanLiteral":
case "BigIntLiteral":
case "JSXAttribute":
case "JSXClosingElement":
case "JSXElement":
case "JSXExpressionContainer":
case "JSXSpreadChild":
case "JSXOpeningElement":
case "JSXText":
case "JSXFragment":
case "JSXOpeningFragment":
case "JSXClosingFragment":
case "DecimalLiteral":
break;
case "Placeholder":
if (node.expectedNode === "StringLiteral") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isUserWhitespacable(node, opts) {
if (!node) return false;
switch (node.type) {
case "ObjectMethod":
case "ObjectProperty":
case "ObjectTypeInternalSlot":
case "ObjectTypeCallProperty":
case "ObjectTypeIndexer":
case "ObjectTypeProperty":
case "ObjectTypeSpreadProperty":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isMethod(node, opts) {
if (!node) return false;
switch (node.type) {
case "ObjectMethod":
case "ClassMethod":
case "ClassPrivateMethod":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isObjectMember(node, opts) {
if (!node) return false;
switch (node.type) {
case "ObjectMethod":
case "ObjectProperty":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isProperty(node, opts) {
if (!node) return false;
switch (node.type) {
case "ObjectProperty":
case "ClassProperty":
case "ClassAccessorProperty":
case "ClassPrivateProperty":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isUnaryLike(node, opts) {
if (!node) return false;
switch (node.type) {
case "UnaryExpression":
case "SpreadElement":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPattern(node, opts) {
if (!node) return false;
switch (node.type) {
case "AssignmentPattern":
case "ArrayPattern":
case "ObjectPattern":
break;
case "Placeholder":
if (node.expectedNode === "Pattern") break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isClass(node, opts) {
if (!node) return false;
switch (node.type) {
case "ClassExpression":
case "ClassDeclaration":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isImportOrExportDeclaration(node, opts) {
if (!node) return false;
switch (node.type) {
case "ExportAllDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
case "ImportDeclaration":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isExportDeclaration(node, opts) {
if (!node) return false;
switch (node.type) {
case "ExportAllDeclaration":
case "ExportDefaultDeclaration":
case "ExportNamedDeclaration":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isModuleSpecifier(node, opts) {
if (!node) return false;
switch (node.type) {
case "ExportSpecifier":
case "ImportDefaultSpecifier":
case "ImportNamespaceSpecifier":
case "ImportSpecifier":
case "ExportNamespaceSpecifier":
case "ExportDefaultSpecifier":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isAccessor(node, opts) {
if (!node) return false;
switch (node.type) {
case "ClassAccessorProperty":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isPrivate(node, opts) {
if (!node) return false;
switch (node.type) {
case "ClassPrivateProperty":
case "ClassPrivateMethod":
case "PrivateName":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFlow(node, opts) {
if (!node) return false;
switch (node.type) {
case "AnyTypeAnnotation":
case "ArrayTypeAnnotation":
case "BooleanTypeAnnotation":
case "BooleanLiteralTypeAnnotation":
case "NullLiteralTypeAnnotation":
case "ClassImplements":
case "DeclareClass":
case "DeclareFunction":
case "DeclareInterface":
case "DeclareModule":
case "DeclareModuleExports":
case "DeclareTypeAlias":
case "DeclareOpaqueType":
case "DeclareVariable":
case "DeclareExportDeclaration":
case "DeclareExportAllDeclaration":
case "DeclaredPredicate":
case "ExistsTypeAnnotation":
case "FunctionTypeAnnotation":
case "FunctionTypeParam":
case "GenericTypeAnnotation":
case "InferredPredicate":
case "InterfaceExtends":
case "InterfaceDeclaration":
case "InterfaceTypeAnnotation":
case "IntersectionTypeAnnotation":
case "MixedTypeAnnotation":
case "EmptyTypeAnnotation":
case "NullableTypeAnnotation":
case "NumberLiteralTypeAnnotation":
case "NumberTypeAnnotation":
case "ObjectTypeAnnotation":
case "ObjectTypeInternalSlot":
case "ObjectTypeCallProperty":
case "ObjectTypeIndexer":
case "ObjectTypeProperty":
case "ObjectTypeSpreadProperty":
case "OpaqueType":
case "QualifiedTypeIdentifier":
case "StringLiteralTypeAnnotation":
case "StringTypeAnnotation":
case "SymbolTypeAnnotation":
case "ThisTypeAnnotation":
case "TupleTypeAnnotation":
case "TypeofTypeAnnotation":
case "TypeAlias":
case "TypeAnnotation":
case "TypeCastExpression":
case "TypeParameter":
case "TypeParameterDeclaration":
case "TypeParameterInstantiation":
case "UnionTypeAnnotation":
case "Variance":
case "VoidTypeAnnotation":
case "EnumDeclaration":
case "EnumBooleanBody":
case "EnumNumberBody":
case "EnumStringBody":
case "EnumSymbolBody":
case "EnumBooleanMember":
case "EnumNumberMember":
case "EnumStringMember":
case "EnumDefaultedMember":
case "IndexedAccessType":
case "OptionalIndexedAccessType":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFlowType(node, opts) {
if (!node) return false;
switch (node.type) {
case "AnyTypeAnnotation":
case "ArrayTypeAnnotation":
case "BooleanTypeAnnotation":
case "BooleanLiteralTypeAnnotation":
case "NullLiteralTypeAnnotation":
case "ExistsTypeAnnotation":
case "FunctionTypeAnnotation":
case "GenericTypeAnnotation":
case "InterfaceTypeAnnotation":
case "IntersectionTypeAnnotation":
case "MixedTypeAnnotation":
case "EmptyTypeAnnotation":
case "NullableTypeAnnotation":
case "NumberLiteralTypeAnnotation":
case "NumberTypeAnnotation":
case "ObjectTypeAnnotation":
case "StringLiteralTypeAnnotation":
case "StringTypeAnnotation":
case "SymbolTypeAnnotation":
case "ThisTypeAnnotation":
case "TupleTypeAnnotation":
case "TypeofTypeAnnotation":
case "UnionTypeAnnotation":
case "VoidTypeAnnotation":
case "IndexedAccessType":
case "OptionalIndexedAccessType":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFlowBaseAnnotation(node, opts) {
if (!node) return false;
switch (node.type) {
case "AnyTypeAnnotation":
case "BooleanTypeAnnotation":
case "NullLiteralTypeAnnotation":
case "MixedTypeAnnotation":
case "EmptyTypeAnnotation":
case "NumberTypeAnnotation":
case "StringTypeAnnotation":
case "SymbolTypeAnnotation":
case "ThisTypeAnnotation":
case "VoidTypeAnnotation":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFlowDeclaration(node, opts) {
if (!node) return false;
switch (node.type) {
case "DeclareClass":
case "DeclareFunction":
case "DeclareInterface":
case "DeclareModule":
case "DeclareModuleExports":
case "DeclareTypeAlias":
case "DeclareOpaqueType":
case "DeclareVariable":
case "DeclareExportDeclaration":
case "DeclareExportAllDeclaration":
case "InterfaceDeclaration":
case "OpaqueType":
case "TypeAlias":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isFlowPredicate(node, opts) {
if (!node) return false;
switch (node.type) {
case "DeclaredPredicate":
case "InferredPredicate":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumBody(node, opts) {
if (!node) return false;
switch (node.type) {
case "EnumBooleanBody":
case "EnumNumberBody":
case "EnumStringBody":
case "EnumSymbolBody":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isEnumMember(node, opts) {
if (!node) return false;
switch (node.type) {
case "EnumBooleanMember":
case "EnumNumberMember":
case "EnumStringMember":
case "EnumDefaultedMember":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isJSX(node, opts) {
if (!node) return false;
switch (node.type) {
case "JSXAttribute":
case "JSXClosingElement":
case "JSXElement":
case "JSXEmptyExpression":
case "JSXExpressionContainer":
case "JSXSpreadChild":
case "JSXIdentifier":
case "JSXMemberExpression":
case "JSXNamespacedName":
case "JSXOpeningElement":
case "JSXSpreadAttribute":
case "JSXText":
case "JSXFragment":
case "JSXOpeningFragment":
case "JSXClosingFragment":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isMiscellaneous(node, opts) {
if (!node) return false;
switch (node.type) {
case "Noop":
case "Placeholder":
case "V8IntrinsicIdentifier":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTypeScript(node, opts) {
if (!node) return false;
switch (node.type) {
case "TSParameterProperty":
case "TSDeclareFunction":
case "TSDeclareMethod":
case "TSQualifiedName":
case "TSCallSignatureDeclaration":
case "TSConstructSignatureDeclaration":
case "TSPropertySignature":
case "TSMethodSignature":
case "TSIndexSignature":
case "TSAnyKeyword":
case "TSBooleanKeyword":
case "TSBigIntKeyword":
case "TSIntrinsicKeyword":
case "TSNeverKeyword":
case "TSNullKeyword":
case "TSNumberKeyword":
case "TSObjectKeyword":
case "TSStringKeyword":
case "TSSymbolKeyword":
case "TSUndefinedKeyword":
case "TSUnknownKeyword":
case "TSVoidKeyword":
case "TSThisType":
case "TSFunctionType":
case "TSConstructorType":
case "TSTypeReference":
case "TSTypePredicate":
case "TSTypeQuery":
case "TSTypeLiteral":
case "TSArrayType":
case "TSTupleType":
case "TSOptionalType":
case "TSRestType":
case "TSNamedTupleMember":
case "TSUnionType":
case "TSIntersectionType":
case "TSConditionalType":
case "TSInferType":
case "TSParenthesizedType":
case "TSTypeOperator":
case "TSIndexedAccessType":
case "TSMappedType":
case "TSLiteralType":
case "TSExpressionWithTypeArguments":
case "TSInterfaceDeclaration":
case "TSInterfaceBody":
case "TSTypeAliasDeclaration":
case "TSInstantiationExpression":
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSEnumDeclaration":
case "TSEnumMember":
case "TSModuleDeclaration":
case "TSModuleBlock":
case "TSImportType":
case "TSImportEqualsDeclaration":
case "TSExternalModuleReference":
case "TSNonNullExpression":
case "TSExportAssignment":
case "TSNamespaceExportDeclaration":
case "TSTypeAnnotation":
case "TSTypeParameterInstantiation":
case "TSTypeParameterDeclaration":
case "TSTypeParameter":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSTypeElement(node, opts) {
if (!node) return false;
switch (node.type) {
case "TSCallSignatureDeclaration":
case "TSConstructSignatureDeclaration":
case "TSPropertySignature":
case "TSMethodSignature":
case "TSIndexSignature":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSType(node, opts) {
if (!node) return false;
switch (node.type) {
case "TSAnyKeyword":
case "TSBooleanKeyword":
case "TSBigIntKeyword":
case "TSIntrinsicKeyword":
case "TSNeverKeyword":
case "TSNullKeyword":
case "TSNumberKeyword":
case "TSObjectKeyword":
case "TSStringKeyword":
case "TSSymbolKeyword":
case "TSUndefinedKeyword":
case "TSUnknownKeyword":
case "TSVoidKeyword":
case "TSThisType":
case "TSFunctionType":
case "TSConstructorType":
case "TSTypeReference":
case "TSTypePredicate":
case "TSTypeQuery":
case "TSTypeLiteral":
case "TSArrayType":
case "TSTupleType":
case "TSOptionalType":
case "TSRestType":
case "TSUnionType":
case "TSIntersectionType":
case "TSConditionalType":
case "TSInferType":
case "TSParenthesizedType":
case "TSTypeOperator":
case "TSIndexedAccessType":
case "TSMappedType":
case "TSLiteralType":
case "TSExpressionWithTypeArguments":
case "TSImportType":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isTSBaseType(node, opts) {
if (!node) return false;
switch (node.type) {
case "TSAnyKeyword":
case "TSBooleanKeyword":
case "TSBigIntKeyword":
case "TSIntrinsicKeyword":
case "TSNeverKeyword":
case "TSNullKeyword":
case "TSNumberKeyword":
case "TSObjectKeyword":
case "TSStringKeyword":
case "TSSymbolKeyword":
case "TSUndefinedKeyword":
case "TSUnknownKeyword":
case "TSVoidKeyword":
case "TSThisType":
case "TSLiteralType":
break;
default:
return false;
}
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isNumberLiteral(node, opts) {
(0, _deprecationWarning.default)("isNumberLiteral", "isNumericLiteral");
if (!node) return false;
if (node.type !== "NumberLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isRegexLiteral(node, opts) {
(0, _deprecationWarning.default)("isRegexLiteral", "isRegExpLiteral");
if (!node) return false;
if (node.type !== "RegexLiteral") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isRestProperty(node, opts) {
(0, _deprecationWarning.default)("isRestProperty", "isRestElement");
if (!node) return false;
if (node.type !== "RestProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isSpreadProperty(node, opts) {
(0, _deprecationWarning.default)("isSpreadProperty", "isSpreadElement");
if (!node) return false;
if (node.type !== "SpreadProperty") return false;
return opts == null || (0, _shallowEqual.default)(node, opts);
}
function isModuleDeclaration(node, opts) {
(0, _deprecationWarning.default)("isModuleDeclaration", "isImportOrExportDeclaration");
return isImportOrExportDeclaration(node, opts);
}
return generated$3;
}
var hasRequiredMatchesPattern;
function requireMatchesPattern () {
if (hasRequiredMatchesPattern) return matchesPattern;
hasRequiredMatchesPattern = 1;
Object.defineProperty(matchesPattern, "__esModule", {
value: true
});
matchesPattern.default = matchesPattern$1;
var _index = requireGenerated$3();
function matchesPattern$1(member, match, allowPartial) {
if (!(0, _index.isMemberExpression)(member)) return false;
const parts = Array.isArray(match) ? match : match.split(".");
const nodes = [];
let node;
for (node = member; (0, _index.isMemberExpression)(node); node = node.object) {
nodes.push(node.property);
}
nodes.push(node);
if (nodes.length < parts.length) return false;
if (!allowPartial && nodes.length > parts.length) return false;
for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
const node = nodes[j];
let value;
if ((0, _index.isIdentifier)(node)) {
value = node.name;
} else if ((0, _index.isStringLiteral)(node)) {
value = node.value;
} else if ((0, _index.isThisExpression)(node)) {
value = "this";
} else {
return false;
}
if (parts[i] !== value) return false;
}
return true;
}
return matchesPattern;
}
var hasRequiredBuildMatchMemberExpression;
function requireBuildMatchMemberExpression () {
if (hasRequiredBuildMatchMemberExpression) return buildMatchMemberExpression;
hasRequiredBuildMatchMemberExpression = 1;
Object.defineProperty(buildMatchMemberExpression, "__esModule", {
value: true
});
buildMatchMemberExpression.default = buildMatchMemberExpression$1;
var _matchesPattern = requireMatchesPattern();
function buildMatchMemberExpression$1(match, allowPartial) {
const parts = match.split(".");
return member => (0, _matchesPattern.default)(member, parts, allowPartial);
}
return buildMatchMemberExpression;
}
var hasRequiredIsReactComponent;
function requireIsReactComponent () {
if (hasRequiredIsReactComponent) return isReactComponent$1;
hasRequiredIsReactComponent = 1;
Object.defineProperty(isReactComponent$1, "__esModule", {
value: true
});
isReactComponent$1.default = void 0;
var _buildMatchMemberExpression = requireBuildMatchMemberExpression();
const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
var _default = isReactComponent;
isReactComponent$1.default = _default;
return isReactComponent$1;
}
var isCompatTag = {};
var hasRequiredIsCompatTag;
function requireIsCompatTag () {
if (hasRequiredIsCompatTag) return isCompatTag;
hasRequiredIsCompatTag = 1;
Object.defineProperty(isCompatTag, "__esModule", {
value: true
});
isCompatTag.default = isCompatTag$1;
function isCompatTag$1(tagName) {
return !!tagName && /^[a-z]/.test(tagName);
}
return isCompatTag;
}
var buildChildren = {};
var cleanJSXElementLiteralChild = {};
var generated$2 = {};
var validateNode = {};
var validate = {};
var definitions = {};
var toFastProperties;
var hasRequiredToFastProperties;
function requireToFastProperties () {
if (hasRequiredToFastProperties) return toFastProperties;
hasRequiredToFastProperties = 1;
let fastProto = null;
// Creates an object with permanently fast properties in V8. See Toon Verwaest's
// for more details. Use %HasFastProperties(object) and the Node.js flag
// --allow-natives-syntax to check whether an object has fast properties.
function FastObject(o) {
// A prototype object will have "fast properties" enabled once it is checked
// against the inline property cache of a function, e.g. fastProto.property:
if (fastProto !== null && typeof fastProto.property) {
const result = fastProto;
fastProto = FastObject.prototype = null;
return result;
}
fastProto = FastObject.prototype = o == null ? Object.create(null) : o;
return new FastObject;
}
// Initialize the inline property cache of FastObject
FastObject();
toFastProperties = function toFastproperties(o) {
return FastObject(o);
};
return toFastProperties;
}
var global$1 = (typeof global !== "undefined" ? global :
typeof self !== "undefined" ? self :
typeof window !== "undefined" ? window : {});
// shim for using process in browser
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
var cachedSetTimeout = defaultSetTimout;
var cachedClearTimeout = defaultClearTimeout;
if (typeof global$1.setTimeout === 'function') {
cachedSetTimeout = setTimeout;
}
if (typeof global$1.clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
}
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
function nextTick(fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
}
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
var title = 'browser';
var platform = 'browser';
var browser = true;
var env = {};
var argv = [];
var version = ''; // empty string to avoid regexp issues
var versions = {};
var release = {};
var config = {};
function noop() {}
var on = noop;
var addListener = noop;
var once = noop;
var off = noop;
var removeListener = noop;
var removeAllListeners = noop;
var emit = noop;
function binding(name) {
throw new Error('process.binding is not supported');
}
function cwd () { return '/' }
function chdir (dir) {
throw new Error('process.chdir is not supported');
}function umask() { return 0; }
var performance = global$1.performance || {};
var performanceNow =
performance.now ||
performance.mozNow ||
performance.msNow ||
performance.oNow ||
performance.webkitNow ||
function(){ return (new Date()).getTime() };
// generate timestamp or delta
function hrtime(previousTimestamp){
var clocktime = performanceNow.call(performance)*1e-3;
var seconds = Math.floor(clocktime);
var nanoseconds = Math.floor((clocktime%1)*1e9);
if (previousTimestamp) {
seconds = seconds - previousTimestamp[0];
nanoseconds = nanoseconds - previousTimestamp[1];
if (nanoseconds<0) {
seconds--;
nanoseconds += 1e9;
}
}
return [seconds,nanoseconds]
}
var startTime = new Date();
function uptime() {
var currentTime = new Date();
var dif = currentTime - startTime;
return dif / 1000;
}
var browser$1 = {
nextTick: nextTick,
title: title,
browser: browser,
env: env,
argv: argv,
version: version,
versions: versions,
on: on,
addListener: addListener,
once: once,
off: off,
removeListener: removeListener,
removeAllListeners: removeAllListeners,
emit: emit,
binding: binding,
cwd: cwd,
chdir: chdir,
umask: umask,
hrtime: hrtime,
platform: platform,
release: release,
config: config,
uptime: uptime
};
var process$1 = browser$1;
var core = {};
var is = {};
var isType = {};
var hasRequiredIsType;
function requireIsType () {
if (hasRequiredIsType) return isType;
hasRequiredIsType = 1;
Object.defineProperty(isType, "__esModule", {
value: true
});
isType.default = isType$1;
var _index = requireDefinitions();
function isType$1(nodeType, targetType) {
if (nodeType === targetType) return true;
if (nodeType == null) return false;
if (_index.ALIAS_KEYS[targetType]) return false;
const aliases = _index.FLIPPED_ALIAS_KEYS[targetType];
if (aliases) {
if (aliases[0] === nodeType) return true;
for (const alias of aliases) {
if (nodeType === alias) return true;
}
}
return false;
}
return isType;
}
var isPlaceholderType = {};
var hasRequiredIsPlaceholderType;
function requireIsPlaceholderType () {
if (hasRequiredIsPlaceholderType) return isPlaceholderType;
hasRequiredIsPlaceholderType = 1;
Object.defineProperty(isPlaceholderType, "__esModule", {
value: true
});
isPlaceholderType.default = isPlaceholderType$1;
var _index = requireDefinitions();
function isPlaceholderType$1(placeholderType, targetType) {
if (placeholderType === targetType) return true;
const aliases = _index.PLACEHOLDERS_ALIAS[placeholderType];
if (aliases) {
for (const alias of aliases) {
if (targetType === alias) return true;
}
}
return false;
}
return isPlaceholderType;
}
var hasRequiredIs;
function requireIs () {
if (hasRequiredIs) return is;
hasRequiredIs = 1;
Object.defineProperty(is, "__esModule", {
value: true
});
is.default = is$1;
var _shallowEqual = requireShallowEqual();
var _isType = requireIsType();
var _isPlaceholderType = requireIsPlaceholderType();
var _index = requireDefinitions();
function is$1(type, node, opts) {
if (!node) return false;
const matches = (0, _isType.default)(node.type, type);
if (!matches) {
if (!opts && node.type === "Placeholder" && type in _index.FLIPPED_ALIAS_KEYS) {
return (0, _isPlaceholderType.default)(node.expectedNode, type);
}
return false;
}
if (typeof opts === "undefined") {
return true;
} else {
return (0, _shallowEqual.default)(node, opts);
}
}
return is;
}
var isValidIdentifier = {};
var lib$3 = {};
var identifier = {};
var hasRequiredIdentifier;
function requireIdentifier () {
if (hasRequiredIdentifier) return identifier;
hasRequiredIdentifier = 1;
Object.defineProperty(identifier, "__esModule", {
value: true
});
identifier.isIdentifierChar = isIdentifierChar;
identifier.isIdentifierName = isIdentifierName;
identifier.isIdentifierStart = isIdentifierStart;
let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
function isInAstralSet(code, set) {
let pos = 0x10000;
for (let i = 0, length = set.length; i < length; i += 2) {
pos += set[i];
if (pos > code) return false;
pos += set[i + 1];
if (pos >= code) return true;
}
return false;
}
function isIdentifierStart(code) {
if (code < 65) return code === 36;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 0xffff) {
return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
}
return isInAstralSet(code, astralIdentifierStartCodes);
}
function isIdentifierChar(code) {
if (code < 48) return code === 36;
if (code < 58) return true;
if (code < 65) return false;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 0xffff) {
return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
}
return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
}
function isIdentifierName(name) {
let isFirst = true;
for (let i = 0; i < name.length; i++) {
let cp = name.charCodeAt(i);
if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
const trail = name.charCodeAt(++i);
if ((trail & 0xfc00) === 0xdc00) {
cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
}
}
if (isFirst) {
isFirst = false;
if (!isIdentifierStart(cp)) {
return false;
}
} else if (!isIdentifierChar(cp)) {
return false;
}
}
return !isFirst;
}
return identifier;
}
var keyword = {};
var hasRequiredKeyword;
function requireKeyword () {
if (hasRequiredKeyword) return keyword;
hasRequiredKeyword = 1;
Object.defineProperty(keyword, "__esModule", {
value: true
});
keyword.isKeyword = isKeyword;
keyword.isReservedWord = isReservedWord;
keyword.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
keyword.isStrictBindReservedWord = isStrictBindReservedWord;
keyword.isStrictReservedWord = isStrictReservedWord;
const reservedWords = {
keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
strictBind: ["eval", "arguments"]
};
const keywords = new Set(reservedWords.keyword);
const reservedWordsStrictSet = new Set(reservedWords.strict);
const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
function isReservedWord(word, inModule) {
return inModule && word === "await" || word === "enum";
}
function isStrictReservedWord(word, inModule) {
return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
}
function isStrictBindOnlyReservedWord(word) {
return reservedWordsStrictBindSet.has(word);
}
function isStrictBindReservedWord(word, inModule) {
return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
}
function isKeyword(word) {
return keywords.has(word);
}
return keyword;
}
var hasRequiredLib$4;
function requireLib$4 () {
if (hasRequiredLib$4) return lib$3;
hasRequiredLib$4 = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "isIdentifierChar", {
enumerable: true,
get: function () {
return _identifier.isIdentifierChar;
}
});
Object.defineProperty(exports, "isIdentifierName", {
enumerable: true,
get: function () {
return _identifier.isIdentifierName;
}
});
Object.defineProperty(exports, "isIdentifierStart", {
enumerable: true,
get: function () {
return _identifier.isIdentifierStart;
}
});
Object.defineProperty(exports, "isKeyword", {
enumerable: true,
get: function () {
return _keyword.isKeyword;
}
});
Object.defineProperty(exports, "isReservedWord", {
enumerable: true,
get: function () {
return _keyword.isReservedWord;
}
});
Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
enumerable: true,
get: function () {
return _keyword.isStrictBindOnlyReservedWord;
}
});
Object.defineProperty(exports, "isStrictBindReservedWord", {
enumerable: true,
get: function () {
return _keyword.isStrictBindReservedWord;
}
});
Object.defineProperty(exports, "isStrictReservedWord", {
enumerable: true,
get: function () {
return _keyword.isStrictReservedWord;
}
});
var _identifier = requireIdentifier();
var _keyword = requireKeyword();
} (lib$3));
return lib$3;
}
var hasRequiredIsValidIdentifier;
function requireIsValidIdentifier () {
if (hasRequiredIsValidIdentifier) return isValidIdentifier;
hasRequiredIsValidIdentifier = 1;
Object.defineProperty(isValidIdentifier, "__esModule", {
value: true
});
isValidIdentifier.default = isValidIdentifier$1;
var _helperValidatorIdentifier = requireLib$4();
function isValidIdentifier$1(name, reserved = true) {
if (typeof name !== "string") return false;
if (reserved) {
if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) {
return false;
}
}
return (0, _helperValidatorIdentifier.isIdentifierName)(name);
}
return isValidIdentifier;
}
var lib$2 = {};
var hasRequiredLib$3;
function requireLib$3 () {
if (hasRequiredLib$3) return lib$2;
hasRequiredLib$3 = 1;
Object.defineProperty(lib$2, "__esModule", {
value: true
});
lib$2.readCodePoint = readCodePoint;
lib$2.readInt = readInt;
lib$2.readStringContents = readStringContents;
var _isDigit = function isDigit(code) {
return code >= 48 && code <= 57;
};
const forbiddenNumericSeparatorSiblings = {
decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
hex: new Set([46, 88, 95, 120])
};
const isAllowedNumericSeparatorSibling = {
bin: ch => ch === 48 || ch === 49,
oct: ch => ch >= 48 && ch <= 55,
dec: ch => ch >= 48 && ch <= 57,
hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
};
function readStringContents(type, input, pos, lineStart, curLine, errors) {
const initialPos = pos;
const initialLineStart = lineStart;
const initialCurLine = curLine;
let out = "";
let firstInvalidLoc = null;
let chunkStart = pos;
const {
length
} = input;
for (;;) {
if (pos >= length) {
errors.unterminated(initialPos, initialLineStart, initialCurLine);
out += input.slice(chunkStart, pos);
break;
}
const ch = input.charCodeAt(pos);
if (isStringEnd(type, ch, input, pos)) {
out += input.slice(chunkStart, pos);
break;
}
if (ch === 92) {
out += input.slice(chunkStart, pos);
const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
if (res.ch === null && !firstInvalidLoc) {
firstInvalidLoc = {
pos,
lineStart,
curLine
};
} else {
out += res.ch;
}
({
pos,
lineStart,
curLine
} = res);
chunkStart = pos;
} else if (ch === 8232 || ch === 8233) {
++pos;
++curLine;
lineStart = pos;
} else if (ch === 10 || ch === 13) {
if (type === "template") {
out += input.slice(chunkStart, pos) + "\n";
++pos;
if (ch === 13 && input.charCodeAt(pos) === 10) {
++pos;
}
++curLine;
chunkStart = lineStart = pos;
} else {
errors.unterminated(initialPos, initialLineStart, initialCurLine);
}
} else {
++pos;
}
}
return {
pos,
str: out,
firstInvalidLoc,
lineStart,
curLine,
containsInvalid: !!firstInvalidLoc
};
}
function isStringEnd(type, ch, input, pos) {
if (type === "template") {
return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
}
return ch === (type === "double" ? 34 : 39);
}
function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
const throwOnInvalid = !inTemplate;
pos++;
const res = ch => ({
pos,
ch,
lineStart,
curLine
});
const ch = input.charCodeAt(pos++);
switch (ch) {
case 110:
return res("\n");
case 114:
return res("\r");
case 120:
{
let code;
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
return res(code === null ? null : String.fromCharCode(code));
}
case 117:
{
let code;
({
code,
pos
} = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
return res(code === null ? null : String.fromCodePoint(code));
}
case 116:
return res("\t");
case 98:
return res("\b");
case 118:
return res("\u000b");
case 102:
return res("\f");
case 13:
if (input.charCodeAt(pos) === 10) {
++pos;
}
case 10:
lineStart = pos;
++curLine;
case 8232:
case 8233:
return res("");
case 56:
case 57:
if (inTemplate) {
return res(null);
} else {
errors.strictNumericEscape(pos - 1, lineStart, curLine);
}
default:
if (ch >= 48 && ch <= 55) {
const startPos = pos - 1;
const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
let octalStr = match[0];
let octal = parseInt(octalStr, 8);
if (octal > 255) {
octalStr = octalStr.slice(0, -1);
octal = parseInt(octalStr, 8);
}
pos += octalStr.length - 1;
const next = input.charCodeAt(pos);
if (octalStr !== "0" || next === 56 || next === 57) {
if (inTemplate) {
return res(null);
} else {
errors.strictNumericEscape(startPos, lineStart, curLine);
}
}
return res(String.fromCharCode(octal));
}
return res(String.fromCharCode(ch));
}
}
function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
const initialPos = pos;
let n;
({
n,
pos
} = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
if (n === null) {
if (throwOnInvalid) {
errors.invalidEscapeSequence(initialPos, lineStart, curLine);
} else {
pos = initialPos - 1;
}
}
return {
code: n,
pos
};
}
function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
const start = pos;
const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
let invalid = false;
let total = 0;
for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
const code = input.charCodeAt(pos);
let val;
if (code === 95 && allowNumSeparator !== "bail") {
const prev = input.charCodeAt(pos - 1);
const next = input.charCodeAt(pos + 1);
if (!allowNumSeparator) {
if (bailOnError) return {
n: null,
pos
};
errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
if (bailOnError) return {
n: null,
pos
};
errors.unexpectedNumericSeparator(pos, lineStart, curLine);
}
++pos;
continue;
}
if (code >= 97) {
val = code - 97 + 10;
} else if (code >= 65) {
val = code - 65 + 10;
} else if (_isDigit(code)) {
val = code - 48;
} else {
val = Infinity;
}
if (val >= radix) {
if (val <= 9 && bailOnError) {
return {
n: null,
pos
};
} else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
val = 0;
} else if (forceLen) {
val = 0;
invalid = true;
} else {
break;
}
}
++pos;
total = total * radix + val;
}
if (pos === start || len != null && pos - start !== len || invalid) {
return {
n: null,
pos
};
}
return {
n: total,
pos
};
}
function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
const ch = input.charCodeAt(pos);
let code;
if (ch === 123) {
++pos;
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
++pos;
if (code !== null && code > 0x10ffff) {
if (throwOnInvalid) {
errors.invalidCodePoint(pos, lineStart, curLine);
} else {
return {
code: null,
pos
};
}
}
} else {
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
}
return {
code,
pos
};
}
return lib$2;
}
var constants = {};
var hasRequiredConstants;
function requireConstants () {
if (hasRequiredConstants) return constants;
hasRequiredConstants = 1;
Object.defineProperty(constants, "__esModule", {
value: true
});
constants.UPDATE_OPERATORS = constants.UNARY_OPERATORS = constants.STRING_UNARY_OPERATORS = constants.STATEMENT_OR_BLOCK_KEYS = constants.NUMBER_UNARY_OPERATORS = constants.NUMBER_BINARY_OPERATORS = constants.NOT_LOCAL_BINDING = constants.LOGICAL_OPERATORS = constants.INHERIT_KEYS = constants.FOR_INIT_KEYS = constants.FLATTENABLE_KEYS = constants.EQUALITY_BINARY_OPERATORS = constants.COMPARISON_BINARY_OPERATORS = constants.COMMENT_KEYS = constants.BOOLEAN_UNARY_OPERATORS = constants.BOOLEAN_NUMBER_BINARY_OPERATORS = constants.BOOLEAN_BINARY_OPERATORS = constants.BLOCK_SCOPED_SYMBOL = constants.BINARY_OPERATORS = constants.ASSIGNMENT_OPERATORS = void 0;
const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
constants.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
const FLATTENABLE_KEYS = ["body", "expressions"];
constants.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
const FOR_INIT_KEYS = ["left", "init"];
constants.FOR_INIT_KEYS = FOR_INIT_KEYS;
const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
constants.COMMENT_KEYS = COMMENT_KEYS;
const LOGICAL_OPERATORS = ["||", "&&", "??"];
constants.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
const UPDATE_OPERATORS = ["++", "--"];
constants.UPDATE_OPERATORS = UPDATE_OPERATORS;
const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
constants.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
constants.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
constants.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
constants.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
constants.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
constants.BINARY_OPERATORS = BINARY_OPERATORS;
const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
constants.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
constants.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
constants.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
const STRING_UNARY_OPERATORS = ["typeof"];
constants.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
constants.UNARY_OPERATORS = UNARY_OPERATORS;
const INHERIT_KEYS = {
optional: ["typeAnnotation", "typeParameters", "returnType"],
force: ["start", "loc", "end"]
};
constants.INHERIT_KEYS = INHERIT_KEYS;
const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
constants.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
constants.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
return constants;
}
var utils = {};
var hasRequiredUtils;
function requireUtils () {
if (hasRequiredUtils) return utils;
hasRequiredUtils = 1;
Object.defineProperty(utils, "__esModule", {
value: true
});
utils.VISITOR_KEYS = utils.NODE_PARENT_VALIDATIONS = utils.NODE_FIELDS = utils.FLIPPED_ALIAS_KEYS = utils.DEPRECATED_KEYS = utils.BUILDER_KEYS = utils.ALIAS_KEYS = void 0;
utils.arrayOf = arrayOf;
utils.arrayOfType = arrayOfType;
utils.assertEach = assertEach;
utils.assertNodeOrValueType = assertNodeOrValueType;
utils.assertNodeType = assertNodeType;
utils.assertOneOf = assertOneOf;
utils.assertOptionalChainStart = assertOptionalChainStart;
utils.assertShape = assertShape;
utils.assertValueType = assertValueType;
utils.chain = chain;
utils.default = defineType;
utils.defineAliasedType = defineAliasedType;
utils.typeIs = typeIs;
utils.validate = validate;
utils.validateArrayOfType = validateArrayOfType;
utils.validateOptional = validateOptional;
utils.validateOptionalType = validateOptionalType;
utils.validateType = validateType;
var _is = requireIs();
var _validate = requireValidate();
const VISITOR_KEYS = {};
utils.VISITOR_KEYS = VISITOR_KEYS;
const ALIAS_KEYS = {};
utils.ALIAS_KEYS = ALIAS_KEYS;
const FLIPPED_ALIAS_KEYS = {};
utils.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
const NODE_FIELDS = {};
utils.NODE_FIELDS = NODE_FIELDS;
const BUILDER_KEYS = {};
utils.BUILDER_KEYS = BUILDER_KEYS;
const DEPRECATED_KEYS = {};
utils.DEPRECATED_KEYS = DEPRECATED_KEYS;
const NODE_PARENT_VALIDATIONS = {};
utils.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
function getType(val) {
if (Array.isArray(val)) {
return "array";
} else if (val === null) {
return "null";
} else {
return typeof val;
}
}
function validate(validate) {
return {
validate
};
}
function typeIs(typeName) {
return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
}
function validateType(typeName) {
return validate(typeIs(typeName));
}
function validateOptional(validate) {
return {
validate,
optional: true
};
}
function validateOptionalType(typeName) {
return {
validate: typeIs(typeName),
optional: true
};
}
function arrayOf(elementType) {
return chain(assertValueType("array"), assertEach(elementType));
}
function arrayOfType(typeName) {
return arrayOf(typeIs(typeName));
}
function validateArrayOfType(typeName) {
return validate(arrayOfType(typeName));
}
function assertEach(callback) {
function validator(node, key, val) {
if (!Array.isArray(val)) return;
for (let i = 0; i < val.length; i++) {
const subkey = `${key}[${i}]`;
const v = val[i];
callback(node, subkey, v);
if (process$1.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
}
}
validator.each = callback;
return validator;
}
function assertOneOf(...values) {
function validate(node, key, val) {
if (values.indexOf(val) < 0) {
throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
}
}
validate.oneOf = values;
return validate;
}
function assertNodeType(...types) {
function validate(node, key, val) {
for (const type of types) {
if ((0, _is.default)(type, val)) {
(0, _validate.validateChild)(node, key, val);
return;
}
}
throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
}
validate.oneOfNodeTypes = types;
return validate;
}
function assertNodeOrValueType(...types) {
function validate(node, key, val) {
for (const type of types) {
if (getType(val) === type || (0, _is.default)(type, val)) {
(0, _validate.validateChild)(node, key, val);
return;
}
}
throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
}
validate.oneOfNodeOrValueTypes = types;
return validate;
}
function assertValueType(type) {
function validate(node, key, val) {
const valid = getType(val) === type;
if (!valid) {
throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
}
}
validate.type = type;
return validate;
}
function assertShape(shape) {
function validate(node, key, val) {
const errors = [];
for (const property of Object.keys(shape)) {
try {
(0, _validate.validateField)(node, property, val[property], shape[property]);
} catch (error) {
if (error instanceof TypeError) {
errors.push(error.message);
continue;
}
throw error;
}
}
if (errors.length) {
throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
}
}
validate.shapeOf = shape;
return validate;
}
function assertOptionalChainStart() {
function validate(node) {
var _current;
let current = node;
while (node) {
const {
type
} = current;
if (type === "OptionalCallExpression") {
if (current.optional) return;
current = current.callee;
continue;
}
if (type === "OptionalMemberExpression") {
if (current.optional) return;
current = current.object;
continue;
}
break;
}
throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
}
return validate;
}
function chain(...fns) {
function validate(...args) {
for (const fn of fns) {
fn(...args);
}
}
validate.chainOf = fns;
if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
}
return validate;
}
const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
const validFieldKeys = ["default", "optional", "deprecated", "validate"];
const store = {};
function defineAliasedType(...aliases) {
return (type, opts = {}) => {
let defined = opts.aliases;
if (!defined) {
var _store$opts$inherits$, _defined;
if (opts.inherits) defined = (_store$opts$inherits$ = store[opts.inherits].aliases) == null ? void 0 : _store$opts$inherits$.slice();
(_defined = defined) != null ? _defined : defined = [];
opts.aliases = defined;
}
const additional = aliases.filter(a => !defined.includes(a));
defined.unshift(...additional);
defineType(type, opts);
};
}
function defineType(type, opts = {}) {
const inherits = opts.inherits && store[opts.inherits] || {};
let fields = opts.fields;
if (!fields) {
fields = {};
if (inherits.fields) {
const keys = Object.getOwnPropertyNames(inherits.fields);
for (const key of keys) {
const field = inherits.fields[key];
const def = field.default;
if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
throw new Error("field defaults can only be primitives or empty arrays currently");
}
fields[key] = {
default: Array.isArray(def) ? [] : def,
optional: field.optional,
deprecated: field.deprecated,
validate: field.validate
};
}
}
}
const visitor = opts.visitor || inherits.visitor || [];
const aliases = opts.aliases || inherits.aliases || [];
const builder = opts.builder || inherits.builder || opts.visitor || [];
for (const k of Object.keys(opts)) {
if (validTypeOpts.indexOf(k) === -1) {
throw new Error(`Unknown type option "${k}" on ${type}`);
}
}
if (opts.deprecatedAlias) {
DEPRECATED_KEYS[opts.deprecatedAlias] = type;
}
for (const key of visitor.concat(builder)) {
fields[key] = fields[key] || {};
}
for (const key of Object.keys(fields)) {
const field = fields[key];
if (field.default !== undefined && builder.indexOf(key) === -1) {
field.optional = true;
}
if (field.default === undefined) {
field.default = null;
} else if (!field.validate && field.default != null) {
field.validate = assertValueType(getType(field.default));
}
for (const k of Object.keys(field)) {
if (validFieldKeys.indexOf(k) === -1) {
throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
}
}
}
VISITOR_KEYS[type] = opts.visitor = visitor;
BUILDER_KEYS[type] = opts.builder = builder;
NODE_FIELDS[type] = opts.fields = fields;
ALIAS_KEYS[type] = opts.aliases = aliases;
aliases.forEach(alias => {
FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
FLIPPED_ALIAS_KEYS[alias].push(type);
});
if (opts.validate) {
NODE_PARENT_VALIDATIONS[type] = opts.validate;
}
store[type] = opts;
}
return utils;
}
var hasRequiredCore;
function requireCore () {
if (hasRequiredCore) return core;
hasRequiredCore = 1;
Object.defineProperty(core, "__esModule", {
value: true
});
core.patternLikeCommon = core.functionTypeAnnotationCommon = core.functionDeclarationCommon = core.functionCommon = core.classMethodOrPropertyCommon = core.classMethodOrDeclareMethodCommon = void 0;
var _is = requireIs();
var _isValidIdentifier = requireIsValidIdentifier();
var _helperValidatorIdentifier = requireLib$4();
var _helperStringParser = requireLib$3();
var _index = requireConstants();
var _utils = requireUtils();
const defineType = (0, _utils.defineAliasedType)("Standardized");
defineType("ArrayExpression", {
fields: {
elements: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
default: !process$1.env.BABEL_TYPES_8_BREAKING ? [] : undefined
}
},
visitor: ["elements"],
aliases: ["Expression"]
});
defineType("AssignmentExpression", {
fields: {
operator: {
validate: function () {
if (!process$1.env.BABEL_TYPES_8_BREAKING) {
return (0, _utils.assertValueType)("string");
}
const identifier = (0, _utils.assertOneOf)(..._index.ASSIGNMENT_OPERATORS);
const pattern = (0, _utils.assertOneOf)("=");
return function (node, key, val) {
const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
validator(node, key, val);
};
}()
},
left: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal", "OptionalMemberExpression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Expression"]
});
defineType("BinaryExpression", {
builder: ["operator", "left", "right"],
fields: {
operator: {
validate: (0, _utils.assertOneOf)(..._index.BINARY_OPERATORS)
},
left: {
validate: function () {
const expression = (0, _utils.assertNodeType)("Expression");
const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
const validator = Object.assign(function (node, key, val) {
const validator = node.operator === "in" ? inOp : expression;
validator(node, key, val);
}, {
oneOfNodeTypes: ["Expression", "PrivateName"]
});
return validator;
}()
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
visitor: ["left", "right"],
aliases: ["Binary", "Expression"]
});
defineType("InterpreterDirective", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
}
});
defineType("Directive", {
visitor: ["value"],
fields: {
value: {
validate: (0, _utils.assertNodeType)("DirectiveLiteral")
}
}
});
defineType("DirectiveLiteral", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
}
});
defineType("BlockStatement", {
builder: ["body", "directives"],
visitor: ["directives", "body"],
fields: {
directives: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
default: []
},
body: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
}
},
aliases: ["Scopable", "BlockParent", "Block", "Statement"]
});
defineType("BreakStatement", {
visitor: ["label"],
fields: {
label: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
}
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
});
defineType("CallExpression", {
visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
builder: ["callee", "arguments"],
aliases: ["Expression"],
fields: Object.assign({
callee: {
validate: (0, _utils.assertNodeType)("Expression", "Super", "V8IntrinsicIdentifier")
},
arguments: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
}
}, !process$1.env.BABEL_TYPES_8_BREAKING ? {
optional: {
validate: (0, _utils.assertOneOf)(true, false),
optional: true
}
} : {}, {
typeArguments: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
optional: true
}
})
});
defineType("CatchClause", {
visitor: ["param", "body"],
fields: {
param: {
validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
}
},
aliases: ["Scopable", "BlockParent"]
});
defineType("ConditionalExpression", {
visitor: ["test", "consequent", "alternate"],
fields: {
test: {
validate: (0, _utils.assertNodeType)("Expression")
},
consequent: {
validate: (0, _utils.assertNodeType)("Expression")
},
alternate: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
aliases: ["Expression", "Conditional"]
});
defineType("ContinueStatement", {
visitor: ["label"],
fields: {
label: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
}
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]
});
defineType("DebuggerStatement", {
aliases: ["Statement"]
});
defineType("DoWhileStatement", {
visitor: ["test", "body"],
fields: {
test: {
validate: (0, _utils.assertNodeType)("Expression")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
},
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
});
defineType("EmptyStatement", {
aliases: ["Statement"]
});
defineType("ExpressionStatement", {
visitor: ["expression"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
aliases: ["Statement", "ExpressionWrapper"]
});
defineType("File", {
builder: ["program", "comments", "tokens"],
visitor: ["program"],
fields: {
program: {
validate: (0, _utils.assertNodeType)("Program")
},
comments: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {
each: {
oneOfNodeTypes: ["CommentBlock", "CommentLine"]
}
}) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
optional: true
},
tokens: {
validate: (0, _utils.assertEach)(Object.assign(() => {}, {
type: "any"
})),
optional: true
}
}
});
defineType("ForInStatement", {
visitor: ["left", "right", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
fields: {
left: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
defineType("ForStatement", {
visitor: ["init", "test", "update", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
fields: {
init: {
validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
optional: true
},
test: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
update: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
const functionCommon = () => ({
params: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
},
generator: {
default: false
},
async: {
default: false
}
});
core.functionCommon = functionCommon;
const functionTypeAnnotationCommon = () => ({
returnType: {
validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
optional: true
}
});
core.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
const functionDeclarationCommon = () => Object.assign({}, functionCommon(), {
declare: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
id: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
}
});
core.functionDeclarationCommon = functionDeclarationCommon;
defineType("FunctionDeclaration", {
builder: ["id", "params", "body", "generator", "async"],
visitor: ["id", "params", "body", "returnType", "typeParameters"],
fields: Object.assign({}, functionDeclarationCommon(), functionTypeAnnotationCommon(), {
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
},
predicate: {
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
optional: true
}
}),
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
validate: function () {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return () => {};
const identifier = (0, _utils.assertNodeType)("Identifier");
return function (parent, key, node) {
if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
identifier(node, "id", node.id);
}
};
}()
});
defineType("FunctionExpression", {
inherits: "FunctionDeclaration",
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
id: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
},
predicate: {
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
optional: true
}
})
});
const patternLikeCommon = () => ({
typeAnnotation: {
validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
optional: true
},
optional: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
}
});
core.patternLikeCommon = patternLikeCommon;
defineType("Identifier", {
builder: ["name"],
visitor: ["typeAnnotation", "decorators"],
aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
fields: Object.assign({}, patternLikeCommon(), {
name: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (!(0, _isValidIdentifier.default)(val, false)) {
throw new TypeError(`"${val}" is not a valid identifier name`);
}
}, {
type: "string"
}))
}
}),
validate(parent, key, node) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
const match = /\.(\w+)$/.exec(key);
if (!match) return;
const [, parentKey] = match;
const nonComp = {
computed: false
};
if (parentKey === "property") {
if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
} else if (parentKey === "key") {
if ((0, _is.default)("Property", parent, nonComp)) return;
if ((0, _is.default)("Method", parent, nonComp)) return;
} else if (parentKey === "exported") {
if ((0, _is.default)("ExportSpecifier", parent)) return;
} else if (parentKey === "imported") {
if ((0, _is.default)("ImportSpecifier", parent, {
imported: node
})) return;
} else if (parentKey === "meta") {
if ((0, _is.default)("MetaProperty", parent, {
meta: node
})) return;
}
if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
throw new TypeError(`"${node.name}" is not a valid identifier`);
}
}
});
defineType("IfStatement", {
visitor: ["test", "consequent", "alternate"],
aliases: ["Statement", "Conditional"],
fields: {
test: {
validate: (0, _utils.assertNodeType)("Expression")
},
consequent: {
validate: (0, _utils.assertNodeType)("Statement")
},
alternate: {
optional: true,
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
defineType("LabeledStatement", {
visitor: ["label", "body"],
aliases: ["Statement"],
fields: {
label: {
validate: (0, _utils.assertNodeType)("Identifier")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
defineType("StringLiteral", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType("NumericLiteral", {
builder: ["value"],
deprecatedAlias: "NumberLiteral",
fields: {
value: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("number"), Object.assign(function (node, key, val) {
}, {
type: "number"
}))
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType("NullLiteral", {
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType("BooleanLiteral", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("boolean")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType("RegExpLiteral", {
builder: ["pattern", "flags"],
deprecatedAlias: "RegexLiteral",
aliases: ["Expression", "Pureish", "Literal"],
fields: {
pattern: {
validate: (0, _utils.assertValueType)("string")
},
flags: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
const invalid = /[^gimsuy]/.exec(val);
if (invalid) {
throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
}
}, {
type: "string"
})),
default: ""
}
}
});
defineType("LogicalExpression", {
builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Binary", "Expression"],
fields: {
operator: {
validate: (0, _utils.assertOneOf)(..._index.LOGICAL_OPERATORS)
},
left: {
validate: (0, _utils.assertNodeType)("Expression")
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("MemberExpression", {
builder: ["object", "property", "computed", ...(!process$1.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])],
visitor: ["object", "property"],
aliases: ["Expression", "LVal"],
fields: Object.assign({
object: {
validate: (0, _utils.assertNodeType)("Expression", "Super")
},
property: {
validate: function () {
const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
const computed = (0, _utils.assertNodeType)("Expression");
const validator = function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
};
validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
return validator;
}()
},
computed: {
default: false
}
}, !process$1.env.BABEL_TYPES_8_BREAKING ? {
optional: {
validate: (0, _utils.assertOneOf)(true, false),
optional: true
}
} : {})
});
defineType("NewExpression", {
inherits: "CallExpression"
});
defineType("Program", {
visitor: ["directives", "body"],
builder: ["body", "directives", "sourceType", "interpreter"],
fields: {
sourceFile: {
validate: (0, _utils.assertValueType)("string")
},
sourceType: {
validate: (0, _utils.assertOneOf)("script", "module"),
default: "script"
},
interpreter: {
validate: (0, _utils.assertNodeType)("InterpreterDirective"),
default: null,
optional: true
},
directives: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
default: []
},
body: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
}
},
aliases: ["Scopable", "BlockParent", "Block"]
});
defineType("ObjectExpression", {
visitor: ["properties"],
aliases: ["Expression"],
fields: {
properties: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
}
}
});
defineType("ObjectMethod", {
builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
kind: Object.assign({
validate: (0, _utils.assertOneOf)("method", "get", "set")
}, !process$1.env.BABEL_TYPES_8_BREAKING ? {
default: "method"
} : {}),
computed: {
default: false
},
key: {
validate: function () {
const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
const computed = (0, _utils.assertNodeType)("Expression");
const validator = function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
};
validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"];
return validator;
}()
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
}
}),
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
});
defineType("ObjectProperty", {
builder: ["key", "value", "computed", "shorthand", ...(!process$1.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
fields: {
computed: {
default: false
},
key: {
validate: function () {
const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName");
const computed = (0, _utils.assertNodeType)("Expression");
const validator = Object.assign(function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
}, {
oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "DecimalLiteral", "PrivateName"]
});
return validator;
}()
},
value: {
validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
},
shorthand: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (val && node.computed) {
throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
}
}, {
type: "boolean"
}), function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (val && !(0, _is.default)("Identifier", node.key)) {
throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
}
}),
default: false
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
}
},
visitor: ["key", "value", "decorators"],
aliases: ["UserWhitespacable", "Property", "ObjectMember"],
validate: function () {
const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion");
const expression = (0, _utils.assertNodeType)("Expression");
return function (parent, key, node) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
validator(node, "value", node.value);
};
}()
});
defineType("RestElement", {
visitor: ["argument", "typeAnnotation"],
builder: ["argument"],
aliases: ["LVal", "PatternLike"],
deprecatedAlias: "RestProperty",
fields: Object.assign({}, patternLikeCommon(), {
argument: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
}
}),
validate(parent, key) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
const match = /(\w+)\[(\d+)\]/.exec(key);
if (!match) throw new Error("Internal Babel error: malformed key.");
const [, listKey, index] = match;
if (parent[listKey].length > +index + 1) {
throw new TypeError(`RestElement must be last element of ${listKey}`);
}
}
});
defineType("ReturnStatement", {
visitor: ["argument"],
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
fields: {
argument: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
}
}
});
defineType("SequenceExpression", {
visitor: ["expressions"],
fields: {
expressions: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
}
},
aliases: ["Expression"]
});
defineType("ParenthesizedExpression", {
visitor: ["expression"],
aliases: ["Expression", "ExpressionWrapper"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("SwitchCase", {
visitor: ["test", "consequent"],
fields: {
test: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
consequent: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
}
}
});
defineType("SwitchStatement", {
visitor: ["discriminant", "cases"],
aliases: ["Statement", "BlockParent", "Scopable"],
fields: {
discriminant: {
validate: (0, _utils.assertNodeType)("Expression")
},
cases: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
}
}
});
defineType("ThisExpression", {
aliases: ["Expression"]
});
defineType("ThrowStatement", {
visitor: ["argument"],
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
fields: {
argument: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("TryStatement", {
visitor: ["block", "handler", "finalizer"],
aliases: ["Statement"],
fields: {
block: {
validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (!node.handler && !node.finalizer) {
throw new TypeError("TryStatement expects either a handler or finalizer, or both");
}
}, {
oneOfNodeTypes: ["BlockStatement"]
}))
},
handler: {
optional: true,
validate: (0, _utils.assertNodeType)("CatchClause")
},
finalizer: {
optional: true,
validate: (0, _utils.assertNodeType)("BlockStatement")
}
}
});
defineType("UnaryExpression", {
builder: ["operator", "argument", "prefix"],
fields: {
prefix: {
default: true
},
argument: {
validate: (0, _utils.assertNodeType)("Expression")
},
operator: {
validate: (0, _utils.assertOneOf)(..._index.UNARY_OPERATORS)
}
},
visitor: ["argument"],
aliases: ["UnaryLike", "Expression"]
});
defineType("UpdateExpression", {
builder: ["operator", "argument", "prefix"],
fields: {
prefix: {
default: false
},
argument: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
},
operator: {
validate: (0, _utils.assertOneOf)(..._index.UPDATE_OPERATORS)
}
},
visitor: ["argument"],
aliases: ["Expression"]
});
defineType("VariableDeclaration", {
builder: ["kind", "declarations"],
visitor: ["declarations"],
aliases: ["Statement", "Declaration"],
fields: {
declare: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
kind: {
validate: (0, _utils.assertOneOf)("var", "let", "const", "using", "await using")
},
declarations: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
}
},
validate(parent, key, node) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (!(0, _is.default)("ForXStatement", parent, {
left: node
})) return;
if (node.declarations.length !== 1) {
throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
}
}
});
defineType("VariableDeclarator", {
visitor: ["id", "init"],
fields: {
id: {
validate: function () {
if (!process$1.env.BABEL_TYPES_8_BREAKING) {
return (0, _utils.assertNodeType)("LVal");
}
const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
const without = (0, _utils.assertNodeType)("Identifier");
return function (node, key, val) {
const validator = node.init ? normal : without;
validator(node, key, val);
};
}()
},
definite: {
optional: true,
validate: (0, _utils.assertValueType)("boolean")
},
init: {
optional: true,
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("WhileStatement", {
visitor: ["test", "body"],
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
fields: {
test: {
validate: (0, _utils.assertNodeType)("Expression")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
defineType("WithStatement", {
visitor: ["object", "body"],
aliases: ["Statement"],
fields: {
object: {
validate: (0, _utils.assertNodeType)("Expression")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
}
}
});
defineType("AssignmentPattern", {
visitor: ["left", "right", "decorators"],
builder: ["left", "right"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, patternLikeCommon(), {
left: {
validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
}
})
});
defineType("ArrayPattern", {
visitor: ["elements", "typeAnnotation"],
builder: ["elements"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, patternLikeCommon(), {
elements: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike", "LVal")))
}
})
});
defineType("ArrowFunctionExpression", {
builder: ["params", "body", "async"],
visitor: ["params", "body", "returnType", "typeParameters"],
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
fields: Object.assign({}, functionCommon(), functionTypeAnnotationCommon(), {
expression: {
validate: (0, _utils.assertValueType)("boolean")
},
body: {
validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
},
predicate: {
validate: (0, _utils.assertNodeType)("DeclaredPredicate", "InferredPredicate"),
optional: true
}
})
});
defineType("ClassBody", {
visitor: ["body"],
fields: {
body: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")))
}
}
});
defineType("ClassExpression", {
builder: ["id", "superClass", "body", "decorators"],
visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
aliases: ["Scopable", "Class", "Expression"],
fields: {
id: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("ClassBody")
},
superClass: {
optional: true,
validate: (0, _utils.assertNodeType)("Expression")
},
superTypeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
optional: true
},
implements: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
mixins: {
validate: (0, _utils.assertNodeType)("InterfaceExtends"),
optional: true
}
}
});
defineType("ClassDeclaration", {
inherits: "ClassExpression",
aliases: ["Scopable", "Class", "Statement", "Declaration"],
fields: {
id: {
validate: (0, _utils.assertNodeType)("Identifier"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
optional: true
},
body: {
validate: (0, _utils.assertNodeType)("ClassBody")
},
superClass: {
optional: true,
validate: (0, _utils.assertNodeType)("Expression")
},
superTypeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
optional: true
},
implements: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
mixins: {
validate: (0, _utils.assertNodeType)("InterfaceExtends"),
optional: true
},
declare: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
abstract: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
}
},
validate: function () {
const identifier = (0, _utils.assertNodeType)("Identifier");
return function (parent, key, node) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
identifier(node, "id", node.id);
}
};
}()
});
defineType("ExportAllDeclaration", {
builder: ["source"],
visitor: ["source", "attributes", "assertions"],
aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
fields: {
source: {
validate: (0, _utils.assertNodeType)("StringLiteral")
},
exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
attributes: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
},
assertions: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
}
}
});
defineType("ExportDefaultDeclaration", {
visitor: ["declaration"],
aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
fields: {
declaration: {
validate: (0, _utils.assertNodeType)("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression")
},
exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
}
});
defineType("ExportNamedDeclaration", {
builder: ["declaration", "specifiers", "source"],
visitor: ["declaration", "specifiers", "source", "attributes", "assertions"],
aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
fields: {
declaration: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (val && node.specifiers.length) {
throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
}
}, {
oneOfNodeTypes: ["Declaration"]
}), function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (val && node.source) {
throw new TypeError("Cannot export a declaration from a source");
}
})
},
attributes: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
},
assertions: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
},
specifiers: {
default: [],
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
if (!process$1.env.BABEL_TYPES_8_BREAKING) return sourced;
return function (node, key, val) {
const validator = node.source ? sourced : sourceless;
validator(node, key, val);
};
}()))
},
source: {
validate: (0, _utils.assertNodeType)("StringLiteral"),
optional: true
},
exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
}
});
defineType("ExportSpecifier", {
visitor: ["local", "exported"],
aliases: ["ModuleSpecifier"],
fields: {
local: {
validate: (0, _utils.assertNodeType)("Identifier")
},
exported: {
validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
},
exportKind: {
validate: (0, _utils.assertOneOf)("type", "value"),
optional: true
}
}
});
defineType("ForOfStatement", {
visitor: ["left", "right", "body"],
builder: ["left", "right", "body", "await"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
fields: {
left: {
validate: function () {
if (!process$1.env.BABEL_TYPES_8_BREAKING) {
return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
}
const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
return function (node, key, val) {
if ((0, _is.default)("VariableDeclaration", val)) {
declaration(node, key, val);
} else {
lval(node, key, val);
}
};
}()
},
right: {
validate: (0, _utils.assertNodeType)("Expression")
},
body: {
validate: (0, _utils.assertNodeType)("Statement")
},
await: {
default: false
}
}
});
defineType("ImportDeclaration", {
builder: ["specifiers", "source"],
visitor: ["specifiers", "source", "attributes", "assertions"],
aliases: ["Statement", "Declaration", "ImportOrExportDeclaration"],
fields: {
attributes: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
},
assertions: {
optional: true,
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
},
module: {
optional: true,
validate: (0, _utils.assertValueType)("boolean")
},
phase: {
default: null,
validate: (0, _utils.assertOneOf)("source", "defer")
},
specifiers: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
},
source: {
validate: (0, _utils.assertNodeType)("StringLiteral")
},
importKind: {
validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
optional: true
}
}
});
defineType("ImportDefaultSpecifier", {
visitor: ["local"],
aliases: ["ModuleSpecifier"],
fields: {
local: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
defineType("ImportNamespaceSpecifier", {
visitor: ["local"],
aliases: ["ModuleSpecifier"],
fields: {
local: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
defineType("ImportSpecifier", {
visitor: ["local", "imported"],
aliases: ["ModuleSpecifier"],
fields: {
local: {
validate: (0, _utils.assertNodeType)("Identifier")
},
imported: {
validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
},
importKind: {
validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
optional: true
}
}
});
defineType("ImportExpression", {
visitor: ["source", "options"],
aliases: ["Expression"],
fields: {
phase: {
default: null,
validate: (0, _utils.assertOneOf)("source", "defer")
},
source: {
validate: (0, _utils.assertNodeType)("Expression")
},
options: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
}
}
});
defineType("MetaProperty", {
visitor: ["meta", "property"],
aliases: ["Expression"],
fields: {
meta: {
validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
let property;
switch (val.name) {
case "function":
property = "sent";
break;
case "new":
property = "target";
break;
case "import":
property = "meta";
break;
}
if (!(0, _is.default)("Identifier", node.property, {
name: property
})) {
throw new TypeError("Unrecognised MetaProperty");
}
}, {
oneOfNodeTypes: ["Identifier"]
}))
},
property: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
const classMethodOrPropertyCommon = () => ({
abstract: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
accessibility: {
validate: (0, _utils.assertOneOf)("public", "private", "protected"),
optional: true
},
static: {
default: false
},
override: {
default: false
},
computed: {
default: false
},
optional: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
key: {
validate: (0, _utils.chain)(function () {
const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
const computed = (0, _utils.assertNodeType)("Expression");
return function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
};
}(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
}
});
core.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
const classMethodOrDeclareMethodCommon = () => Object.assign({}, functionCommon(), classMethodOrPropertyCommon(), {
params: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
},
kind: {
validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
default: "method"
},
access: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
}
});
core.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
defineType("ClassMethod", {
aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
}
})
});
defineType("ObjectPattern", {
visitor: ["properties", "typeAnnotation", "decorators"],
builder: ["properties"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, patternLikeCommon(), {
properties: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
}
})
});
defineType("SpreadElement", {
visitor: ["argument"],
aliases: ["UnaryLike"],
deprecatedAlias: "SpreadProperty",
fields: {
argument: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("Super", {
aliases: ["Expression"]
});
defineType("TaggedTemplateExpression", {
visitor: ["tag", "quasi", "typeParameters"],
builder: ["tag", "quasi"],
aliases: ["Expression"],
fields: {
tag: {
validate: (0, _utils.assertNodeType)("Expression")
},
quasi: {
validate: (0, _utils.assertNodeType)("TemplateLiteral")
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
optional: true
}
}
});
defineType("TemplateElement", {
builder: ["value", "tail"],
fields: {
value: {
validate: (0, _utils.chain)((0, _utils.assertShape)({
raw: {
validate: (0, _utils.assertValueType)("string")
},
cooked: {
validate: (0, _utils.assertValueType)("string"),
optional: true
}
}), function templateElementCookedValidator(node) {
const raw = node.value.raw;
let unterminatedCalled = false;
const error = () => {
throw new Error("Internal @babel/types error.");
};
const {
str,
firstInvalidLoc
} = (0, _helperStringParser.readStringContents)("template", raw, 0, 0, 0, {
unterminated() {
unterminatedCalled = true;
},
strictNumericEscape: error,
invalidEscapeSequence: error,
numericSeparatorInEscapeSequence: error,
unexpectedNumericSeparator: error,
invalidDigit: error,
invalidCodePoint: error
});
if (!unterminatedCalled) throw new Error("Invalid raw");
node.value.cooked = firstInvalidLoc ? null : str;
})
},
tail: {
default: false
}
}
});
defineType("TemplateLiteral", {
visitor: ["quasis", "expressions"],
aliases: ["Expression", "Literal"],
fields: {
quasis: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
},
expressions: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
if (node.quasis.length !== val.length + 1) {
throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
}
})
}
}
});
defineType("YieldExpression", {
builder: ["argument", "delegate"],
visitor: ["argument"],
aliases: ["Expression", "Terminatorless"],
fields: {
delegate: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
if (!process$1.env.BABEL_TYPES_8_BREAKING) return;
if (val && !node.argument) {
throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
}
}, {
type: "boolean"
})),
default: false
},
argument: {
optional: true,
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("AwaitExpression", {
builder: ["argument"],
visitor: ["argument"],
aliases: ["Expression", "Terminatorless"],
fields: {
argument: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("Import", {
aliases: ["Expression"]
});
defineType("BigIntLiteral", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
defineType("ExportNamespaceSpecifier", {
visitor: ["exported"],
aliases: ["ModuleSpecifier"],
fields: {
exported: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
defineType("OptionalMemberExpression", {
builder: ["object", "property", "computed", "optional"],
visitor: ["object", "property"],
aliases: ["Expression"],
fields: {
object: {
validate: (0, _utils.assertNodeType)("Expression")
},
property: {
validate: function () {
const normal = (0, _utils.assertNodeType)("Identifier");
const computed = (0, _utils.assertNodeType)("Expression");
const validator = Object.assign(function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
}, {
oneOfNodeTypes: ["Expression", "Identifier"]
});
return validator;
}()
},
computed: {
default: false
},
optional: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
}
}
});
defineType("OptionalCallExpression", {
visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
builder: ["callee", "arguments", "optional"],
aliases: ["Expression"],
fields: {
callee: {
validate: (0, _utils.assertNodeType)("Expression")
},
arguments: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
},
optional: {
validate: !process$1.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
},
typeArguments: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
optional: true
}
}
});
defineType("ClassProperty", {
visitor: ["key", "value", "typeAnnotation", "decorators"],
builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
aliases: ["Property"],
fields: Object.assign({}, classMethodOrPropertyCommon(), {
value: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
definite: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
typeAnnotation: {
validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
readonly: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
declare: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
variance: {
validate: (0, _utils.assertNodeType)("Variance"),
optional: true
}
})
});
defineType("ClassAccessorProperty", {
visitor: ["key", "value", "typeAnnotation", "decorators"],
builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
aliases: ["Property", "Accessor"],
fields: Object.assign({}, classMethodOrPropertyCommon(), {
key: {
validate: (0, _utils.chain)(function () {
const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
const computed = (0, _utils.assertNodeType)("Expression");
return function (node, key, val) {
const validator = node.computed ? computed : normal;
validator(node, key, val);
};
}(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
},
value: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
definite: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
typeAnnotation: {
validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
readonly: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
declare: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
variance: {
validate: (0, _utils.assertNodeType)("Variance"),
optional: true
}
})
});
defineType("ClassPrivateProperty", {
visitor: ["key", "value", "decorators", "typeAnnotation"],
builder: ["key", "value", "decorators", "static"],
aliases: ["Property", "Private"],
fields: {
key: {
validate: (0, _utils.assertNodeType)("PrivateName")
},
value: {
validate: (0, _utils.assertNodeType)("Expression"),
optional: true
},
typeAnnotation: {
validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
},
static: {
validate: (0, _utils.assertValueType)("boolean"),
default: false
},
readonly: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
definite: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
variance: {
validate: (0, _utils.assertNodeType)("Variance"),
optional: true
}
}
});
defineType("ClassPrivateMethod", {
builder: ["kind", "key", "params", "body", "static"],
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
fields: Object.assign({}, classMethodOrDeclareMethodCommon(), functionTypeAnnotationCommon(), {
kind: {
validate: (0, _utils.assertOneOf)("get", "set", "method"),
default: "method"
},
key: {
validate: (0, _utils.assertNodeType)("PrivateName")
},
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
}
})
});
defineType("PrivateName", {
visitor: ["id"],
aliases: ["Private"],
fields: {
id: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
defineType("StaticBlock", {
visitor: ["body"],
fields: {
body: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
}
},
aliases: ["Scopable", "BlockParent", "FunctionParent"]
});
return core;
}
var flow$1 = {};
var hasRequiredFlow$1;
function requireFlow$1 () {
if (hasRequiredFlow$1) return flow$1;
hasRequiredFlow$1 = 1;
var _utils = requireUtils();
const defineType = (0, _utils.defineAliasedType)("Flow");
const defineInterfaceishType = name => {
const isDeclareClass = name === "DeclareClass";
defineType(name, {
builder: ["id", "typeParameters", "extends", "body"],
visitor: ["id", "typeParameters", "extends", ...(isDeclareClass ? ["mixins", "implements"] : []), "body"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: Object.assign({
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends"))
}, isDeclareClass ? {
mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements"))
} : {}, {
body: (0, _utils.validateType)("ObjectTypeAnnotation")
})
});
};
defineType("AnyTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("ArrayTypeAnnotation", {
visitor: ["elementType"],
aliases: ["FlowType"],
fields: {
elementType: (0, _utils.validateType)("FlowType")
}
});
defineType("BooleanTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("BooleanLiteralTypeAnnotation", {
builder: ["value"],
aliases: ["FlowType"],
fields: {
value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("NullLiteralTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("ClassImplements", {
visitor: ["id", "typeParameters"],
fields: {
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}
});
defineInterfaceishType("DeclareClass");
defineType("DeclareFunction", {
visitor: ["id"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier"),
predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
}
});
defineInterfaceishType("DeclareInterface");
defineType("DeclareModule", {
builder: ["id", "body", "kind"],
visitor: ["id", "body"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
body: (0, _utils.validateType)("BlockStatement"),
kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
}
});
defineType("DeclareModuleExports", {
visitor: ["typeAnnotation"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
}
});
defineType("DeclareTypeAlias", {
visitor: ["id", "typeParameters", "right"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
right: (0, _utils.validateType)("FlowType")
}
});
defineType("DeclareOpaqueType", {
visitor: ["id", "typeParameters", "supertype"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
supertype: (0, _utils.validateOptionalType)("FlowType"),
impltype: (0, _utils.validateOptionalType)("FlowType")
}
});
defineType("DeclareVariable", {
visitor: ["id"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier")
}
});
defineType("DeclareExportDeclaration", {
visitor: ["declaration", "specifiers", "source"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
declaration: (0, _utils.validateOptionalType)("Flow"),
specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
source: (0, _utils.validateOptionalType)("StringLiteral"),
default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}
});
defineType("DeclareExportAllDeclaration", {
visitor: ["source"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
source: (0, _utils.validateType)("StringLiteral"),
exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
}
});
defineType("DeclaredPredicate", {
visitor: ["value"],
aliases: ["FlowPredicate"],
fields: {
value: (0, _utils.validateType)("Flow")
}
});
defineType("ExistsTypeAnnotation", {
aliases: ["FlowType"]
});
defineType("FunctionTypeAnnotation", {
visitor: ["typeParameters", "params", "rest", "returnType"],
aliases: ["FlowType"],
fields: {
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
returnType: (0, _utils.validateType)("FlowType")
}
});
defineType("FunctionTypeParam", {
visitor: ["name", "typeAnnotation"],
fields: {
name: (0, _utils.validateOptionalType)("Identifier"),
typeAnnotation: (0, _utils.validateType)("FlowType"),
optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}
});
defineType("GenericTypeAnnotation", {
visitor: ["id", "typeParameters"],
aliases: ["FlowType"],
fields: {
id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}
});
defineType("InferredPredicate", {
aliases: ["FlowPredicate"]
});
defineType("InterfaceExtends", {
visitor: ["id", "typeParameters"],
fields: {
id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}
});
defineInterfaceishType("InterfaceDeclaration");
defineType("InterfaceTypeAnnotation", {
visitor: ["extends", "body"],
aliases: ["FlowType"],
fields: {
extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
body: (0, _utils.validateType)("ObjectTypeAnnotation")
}
});
defineType("IntersectionTypeAnnotation", {
visitor: ["types"],
aliases: ["FlowType"],
fields: {
types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}
});
defineType("MixedTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("EmptyTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("NullableTypeAnnotation", {
visitor: ["typeAnnotation"],
aliases: ["FlowType"],
fields: {
typeAnnotation: (0, _utils.validateType)("FlowType")
}
});
defineType("NumberLiteralTypeAnnotation", {
builder: ["value"],
aliases: ["FlowType"],
fields: {
value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
}
});
defineType("NumberTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("ObjectTypeAnnotation", {
visitor: ["properties", "indexers", "callProperties", "internalSlots"],
aliases: ["FlowType"],
builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
fields: {
properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
indexers: {
validate: (0, _utils.arrayOfType)("ObjectTypeIndexer"),
optional: true,
default: []
},
callProperties: {
validate: (0, _utils.arrayOfType)("ObjectTypeCallProperty"),
optional: true,
default: []
},
internalSlots: {
validate: (0, _utils.arrayOfType)("ObjectTypeInternalSlot"),
optional: true,
default: []
},
exact: {
validate: (0, _utils.assertValueType)("boolean"),
default: false
},
inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}
});
defineType("ObjectTypeInternalSlot", {
visitor: ["id", "value", "optional", "static", "method"],
aliases: ["UserWhitespacable"],
fields: {
id: (0, _utils.validateType)("Identifier"),
value: (0, _utils.validateType)("FlowType"),
optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("ObjectTypeCallProperty", {
visitor: ["value"],
aliases: ["UserWhitespacable"],
fields: {
value: (0, _utils.validateType)("FlowType"),
static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("ObjectTypeIndexer", {
visitor: ["id", "key", "value", "variance"],
aliases: ["UserWhitespacable"],
fields: {
id: (0, _utils.validateOptionalType)("Identifier"),
key: (0, _utils.validateType)("FlowType"),
value: (0, _utils.validateType)("FlowType"),
static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
variance: (0, _utils.validateOptionalType)("Variance")
}
});
defineType("ObjectTypeProperty", {
visitor: ["key", "value", "variance"],
aliases: ["UserWhitespacable"],
fields: {
key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
value: (0, _utils.validateType)("FlowType"),
kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
variance: (0, _utils.validateOptionalType)("Variance"),
method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("ObjectTypeSpreadProperty", {
visitor: ["argument"],
aliases: ["UserWhitespacable"],
fields: {
argument: (0, _utils.validateType)("FlowType")
}
});
defineType("OpaqueType", {
visitor: ["id", "typeParameters", "supertype", "impltype"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
supertype: (0, _utils.validateOptionalType)("FlowType"),
impltype: (0, _utils.validateType)("FlowType")
}
});
defineType("QualifiedTypeIdentifier", {
visitor: ["id", "qualification"],
fields: {
id: (0, _utils.validateType)("Identifier"),
qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
}
});
defineType("StringLiteralTypeAnnotation", {
builder: ["value"],
aliases: ["FlowType"],
fields: {
value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
}
});
defineType("StringTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("SymbolTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("ThisTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("TupleTypeAnnotation", {
visitor: ["types"],
aliases: ["FlowType"],
fields: {
types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}
});
defineType("TypeofTypeAnnotation", {
visitor: ["argument"],
aliases: ["FlowType"],
fields: {
argument: (0, _utils.validateType)("FlowType")
}
});
defineType("TypeAlias", {
visitor: ["id", "typeParameters", "right"],
aliases: ["FlowDeclaration", "Statement", "Declaration"],
fields: {
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
right: (0, _utils.validateType)("FlowType")
}
});
defineType("TypeAnnotation", {
visitor: ["typeAnnotation"],
fields: {
typeAnnotation: (0, _utils.validateType)("FlowType")
}
});
defineType("TypeCastExpression", {
visitor: ["expression", "typeAnnotation"],
aliases: ["ExpressionWrapper", "Expression"],
fields: {
expression: (0, _utils.validateType)("Expression"),
typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
}
});
defineType("TypeParameter", {
visitor: ["bound", "default", "variance"],
fields: {
name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
default: (0, _utils.validateOptionalType)("FlowType"),
variance: (0, _utils.validateOptionalType)("Variance")
}
});
defineType("TypeParameterDeclaration", {
visitor: ["params"],
fields: {
params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
}
});
defineType("TypeParameterInstantiation", {
visitor: ["params"],
fields: {
params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}
});
defineType("UnionTypeAnnotation", {
visitor: ["types"],
aliases: ["FlowType"],
fields: {
types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}
});
defineType("Variance", {
builder: ["kind"],
fields: {
kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
}
});
defineType("VoidTypeAnnotation", {
aliases: ["FlowType", "FlowBaseAnnotation"]
});
defineType("EnumDeclaration", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "body"],
fields: {
id: (0, _utils.validateType)("Identifier"),
body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
}
});
defineType("EnumBooleanBody", {
aliases: ["EnumBody"],
visitor: ["members"],
fields: {
explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("EnumNumberBody", {
aliases: ["EnumBody"],
visitor: ["members"],
fields: {
explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("EnumStringBody", {
aliases: ["EnumBody"],
visitor: ["members"],
fields: {
explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("EnumSymbolBody", {
aliases: ["EnumBody"],
visitor: ["members"],
fields: {
members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
defineType("EnumBooleanMember", {
aliases: ["EnumMember"],
visitor: ["id"],
fields: {
id: (0, _utils.validateType)("Identifier"),
init: (0, _utils.validateType)("BooleanLiteral")
}
});
defineType("EnumNumberMember", {
aliases: ["EnumMember"],
visitor: ["id", "init"],
fields: {
id: (0, _utils.validateType)("Identifier"),
init: (0, _utils.validateType)("NumericLiteral")
}
});
defineType("EnumStringMember", {
aliases: ["EnumMember"],
visitor: ["id", "init"],
fields: {
id: (0, _utils.validateType)("Identifier"),
init: (0, _utils.validateType)("StringLiteral")
}
});
defineType("EnumDefaultedMember", {
aliases: ["EnumMember"],
visitor: ["id"],
fields: {
id: (0, _utils.validateType)("Identifier")
}
});
defineType("IndexedAccessType", {
visitor: ["objectType", "indexType"],
aliases: ["FlowType"],
fields: {
objectType: (0, _utils.validateType)("FlowType"),
indexType: (0, _utils.validateType)("FlowType")
}
});
defineType("OptionalIndexedAccessType", {
visitor: ["objectType", "indexType"],
aliases: ["FlowType"],
fields: {
objectType: (0, _utils.validateType)("FlowType"),
indexType: (0, _utils.validateType)("FlowType"),
optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}
});
return flow$1;
}
var jsx$1 = {};
var hasRequiredJsx$1;
function requireJsx$1 () {
if (hasRequiredJsx$1) return jsx$1;
hasRequiredJsx$1 = 1;
var _utils = requireUtils();
const defineType = (0, _utils.defineAliasedType)("JSX");
defineType("JSXAttribute", {
visitor: ["name", "value"],
aliases: ["Immutable"],
fields: {
name: {
validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
},
value: {
optional: true,
validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
}
}
});
defineType("JSXClosingElement", {
visitor: ["name"],
aliases: ["Immutable"],
fields: {
name: {
validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
}
}
});
defineType("JSXElement", {
builder: ["openingElement", "closingElement", "children", "selfClosing"],
visitor: ["openingElement", "children", "closingElement"],
aliases: ["Immutable", "Expression"],
fields: Object.assign({
openingElement: {
validate: (0, _utils.assertNodeType)("JSXOpeningElement")
},
closingElement: {
optional: true,
validate: (0, _utils.assertNodeType)("JSXClosingElement")
},
children: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
}
}, {
selfClosing: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
}
})
});
defineType("JSXEmptyExpression", {});
defineType("JSXExpressionContainer", {
visitor: ["expression"],
aliases: ["Immutable"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
}
}
});
defineType("JSXSpreadChild", {
visitor: ["expression"],
aliases: ["Immutable"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("JSXIdentifier", {
builder: ["name"],
fields: {
name: {
validate: (0, _utils.assertValueType)("string")
}
}
});
defineType("JSXMemberExpression", {
visitor: ["object", "property"],
fields: {
object: {
validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
},
property: {
validate: (0, _utils.assertNodeType)("JSXIdentifier")
}
}
});
defineType("JSXNamespacedName", {
visitor: ["namespace", "name"],
fields: {
namespace: {
validate: (0, _utils.assertNodeType)("JSXIdentifier")
},
name: {
validate: (0, _utils.assertNodeType)("JSXIdentifier")
}
}
});
defineType("JSXOpeningElement", {
builder: ["name", "attributes", "selfClosing"],
visitor: ["name", "attributes"],
aliases: ["Immutable"],
fields: {
name: {
validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
},
selfClosing: {
default: false
},
attributes: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
optional: true
}
}
});
defineType("JSXSpreadAttribute", {
visitor: ["argument"],
fields: {
argument: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
defineType("JSXText", {
aliases: ["Immutable"],
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
}
});
defineType("JSXFragment", {
builder: ["openingFragment", "closingFragment", "children"],
visitor: ["openingFragment", "children", "closingFragment"],
aliases: ["Immutable", "Expression"],
fields: {
openingFragment: {
validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
},
closingFragment: {
validate: (0, _utils.assertNodeType)("JSXClosingFragment")
},
children: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
}
}
});
defineType("JSXOpeningFragment", {
aliases: ["Immutable"]
});
defineType("JSXClosingFragment", {
aliases: ["Immutable"]
});
return jsx$1;
}
var misc = {};
var placeholders = {};
var hasRequiredPlaceholders;
function requirePlaceholders () {
if (hasRequiredPlaceholders) return placeholders;
hasRequiredPlaceholders = 1;
Object.defineProperty(placeholders, "__esModule", {
value: true
});
placeholders.PLACEHOLDERS_FLIPPED_ALIAS = placeholders.PLACEHOLDERS_ALIAS = placeholders.PLACEHOLDERS = void 0;
var _utils = requireUtils();
const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
placeholders.PLACEHOLDERS = PLACEHOLDERS;
const PLACEHOLDERS_ALIAS = {
Declaration: ["Statement"],
Pattern: ["PatternLike", "LVal"]
};
placeholders.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
for (const type of PLACEHOLDERS) {
const alias = _utils.ALIAS_KEYS[type];
if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
}
const PLACEHOLDERS_FLIPPED_ALIAS = {};
placeholders.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
PLACEHOLDERS_ALIAS[type].forEach(alias => {
if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
}
PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
});
});
return placeholders;
}
var hasRequiredMisc;
function requireMisc () {
if (hasRequiredMisc) return misc;
hasRequiredMisc = 1;
var _utils = requireUtils();
var _placeholders = requirePlaceholders();
const defineType = (0, _utils.defineAliasedType)("Miscellaneous");
{
defineType("Noop", {
visitor: []
});
}
defineType("Placeholder", {
visitor: [],
builder: ["expectedNode", "name"],
fields: {
name: {
validate: (0, _utils.assertNodeType)("Identifier")
},
expectedNode: {
validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
}
}
});
defineType("V8IntrinsicIdentifier", {
builder: ["name"],
fields: {
name: {
validate: (0, _utils.assertValueType)("string")
}
}
});
return misc;
}
var experimental = {};
var hasRequiredExperimental;
function requireExperimental () {
if (hasRequiredExperimental) return experimental;
hasRequiredExperimental = 1;
var _utils = requireUtils();
(0, _utils.default)("ArgumentPlaceholder", {});
(0, _utils.default)("BindExpression", {
visitor: ["object", "callee"],
aliases: ["Expression"],
fields: !process$1.env.BABEL_TYPES_8_BREAKING ? {
object: {
validate: Object.assign(() => {}, {
oneOfNodeTypes: ["Expression"]
})
},
callee: {
validate: Object.assign(() => {}, {
oneOfNodeTypes: ["Expression"]
})
}
} : {
object: {
validate: (0, _utils.assertNodeType)("Expression")
},
callee: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
(0, _utils.default)("ImportAttribute", {
visitor: ["key", "value"],
fields: {
key: {
validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
},
value: {
validate: (0, _utils.assertNodeType)("StringLiteral")
}
}
});
(0, _utils.default)("Decorator", {
visitor: ["expression"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression")
}
}
});
(0, _utils.default)("DoExpression", {
visitor: ["body"],
builder: ["body", "async"],
aliases: ["Expression"],
fields: {
body: {
validate: (0, _utils.assertNodeType)("BlockStatement")
},
async: {
validate: (0, _utils.assertValueType)("boolean"),
default: false
}
}
});
(0, _utils.default)("ExportDefaultSpecifier", {
visitor: ["exported"],
aliases: ["ModuleSpecifier"],
fields: {
exported: {
validate: (0, _utils.assertNodeType)("Identifier")
}
}
});
(0, _utils.default)("RecordExpression", {
visitor: ["properties"],
aliases: ["Expression"],
fields: {
properties: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
}
}
});
(0, _utils.default)("TupleExpression", {
fields: {
elements: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
default: []
}
},
visitor: ["elements"],
aliases: ["Expression"]
});
(0, _utils.default)("DecimalLiteral", {
builder: ["value"],
fields: {
value: {
validate: (0, _utils.assertValueType)("string")
}
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]
});
(0, _utils.default)("ModuleExpression", {
visitor: ["body"],
fields: {
body: {
validate: (0, _utils.assertNodeType)("Program")
}
},
aliases: ["Expression"]
});
(0, _utils.default)("TopicReference", {
aliases: ["Expression"]
});
(0, _utils.default)("PipelineTopicExpression", {
builder: ["expression"],
visitor: ["expression"],
fields: {
expression: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
aliases: ["Expression"]
});
(0, _utils.default)("PipelineBareFunction", {
builder: ["callee"],
visitor: ["callee"],
fields: {
callee: {
validate: (0, _utils.assertNodeType)("Expression")
}
},
aliases: ["Expression"]
});
(0, _utils.default)("PipelinePrimaryTopicReference", {
aliases: ["Expression"]
});
return experimental;
}
var typescript$1 = {};
var hasRequiredTypescript$1;
function requireTypescript$1 () {
if (hasRequiredTypescript$1) return typescript$1;
hasRequiredTypescript$1 = 1;
var _utils = requireUtils();
var _core = requireCore();
var _is = requireIs();
const defineType = (0, _utils.defineAliasedType)("TypeScript");
const bool = (0, _utils.assertValueType)("boolean");
const tSFunctionTypeAnnotationCommon = () => ({
returnType: {
validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
optional: true
},
typeParameters: {
validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
optional: true
}
});
defineType("TSParameterProperty", {
aliases: ["LVal"],
visitor: ["parameter"],
fields: {
accessibility: {
validate: (0, _utils.assertOneOf)("public", "private", "protected"),
optional: true
},
readonly: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
parameter: {
validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
},
override: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
decorators: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
optional: true
}
}
});
defineType("TSDeclareFunction", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "params", "returnType"],
fields: Object.assign({}, (0, _core.functionDeclarationCommon)(), tSFunctionTypeAnnotationCommon())
});
defineType("TSDeclareMethod", {
visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
fields: Object.assign({}, (0, _core.classMethodOrDeclareMethodCommon)(), tSFunctionTypeAnnotationCommon())
});
defineType("TSQualifiedName", {
aliases: ["TSEntityName"],
visitor: ["left", "right"],
fields: {
left: (0, _utils.validateType)("TSEntityName"),
right: (0, _utils.validateType)("Identifier")
}
});
const signatureDeclarationCommon = () => ({
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
["parameters"]: (0, _utils.validateArrayOfType)(["ArrayPattern", "Identifier", "ObjectPattern", "RestElement"]),
["typeAnnotation"]: (0, _utils.validateOptionalType)("TSTypeAnnotation")
});
const callConstructSignatureDeclaration = {
aliases: ["TSTypeElement"],
visitor: ["typeParameters", "parameters", "typeAnnotation"],
fields: signatureDeclarationCommon()
};
defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
const namedTypeElementCommon = () => ({
key: (0, _utils.validateType)("Expression"),
computed: {
default: false
},
optional: (0, _utils.validateOptional)(bool)
});
defineType("TSPropertySignature", {
aliases: ["TSTypeElement"],
visitor: ["key", "typeAnnotation", "initializer"],
fields: Object.assign({}, namedTypeElementCommon(), {
readonly: (0, _utils.validateOptional)(bool),
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
initializer: (0, _utils.validateOptionalType)("Expression"),
kind: {
validate: (0, _utils.assertOneOf)("get", "set")
}
})
});
defineType("TSMethodSignature", {
aliases: ["TSTypeElement"],
visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
fields: Object.assign({}, signatureDeclarationCommon(), namedTypeElementCommon(), {
kind: {
validate: (0, _utils.assertOneOf)("method", "get", "set")
}
})
});
defineType("TSIndexSignature", {
aliases: ["TSTypeElement"],
visitor: ["parameters", "typeAnnotation"],
fields: {
readonly: (0, _utils.validateOptional)(bool),
static: (0, _utils.validateOptional)(bool),
parameters: (0, _utils.validateArrayOfType)("Identifier"),
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
}
});
const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
for (const type of tsKeywordTypes) {
defineType(type, {
aliases: ["TSType", "TSBaseType"],
visitor: [],
fields: {}
});
}
defineType("TSThisType", {
aliases: ["TSType", "TSBaseType"],
visitor: [],
fields: {}
});
const fnOrCtrBase = {
aliases: ["TSType"],
visitor: ["typeParameters", "parameters", "typeAnnotation"]
};
defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, {
fields: signatureDeclarationCommon()
}));
defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, {
fields: Object.assign({}, signatureDeclarationCommon(), {
abstract: (0, _utils.validateOptional)(bool)
})
}));
defineType("TSTypeReference", {
aliases: ["TSType"],
visitor: ["typeName", "typeParameters"],
fields: {
typeName: (0, _utils.validateType)("TSEntityName"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}
});
defineType("TSTypePredicate", {
aliases: ["TSType"],
visitor: ["parameterName", "typeAnnotation"],
builder: ["parameterName", "typeAnnotation", "asserts"],
fields: {
parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
asserts: (0, _utils.validateOptional)(bool)
}
});
defineType("TSTypeQuery", {
aliases: ["TSType"],
visitor: ["exprName", "typeParameters"],
fields: {
exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"]),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}
});
defineType("TSTypeLiteral", {
aliases: ["TSType"],
visitor: ["members"],
fields: {
members: (0, _utils.validateArrayOfType)("TSTypeElement")
}
});
defineType("TSArrayType", {
aliases: ["TSType"],
visitor: ["elementType"],
fields: {
elementType: (0, _utils.validateType)("TSType")
}
});
defineType("TSTupleType", {
aliases: ["TSType"],
visitor: ["elementTypes"],
fields: {
elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
}
});
defineType("TSOptionalType", {
aliases: ["TSType"],
visitor: ["typeAnnotation"],
fields: {
typeAnnotation: (0, _utils.validateType)("TSType")
}
});
defineType("TSRestType", {
aliases: ["TSType"],
visitor: ["typeAnnotation"],
fields: {
typeAnnotation: (0, _utils.validateType)("TSType")
}
});
defineType("TSNamedTupleMember", {
visitor: ["label", "elementType"],
builder: ["label", "elementType", "optional"],
fields: {
label: (0, _utils.validateType)("Identifier"),
optional: {
validate: bool,
default: false
},
elementType: (0, _utils.validateType)("TSType")
}
});
const unionOrIntersection = {
aliases: ["TSType"],
visitor: ["types"],
fields: {
types: (0, _utils.validateArrayOfType)("TSType")
}
};
defineType("TSUnionType", unionOrIntersection);
defineType("TSIntersectionType", unionOrIntersection);
defineType("TSConditionalType", {
aliases: ["TSType"],
visitor: ["checkType", "extendsType", "trueType", "falseType"],
fields: {
checkType: (0, _utils.validateType)("TSType"),
extendsType: (0, _utils.validateType)("TSType"),
trueType: (0, _utils.validateType)("TSType"),
falseType: (0, _utils.validateType)("TSType")
}
});
defineType("TSInferType", {
aliases: ["TSType"],
visitor: ["typeParameter"],
fields: {
typeParameter: (0, _utils.validateType)("TSTypeParameter")
}
});
defineType("TSParenthesizedType", {
aliases: ["TSType"],
visitor: ["typeAnnotation"],
fields: {
typeAnnotation: (0, _utils.validateType)("TSType")
}
});
defineType("TSTypeOperator", {
aliases: ["TSType"],
visitor: ["typeAnnotation"],
fields: {
operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
typeAnnotation: (0, _utils.validateType)("TSType")
}
});
defineType("TSIndexedAccessType", {
aliases: ["TSType"],
visitor: ["objectType", "indexType"],
fields: {
objectType: (0, _utils.validateType)("TSType"),
indexType: (0, _utils.validateType)("TSType")
}
});
defineType("TSMappedType", {
aliases: ["TSType"],
visitor: ["typeParameter", "typeAnnotation", "nameType"],
fields: {
readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
typeParameter: (0, _utils.validateType)("TSTypeParameter"),
optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")),
typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
nameType: (0, _utils.validateOptionalType)("TSType")
}
});
defineType("TSLiteralType", {
aliases: ["TSType", "TSBaseType"],
visitor: ["literal"],
fields: {
literal: {
validate: function () {
const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
const unaryOperator = (0, _utils.assertOneOf)("-");
const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
function validator(parent, key, node) {
if ((0, _is.default)("UnaryExpression", node)) {
unaryOperator(node, "operator", node.operator);
unaryExpression(node, "argument", node.argument);
} else {
literal(parent, key, node);
}
}
validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"];
return validator;
}()
}
}
});
defineType("TSExpressionWithTypeArguments", {
aliases: ["TSType"],
visitor: ["expression", "typeParameters"],
fields: {
expression: (0, _utils.validateType)("TSEntityName"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}
});
defineType("TSInterfaceDeclaration", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "extends", "body"],
fields: {
declare: (0, _utils.validateOptional)(bool),
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
body: (0, _utils.validateType)("TSInterfaceBody")
}
});
defineType("TSInterfaceBody", {
visitor: ["body"],
fields: {
body: (0, _utils.validateArrayOfType)("TSTypeElement")
}
});
defineType("TSTypeAliasDeclaration", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "typeAnnotation"],
fields: {
declare: (0, _utils.validateOptional)(bool),
id: (0, _utils.validateType)("Identifier"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
typeAnnotation: (0, _utils.validateType)("TSType")
}
});
defineType("TSInstantiationExpression", {
aliases: ["Expression"],
visitor: ["expression", "typeParameters"],
fields: {
expression: (0, _utils.validateType)("Expression"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}
});
const TSTypeExpression = {
aliases: ["Expression", "LVal", "PatternLike"],
visitor: ["expression", "typeAnnotation"],
fields: {
expression: (0, _utils.validateType)("Expression"),
typeAnnotation: (0, _utils.validateType)("TSType")
}
};
defineType("TSAsExpression", TSTypeExpression);
defineType("TSSatisfiesExpression", TSTypeExpression);
defineType("TSTypeAssertion", {
aliases: ["Expression", "LVal", "PatternLike"],
visitor: ["typeAnnotation", "expression"],
fields: {
typeAnnotation: (0, _utils.validateType)("TSType"),
expression: (0, _utils.validateType)("Expression")
}
});
defineType("TSEnumDeclaration", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "members"],
fields: {
declare: (0, _utils.validateOptional)(bool),
const: (0, _utils.validateOptional)(bool),
id: (0, _utils.validateType)("Identifier"),
members: (0, _utils.validateArrayOfType)("TSEnumMember"),
initializer: (0, _utils.validateOptionalType)("Expression")
}
});
defineType("TSEnumMember", {
visitor: ["id", "initializer"],
fields: {
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
initializer: (0, _utils.validateOptionalType)("Expression")
}
});
defineType("TSModuleDeclaration", {
aliases: ["Statement", "Declaration"],
visitor: ["id", "body"],
fields: {
declare: (0, _utils.validateOptional)(bool),
global: (0, _utils.validateOptional)(bool),
id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
}
});
defineType("TSModuleBlock", {
aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"],
visitor: ["body"],
fields: {
body: (0, _utils.validateArrayOfType)("Statement")
}
});
defineType("TSImportType", {
aliases: ["TSType"],
visitor: ["argument", "qualifier", "typeParameters"],
fields: {
argument: (0, _utils.validateType)("StringLiteral"),
qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}
});
defineType("TSImportEqualsDeclaration", {
aliases: ["Statement"],
visitor: ["id", "moduleReference"],
fields: {
isExport: (0, _utils.validate)(bool),
id: (0, _utils.validateType)("Identifier"),
moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
importKind: {
validate: (0, _utils.assertOneOf)("type", "value"),
optional: true
}
}
});
defineType("TSExternalModuleReference", {
visitor: ["expression"],
fields: {
expression: (0, _utils.validateType)("StringLiteral")
}
});
defineType("TSNonNullExpression", {
aliases: ["Expression", "LVal", "PatternLike"],
visitor: ["expression"],
fields: {
expression: (0, _utils.validateType)("Expression")
}
});
defineType("TSExportAssignment", {
aliases: ["Statement"],
visitor: ["expression"],
fields: {
expression: (0, _utils.validateType)("Expression")
}
});
defineType("TSNamespaceExportDeclaration", {
aliases: ["Statement"],
visitor: ["id"],
fields: {
id: (0, _utils.validateType)("Identifier")
}
});
defineType("TSTypeAnnotation", {
visitor: ["typeAnnotation"],
fields: {
typeAnnotation: {
validate: (0, _utils.assertNodeType)("TSType")
}
}
});
defineType("TSTypeParameterInstantiation", {
visitor: ["params"],
fields: {
params: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
}
}
});
defineType("TSTypeParameterDeclaration", {
visitor: ["params"],
fields: {
params: {
validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
}
}
});
defineType("TSTypeParameter", {
builder: ["constraint", "default", "name"],
visitor: ["constraint", "default"],
fields: {
name: {
validate: (0, _utils.assertValueType)("string")
},
in: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
out: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
const: {
validate: (0, _utils.assertValueType)("boolean"),
optional: true
},
constraint: {
validate: (0, _utils.assertNodeType)("TSType"),
optional: true
},
default: {
validate: (0, _utils.assertNodeType)("TSType"),
optional: true
}
}
});
return typescript$1;
}
var deprecatedAliases = {};
var hasRequiredDeprecatedAliases;
function requireDeprecatedAliases () {
if (hasRequiredDeprecatedAliases) return deprecatedAliases;
hasRequiredDeprecatedAliases = 1;
Object.defineProperty(deprecatedAliases, "__esModule", {
value: true
});
deprecatedAliases.DEPRECATED_ALIASES = void 0;
const DEPRECATED_ALIASES = {
ModuleDeclaration: "ImportOrExportDeclaration"
};
deprecatedAliases.DEPRECATED_ALIASES = DEPRECATED_ALIASES;
return deprecatedAliases;
}
var hasRequiredDefinitions;
function requireDefinitions () {
if (hasRequiredDefinitions) return definitions;
hasRequiredDefinitions = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "ALIAS_KEYS", {
enumerable: true,
get: function () {
return _utils.ALIAS_KEYS;
}
});
Object.defineProperty(exports, "BUILDER_KEYS", {
enumerable: true,
get: function () {
return _utils.BUILDER_KEYS;
}
});
Object.defineProperty(exports, "DEPRECATED_ALIASES", {
enumerable: true,
get: function () {
return _deprecatedAliases.DEPRECATED_ALIASES;
}
});
Object.defineProperty(exports, "DEPRECATED_KEYS", {
enumerable: true,
get: function () {
return _utils.DEPRECATED_KEYS;
}
});
Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
enumerable: true,
get: function () {
return _utils.FLIPPED_ALIAS_KEYS;
}
});
Object.defineProperty(exports, "NODE_FIELDS", {
enumerable: true,
get: function () {
return _utils.NODE_FIELDS;
}
});
Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
enumerable: true,
get: function () {
return _utils.NODE_PARENT_VALIDATIONS;
}
});
Object.defineProperty(exports, "PLACEHOLDERS", {
enumerable: true,
get: function () {
return _placeholders.PLACEHOLDERS;
}
});
Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
enumerable: true,
get: function () {
return _placeholders.PLACEHOLDERS_ALIAS;
}
});
Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
enumerable: true,
get: function () {
return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
}
});
exports.TYPES = void 0;
Object.defineProperty(exports, "VISITOR_KEYS", {
enumerable: true,
get: function () {
return _utils.VISITOR_KEYS;
}
});
var _toFastProperties = requireToFastProperties();
requireCore();
requireFlow$1();
requireJsx$1();
requireMisc();
requireExperimental();
requireTypescript$1();
var _utils = requireUtils();
var _placeholders = requirePlaceholders();
var _deprecatedAliases = requireDeprecatedAliases();
Object.keys(_deprecatedAliases.DEPRECATED_ALIASES).forEach(deprecatedAlias => {
_utils.FLIPPED_ALIAS_KEYS[deprecatedAlias] = _utils.FLIPPED_ALIAS_KEYS[_deprecatedAliases.DEPRECATED_ALIASES[deprecatedAlias]];
});
_toFastProperties(_utils.VISITOR_KEYS);
_toFastProperties(_utils.ALIAS_KEYS);
_toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
_toFastProperties(_utils.NODE_FIELDS);
_toFastProperties(_utils.BUILDER_KEYS);
_toFastProperties(_utils.DEPRECATED_KEYS);
_toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
_toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
const TYPES = [].concat(Object.keys(_utils.VISITOR_KEYS), Object.keys(_utils.FLIPPED_ALIAS_KEYS), Object.keys(_utils.DEPRECATED_KEYS));
exports.TYPES = TYPES;
} (definitions));
return definitions;
}
var hasRequiredValidate;
function requireValidate () {
if (hasRequiredValidate) return validate;
hasRequiredValidate = 1;
Object.defineProperty(validate, "__esModule", {
value: true
});
validate.default = validate$1;
validate.validateChild = validateChild;
validate.validateField = validateField;
var _index = requireDefinitions();
function validate$1(node, key, val) {
if (!node) return;
const fields = _index.NODE_FIELDS[node.type];
if (!fields) return;
const field = fields[key];
validateField(node, key, val, field);
validateChild(node, key, val);
}
function validateField(node, key, val, field) {
if (!(field != null && field.validate)) return;
if (field.optional && val == null) return;
field.validate(node, key, val);
}
function validateChild(node, key, val) {
if (val == null) return;
const validate = _index.NODE_PARENT_VALIDATIONS[val.type];
if (!validate) return;
validate(node, key, val);
}
return validate;
}
var hasRequiredValidateNode;
function requireValidateNode () {
if (hasRequiredValidateNode) return validateNode;
hasRequiredValidateNode = 1;
Object.defineProperty(validateNode, "__esModule", {
value: true
});
validateNode.default = validateNode$1;
var _validate = requireValidate();
var _index = requireLib$2();
function validateNode$1(node) {
const keys = _index.BUILDER_KEYS[node.type];
for (const key of keys) {
(0, _validate.default)(node, key, node[key]);
}
return node;
}
return validateNode;
}
var hasRequiredGenerated$2;
function requireGenerated$2 () {
if (hasRequiredGenerated$2) return generated$2;
hasRequiredGenerated$2 = 1;
Object.defineProperty(generated$2, "__esModule", {
value: true
});
generated$2.anyTypeAnnotation = anyTypeAnnotation;
generated$2.argumentPlaceholder = argumentPlaceholder;
generated$2.arrayExpression = arrayExpression;
generated$2.arrayPattern = arrayPattern;
generated$2.arrayTypeAnnotation = arrayTypeAnnotation;
generated$2.arrowFunctionExpression = arrowFunctionExpression;
generated$2.assignmentExpression = assignmentExpression;
generated$2.assignmentPattern = assignmentPattern;
generated$2.awaitExpression = awaitExpression;
generated$2.bigIntLiteral = bigIntLiteral;
generated$2.binaryExpression = binaryExpression;
generated$2.bindExpression = bindExpression;
generated$2.blockStatement = blockStatement;
generated$2.booleanLiteral = booleanLiteral;
generated$2.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
generated$2.booleanTypeAnnotation = booleanTypeAnnotation;
generated$2.breakStatement = breakStatement;
generated$2.callExpression = callExpression;
generated$2.catchClause = catchClause;
generated$2.classAccessorProperty = classAccessorProperty;
generated$2.classBody = classBody;
generated$2.classDeclaration = classDeclaration;
generated$2.classExpression = classExpression;
generated$2.classImplements = classImplements;
generated$2.classMethod = classMethod;
generated$2.classPrivateMethod = classPrivateMethod;
generated$2.classPrivateProperty = classPrivateProperty;
generated$2.classProperty = classProperty;
generated$2.conditionalExpression = conditionalExpression;
generated$2.continueStatement = continueStatement;
generated$2.debuggerStatement = debuggerStatement;
generated$2.decimalLiteral = decimalLiteral;
generated$2.declareClass = declareClass;
generated$2.declareExportAllDeclaration = declareExportAllDeclaration;
generated$2.declareExportDeclaration = declareExportDeclaration;
generated$2.declareFunction = declareFunction;
generated$2.declareInterface = declareInterface;
generated$2.declareModule = declareModule;
generated$2.declareModuleExports = declareModuleExports;
generated$2.declareOpaqueType = declareOpaqueType;
generated$2.declareTypeAlias = declareTypeAlias;
generated$2.declareVariable = declareVariable;
generated$2.declaredPredicate = declaredPredicate;
generated$2.decorator = decorator;
generated$2.directive = directive;
generated$2.directiveLiteral = directiveLiteral;
generated$2.doExpression = doExpression;
generated$2.doWhileStatement = doWhileStatement;
generated$2.emptyStatement = emptyStatement;
generated$2.emptyTypeAnnotation = emptyTypeAnnotation;
generated$2.enumBooleanBody = enumBooleanBody;
generated$2.enumBooleanMember = enumBooleanMember;
generated$2.enumDeclaration = enumDeclaration;
generated$2.enumDefaultedMember = enumDefaultedMember;
generated$2.enumNumberBody = enumNumberBody;
generated$2.enumNumberMember = enumNumberMember;
generated$2.enumStringBody = enumStringBody;
generated$2.enumStringMember = enumStringMember;
generated$2.enumSymbolBody = enumSymbolBody;
generated$2.existsTypeAnnotation = existsTypeAnnotation;
generated$2.exportAllDeclaration = exportAllDeclaration;
generated$2.exportDefaultDeclaration = exportDefaultDeclaration;
generated$2.exportDefaultSpecifier = exportDefaultSpecifier;
generated$2.exportNamedDeclaration = exportNamedDeclaration;
generated$2.exportNamespaceSpecifier = exportNamespaceSpecifier;
generated$2.exportSpecifier = exportSpecifier;
generated$2.expressionStatement = expressionStatement;
generated$2.file = file;
generated$2.forInStatement = forInStatement;
generated$2.forOfStatement = forOfStatement;
generated$2.forStatement = forStatement;
generated$2.functionDeclaration = functionDeclaration;
generated$2.functionExpression = functionExpression;
generated$2.functionTypeAnnotation = functionTypeAnnotation;
generated$2.functionTypeParam = functionTypeParam;
generated$2.genericTypeAnnotation = genericTypeAnnotation;
generated$2.identifier = identifier;
generated$2.ifStatement = ifStatement;
generated$2.import = _import;
generated$2.importAttribute = importAttribute;
generated$2.importDeclaration = importDeclaration;
generated$2.importDefaultSpecifier = importDefaultSpecifier;
generated$2.importExpression = importExpression;
generated$2.importNamespaceSpecifier = importNamespaceSpecifier;
generated$2.importSpecifier = importSpecifier;
generated$2.indexedAccessType = indexedAccessType;
generated$2.inferredPredicate = inferredPredicate;
generated$2.interfaceDeclaration = interfaceDeclaration;
generated$2.interfaceExtends = interfaceExtends;
generated$2.interfaceTypeAnnotation = interfaceTypeAnnotation;
generated$2.interpreterDirective = interpreterDirective;
generated$2.intersectionTypeAnnotation = intersectionTypeAnnotation;
generated$2.jSXAttribute = generated$2.jsxAttribute = jsxAttribute;
generated$2.jSXClosingElement = generated$2.jsxClosingElement = jsxClosingElement;
generated$2.jSXClosingFragment = generated$2.jsxClosingFragment = jsxClosingFragment;
generated$2.jSXElement = generated$2.jsxElement = jsxElement;
generated$2.jSXEmptyExpression = generated$2.jsxEmptyExpression = jsxEmptyExpression;
generated$2.jSXExpressionContainer = generated$2.jsxExpressionContainer = jsxExpressionContainer;
generated$2.jSXFragment = generated$2.jsxFragment = jsxFragment;
generated$2.jSXIdentifier = generated$2.jsxIdentifier = jsxIdentifier;
generated$2.jSXMemberExpression = generated$2.jsxMemberExpression = jsxMemberExpression;
generated$2.jSXNamespacedName = generated$2.jsxNamespacedName = jsxNamespacedName;
generated$2.jSXOpeningElement = generated$2.jsxOpeningElement = jsxOpeningElement;
generated$2.jSXOpeningFragment = generated$2.jsxOpeningFragment = jsxOpeningFragment;
generated$2.jSXSpreadAttribute = generated$2.jsxSpreadAttribute = jsxSpreadAttribute;
generated$2.jSXSpreadChild = generated$2.jsxSpreadChild = jsxSpreadChild;
generated$2.jSXText = generated$2.jsxText = jsxText;
generated$2.labeledStatement = labeledStatement;
generated$2.logicalExpression = logicalExpression;
generated$2.memberExpression = memberExpression;
generated$2.metaProperty = metaProperty;
generated$2.mixedTypeAnnotation = mixedTypeAnnotation;
generated$2.moduleExpression = moduleExpression;
generated$2.newExpression = newExpression;
generated$2.noop = noop;
generated$2.nullLiteral = nullLiteral;
generated$2.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
generated$2.nullableTypeAnnotation = nullableTypeAnnotation;
generated$2.numberLiteral = NumberLiteral;
generated$2.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
generated$2.numberTypeAnnotation = numberTypeAnnotation;
generated$2.numericLiteral = numericLiteral;
generated$2.objectExpression = objectExpression;
generated$2.objectMethod = objectMethod;
generated$2.objectPattern = objectPattern;
generated$2.objectProperty = objectProperty;
generated$2.objectTypeAnnotation = objectTypeAnnotation;
generated$2.objectTypeCallProperty = objectTypeCallProperty;
generated$2.objectTypeIndexer = objectTypeIndexer;
generated$2.objectTypeInternalSlot = objectTypeInternalSlot;
generated$2.objectTypeProperty = objectTypeProperty;
generated$2.objectTypeSpreadProperty = objectTypeSpreadProperty;
generated$2.opaqueType = opaqueType;
generated$2.optionalCallExpression = optionalCallExpression;
generated$2.optionalIndexedAccessType = optionalIndexedAccessType;
generated$2.optionalMemberExpression = optionalMemberExpression;
generated$2.parenthesizedExpression = parenthesizedExpression;
generated$2.pipelineBareFunction = pipelineBareFunction;
generated$2.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
generated$2.pipelineTopicExpression = pipelineTopicExpression;
generated$2.placeholder = placeholder;
generated$2.privateName = privateName;
generated$2.program = program;
generated$2.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
generated$2.recordExpression = recordExpression;
generated$2.regExpLiteral = regExpLiteral;
generated$2.regexLiteral = RegexLiteral;
generated$2.restElement = restElement;
generated$2.restProperty = RestProperty;
generated$2.returnStatement = returnStatement;
generated$2.sequenceExpression = sequenceExpression;
generated$2.spreadElement = spreadElement;
generated$2.spreadProperty = SpreadProperty;
generated$2.staticBlock = staticBlock;
generated$2.stringLiteral = stringLiteral;
generated$2.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
generated$2.stringTypeAnnotation = stringTypeAnnotation;
generated$2.super = _super;
generated$2.switchCase = switchCase;
generated$2.switchStatement = switchStatement;
generated$2.symbolTypeAnnotation = symbolTypeAnnotation;
generated$2.taggedTemplateExpression = taggedTemplateExpression;
generated$2.templateElement = templateElement;
generated$2.templateLiteral = templateLiteral;
generated$2.thisExpression = thisExpression;
generated$2.thisTypeAnnotation = thisTypeAnnotation;
generated$2.throwStatement = throwStatement;
generated$2.topicReference = topicReference;
generated$2.tryStatement = tryStatement;
generated$2.tSAnyKeyword = generated$2.tsAnyKeyword = tsAnyKeyword;
generated$2.tSArrayType = generated$2.tsArrayType = tsArrayType;
generated$2.tSAsExpression = generated$2.tsAsExpression = tsAsExpression;
generated$2.tSBigIntKeyword = generated$2.tsBigIntKeyword = tsBigIntKeyword;
generated$2.tSBooleanKeyword = generated$2.tsBooleanKeyword = tsBooleanKeyword;
generated$2.tSCallSignatureDeclaration = generated$2.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
generated$2.tSConditionalType = generated$2.tsConditionalType = tsConditionalType;
generated$2.tSConstructSignatureDeclaration = generated$2.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
generated$2.tSConstructorType = generated$2.tsConstructorType = tsConstructorType;
generated$2.tSDeclareFunction = generated$2.tsDeclareFunction = tsDeclareFunction;
generated$2.tSDeclareMethod = generated$2.tsDeclareMethod = tsDeclareMethod;
generated$2.tSEnumDeclaration = generated$2.tsEnumDeclaration = tsEnumDeclaration;
generated$2.tSEnumMember = generated$2.tsEnumMember = tsEnumMember;
generated$2.tSExportAssignment = generated$2.tsExportAssignment = tsExportAssignment;
generated$2.tSExpressionWithTypeArguments = generated$2.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
generated$2.tSExternalModuleReference = generated$2.tsExternalModuleReference = tsExternalModuleReference;
generated$2.tSFunctionType = generated$2.tsFunctionType = tsFunctionType;
generated$2.tSImportEqualsDeclaration = generated$2.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
generated$2.tSImportType = generated$2.tsImportType = tsImportType;
generated$2.tSIndexSignature = generated$2.tsIndexSignature = tsIndexSignature;
generated$2.tSIndexedAccessType = generated$2.tsIndexedAccessType = tsIndexedAccessType;
generated$2.tSInferType = generated$2.tsInferType = tsInferType;
generated$2.tSInstantiationExpression = generated$2.tsInstantiationExpression = tsInstantiationExpression;
generated$2.tSInterfaceBody = generated$2.tsInterfaceBody = tsInterfaceBody;
generated$2.tSInterfaceDeclaration = generated$2.tsInterfaceDeclaration = tsInterfaceDeclaration;
generated$2.tSIntersectionType = generated$2.tsIntersectionType = tsIntersectionType;
generated$2.tSIntrinsicKeyword = generated$2.tsIntrinsicKeyword = tsIntrinsicKeyword;
generated$2.tSLiteralType = generated$2.tsLiteralType = tsLiteralType;
generated$2.tSMappedType = generated$2.tsMappedType = tsMappedType;
generated$2.tSMethodSignature = generated$2.tsMethodSignature = tsMethodSignature;
generated$2.tSModuleBlock = generated$2.tsModuleBlock = tsModuleBlock;
generated$2.tSModuleDeclaration = generated$2.tsModuleDeclaration = tsModuleDeclaration;
generated$2.tSNamedTupleMember = generated$2.tsNamedTupleMember = tsNamedTupleMember;
generated$2.tSNamespaceExportDeclaration = generated$2.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
generated$2.tSNeverKeyword = generated$2.tsNeverKeyword = tsNeverKeyword;
generated$2.tSNonNullExpression = generated$2.tsNonNullExpression = tsNonNullExpression;
generated$2.tSNullKeyword = generated$2.tsNullKeyword = tsNullKeyword;
generated$2.tSNumberKeyword = generated$2.tsNumberKeyword = tsNumberKeyword;
generated$2.tSObjectKeyword = generated$2.tsObjectKeyword = tsObjectKeyword;
generated$2.tSOptionalType = generated$2.tsOptionalType = tsOptionalType;
generated$2.tSParameterProperty = generated$2.tsParameterProperty = tsParameterProperty;
generated$2.tSParenthesizedType = generated$2.tsParenthesizedType = tsParenthesizedType;
generated$2.tSPropertySignature = generated$2.tsPropertySignature = tsPropertySignature;
generated$2.tSQualifiedName = generated$2.tsQualifiedName = tsQualifiedName;
generated$2.tSRestType = generated$2.tsRestType = tsRestType;
generated$2.tSSatisfiesExpression = generated$2.tsSatisfiesExpression = tsSatisfiesExpression;
generated$2.tSStringKeyword = generated$2.tsStringKeyword = tsStringKeyword;
generated$2.tSSymbolKeyword = generated$2.tsSymbolKeyword = tsSymbolKeyword;
generated$2.tSThisType = generated$2.tsThisType = tsThisType;
generated$2.tSTupleType = generated$2.tsTupleType = tsTupleType;
generated$2.tSTypeAliasDeclaration = generated$2.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
generated$2.tSTypeAnnotation = generated$2.tsTypeAnnotation = tsTypeAnnotation;
generated$2.tSTypeAssertion = generated$2.tsTypeAssertion = tsTypeAssertion;
generated$2.tSTypeLiteral = generated$2.tsTypeLiteral = tsTypeLiteral;
generated$2.tSTypeOperator = generated$2.tsTypeOperator = tsTypeOperator;
generated$2.tSTypeParameter = generated$2.tsTypeParameter = tsTypeParameter;
generated$2.tSTypeParameterDeclaration = generated$2.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
generated$2.tSTypeParameterInstantiation = generated$2.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
generated$2.tSTypePredicate = generated$2.tsTypePredicate = tsTypePredicate;
generated$2.tSTypeQuery = generated$2.tsTypeQuery = tsTypeQuery;
generated$2.tSTypeReference = generated$2.tsTypeReference = tsTypeReference;
generated$2.tSUndefinedKeyword = generated$2.tsUndefinedKeyword = tsUndefinedKeyword;
generated$2.tSUnionType = generated$2.tsUnionType = tsUnionType;
generated$2.tSUnknownKeyword = generated$2.tsUnknownKeyword = tsUnknownKeyword;
generated$2.tSVoidKeyword = generated$2.tsVoidKeyword = tsVoidKeyword;
generated$2.tupleExpression = tupleExpression;
generated$2.tupleTypeAnnotation = tupleTypeAnnotation;
generated$2.typeAlias = typeAlias;
generated$2.typeAnnotation = typeAnnotation;
generated$2.typeCastExpression = typeCastExpression;
generated$2.typeParameter = typeParameter;
generated$2.typeParameterDeclaration = typeParameterDeclaration;
generated$2.typeParameterInstantiation = typeParameterInstantiation;
generated$2.typeofTypeAnnotation = typeofTypeAnnotation;
generated$2.unaryExpression = unaryExpression;
generated$2.unionTypeAnnotation = unionTypeAnnotation;
generated$2.updateExpression = updateExpression;
generated$2.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
generated$2.variableDeclaration = variableDeclaration;
generated$2.variableDeclarator = variableDeclarator;
generated$2.variance = variance;
generated$2.voidTypeAnnotation = voidTypeAnnotation;
generated$2.whileStatement = whileStatement;
generated$2.withStatement = withStatement;
generated$2.yieldExpression = yieldExpression;
var _validateNode = requireValidateNode();
var _deprecationWarning = requireDeprecationWarning();
function arrayExpression(elements = []) {
return (0, _validateNode.default)({
type: "ArrayExpression",
elements
});
}
function assignmentExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "AssignmentExpression",
operator,
left,
right
});
}
function binaryExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "BinaryExpression",
operator,
left,
right
});
}
function interpreterDirective(value) {
return (0, _validateNode.default)({
type: "InterpreterDirective",
value
});
}
function directive(value) {
return (0, _validateNode.default)({
type: "Directive",
value
});
}
function directiveLiteral(value) {
return (0, _validateNode.default)({
type: "DirectiveLiteral",
value
});
}
function blockStatement(body, directives = []) {
return (0, _validateNode.default)({
type: "BlockStatement",
body,
directives
});
}
function breakStatement(label = null) {
return (0, _validateNode.default)({
type: "BreakStatement",
label
});
}
function callExpression(callee, _arguments) {
return (0, _validateNode.default)({
type: "CallExpression",
callee,
arguments: _arguments
});
}
function catchClause(param = null, body) {
return (0, _validateNode.default)({
type: "CatchClause",
param,
body
});
}
function conditionalExpression(test, consequent, alternate) {
return (0, _validateNode.default)({
type: "ConditionalExpression",
test,
consequent,
alternate
});
}
function continueStatement(label = null) {
return (0, _validateNode.default)({
type: "ContinueStatement",
label
});
}
function debuggerStatement() {
return {
type: "DebuggerStatement"
};
}
function doWhileStatement(test, body) {
return (0, _validateNode.default)({
type: "DoWhileStatement",
test,
body
});
}
function emptyStatement() {
return {
type: "EmptyStatement"
};
}
function expressionStatement(expression) {
return (0, _validateNode.default)({
type: "ExpressionStatement",
expression
});
}
function file(program, comments = null, tokens = null) {
return (0, _validateNode.default)({
type: "File",
program,
comments,
tokens
});
}
function forInStatement(left, right, body) {
return (0, _validateNode.default)({
type: "ForInStatement",
left,
right,
body
});
}
function forStatement(init = null, test = null, update = null, body) {
return (0, _validateNode.default)({
type: "ForStatement",
init,
test,
update,
body
});
}
function functionDeclaration(id = null, params, body, generator = false, async = false) {
return (0, _validateNode.default)({
type: "FunctionDeclaration",
id,
params,
body,
generator,
async
});
}
function functionExpression(id = null, params, body, generator = false, async = false) {
return (0, _validateNode.default)({
type: "FunctionExpression",
id,
params,
body,
generator,
async
});
}
function identifier(name) {
return (0, _validateNode.default)({
type: "Identifier",
name
});
}
function ifStatement(test, consequent, alternate = null) {
return (0, _validateNode.default)({
type: "IfStatement",
test,
consequent,
alternate
});
}
function labeledStatement(label, body) {
return (0, _validateNode.default)({
type: "LabeledStatement",
label,
body
});
}
function stringLiteral(value) {
return (0, _validateNode.default)({
type: "StringLiteral",
value
});
}
function numericLiteral(value) {
return (0, _validateNode.default)({
type: "NumericLiteral",
value
});
}
function nullLiteral() {
return {
type: "NullLiteral"
};
}
function booleanLiteral(value) {
return (0, _validateNode.default)({
type: "BooleanLiteral",
value
});
}
function regExpLiteral(pattern, flags = "") {
return (0, _validateNode.default)({
type: "RegExpLiteral",
pattern,
flags
});
}
function logicalExpression(operator, left, right) {
return (0, _validateNode.default)({
type: "LogicalExpression",
operator,
left,
right
});
}
function memberExpression(object, property, computed = false, optional = null) {
return (0, _validateNode.default)({
type: "MemberExpression",
object,
property,
computed,
optional
});
}
function newExpression(callee, _arguments) {
return (0, _validateNode.default)({
type: "NewExpression",
callee,
arguments: _arguments
});
}
function program(body, directives = [], sourceType = "script", interpreter = null) {
return (0, _validateNode.default)({
type: "Program",
body,
directives,
sourceType,
interpreter,
sourceFile: null
});
}
function objectExpression(properties) {
return (0, _validateNode.default)({
type: "ObjectExpression",
properties
});
}
function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
return (0, _validateNode.default)({
type: "ObjectMethod",
kind,
key,
params,
body,
computed,
generator,
async
});
}
function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
return (0, _validateNode.default)({
type: "ObjectProperty",
key,
value,
computed,
shorthand,
decorators
});
}
function restElement(argument) {
return (0, _validateNode.default)({
type: "RestElement",
argument
});
}
function returnStatement(argument = null) {
return (0, _validateNode.default)({
type: "ReturnStatement",
argument
});
}
function sequenceExpression(expressions) {
return (0, _validateNode.default)({
type: "SequenceExpression",
expressions
});
}
function parenthesizedExpression(expression) {
return (0, _validateNode.default)({
type: "ParenthesizedExpression",
expression
});
}
function switchCase(test = null, consequent) {
return (0, _validateNode.default)({
type: "SwitchCase",
test,
consequent
});
}
function switchStatement(discriminant, cases) {
return (0, _validateNode.default)({
type: "SwitchStatement",
discriminant,
cases
});
}
function thisExpression() {
return {
type: "ThisExpression"
};
}
function throwStatement(argument) {
return (0, _validateNode.default)({
type: "ThrowStatement",
argument
});
}
function tryStatement(block, handler = null, finalizer = null) {
return (0, _validateNode.default)({
type: "TryStatement",
block,
handler,
finalizer
});
}
function unaryExpression(operator, argument, prefix = true) {
return (0, _validateNode.default)({
type: "UnaryExpression",
operator,
argument,
prefix
});
}
function updateExpression(operator, argument, prefix = false) {
return (0, _validateNode.default)({
type: "UpdateExpression",
operator,
argument,
prefix
});
}
function variableDeclaration(kind, declarations) {
return (0, _validateNode.default)({
type: "VariableDeclaration",
kind,
declarations
});
}
function variableDeclarator(id, init = null) {
return (0, _validateNode.default)({
type: "VariableDeclarator",
id,
init
});
}
function whileStatement(test, body) {
return (0, _validateNode.default)({
type: "WhileStatement",
test,
body
});
}
function withStatement(object, body) {
return (0, _validateNode.default)({
type: "WithStatement",
object,
body
});
}
function assignmentPattern(left, right) {
return (0, _validateNode.default)({
type: "AssignmentPattern",
left,
right
});
}
function arrayPattern(elements) {
return (0, _validateNode.default)({
type: "ArrayPattern",
elements
});
}
function arrowFunctionExpression(params, body, async = false) {
return (0, _validateNode.default)({
type: "ArrowFunctionExpression",
params,
body,
async,
expression: null
});
}
function classBody(body) {
return (0, _validateNode.default)({
type: "ClassBody",
body
});
}
function classExpression(id = null, superClass = null, body, decorators = null) {
return (0, _validateNode.default)({
type: "ClassExpression",
id,
superClass,
body,
decorators
});
}
function classDeclaration(id = null, superClass = null, body, decorators = null) {
return (0, _validateNode.default)({
type: "ClassDeclaration",
id,
superClass,
body,
decorators
});
}
function exportAllDeclaration(source) {
return (0, _validateNode.default)({
type: "ExportAllDeclaration",
source
});
}
function exportDefaultDeclaration(declaration) {
return (0, _validateNode.default)({
type: "ExportDefaultDeclaration",
declaration
});
}
function exportNamedDeclaration(declaration = null, specifiers = [], source = null) {
return (0, _validateNode.default)({
type: "ExportNamedDeclaration",
declaration,
specifiers,
source
});
}
function exportSpecifier(local, exported) {
return (0, _validateNode.default)({
type: "ExportSpecifier",
local,
exported
});
}
function forOfStatement(left, right, body, _await = false) {
return (0, _validateNode.default)({
type: "ForOfStatement",
left,
right,
body,
await: _await
});
}
function importDeclaration(specifiers, source) {
return (0, _validateNode.default)({
type: "ImportDeclaration",
specifiers,
source
});
}
function importDefaultSpecifier(local) {
return (0, _validateNode.default)({
type: "ImportDefaultSpecifier",
local
});
}
function importNamespaceSpecifier(local) {
return (0, _validateNode.default)({
type: "ImportNamespaceSpecifier",
local
});
}
function importSpecifier(local, imported) {
return (0, _validateNode.default)({
type: "ImportSpecifier",
local,
imported
});
}
function importExpression(source, options = null) {
return (0, _validateNode.default)({
type: "ImportExpression",
source,
options
});
}
function metaProperty(meta, property) {
return (0, _validateNode.default)({
type: "MetaProperty",
meta,
property
});
}
function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
return (0, _validateNode.default)({
type: "ClassMethod",
kind,
key,
params,
body,
computed,
static: _static,
generator,
async
});
}
function objectPattern(properties) {
return (0, _validateNode.default)({
type: "ObjectPattern",
properties
});
}
function spreadElement(argument) {
return (0, _validateNode.default)({
type: "SpreadElement",
argument
});
}
function _super() {
return {
type: "Super"
};
}
function taggedTemplateExpression(tag, quasi) {
return (0, _validateNode.default)({
type: "TaggedTemplateExpression",
tag,
quasi
});
}
function templateElement(value, tail = false) {
return (0, _validateNode.default)({
type: "TemplateElement",
value,
tail
});
}
function templateLiteral(quasis, expressions) {
return (0, _validateNode.default)({
type: "TemplateLiteral",
quasis,
expressions
});
}
function yieldExpression(argument = null, delegate = false) {
return (0, _validateNode.default)({
type: "YieldExpression",
argument,
delegate
});
}
function awaitExpression(argument) {
return (0, _validateNode.default)({
type: "AwaitExpression",
argument
});
}
function _import() {
return {
type: "Import"
};
}
function bigIntLiteral(value) {
return (0, _validateNode.default)({
type: "BigIntLiteral",
value
});
}
function exportNamespaceSpecifier(exported) {
return (0, _validateNode.default)({
type: "ExportNamespaceSpecifier",
exported
});
}
function optionalMemberExpression(object, property, computed = false, optional) {
return (0, _validateNode.default)({
type: "OptionalMemberExpression",
object,
property,
computed,
optional
});
}
function optionalCallExpression(callee, _arguments, optional) {
return (0, _validateNode.default)({
type: "OptionalCallExpression",
callee,
arguments: _arguments,
optional
});
}
function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return (0, _validateNode.default)({
type: "ClassProperty",
key,
value,
typeAnnotation,
decorators,
computed,
static: _static
});
}
function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
return (0, _validateNode.default)({
type: "ClassAccessorProperty",
key,
value,
typeAnnotation,
decorators,
computed,
static: _static
});
}
function classPrivateProperty(key, value = null, decorators = null, _static = false) {
return (0, _validateNode.default)({
type: "ClassPrivateProperty",
key,
value,
decorators,
static: _static
});
}
function classPrivateMethod(kind = "method", key, params, body, _static = false) {
return (0, _validateNode.default)({
type: "ClassPrivateMethod",
kind,
key,
params,
body,
static: _static
});
}
function privateName(id) {
return (0, _validateNode.default)({
type: "PrivateName",
id
});
}
function staticBlock(body) {
return (0, _validateNode.default)({
type: "StaticBlock",
body
});
}
function anyTypeAnnotation() {
return {
type: "AnyTypeAnnotation"
};
}
function arrayTypeAnnotation(elementType) {
return (0, _validateNode.default)({
type: "ArrayTypeAnnotation",
elementType
});
}
function booleanTypeAnnotation() {
return {
type: "BooleanTypeAnnotation"
};
}
function booleanLiteralTypeAnnotation(value) {
return (0, _validateNode.default)({
type: "BooleanLiteralTypeAnnotation",
value
});
}
function nullLiteralTypeAnnotation() {
return {
type: "NullLiteralTypeAnnotation"
};
}
function classImplements(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "ClassImplements",
id,
typeParameters
});
}
function declareClass(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "DeclareClass",
id,
typeParameters,
extends: _extends,
body
});
}
function declareFunction(id) {
return (0, _validateNode.default)({
type: "DeclareFunction",
id
});
}
function declareInterface(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "DeclareInterface",
id,
typeParameters,
extends: _extends,
body
});
}
function declareModule(id, body, kind = null) {
return (0, _validateNode.default)({
type: "DeclareModule",
id,
body,
kind
});
}
function declareModuleExports(typeAnnotation) {
return (0, _validateNode.default)({
type: "DeclareModuleExports",
typeAnnotation
});
}
function declareTypeAlias(id, typeParameters = null, right) {
return (0, _validateNode.default)({
type: "DeclareTypeAlias",
id,
typeParameters,
right
});
}
function declareOpaqueType(id, typeParameters = null, supertype = null) {
return (0, _validateNode.default)({
type: "DeclareOpaqueType",
id,
typeParameters,
supertype
});
}
function declareVariable(id) {
return (0, _validateNode.default)({
type: "DeclareVariable",
id
});
}
function declareExportDeclaration(declaration = null, specifiers = null, source = null) {
return (0, _validateNode.default)({
type: "DeclareExportDeclaration",
declaration,
specifiers,
source
});
}
function declareExportAllDeclaration(source) {
return (0, _validateNode.default)({
type: "DeclareExportAllDeclaration",
source
});
}
function declaredPredicate(value) {
return (0, _validateNode.default)({
type: "DeclaredPredicate",
value
});
}
function existsTypeAnnotation() {
return {
type: "ExistsTypeAnnotation"
};
}
function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
return (0, _validateNode.default)({
type: "FunctionTypeAnnotation",
typeParameters,
params,
rest,
returnType
});
}
function functionTypeParam(name = null, typeAnnotation) {
return (0, _validateNode.default)({
type: "FunctionTypeParam",
name,
typeAnnotation
});
}
function genericTypeAnnotation(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "GenericTypeAnnotation",
id,
typeParameters
});
}
function inferredPredicate() {
return {
type: "InferredPredicate"
};
}
function interfaceExtends(id, typeParameters = null) {
return (0, _validateNode.default)({
type: "InterfaceExtends",
id,
typeParameters
});
}
function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "InterfaceDeclaration",
id,
typeParameters,
extends: _extends,
body
});
}
function interfaceTypeAnnotation(_extends = null, body) {
return (0, _validateNode.default)({
type: "InterfaceTypeAnnotation",
extends: _extends,
body
});
}
function intersectionTypeAnnotation(types) {
return (0, _validateNode.default)({
type: "IntersectionTypeAnnotation",
types
});
}
function mixedTypeAnnotation() {
return {
type: "MixedTypeAnnotation"
};
}
function emptyTypeAnnotation() {
return {
type: "EmptyTypeAnnotation"
};
}
function nullableTypeAnnotation(typeAnnotation) {
return (0, _validateNode.default)({
type: "NullableTypeAnnotation",
typeAnnotation
});
}
function numberLiteralTypeAnnotation(value) {
return (0, _validateNode.default)({
type: "NumberLiteralTypeAnnotation",
value
});
}
function numberTypeAnnotation() {
return {
type: "NumberTypeAnnotation"
};
}
function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
return (0, _validateNode.default)({
type: "ObjectTypeAnnotation",
properties,
indexers,
callProperties,
internalSlots,
exact
});
}
function objectTypeInternalSlot(id, value, optional, _static, method) {
return (0, _validateNode.default)({
type: "ObjectTypeInternalSlot",
id,
value,
optional,
static: _static,
method
});
}
function objectTypeCallProperty(value) {
return (0, _validateNode.default)({
type: "ObjectTypeCallProperty",
value,
static: null
});
}
function objectTypeIndexer(id = null, key, value, variance = null) {
return (0, _validateNode.default)({
type: "ObjectTypeIndexer",
id,
key,
value,
variance,
static: null
});
}
function objectTypeProperty(key, value, variance = null) {
return (0, _validateNode.default)({
type: "ObjectTypeProperty",
key,
value,
variance,
kind: null,
method: null,
optional: null,
proto: null,
static: null
});
}
function objectTypeSpreadProperty(argument) {
return (0, _validateNode.default)({
type: "ObjectTypeSpreadProperty",
argument
});
}
function opaqueType(id, typeParameters = null, supertype = null, impltype) {
return (0, _validateNode.default)({
type: "OpaqueType",
id,
typeParameters,
supertype,
impltype
});
}
function qualifiedTypeIdentifier(id, qualification) {
return (0, _validateNode.default)({
type: "QualifiedTypeIdentifier",
id,
qualification
});
}
function stringLiteralTypeAnnotation(value) {
return (0, _validateNode.default)({
type: "StringLiteralTypeAnnotation",
value
});
}
function stringTypeAnnotation() {
return {
type: "StringTypeAnnotation"
};
}
function symbolTypeAnnotation() {
return {
type: "SymbolTypeAnnotation"
};
}
function thisTypeAnnotation() {
return {
type: "ThisTypeAnnotation"
};
}
function tupleTypeAnnotation(types) {
return (0, _validateNode.default)({
type: "TupleTypeAnnotation",
types
});
}
function typeofTypeAnnotation(argument) {
return (0, _validateNode.default)({
type: "TypeofTypeAnnotation",
argument
});
}
function typeAlias(id, typeParameters = null, right) {
return (0, _validateNode.default)({
type: "TypeAlias",
id,
typeParameters,
right
});
}
function typeAnnotation(typeAnnotation) {
return (0, _validateNode.default)({
type: "TypeAnnotation",
typeAnnotation
});
}
function typeCastExpression(expression, typeAnnotation) {
return (0, _validateNode.default)({
type: "TypeCastExpression",
expression,
typeAnnotation
});
}
function typeParameter(bound = null, _default = null, variance = null) {
return (0, _validateNode.default)({
type: "TypeParameter",
bound,
default: _default,
variance,
name: null
});
}
function typeParameterDeclaration(params) {
return (0, _validateNode.default)({
type: "TypeParameterDeclaration",
params
});
}
function typeParameterInstantiation(params) {
return (0, _validateNode.default)({
type: "TypeParameterInstantiation",
params
});
}
function unionTypeAnnotation(types) {
return (0, _validateNode.default)({
type: "UnionTypeAnnotation",
types
});
}
function variance(kind) {
return (0, _validateNode.default)({
type: "Variance",
kind
});
}
function voidTypeAnnotation() {
return {
type: "VoidTypeAnnotation"
};
}
function enumDeclaration(id, body) {
return (0, _validateNode.default)({
type: "EnumDeclaration",
id,
body
});
}
function enumBooleanBody(members) {
return (0, _validateNode.default)({
type: "EnumBooleanBody",
members,
explicitType: null,
hasUnknownMembers: null
});
}
function enumNumberBody(members) {
return (0, _validateNode.default)({
type: "EnumNumberBody",
members,
explicitType: null,
hasUnknownMembers: null
});
}
function enumStringBody(members) {
return (0, _validateNode.default)({
type: "EnumStringBody",
members,
explicitType: null,
hasUnknownMembers: null
});
}
function enumSymbolBody(members) {
return (0, _validateNode.default)({
type: "EnumSymbolBody",
members,
hasUnknownMembers: null
});
}
function enumBooleanMember(id) {
return (0, _validateNode.default)({
type: "EnumBooleanMember",
id,
init: null
});
}
function enumNumberMember(id, init) {
return (0, _validateNode.default)({
type: "EnumNumberMember",
id,
init
});
}
function enumStringMember(id, init) {
return (0, _validateNode.default)({
type: "EnumStringMember",
id,
init
});
}
function enumDefaultedMember(id) {
return (0, _validateNode.default)({
type: "EnumDefaultedMember",
id
});
}
function indexedAccessType(objectType, indexType) {
return (0, _validateNode.default)({
type: "IndexedAccessType",
objectType,
indexType
});
}
function optionalIndexedAccessType(objectType, indexType) {
return (0, _validateNode.default)({
type: "OptionalIndexedAccessType",
objectType,
indexType,
optional: null
});
}
function jsxAttribute(name, value = null) {
return (0, _validateNode.default)({
type: "JSXAttribute",
name,
value
});
}
function jsxClosingElement(name) {
return (0, _validateNode.default)({
type: "JSXClosingElement",
name
});
}
function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
return (0, _validateNode.default)({
type: "JSXElement",
openingElement,
closingElement,
children,
selfClosing
});
}
function jsxEmptyExpression() {
return {
type: "JSXEmptyExpression"
};
}
function jsxExpressionContainer(expression) {
return (0, _validateNode.default)({
type: "JSXExpressionContainer",
expression
});
}
function jsxSpreadChild(expression) {
return (0, _validateNode.default)({
type: "JSXSpreadChild",
expression
});
}
function jsxIdentifier(name) {
return (0, _validateNode.default)({
type: "JSXIdentifier",
name
});
}
function jsxMemberExpression(object, property) {
return (0, _validateNode.default)({
type: "JSXMemberExpression",
object,
property
});
}
function jsxNamespacedName(namespace, name) {
return (0, _validateNode.default)({
type: "JSXNamespacedName",
namespace,
name
});
}
function jsxOpeningElement(name, attributes, selfClosing = false) {
return (0, _validateNode.default)({
type: "JSXOpeningElement",
name,
attributes,
selfClosing
});
}
function jsxSpreadAttribute(argument) {
return (0, _validateNode.default)({
type: "JSXSpreadAttribute",
argument
});
}
function jsxText(value) {
return (0, _validateNode.default)({
type: "JSXText",
value
});
}
function jsxFragment(openingFragment, closingFragment, children) {
return (0, _validateNode.default)({
type: "JSXFragment",
openingFragment,
closingFragment,
children
});
}
function jsxOpeningFragment() {
return {
type: "JSXOpeningFragment"
};
}
function jsxClosingFragment() {
return {
type: "JSXClosingFragment"
};
}
function noop() {
return {
type: "Noop"
};
}
function placeholder(expectedNode, name) {
return (0, _validateNode.default)({
type: "Placeholder",
expectedNode,
name
});
}
function v8IntrinsicIdentifier(name) {
return (0, _validateNode.default)({
type: "V8IntrinsicIdentifier",
name
});
}
function argumentPlaceholder() {
return {
type: "ArgumentPlaceholder"
};
}
function bindExpression(object, callee) {
return (0, _validateNode.default)({
type: "BindExpression",
object,
callee
});
}
function importAttribute(key, value) {
return (0, _validateNode.default)({
type: "ImportAttribute",
key,
value
});
}
function decorator(expression) {
return (0, _validateNode.default)({
type: "Decorator",
expression
});
}
function doExpression(body, async = false) {
return (0, _validateNode.default)({
type: "DoExpression",
body,
async
});
}
function exportDefaultSpecifier(exported) {
return (0, _validateNode.default)({
type: "ExportDefaultSpecifier",
exported
});
}
function recordExpression(properties) {
return (0, _validateNode.default)({
type: "RecordExpression",
properties
});
}
function tupleExpression(elements = []) {
return (0, _validateNode.default)({
type: "TupleExpression",
elements
});
}
function decimalLiteral(value) {
return (0, _validateNode.default)({
type: "DecimalLiteral",
value
});
}
function moduleExpression(body) {
return (0, _validateNode.default)({
type: "ModuleExpression",
body
});
}
function topicReference() {
return {
type: "TopicReference"
};
}
function pipelineTopicExpression(expression) {
return (0, _validateNode.default)({
type: "PipelineTopicExpression",
expression
});
}
function pipelineBareFunction(callee) {
return (0, _validateNode.default)({
type: "PipelineBareFunction",
callee
});
}
function pipelinePrimaryTopicReference() {
return {
type: "PipelinePrimaryTopicReference"
};
}
function tsParameterProperty(parameter) {
return (0, _validateNode.default)({
type: "TSParameterProperty",
parameter
});
}
function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
return (0, _validateNode.default)({
type: "TSDeclareFunction",
id,
typeParameters,
params,
returnType
});
}
function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
return (0, _validateNode.default)({
type: "TSDeclareMethod",
decorators,
key,
typeParameters,
params,
returnType
});
}
function tsQualifiedName(left, right) {
return (0, _validateNode.default)({
type: "TSQualifiedName",
left,
right
});
}
function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSCallSignatureDeclaration",
typeParameters,
parameters,
typeAnnotation
});
}
function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSConstructSignatureDeclaration",
typeParameters,
parameters,
typeAnnotation
});
}
function tsPropertySignature(key, typeAnnotation = null, initializer = null) {
return (0, _validateNode.default)({
type: "TSPropertySignature",
key,
typeAnnotation,
initializer,
kind: null
});
}
function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSMethodSignature",
key,
typeParameters,
parameters,
typeAnnotation,
kind: null
});
}
function tsIndexSignature(parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSIndexSignature",
parameters,
typeAnnotation
});
}
function tsAnyKeyword() {
return {
type: "TSAnyKeyword"
};
}
function tsBooleanKeyword() {
return {
type: "TSBooleanKeyword"
};
}
function tsBigIntKeyword() {
return {
type: "TSBigIntKeyword"
};
}
function tsIntrinsicKeyword() {
return {
type: "TSIntrinsicKeyword"
};
}
function tsNeverKeyword() {
return {
type: "TSNeverKeyword"
};
}
function tsNullKeyword() {
return {
type: "TSNullKeyword"
};
}
function tsNumberKeyword() {
return {
type: "TSNumberKeyword"
};
}
function tsObjectKeyword() {
return {
type: "TSObjectKeyword"
};
}
function tsStringKeyword() {
return {
type: "TSStringKeyword"
};
}
function tsSymbolKeyword() {
return {
type: "TSSymbolKeyword"
};
}
function tsUndefinedKeyword() {
return {
type: "TSUndefinedKeyword"
};
}
function tsUnknownKeyword() {
return {
type: "TSUnknownKeyword"
};
}
function tsVoidKeyword() {
return {
type: "TSVoidKeyword"
};
}
function tsThisType() {
return {
type: "TSThisType"
};
}
function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSFunctionType",
typeParameters,
parameters,
typeAnnotation
});
}
function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {
return (0, _validateNode.default)({
type: "TSConstructorType",
typeParameters,
parameters,
typeAnnotation
});
}
function tsTypeReference(typeName, typeParameters = null) {
return (0, _validateNode.default)({
type: "TSTypeReference",
typeName,
typeParameters
});
}
function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {
return (0, _validateNode.default)({
type: "TSTypePredicate",
parameterName,
typeAnnotation,
asserts
});
}
function tsTypeQuery(exprName, typeParameters = null) {
return (0, _validateNode.default)({
type: "TSTypeQuery",
exprName,
typeParameters
});
}
function tsTypeLiteral(members) {
return (0, _validateNode.default)({
type: "TSTypeLiteral",
members
});
}
function tsArrayType(elementType) {
return (0, _validateNode.default)({
type: "TSArrayType",
elementType
});
}
function tsTupleType(elementTypes) {
return (0, _validateNode.default)({
type: "TSTupleType",
elementTypes
});
}
function tsOptionalType(typeAnnotation) {
return (0, _validateNode.default)({
type: "TSOptionalType",
typeAnnotation
});
}
function tsRestType(typeAnnotation) {
return (0, _validateNode.default)({
type: "TSRestType",
typeAnnotation
});
}
function tsNamedTupleMember(label, elementType, optional = false) {
return (0, _validateNode.default)({
type: "TSNamedTupleMember",
label,
elementType,
optional
});
}
function tsUnionType(types) {
return (0, _validateNode.default)({
type: "TSUnionType",
types
});
}
function tsIntersectionType(types) {
return (0, _validateNode.default)({
type: "TSIntersectionType",
types
});
}
function tsConditionalType(checkType, extendsType, trueType, falseType) {
return (0, _validateNode.default)({
type: "TSConditionalType",
checkType,
extendsType,
trueType,
falseType
});
}
function tsInferType(typeParameter) {
return (0, _validateNode.default)({
type: "TSInferType",
typeParameter
});
}
function tsParenthesizedType(typeAnnotation) {
return (0, _validateNode.default)({
type: "TSParenthesizedType",
typeAnnotation
});
}
function tsTypeOperator(typeAnnotation) {
return (0, _validateNode.default)({
type: "TSTypeOperator",
typeAnnotation,
operator: null
});
}
function tsIndexedAccessType(objectType, indexType) {
return (0, _validateNode.default)({
type: "TSIndexedAccessType",
objectType,
indexType
});
}
function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {
return (0, _validateNode.default)({
type: "TSMappedType",
typeParameter,
typeAnnotation,
nameType
});
}
function tsLiteralType(literal) {
return (0, _validateNode.default)({
type: "TSLiteralType",
literal
});
}
function tsExpressionWithTypeArguments(expression, typeParameters = null) {
return (0, _validateNode.default)({
type: "TSExpressionWithTypeArguments",
expression,
typeParameters
});
}
function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
return (0, _validateNode.default)({
type: "TSInterfaceDeclaration",
id,
typeParameters,
extends: _extends,
body
});
}
function tsInterfaceBody(body) {
return (0, _validateNode.default)({
type: "TSInterfaceBody",
body
});
}
function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {
return (0, _validateNode.default)({
type: "TSTypeAliasDeclaration",
id,
typeParameters,
typeAnnotation
});
}
function tsInstantiationExpression(expression, typeParameters = null) {
return (0, _validateNode.default)({
type: "TSInstantiationExpression",
expression,
typeParameters
});
}
function tsAsExpression(expression, typeAnnotation) {
return (0, _validateNode.default)({
type: "TSAsExpression",
expression,
typeAnnotation
});
}
function tsSatisfiesExpression(expression, typeAnnotation) {
return (0, _validateNode.default)({
type: "TSSatisfiesExpression",
expression,
typeAnnotation
});
}
function tsTypeAssertion(typeAnnotation, expression) {
return (0, _validateNode.default)({
type: "TSTypeAssertion",
typeAnnotation,
expression
});
}
function tsEnumDeclaration(id, members) {
return (0, _validateNode.default)({
type: "TSEnumDeclaration",
id,
members
});
}
function tsEnumMember(id, initializer = null) {
return (0, _validateNode.default)({
type: "TSEnumMember",
id,
initializer
});
}
function tsModuleDeclaration(id, body) {
return (0, _validateNode.default)({
type: "TSModuleDeclaration",
id,
body
});
}
function tsModuleBlock(body) {
return (0, _validateNode.default)({
type: "TSModuleBlock",
body
});
}
function tsImportType(argument, qualifier = null, typeParameters = null) {
return (0, _validateNode.default)({
type: "TSImportType",
argument,
qualifier,
typeParameters
});
}
function tsImportEqualsDeclaration(id, moduleReference) {
return (0, _validateNode.default)({
type: "TSImportEqualsDeclaration",
id,
moduleReference,
isExport: null
});
}
function tsExternalModuleReference(expression) {
return (0, _validateNode.default)({
type: "TSExternalModuleReference",
expression
});
}
function tsNonNullExpression(expression) {
return (0, _validateNode.default)({
type: "TSNonNullExpression",
expression
});
}
function tsExportAssignment(expression) {
return (0, _validateNode.default)({
type: "TSExportAssignment",
expression
});
}
function tsNamespaceExportDeclaration(id) {
return (0, _validateNode.default)({
type: "TSNamespaceExportDeclaration",
id
});
}
function tsTypeAnnotation(typeAnnotation) {
return (0, _validateNode.default)({
type: "TSTypeAnnotation",
typeAnnotation
});
}
function tsTypeParameterInstantiation(params) {
return (0, _validateNode.default)({
type: "TSTypeParameterInstantiation",
params
});
}
function tsTypeParameterDeclaration(params) {
return (0, _validateNode.default)({
type: "TSTypeParameterDeclaration",
params
});
}
function tsTypeParameter(constraint = null, _default = null, name) {
return (0, _validateNode.default)({
type: "TSTypeParameter",
constraint,
default: _default,
name
});
}
function NumberLiteral(value) {
(0, _deprecationWarning.default)("NumberLiteral", "NumericLiteral", "The node type ");
return numericLiteral(value);
}
function RegexLiteral(pattern, flags = "") {
(0, _deprecationWarning.default)("RegexLiteral", "RegExpLiteral", "The node type ");
return regExpLiteral(pattern, flags);
}
function RestProperty(argument) {
(0, _deprecationWarning.default)("RestProperty", "RestElement", "The node type ");
return restElement(argument);
}
function SpreadProperty(argument) {
(0, _deprecationWarning.default)("SpreadProperty", "SpreadElement", "The node type ");
return spreadElement(argument);
}
return generated$2;
}
var hasRequiredCleanJSXElementLiteralChild;
function requireCleanJSXElementLiteralChild () {
if (hasRequiredCleanJSXElementLiteralChild) return cleanJSXElementLiteralChild;
hasRequiredCleanJSXElementLiteralChild = 1;
Object.defineProperty(cleanJSXElementLiteralChild, "__esModule", {
value: true
});
cleanJSXElementLiteralChild.default = cleanJSXElementLiteralChild$1;
var _index = requireGenerated$2();
var _index2 = requireLib$2();
function cleanJSXElementLiteralChild$1(child, args) {
const lines = child.value.split(/\r\n|\n|\r/);
let lastNonEmptyLine = 0;
for (let i = 0; i < lines.length; i++) {
if (lines[i].match(/[^ \t]/)) {
lastNonEmptyLine = i;
}
}
let str = "";
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
const isFirstLine = i === 0;
const isLastLine = i === lines.length - 1;
const isLastNonEmptyLine = i === lastNonEmptyLine;
let trimmedLine = line.replace(/\t/g, " ");
if (!isFirstLine) {
trimmedLine = trimmedLine.replace(/^[ ]+/, "");
}
if (!isLastLine) {
trimmedLine = trimmedLine.replace(/[ ]+$/, "");
}
if (trimmedLine) {
if (!isLastNonEmptyLine) {
trimmedLine += " ";
}
str += trimmedLine;
}
}
if (str) args.push((0, _index2.inherits)((0, _index.stringLiteral)(str), child));
}
return cleanJSXElementLiteralChild;
}
var hasRequiredBuildChildren;
function requireBuildChildren () {
if (hasRequiredBuildChildren) return buildChildren;
hasRequiredBuildChildren = 1;
Object.defineProperty(buildChildren, "__esModule", {
value: true
});
buildChildren.default = buildChildren$1;
var _index = requireGenerated$3();
var _cleanJSXElementLiteralChild = requireCleanJSXElementLiteralChild();
function buildChildren$1(node) {
const elements = [];
for (let i = 0; i < node.children.length; i++) {
let child = node.children[i];
if ((0, _index.isJSXText)(child)) {
(0, _cleanJSXElementLiteralChild.default)(child, elements);
continue;
}
if ((0, _index.isJSXExpressionContainer)(child)) child = child.expression;
if ((0, _index.isJSXEmptyExpression)(child)) continue;
elements.push(child);
}
return elements;
}
return buildChildren;
}
var assertNode = {};
var isNode$1 = {};
var hasRequiredIsNode;
function requireIsNode () {
if (hasRequiredIsNode) return isNode$1;
hasRequiredIsNode = 1;
Object.defineProperty(isNode$1, "__esModule", {
value: true
});
isNode$1.default = isNode;
var _index = requireDefinitions();
function isNode(node) {
return !!(node && _index.VISITOR_KEYS[node.type]);
}
return isNode$1;
}
var hasRequiredAssertNode;
function requireAssertNode () {
if (hasRequiredAssertNode) return assertNode;
hasRequiredAssertNode = 1;
Object.defineProperty(assertNode, "__esModule", {
value: true
});
assertNode.default = assertNode$1;
var _isNode = requireIsNode();
function assertNode$1(node) {
if (!(0, _isNode.default)(node)) {
var _node$type;
const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
throw new TypeError(`Not a valid node of type "${type}"`);
}
}
return assertNode;
}
var generated$1 = {};
var hasRequiredGenerated$1;
function requireGenerated$1 () {
if (hasRequiredGenerated$1) return generated$1;
hasRequiredGenerated$1 = 1;
Object.defineProperty(generated$1, "__esModule", {
value: true
});
generated$1.assertAccessor = assertAccessor;
generated$1.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
generated$1.assertArgumentPlaceholder = assertArgumentPlaceholder;
generated$1.assertArrayExpression = assertArrayExpression;
generated$1.assertArrayPattern = assertArrayPattern;
generated$1.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
generated$1.assertArrowFunctionExpression = assertArrowFunctionExpression;
generated$1.assertAssignmentExpression = assertAssignmentExpression;
generated$1.assertAssignmentPattern = assertAssignmentPattern;
generated$1.assertAwaitExpression = assertAwaitExpression;
generated$1.assertBigIntLiteral = assertBigIntLiteral;
generated$1.assertBinary = assertBinary;
generated$1.assertBinaryExpression = assertBinaryExpression;
generated$1.assertBindExpression = assertBindExpression;
generated$1.assertBlock = assertBlock;
generated$1.assertBlockParent = assertBlockParent;
generated$1.assertBlockStatement = assertBlockStatement;
generated$1.assertBooleanLiteral = assertBooleanLiteral;
generated$1.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
generated$1.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
generated$1.assertBreakStatement = assertBreakStatement;
generated$1.assertCallExpression = assertCallExpression;
generated$1.assertCatchClause = assertCatchClause;
generated$1.assertClass = assertClass;
generated$1.assertClassAccessorProperty = assertClassAccessorProperty;
generated$1.assertClassBody = assertClassBody;
generated$1.assertClassDeclaration = assertClassDeclaration;
generated$1.assertClassExpression = assertClassExpression;
generated$1.assertClassImplements = assertClassImplements;
generated$1.assertClassMethod = assertClassMethod;
generated$1.assertClassPrivateMethod = assertClassPrivateMethod;
generated$1.assertClassPrivateProperty = assertClassPrivateProperty;
generated$1.assertClassProperty = assertClassProperty;
generated$1.assertCompletionStatement = assertCompletionStatement;
generated$1.assertConditional = assertConditional;
generated$1.assertConditionalExpression = assertConditionalExpression;
generated$1.assertContinueStatement = assertContinueStatement;
generated$1.assertDebuggerStatement = assertDebuggerStatement;
generated$1.assertDecimalLiteral = assertDecimalLiteral;
generated$1.assertDeclaration = assertDeclaration;
generated$1.assertDeclareClass = assertDeclareClass;
generated$1.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
generated$1.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
generated$1.assertDeclareFunction = assertDeclareFunction;
generated$1.assertDeclareInterface = assertDeclareInterface;
generated$1.assertDeclareModule = assertDeclareModule;
generated$1.assertDeclareModuleExports = assertDeclareModuleExports;
generated$1.assertDeclareOpaqueType = assertDeclareOpaqueType;
generated$1.assertDeclareTypeAlias = assertDeclareTypeAlias;
generated$1.assertDeclareVariable = assertDeclareVariable;
generated$1.assertDeclaredPredicate = assertDeclaredPredicate;
generated$1.assertDecorator = assertDecorator;
generated$1.assertDirective = assertDirective;
generated$1.assertDirectiveLiteral = assertDirectiveLiteral;
generated$1.assertDoExpression = assertDoExpression;
generated$1.assertDoWhileStatement = assertDoWhileStatement;
generated$1.assertEmptyStatement = assertEmptyStatement;
generated$1.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
generated$1.assertEnumBody = assertEnumBody;
generated$1.assertEnumBooleanBody = assertEnumBooleanBody;
generated$1.assertEnumBooleanMember = assertEnumBooleanMember;
generated$1.assertEnumDeclaration = assertEnumDeclaration;
generated$1.assertEnumDefaultedMember = assertEnumDefaultedMember;
generated$1.assertEnumMember = assertEnumMember;
generated$1.assertEnumNumberBody = assertEnumNumberBody;
generated$1.assertEnumNumberMember = assertEnumNumberMember;
generated$1.assertEnumStringBody = assertEnumStringBody;
generated$1.assertEnumStringMember = assertEnumStringMember;
generated$1.assertEnumSymbolBody = assertEnumSymbolBody;
generated$1.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
generated$1.assertExportAllDeclaration = assertExportAllDeclaration;
generated$1.assertExportDeclaration = assertExportDeclaration;
generated$1.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
generated$1.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
generated$1.assertExportNamedDeclaration = assertExportNamedDeclaration;
generated$1.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
generated$1.assertExportSpecifier = assertExportSpecifier;
generated$1.assertExpression = assertExpression;
generated$1.assertExpressionStatement = assertExpressionStatement;
generated$1.assertExpressionWrapper = assertExpressionWrapper;
generated$1.assertFile = assertFile;
generated$1.assertFlow = assertFlow;
generated$1.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
generated$1.assertFlowDeclaration = assertFlowDeclaration;
generated$1.assertFlowPredicate = assertFlowPredicate;
generated$1.assertFlowType = assertFlowType;
generated$1.assertFor = assertFor;
generated$1.assertForInStatement = assertForInStatement;
generated$1.assertForOfStatement = assertForOfStatement;
generated$1.assertForStatement = assertForStatement;
generated$1.assertForXStatement = assertForXStatement;
generated$1.assertFunction = assertFunction;
generated$1.assertFunctionDeclaration = assertFunctionDeclaration;
generated$1.assertFunctionExpression = assertFunctionExpression;
generated$1.assertFunctionParent = assertFunctionParent;
generated$1.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
generated$1.assertFunctionTypeParam = assertFunctionTypeParam;
generated$1.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
generated$1.assertIdentifier = assertIdentifier;
generated$1.assertIfStatement = assertIfStatement;
generated$1.assertImmutable = assertImmutable;
generated$1.assertImport = assertImport;
generated$1.assertImportAttribute = assertImportAttribute;
generated$1.assertImportDeclaration = assertImportDeclaration;
generated$1.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
generated$1.assertImportExpression = assertImportExpression;
generated$1.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
generated$1.assertImportOrExportDeclaration = assertImportOrExportDeclaration;
generated$1.assertImportSpecifier = assertImportSpecifier;
generated$1.assertIndexedAccessType = assertIndexedAccessType;
generated$1.assertInferredPredicate = assertInferredPredicate;
generated$1.assertInterfaceDeclaration = assertInterfaceDeclaration;
generated$1.assertInterfaceExtends = assertInterfaceExtends;
generated$1.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
generated$1.assertInterpreterDirective = assertInterpreterDirective;
generated$1.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
generated$1.assertJSX = assertJSX;
generated$1.assertJSXAttribute = assertJSXAttribute;
generated$1.assertJSXClosingElement = assertJSXClosingElement;
generated$1.assertJSXClosingFragment = assertJSXClosingFragment;
generated$1.assertJSXElement = assertJSXElement;
generated$1.assertJSXEmptyExpression = assertJSXEmptyExpression;
generated$1.assertJSXExpressionContainer = assertJSXExpressionContainer;
generated$1.assertJSXFragment = assertJSXFragment;
generated$1.assertJSXIdentifier = assertJSXIdentifier;
generated$1.assertJSXMemberExpression = assertJSXMemberExpression;
generated$1.assertJSXNamespacedName = assertJSXNamespacedName;
generated$1.assertJSXOpeningElement = assertJSXOpeningElement;
generated$1.assertJSXOpeningFragment = assertJSXOpeningFragment;
generated$1.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
generated$1.assertJSXSpreadChild = assertJSXSpreadChild;
generated$1.assertJSXText = assertJSXText;
generated$1.assertLVal = assertLVal;
generated$1.assertLabeledStatement = assertLabeledStatement;
generated$1.assertLiteral = assertLiteral;
generated$1.assertLogicalExpression = assertLogicalExpression;
generated$1.assertLoop = assertLoop;
generated$1.assertMemberExpression = assertMemberExpression;
generated$1.assertMetaProperty = assertMetaProperty;
generated$1.assertMethod = assertMethod;
generated$1.assertMiscellaneous = assertMiscellaneous;
generated$1.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
generated$1.assertModuleDeclaration = assertModuleDeclaration;
generated$1.assertModuleExpression = assertModuleExpression;
generated$1.assertModuleSpecifier = assertModuleSpecifier;
generated$1.assertNewExpression = assertNewExpression;
generated$1.assertNoop = assertNoop;
generated$1.assertNullLiteral = assertNullLiteral;
generated$1.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
generated$1.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
generated$1.assertNumberLiteral = assertNumberLiteral;
generated$1.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
generated$1.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
generated$1.assertNumericLiteral = assertNumericLiteral;
generated$1.assertObjectExpression = assertObjectExpression;
generated$1.assertObjectMember = assertObjectMember;
generated$1.assertObjectMethod = assertObjectMethod;
generated$1.assertObjectPattern = assertObjectPattern;
generated$1.assertObjectProperty = assertObjectProperty;
generated$1.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
generated$1.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
generated$1.assertObjectTypeIndexer = assertObjectTypeIndexer;
generated$1.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
generated$1.assertObjectTypeProperty = assertObjectTypeProperty;
generated$1.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
generated$1.assertOpaqueType = assertOpaqueType;
generated$1.assertOptionalCallExpression = assertOptionalCallExpression;
generated$1.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
generated$1.assertOptionalMemberExpression = assertOptionalMemberExpression;
generated$1.assertParenthesizedExpression = assertParenthesizedExpression;
generated$1.assertPattern = assertPattern;
generated$1.assertPatternLike = assertPatternLike;
generated$1.assertPipelineBareFunction = assertPipelineBareFunction;
generated$1.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
generated$1.assertPipelineTopicExpression = assertPipelineTopicExpression;
generated$1.assertPlaceholder = assertPlaceholder;
generated$1.assertPrivate = assertPrivate;
generated$1.assertPrivateName = assertPrivateName;
generated$1.assertProgram = assertProgram;
generated$1.assertProperty = assertProperty;
generated$1.assertPureish = assertPureish;
generated$1.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
generated$1.assertRecordExpression = assertRecordExpression;
generated$1.assertRegExpLiteral = assertRegExpLiteral;
generated$1.assertRegexLiteral = assertRegexLiteral;
generated$1.assertRestElement = assertRestElement;
generated$1.assertRestProperty = assertRestProperty;
generated$1.assertReturnStatement = assertReturnStatement;
generated$1.assertScopable = assertScopable;
generated$1.assertSequenceExpression = assertSequenceExpression;
generated$1.assertSpreadElement = assertSpreadElement;
generated$1.assertSpreadProperty = assertSpreadProperty;
generated$1.assertStandardized = assertStandardized;
generated$1.assertStatement = assertStatement;
generated$1.assertStaticBlock = assertStaticBlock;
generated$1.assertStringLiteral = assertStringLiteral;
generated$1.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
generated$1.assertStringTypeAnnotation = assertStringTypeAnnotation;
generated$1.assertSuper = assertSuper;
generated$1.assertSwitchCase = assertSwitchCase;
generated$1.assertSwitchStatement = assertSwitchStatement;
generated$1.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
generated$1.assertTSAnyKeyword = assertTSAnyKeyword;
generated$1.assertTSArrayType = assertTSArrayType;
generated$1.assertTSAsExpression = assertTSAsExpression;
generated$1.assertTSBaseType = assertTSBaseType;
generated$1.assertTSBigIntKeyword = assertTSBigIntKeyword;
generated$1.assertTSBooleanKeyword = assertTSBooleanKeyword;
generated$1.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
generated$1.assertTSConditionalType = assertTSConditionalType;
generated$1.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
generated$1.assertTSConstructorType = assertTSConstructorType;
generated$1.assertTSDeclareFunction = assertTSDeclareFunction;
generated$1.assertTSDeclareMethod = assertTSDeclareMethod;
generated$1.assertTSEntityName = assertTSEntityName;
generated$1.assertTSEnumDeclaration = assertTSEnumDeclaration;
generated$1.assertTSEnumMember = assertTSEnumMember;
generated$1.assertTSExportAssignment = assertTSExportAssignment;
generated$1.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
generated$1.assertTSExternalModuleReference = assertTSExternalModuleReference;
generated$1.assertTSFunctionType = assertTSFunctionType;
generated$1.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
generated$1.assertTSImportType = assertTSImportType;
generated$1.assertTSIndexSignature = assertTSIndexSignature;
generated$1.assertTSIndexedAccessType = assertTSIndexedAccessType;
generated$1.assertTSInferType = assertTSInferType;
generated$1.assertTSInstantiationExpression = assertTSInstantiationExpression;
generated$1.assertTSInterfaceBody = assertTSInterfaceBody;
generated$1.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
generated$1.assertTSIntersectionType = assertTSIntersectionType;
generated$1.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
generated$1.assertTSLiteralType = assertTSLiteralType;
generated$1.assertTSMappedType = assertTSMappedType;
generated$1.assertTSMethodSignature = assertTSMethodSignature;
generated$1.assertTSModuleBlock = assertTSModuleBlock;
generated$1.assertTSModuleDeclaration = assertTSModuleDeclaration;
generated$1.assertTSNamedTupleMember = assertTSNamedTupleMember;
generated$1.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
generated$1.assertTSNeverKeyword = assertTSNeverKeyword;
generated$1.assertTSNonNullExpression = assertTSNonNullExpression;
generated$1.assertTSNullKeyword = assertTSNullKeyword;
generated$1.assertTSNumberKeyword = assertTSNumberKeyword;
generated$1.assertTSObjectKeyword = assertTSObjectKeyword;
generated$1.assertTSOptionalType = assertTSOptionalType;
generated$1.assertTSParameterProperty = assertTSParameterProperty;
generated$1.assertTSParenthesizedType = assertTSParenthesizedType;
generated$1.assertTSPropertySignature = assertTSPropertySignature;
generated$1.assertTSQualifiedName = assertTSQualifiedName;
generated$1.assertTSRestType = assertTSRestType;
generated$1.assertTSSatisfiesExpression = assertTSSatisfiesExpression;
generated$1.assertTSStringKeyword = assertTSStringKeyword;
generated$1.assertTSSymbolKeyword = assertTSSymbolKeyword;
generated$1.assertTSThisType = assertTSThisType;
generated$1.assertTSTupleType = assertTSTupleType;
generated$1.assertTSType = assertTSType;
generated$1.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
generated$1.assertTSTypeAnnotation = assertTSTypeAnnotation;
generated$1.assertTSTypeAssertion = assertTSTypeAssertion;
generated$1.assertTSTypeElement = assertTSTypeElement;
generated$1.assertTSTypeLiteral = assertTSTypeLiteral;
generated$1.assertTSTypeOperator = assertTSTypeOperator;
generated$1.assertTSTypeParameter = assertTSTypeParameter;
generated$1.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
generated$1.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
generated$1.assertTSTypePredicate = assertTSTypePredicate;
generated$1.assertTSTypeQuery = assertTSTypeQuery;
generated$1.assertTSTypeReference = assertTSTypeReference;
generated$1.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
generated$1.assertTSUnionType = assertTSUnionType;
generated$1.assertTSUnknownKeyword = assertTSUnknownKeyword;
generated$1.assertTSVoidKeyword = assertTSVoidKeyword;
generated$1.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
generated$1.assertTemplateElement = assertTemplateElement;
generated$1.assertTemplateLiteral = assertTemplateLiteral;
generated$1.assertTerminatorless = assertTerminatorless;
generated$1.assertThisExpression = assertThisExpression;
generated$1.assertThisTypeAnnotation = assertThisTypeAnnotation;
generated$1.assertThrowStatement = assertThrowStatement;
generated$1.assertTopicReference = assertTopicReference;
generated$1.assertTryStatement = assertTryStatement;
generated$1.assertTupleExpression = assertTupleExpression;
generated$1.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
generated$1.assertTypeAlias = assertTypeAlias;
generated$1.assertTypeAnnotation = assertTypeAnnotation;
generated$1.assertTypeCastExpression = assertTypeCastExpression;
generated$1.assertTypeParameter = assertTypeParameter;
generated$1.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
generated$1.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
generated$1.assertTypeScript = assertTypeScript;
generated$1.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
generated$1.assertUnaryExpression = assertUnaryExpression;
generated$1.assertUnaryLike = assertUnaryLike;
generated$1.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
generated$1.assertUpdateExpression = assertUpdateExpression;
generated$1.assertUserWhitespacable = assertUserWhitespacable;
generated$1.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
generated$1.assertVariableDeclaration = assertVariableDeclaration;
generated$1.assertVariableDeclarator = assertVariableDeclarator;
generated$1.assertVariance = assertVariance;
generated$1.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
generated$1.assertWhile = assertWhile;
generated$1.assertWhileStatement = assertWhileStatement;
generated$1.assertWithStatement = assertWithStatement;
generated$1.assertYieldExpression = assertYieldExpression;
var _is = requireIs();
var _deprecationWarning = requireDeprecationWarning();
function assert(type, node, opts) {
if (!(0, _is.default)(type, node, opts)) {
throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
}
}
function assertArrayExpression(node, opts) {
assert("ArrayExpression", node, opts);
}
function assertAssignmentExpression(node, opts) {
assert("AssignmentExpression", node, opts);
}
function assertBinaryExpression(node, opts) {
assert("BinaryExpression", node, opts);
}
function assertInterpreterDirective(node, opts) {
assert("InterpreterDirective", node, opts);
}
function assertDirective(node, opts) {
assert("Directive", node, opts);
}
function assertDirectiveLiteral(node, opts) {
assert("DirectiveLiteral", node, opts);
}
function assertBlockStatement(node, opts) {
assert("BlockStatement", node, opts);
}
function assertBreakStatement(node, opts) {
assert("BreakStatement", node, opts);
}
function assertCallExpression(node, opts) {
assert("CallExpression", node, opts);
}
function assertCatchClause(node, opts) {
assert("CatchClause", node, opts);
}
function assertConditionalExpression(node, opts) {
assert("ConditionalExpression", node, opts);
}
function assertContinueStatement(node, opts) {
assert("ContinueStatement", node, opts);
}
function assertDebuggerStatement(node, opts) {
assert("DebuggerStatement", node, opts);
}
function assertDoWhileStatement(node, opts) {
assert("DoWhileStatement", node, opts);
}
function assertEmptyStatement(node, opts) {
assert("EmptyStatement", node, opts);
}
function assertExpressionStatement(node, opts) {
assert("ExpressionStatement", node, opts);
}
function assertFile(node, opts) {
assert("File", node, opts);
}
function assertForInStatement(node, opts) {
assert("ForInStatement", node, opts);
}
function assertForStatement(node, opts) {
assert("ForStatement", node, opts);
}
function assertFunctionDeclaration(node, opts) {
assert("FunctionDeclaration", node, opts);
}
function assertFunctionExpression(node, opts) {
assert("FunctionExpression", node, opts);
}
function assertIdentifier(node, opts) {
assert("Identifier", node, opts);
}
function assertIfStatement(node, opts) {
assert("IfStatement", node, opts);
}
function assertLabeledStatement(node, opts) {
assert("LabeledStatement", node, opts);
}
function assertStringLiteral(node, opts) {
assert("StringLiteral", node, opts);
}
function assertNumericLiteral(node, opts) {
assert("NumericLiteral", node, opts);
}
function assertNullLiteral(node, opts) {
assert("NullLiteral", node, opts);
}
function assertBooleanLiteral(node, opts) {
assert("BooleanLiteral", node, opts);
}
function assertRegExpLiteral(node, opts) {
assert("RegExpLiteral", node, opts);
}
function assertLogicalExpression(node, opts) {
assert("LogicalExpression", node, opts);
}
function assertMemberExpression(node, opts) {
assert("MemberExpression", node, opts);
}
function assertNewExpression(node, opts) {
assert("NewExpression", node, opts);
}
function assertProgram(node, opts) {
assert("Program", node, opts);
}
function assertObjectExpression(node, opts) {
assert("ObjectExpression", node, opts);
}
function assertObjectMethod(node, opts) {
assert("ObjectMethod", node, opts);
}
function assertObjectProperty(node, opts) {
assert("ObjectProperty", node, opts);
}
function assertRestElement(node, opts) {
assert("RestElement", node, opts);
}
function assertReturnStatement(node, opts) {
assert("ReturnStatement", node, opts);
}
function assertSequenceExpression(node, opts) {
assert("SequenceExpression", node, opts);
}
function assertParenthesizedExpression(node, opts) {
assert("ParenthesizedExpression", node, opts);
}
function assertSwitchCase(node, opts) {
assert("SwitchCase", node, opts);
}
function assertSwitchStatement(node, opts) {
assert("SwitchStatement", node, opts);
}
function assertThisExpression(node, opts) {
assert("ThisExpression", node, opts);
}
function assertThrowStatement(node, opts) {
assert("ThrowStatement", node, opts);
}
function assertTryStatement(node, opts) {
assert("TryStatement", node, opts);
}
function assertUnaryExpression(node, opts) {
assert("UnaryExpression", node, opts);
}
function assertUpdateExpression(node, opts) {
assert("UpdateExpression", node, opts);
}
function assertVariableDeclaration(node, opts) {
assert("VariableDeclaration", node, opts);
}
function assertVariableDeclarator(node, opts) {
assert("VariableDeclarator", node, opts);
}
function assertWhileStatement(node, opts) {
assert("WhileStatement", node, opts);
}
function assertWithStatement(node, opts) {
assert("WithStatement", node, opts);
}
function assertAssignmentPattern(node, opts) {
assert("AssignmentPattern", node, opts);
}
function assertArrayPattern(node, opts) {
assert("ArrayPattern", node, opts);
}
function assertArrowFunctionExpression(node, opts) {
assert("ArrowFunctionExpression", node, opts);
}
function assertClassBody(node, opts) {
assert("ClassBody", node, opts);
}
function assertClassExpression(node, opts) {
assert("ClassExpression", node, opts);
}
function assertClassDeclaration(node, opts) {
assert("ClassDeclaration", node, opts);
}
function assertExportAllDeclaration(node, opts) {
assert("ExportAllDeclaration", node, opts);
}
function assertExportDefaultDeclaration(node, opts) {
assert("ExportDefaultDeclaration", node, opts);
}
function assertExportNamedDeclaration(node, opts) {
assert("ExportNamedDeclaration", node, opts);
}
function assertExportSpecifier(node, opts) {
assert("ExportSpecifier", node, opts);
}
function assertForOfStatement(node, opts) {
assert("ForOfStatement", node, opts);
}
function assertImportDeclaration(node, opts) {
assert("ImportDeclaration", node, opts);
}
function assertImportDefaultSpecifier(node, opts) {
assert("ImportDefaultSpecifier", node, opts);
}
function assertImportNamespaceSpecifier(node, opts) {
assert("ImportNamespaceSpecifier", node, opts);
}
function assertImportSpecifier(node, opts) {
assert("ImportSpecifier", node, opts);
}
function assertImportExpression(node, opts) {
assert("ImportExpression", node, opts);
}
function assertMetaProperty(node, opts) {
assert("MetaProperty", node, opts);
}
function assertClassMethod(node, opts) {
assert("ClassMethod", node, opts);
}
function assertObjectPattern(node, opts) {
assert("ObjectPattern", node, opts);
}
function assertSpreadElement(node, opts) {
assert("SpreadElement", node, opts);
}
function assertSuper(node, opts) {
assert("Super", node, opts);
}
function assertTaggedTemplateExpression(node, opts) {
assert("TaggedTemplateExpression", node, opts);
}
function assertTemplateElement(node, opts) {
assert("TemplateElement", node, opts);
}
function assertTemplateLiteral(node, opts) {
assert("TemplateLiteral", node, opts);
}
function assertYieldExpression(node, opts) {
assert("YieldExpression", node, opts);
}
function assertAwaitExpression(node, opts) {
assert("AwaitExpression", node, opts);
}
function assertImport(node, opts) {
assert("Import", node, opts);
}
function assertBigIntLiteral(node, opts) {
assert("BigIntLiteral", node, opts);
}
function assertExportNamespaceSpecifier(node, opts) {
assert("ExportNamespaceSpecifier", node, opts);
}
function assertOptionalMemberExpression(node, opts) {
assert("OptionalMemberExpression", node, opts);
}
function assertOptionalCallExpression(node, opts) {
assert("OptionalCallExpression", node, opts);
}
function assertClassProperty(node, opts) {
assert("ClassProperty", node, opts);
}
function assertClassAccessorProperty(node, opts) {
assert("ClassAccessorProperty", node, opts);
}
function assertClassPrivateProperty(node, opts) {
assert("ClassPrivateProperty", node, opts);
}
function assertClassPrivateMethod(node, opts) {
assert("ClassPrivateMethod", node, opts);
}
function assertPrivateName(node, opts) {
assert("PrivateName", node, opts);
}
function assertStaticBlock(node, opts) {
assert("StaticBlock", node, opts);
}
function assertAnyTypeAnnotation(node, opts) {
assert("AnyTypeAnnotation", node, opts);
}
function assertArrayTypeAnnotation(node, opts) {
assert("ArrayTypeAnnotation", node, opts);
}
function assertBooleanTypeAnnotation(node, opts) {
assert("BooleanTypeAnnotation", node, opts);
}
function assertBooleanLiteralTypeAnnotation(node, opts) {
assert("BooleanLiteralTypeAnnotation", node, opts);
}
function assertNullLiteralTypeAnnotation(node, opts) {
assert("NullLiteralTypeAnnotation", node, opts);
}
function assertClassImplements(node, opts) {
assert("ClassImplements", node, opts);
}
function assertDeclareClass(node, opts) {
assert("DeclareClass", node, opts);
}
function assertDeclareFunction(node, opts) {
assert("DeclareFunction", node, opts);
}
function assertDeclareInterface(node, opts) {
assert("DeclareInterface", node, opts);
}
function assertDeclareModule(node, opts) {
assert("DeclareModule", node, opts);
}
function assertDeclareModuleExports(node, opts) {
assert("DeclareModuleExports", node, opts);
}
function assertDeclareTypeAlias(node, opts) {
assert("DeclareTypeAlias", node, opts);
}
function assertDeclareOpaqueType(node, opts) {
assert("DeclareOpaqueType", node, opts);
}
function assertDeclareVariable(node, opts) {
assert("DeclareVariable", node, opts);
}
function assertDeclareExportDeclaration(node, opts) {
assert("DeclareExportDeclaration", node, opts);
}
function assertDeclareExportAllDeclaration(node, opts) {
assert("DeclareExportAllDeclaration", node, opts);
}
function assertDeclaredPredicate(node, opts) {
assert("DeclaredPredicate", node, opts);
}
function assertExistsTypeAnnotation(node, opts) {
assert("ExistsTypeAnnotation", node, opts);
}
function assertFunctionTypeAnnotation(node, opts) {
assert("FunctionTypeAnnotation", node, opts);
}
function assertFunctionTypeParam(node, opts) {
assert("FunctionTypeParam", node, opts);
}
function assertGenericTypeAnnotation(node, opts) {
assert("GenericTypeAnnotation", node, opts);
}
function assertInferredPredicate(node, opts) {
assert("InferredPredicate", node, opts);
}
function assertInterfaceExtends(node, opts) {
assert("InterfaceExtends", node, opts);
}
function assertInterfaceDeclaration(node, opts) {
assert("InterfaceDeclaration", node, opts);
}
function assertInterfaceTypeAnnotation(node, opts) {
assert("InterfaceTypeAnnotation", node, opts);
}
function assertIntersectionTypeAnnotation(node, opts) {
assert("IntersectionTypeAnnotation", node, opts);
}
function assertMixedTypeAnnotation(node, opts) {
assert("MixedTypeAnnotation", node, opts);
}
function assertEmptyTypeAnnotation(node, opts) {
assert("EmptyTypeAnnotation", node, opts);
}
function assertNullableTypeAnnotation(node, opts) {
assert("NullableTypeAnnotation", node, opts);
}
function assertNumberLiteralTypeAnnotation(node, opts) {
assert("NumberLiteralTypeAnnotation", node, opts);
}
function assertNumberTypeAnnotation(node, opts) {
assert("NumberTypeAnnotation", node, opts);
}
function assertObjectTypeAnnotation(node, opts) {
assert("ObjectTypeAnnotation", node, opts);
}
function assertObjectTypeInternalSlot(node, opts) {
assert("ObjectTypeInternalSlot", node, opts);
}
function assertObjectTypeCallProperty(node, opts) {
assert("ObjectTypeCallProperty", node, opts);
}
function assertObjectTypeIndexer(node, opts) {
assert("ObjectTypeIndexer", node, opts);
}
function assertObjectTypeProperty(node, opts) {
assert("ObjectTypeProperty", node, opts);
}
function assertObjectTypeSpreadProperty(node, opts) {
assert("ObjectTypeSpreadProperty", node, opts);
}
function assertOpaqueType(node, opts) {
assert("OpaqueType", node, opts);
}
function assertQualifiedTypeIdentifier(node, opts) {
assert("QualifiedTypeIdentifier", node, opts);
}
function assertStringLiteralTypeAnnotation(node, opts) {
assert("StringLiteralTypeAnnotation", node, opts);
}
function assertStringTypeAnnotation(node, opts) {
assert("StringTypeAnnotation", node, opts);
}
function assertSymbolTypeAnnotation(node, opts) {
assert("SymbolTypeAnnotation", node, opts);
}
function assertThisTypeAnnotation(node, opts) {
assert("ThisTypeAnnotation", node, opts);
}
function assertTupleTypeAnnotation(node, opts) {
assert("TupleTypeAnnotation", node, opts);
}
function assertTypeofTypeAnnotation(node, opts) {
assert("TypeofTypeAnnotation", node, opts);
}
function assertTypeAlias(node, opts) {
assert("TypeAlias", node, opts);
}
function assertTypeAnnotation(node, opts) {
assert("TypeAnnotation", node, opts);
}
function assertTypeCastExpression(node, opts) {
assert("TypeCastExpression", node, opts);
}
function assertTypeParameter(node, opts) {
assert("TypeParameter", node, opts);
}
function assertTypeParameterDeclaration(node, opts) {
assert("TypeParameterDeclaration", node, opts);
}
function assertTypeParameterInstantiation(node, opts) {
assert("TypeParameterInstantiation", node, opts);
}
function assertUnionTypeAnnotation(node, opts) {
assert("UnionTypeAnnotation", node, opts);
}
function assertVariance(node, opts) {
assert("Variance", node, opts);
}
function assertVoidTypeAnnotation(node, opts) {
assert("VoidTypeAnnotation", node, opts);
}
function assertEnumDeclaration(node, opts) {
assert("EnumDeclaration", node, opts);
}
function assertEnumBooleanBody(node, opts) {
assert("EnumBooleanBody", node, opts);
}
function assertEnumNumberBody(node, opts) {
assert("EnumNumberBody", node, opts);
}
function assertEnumStringBody(node, opts) {
assert("EnumStringBody", node, opts);
}
function assertEnumSymbolBody(node, opts) {
assert("EnumSymbolBody", node, opts);
}
function assertEnumBooleanMember(node, opts) {
assert("EnumBooleanMember", node, opts);
}
function assertEnumNumberMember(node, opts) {
assert("EnumNumberMember", node, opts);
}
function assertEnumStringMember(node, opts) {
assert("EnumStringMember", node, opts);
}
function assertEnumDefaultedMember(node, opts) {
assert("EnumDefaultedMember", node, opts);
}
function assertIndexedAccessType(node, opts) {
assert("IndexedAccessType", node, opts);
}
function assertOptionalIndexedAccessType(node, opts) {
assert("OptionalIndexedAccessType", node, opts);
}
function assertJSXAttribute(node, opts) {
assert("JSXAttribute", node, opts);
}
function assertJSXClosingElement(node, opts) {
assert("JSXClosingElement", node, opts);
}
function assertJSXElement(node, opts) {
assert("JSXElement", node, opts);
}
function assertJSXEmptyExpression(node, opts) {
assert("JSXEmptyExpression", node, opts);
}
function assertJSXExpressionContainer(node, opts) {
assert("JSXExpressionContainer", node, opts);
}
function assertJSXSpreadChild(node, opts) {
assert("JSXSpreadChild", node, opts);
}
function assertJSXIdentifier(node, opts) {
assert("JSXIdentifier", node, opts);
}
function assertJSXMemberExpression(node, opts) {
assert("JSXMemberExpression", node, opts);
}
function assertJSXNamespacedName(node, opts) {
assert("JSXNamespacedName", node, opts);
}
function assertJSXOpeningElement(node, opts) {
assert("JSXOpeningElement", node, opts);
}
function assertJSXSpreadAttribute(node, opts) {
assert("JSXSpreadAttribute", node, opts);
}
function assertJSXText(node, opts) {
assert("JSXText", node, opts);
}
function assertJSXFragment(node, opts) {
assert("JSXFragment", node, opts);
}
function assertJSXOpeningFragment(node, opts) {
assert("JSXOpeningFragment", node, opts);
}
function assertJSXClosingFragment(node, opts) {
assert("JSXClosingFragment", node, opts);
}
function assertNoop(node, opts) {
assert("Noop", node, opts);
}
function assertPlaceholder(node, opts) {
assert("Placeholder", node, opts);
}
function assertV8IntrinsicIdentifier(node, opts) {
assert("V8IntrinsicIdentifier", node, opts);
}
function assertArgumentPlaceholder(node, opts) {
assert("ArgumentPlaceholder", node, opts);
}
function assertBindExpression(node, opts) {
assert("BindExpression", node, opts);
}
function assertImportAttribute(node, opts) {
assert("ImportAttribute", node, opts);
}
function assertDecorator(node, opts) {
assert("Decorator", node, opts);
}
function assertDoExpression(node, opts) {
assert("DoExpression", node, opts);
}
function assertExportDefaultSpecifier(node, opts) {
assert("ExportDefaultSpecifier", node, opts);
}
function assertRecordExpression(node, opts) {
assert("RecordExpression", node, opts);
}
function assertTupleExpression(node, opts) {
assert("TupleExpression", node, opts);
}
function assertDecimalLiteral(node, opts) {
assert("DecimalLiteral", node, opts);
}
function assertModuleExpression(node, opts) {
assert("ModuleExpression", node, opts);
}
function assertTopicReference(node, opts) {
assert("TopicReference", node, opts);
}
function assertPipelineTopicExpression(node, opts) {
assert("PipelineTopicExpression", node, opts);
}
function assertPipelineBareFunction(node, opts) {
assert("PipelineBareFunction", node, opts);
}
function assertPipelinePrimaryTopicReference(node, opts) {
assert("PipelinePrimaryTopicReference", node, opts);
}
function assertTSParameterProperty(node, opts) {
assert("TSParameterProperty", node, opts);
}
function assertTSDeclareFunction(node, opts) {
assert("TSDeclareFunction", node, opts);
}
function assertTSDeclareMethod(node, opts) {
assert("TSDeclareMethod", node, opts);
}
function assertTSQualifiedName(node, opts) {
assert("TSQualifiedName", node, opts);
}
function assertTSCallSignatureDeclaration(node, opts) {
assert("TSCallSignatureDeclaration", node, opts);
}
function assertTSConstructSignatureDeclaration(node, opts) {
assert("TSConstructSignatureDeclaration", node, opts);
}
function assertTSPropertySignature(node, opts) {
assert("TSPropertySignature", node, opts);
}
function assertTSMethodSignature(node, opts) {
assert("TSMethodSignature", node, opts);
}
function assertTSIndexSignature(node, opts) {
assert("TSIndexSignature", node, opts);
}
function assertTSAnyKeyword(node, opts) {
assert("TSAnyKeyword", node, opts);
}
function assertTSBooleanKeyword(node, opts) {
assert("TSBooleanKeyword", node, opts);
}
function assertTSBigIntKeyword(node, opts) {
assert("TSBigIntKeyword", node, opts);
}
function assertTSIntrinsicKeyword(node, opts) {
assert("TSIntrinsicKeyword", node, opts);
}
function assertTSNeverKeyword(node, opts) {
assert("TSNeverKeyword", node, opts);
}
function assertTSNullKeyword(node, opts) {
assert("TSNullKeyword", node, opts);
}
function assertTSNumberKeyword(node, opts) {
assert("TSNumberKeyword", node, opts);
}
function assertTSObjectKeyword(node, opts) {
assert("TSObjectKeyword", node, opts);
}
function assertTSStringKeyword(node, opts) {
assert("TSStringKeyword", node, opts);
}
function assertTSSymbolKeyword(node, opts) {
assert("TSSymbolKeyword", node, opts);
}
function assertTSUndefinedKeyword(node, opts) {
assert("TSUndefinedKeyword", node, opts);
}
function assertTSUnknownKeyword(node, opts) {
assert("TSUnknownKeyword", node, opts);
}
function assertTSVoidKeyword(node, opts) {
assert("TSVoidKeyword", node, opts);
}
function assertTSThisType(node, opts) {
assert("TSThisType", node, opts);
}
function assertTSFunctionType(node, opts) {
assert("TSFunctionType", node, opts);
}
function assertTSConstructorType(node, opts) {
assert("TSConstructorType", node, opts);
}
function assertTSTypeReference(node, opts) {
assert("TSTypeReference", node, opts);
}
function assertTSTypePredicate(node, opts) {
assert("TSTypePredicate", node, opts);
}
function assertTSTypeQuery(node, opts) {
assert("TSTypeQuery", node, opts);
}
function assertTSTypeLiteral(node, opts) {
assert("TSTypeLiteral", node, opts);
}
function assertTSArrayType(node, opts) {
assert("TSArrayType", node, opts);
}
function assertTSTupleType(node, opts) {
assert("TSTupleType", node, opts);
}
function assertTSOptionalType(node, opts) {
assert("TSOptionalType", node, opts);
}
function assertTSRestType(node, opts) {
assert("TSRestType", node, opts);
}
function assertTSNamedTupleMember(node, opts) {
assert("TSNamedTupleMember", node, opts);
}
function assertTSUnionType(node, opts) {
assert("TSUnionType", node, opts);
}
function assertTSIntersectionType(node, opts) {
assert("TSIntersectionType", node, opts);
}
function assertTSConditionalType(node, opts) {
assert("TSConditionalType", node, opts);
}
function assertTSInferType(node, opts) {
assert("TSInferType", node, opts);
}
function assertTSParenthesizedType(node, opts) {
assert("TSParenthesizedType", node, opts);
}
function assertTSTypeOperator(node, opts) {
assert("TSTypeOperator", node, opts);
}
function assertTSIndexedAccessType(node, opts) {
assert("TSIndexedAccessType", node, opts);
}
function assertTSMappedType(node, opts) {
assert("TSMappedType", node, opts);
}
function assertTSLiteralType(node, opts) {
assert("TSLiteralType", node, opts);
}
function assertTSExpressionWithTypeArguments(node, opts) {
assert("TSExpressionWithTypeArguments", node, opts);
}
function assertTSInterfaceDeclaration(node, opts) {
assert("TSInterfaceDeclaration", node, opts);
}
function assertTSInterfaceBody(node, opts) {
assert("TSInterfaceBody", node, opts);
}
function assertTSTypeAliasDeclaration(node, opts) {
assert("TSTypeAliasDeclaration", node, opts);
}
function assertTSInstantiationExpression(node, opts) {
assert("TSInstantiationExpression", node, opts);
}
function assertTSAsExpression(node, opts) {
assert("TSAsExpression", node, opts);
}
function assertTSSatisfiesExpression(node, opts) {
assert("TSSatisfiesExpression", node, opts);
}
function assertTSTypeAssertion(node, opts) {
assert("TSTypeAssertion", node, opts);
}
function assertTSEnumDeclaration(node, opts) {
assert("TSEnumDeclaration", node, opts);
}
function assertTSEnumMember(node, opts) {
assert("TSEnumMember", node, opts);
}
function assertTSModuleDeclaration(node, opts) {
assert("TSModuleDeclaration", node, opts);
}
function assertTSModuleBlock(node, opts) {
assert("TSModuleBlock", node, opts);
}
function assertTSImportType(node, opts) {
assert("TSImportType", node, opts);
}
function assertTSImportEqualsDeclaration(node, opts) {
assert("TSImportEqualsDeclaration", node, opts);
}
function assertTSExternalModuleReference(node, opts) {
assert("TSExternalModuleReference", node, opts);
}
function assertTSNonNullExpression(node, opts) {
assert("TSNonNullExpression", node, opts);
}
function assertTSExportAssignment(node, opts) {
assert("TSExportAssignment", node, opts);
}
function assertTSNamespaceExportDeclaration(node, opts) {
assert("TSNamespaceExportDeclaration", node, opts);
}
function assertTSTypeAnnotation(node, opts) {
assert("TSTypeAnnotation", node, opts);
}
function assertTSTypeParameterInstantiation(node, opts) {
assert("TSTypeParameterInstantiation", node, opts);
}
function assertTSTypeParameterDeclaration(node, opts) {
assert("TSTypeParameterDeclaration", node, opts);
}
function assertTSTypeParameter(node, opts) {
assert("TSTypeParameter", node, opts);
}
function assertStandardized(node, opts) {
assert("Standardized", node, opts);
}
function assertExpression(node, opts) {
assert("Expression", node, opts);
}
function assertBinary(node, opts) {
assert("Binary", node, opts);
}
function assertScopable(node, opts) {
assert("Scopable", node, opts);
}
function assertBlockParent(node, opts) {
assert("BlockParent", node, opts);
}
function assertBlock(node, opts) {
assert("Block", node, opts);
}
function assertStatement(node, opts) {
assert("Statement", node, opts);
}
function assertTerminatorless(node, opts) {
assert("Terminatorless", node, opts);
}
function assertCompletionStatement(node, opts) {
assert("CompletionStatement", node, opts);
}
function assertConditional(node, opts) {
assert("Conditional", node, opts);
}
function assertLoop(node, opts) {
assert("Loop", node, opts);
}
function assertWhile(node, opts) {
assert("While", node, opts);
}
function assertExpressionWrapper(node, opts) {
assert("ExpressionWrapper", node, opts);
}
function assertFor(node, opts) {
assert("For", node, opts);
}
function assertForXStatement(node, opts) {
assert("ForXStatement", node, opts);
}
function assertFunction(node, opts) {
assert("Function", node, opts);
}
function assertFunctionParent(node, opts) {
assert("FunctionParent", node, opts);
}
function assertPureish(node, opts) {
assert("Pureish", node, opts);
}
function assertDeclaration(node, opts) {
assert("Declaration", node, opts);
}
function assertPatternLike(node, opts) {
assert("PatternLike", node, opts);
}
function assertLVal(node, opts) {
assert("LVal", node, opts);
}
function assertTSEntityName(node, opts) {
assert("TSEntityName", node, opts);
}
function assertLiteral(node, opts) {
assert("Literal", node, opts);
}
function assertImmutable(node, opts) {
assert("Immutable", node, opts);
}
function assertUserWhitespacable(node, opts) {
assert("UserWhitespacable", node, opts);
}
function assertMethod(node, opts) {
assert("Method", node, opts);
}
function assertObjectMember(node, opts) {
assert("ObjectMember", node, opts);
}
function assertProperty(node, opts) {
assert("Property", node, opts);
}
function assertUnaryLike(node, opts) {
assert("UnaryLike", node, opts);
}
function assertPattern(node, opts) {
assert("Pattern", node, opts);
}
function assertClass(node, opts) {
assert("Class", node, opts);
}
function assertImportOrExportDeclaration(node, opts) {
assert("ImportOrExportDeclaration", node, opts);
}
function assertExportDeclaration(node, opts) {
assert("ExportDeclaration", node, opts);
}
function assertModuleSpecifier(node, opts) {
assert("ModuleSpecifier", node, opts);
}
function assertAccessor(node, opts) {
assert("Accessor", node, opts);
}
function assertPrivate(node, opts) {
assert("Private", node, opts);
}
function assertFlow(node, opts) {
assert("Flow", node, opts);
}
function assertFlowType(node, opts) {
assert("FlowType", node, opts);
}
function assertFlowBaseAnnotation(node, opts) {
assert("FlowBaseAnnotation", node, opts);
}
function assertFlowDeclaration(node, opts) {
assert("FlowDeclaration", node, opts);
}
function assertFlowPredicate(node, opts) {
assert("FlowPredicate", node, opts);
}
function assertEnumBody(node, opts) {
assert("EnumBody", node, opts);
}
function assertEnumMember(node, opts) {
assert("EnumMember", node, opts);
}
function assertJSX(node, opts) {
assert("JSX", node, opts);
}
function assertMiscellaneous(node, opts) {
assert("Miscellaneous", node, opts);
}
function assertTypeScript(node, opts) {
assert("TypeScript", node, opts);
}
function assertTSTypeElement(node, opts) {
assert("TSTypeElement", node, opts);
}
function assertTSType(node, opts) {
assert("TSType", node, opts);
}
function assertTSBaseType(node, opts) {
assert("TSBaseType", node, opts);
}
function assertNumberLiteral(node, opts) {
(0, _deprecationWarning.default)("assertNumberLiteral", "assertNumericLiteral");
assert("NumberLiteral", node, opts);
}
function assertRegexLiteral(node, opts) {
(0, _deprecationWarning.default)("assertRegexLiteral", "assertRegExpLiteral");
assert("RegexLiteral", node, opts);
}
function assertRestProperty(node, opts) {
(0, _deprecationWarning.default)("assertRestProperty", "assertRestElement");
assert("RestProperty", node, opts);
}
function assertSpreadProperty(node, opts) {
(0, _deprecationWarning.default)("assertSpreadProperty", "assertSpreadElement");
assert("SpreadProperty", node, opts);
}
function assertModuleDeclaration(node, opts) {
(0, _deprecationWarning.default)("assertModuleDeclaration", "assertImportOrExportDeclaration");
assert("ModuleDeclaration", node, opts);
}
return generated$1;
}
var createTypeAnnotationBasedOnTypeof = {};
var hasRequiredCreateTypeAnnotationBasedOnTypeof;
function requireCreateTypeAnnotationBasedOnTypeof () {
if (hasRequiredCreateTypeAnnotationBasedOnTypeof) return createTypeAnnotationBasedOnTypeof;
hasRequiredCreateTypeAnnotationBasedOnTypeof = 1;
Object.defineProperty(createTypeAnnotationBasedOnTypeof, "__esModule", {
value: true
});
createTypeAnnotationBasedOnTypeof.default = void 0;
var _index = requireGenerated$2();
var _default = createTypeAnnotationBasedOnTypeof$1;
createTypeAnnotationBasedOnTypeof.default = _default;
function createTypeAnnotationBasedOnTypeof$1(type) {
switch (type) {
case "string":
return (0, _index.stringTypeAnnotation)();
case "number":
return (0, _index.numberTypeAnnotation)();
case "undefined":
return (0, _index.voidTypeAnnotation)();
case "boolean":
return (0, _index.booleanTypeAnnotation)();
case "function":
return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Function"));
case "object":
return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Object"));
case "symbol":
return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Symbol"));
case "bigint":
return (0, _index.anyTypeAnnotation)();
}
throw new Error("Invalid typeof value: " + type);
}
return createTypeAnnotationBasedOnTypeof;
}
var createFlowUnionType = {};
var removeTypeDuplicates$1 = {};
var hasRequiredRemoveTypeDuplicates$1;
function requireRemoveTypeDuplicates$1 () {
if (hasRequiredRemoveTypeDuplicates$1) return removeTypeDuplicates$1;
hasRequiredRemoveTypeDuplicates$1 = 1;
Object.defineProperty(removeTypeDuplicates$1, "__esModule", {
value: true
});
removeTypeDuplicates$1.default = removeTypeDuplicates;
var _index = requireGenerated$3();
function getQualifiedName(node) {
return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
}
function removeTypeDuplicates(nodesIn) {
const nodes = Array.from(nodesIn);
const generics = new Map();
const bases = new Map();
const typeGroups = new Set();
const types = [];
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (!node) continue;
if (types.indexOf(node) >= 0) {
continue;
}
if ((0, _index.isAnyTypeAnnotation)(node)) {
return [node];
}
if ((0, _index.isFlowBaseAnnotation)(node)) {
bases.set(node.type, node);
continue;
}
if ((0, _index.isUnionTypeAnnotation)(node)) {
if (!typeGroups.has(node.types)) {
nodes.push(...node.types);
typeGroups.add(node.types);
}
continue;
}
if ((0, _index.isGenericTypeAnnotation)(node)) {
const name = getQualifiedName(node.id);
if (generics.has(name)) {
let existing = generics.get(name);
if (existing.typeParameters) {
if (node.typeParameters) {
existing.typeParameters.params.push(...node.typeParameters.params);
existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params);
}
} else {
existing = node.typeParameters;
}
} else {
generics.set(name, node);
}
continue;
}
types.push(node);
}
for (const [, baseType] of bases) {
types.push(baseType);
}
for (const [, genericName] of generics) {
types.push(genericName);
}
return types;
}
return removeTypeDuplicates$1;
}
var hasRequiredCreateFlowUnionType;
function requireCreateFlowUnionType () {
if (hasRequiredCreateFlowUnionType) return createFlowUnionType;
hasRequiredCreateFlowUnionType = 1;
Object.defineProperty(createFlowUnionType, "__esModule", {
value: true
});
createFlowUnionType.default = createFlowUnionType$1;
var _index = requireGenerated$2();
var _removeTypeDuplicates = requireRemoveTypeDuplicates$1();
function createFlowUnionType$1(types) {
const flattened = (0, _removeTypeDuplicates.default)(types);
if (flattened.length === 1) {
return flattened[0];
} else {
return (0, _index.unionTypeAnnotation)(flattened);
}
}
return createFlowUnionType;
}
var createTSUnionType = {};
var removeTypeDuplicates = {};
var hasRequiredRemoveTypeDuplicates;
function requireRemoveTypeDuplicates () {
if (hasRequiredRemoveTypeDuplicates) return removeTypeDuplicates;
hasRequiredRemoveTypeDuplicates = 1;
Object.defineProperty(removeTypeDuplicates, "__esModule", {
value: true
});
removeTypeDuplicates.default = removeTypeDuplicates$1;
var _index = requireGenerated$3();
function getQualifiedName(node) {
return (0, _index.isIdentifier)(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`;
}
function removeTypeDuplicates$1(nodesIn) {
const nodes = Array.from(nodesIn);
const generics = new Map();
const bases = new Map();
const typeGroups = new Set();
const types = [];
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (!node) continue;
if (types.indexOf(node) >= 0) {
continue;
}
if ((0, _index.isTSAnyKeyword)(node)) {
return [node];
}
if ((0, _index.isTSBaseType)(node)) {
bases.set(node.type, node);
continue;
}
if ((0, _index.isTSUnionType)(node)) {
if (!typeGroups.has(node.types)) {
nodes.push(...node.types);
typeGroups.add(node.types);
}
continue;
}
if ((0, _index.isTSTypeReference)(node) && node.typeParameters) {
const name = getQualifiedName(node.typeName);
if (generics.has(name)) {
let existing = generics.get(name);
if (existing.typeParameters) {
if (node.typeParameters) {
existing.typeParameters.params.push(...node.typeParameters.params);
existing.typeParameters.params = removeTypeDuplicates$1(existing.typeParameters.params);
}
} else {
existing = node.typeParameters;
}
} else {
generics.set(name, node);
}
continue;
}
types.push(node);
}
for (const [, baseType] of bases) {
types.push(baseType);
}
for (const [, genericName] of generics) {
types.push(genericName);
}
return types;
}
return removeTypeDuplicates;
}
var hasRequiredCreateTSUnionType;
function requireCreateTSUnionType () {
if (hasRequiredCreateTSUnionType) return createTSUnionType;
hasRequiredCreateTSUnionType = 1;
Object.defineProperty(createTSUnionType, "__esModule", {
value: true
});
createTSUnionType.default = createTSUnionType$1;
var _index = requireGenerated$2();
var _removeTypeDuplicates = requireRemoveTypeDuplicates();
var _index2 = requireGenerated$3();
function createTSUnionType$1(typeAnnotations) {
const types = typeAnnotations.map(type => {
return (0, _index2.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
});
const flattened = (0, _removeTypeDuplicates.default)(types);
if (flattened.length === 1) {
return flattened[0];
} else {
return (0, _index.tsUnionType)(flattened);
}
}
return createTSUnionType;
}
var uppercase = {};
var hasRequiredUppercase;
function requireUppercase () {
if (hasRequiredUppercase) return uppercase;
hasRequiredUppercase = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "AnyTypeAnnotation", {
enumerable: true,
get: function () {
return _index.anyTypeAnnotation;
}
});
Object.defineProperty(exports, "ArgumentPlaceholder", {
enumerable: true,
get: function () {
return _index.argumentPlaceholder;
}
});
Object.defineProperty(exports, "ArrayExpression", {
enumerable: true,
get: function () {
return _index.arrayExpression;
}
});
Object.defineProperty(exports, "ArrayPattern", {
enumerable: true,
get: function () {
return _index.arrayPattern;
}
});
Object.defineProperty(exports, "ArrayTypeAnnotation", {
enumerable: true,
get: function () {
return _index.arrayTypeAnnotation;
}
});
Object.defineProperty(exports, "ArrowFunctionExpression", {
enumerable: true,
get: function () {
return _index.arrowFunctionExpression;
}
});
Object.defineProperty(exports, "AssignmentExpression", {
enumerable: true,
get: function () {
return _index.assignmentExpression;
}
});
Object.defineProperty(exports, "AssignmentPattern", {
enumerable: true,
get: function () {
return _index.assignmentPattern;
}
});
Object.defineProperty(exports, "AwaitExpression", {
enumerable: true,
get: function () {
return _index.awaitExpression;
}
});
Object.defineProperty(exports, "BigIntLiteral", {
enumerable: true,
get: function () {
return _index.bigIntLiteral;
}
});
Object.defineProperty(exports, "BinaryExpression", {
enumerable: true,
get: function () {
return _index.binaryExpression;
}
});
Object.defineProperty(exports, "BindExpression", {
enumerable: true,
get: function () {
return _index.bindExpression;
}
});
Object.defineProperty(exports, "BlockStatement", {
enumerable: true,
get: function () {
return _index.blockStatement;
}
});
Object.defineProperty(exports, "BooleanLiteral", {
enumerable: true,
get: function () {
return _index.booleanLiteral;
}
});
Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _index.booleanLiteralTypeAnnotation;
}
});
Object.defineProperty(exports, "BooleanTypeAnnotation", {
enumerable: true,
get: function () {
return _index.booleanTypeAnnotation;
}
});
Object.defineProperty(exports, "BreakStatement", {
enumerable: true,
get: function () {
return _index.breakStatement;
}
});
Object.defineProperty(exports, "CallExpression", {
enumerable: true,
get: function () {
return _index.callExpression;
}
});
Object.defineProperty(exports, "CatchClause", {
enumerable: true,
get: function () {
return _index.catchClause;
}
});
Object.defineProperty(exports, "ClassAccessorProperty", {
enumerable: true,
get: function () {
return _index.classAccessorProperty;
}
});
Object.defineProperty(exports, "ClassBody", {
enumerable: true,
get: function () {
return _index.classBody;
}
});
Object.defineProperty(exports, "ClassDeclaration", {
enumerable: true,
get: function () {
return _index.classDeclaration;
}
});
Object.defineProperty(exports, "ClassExpression", {
enumerable: true,
get: function () {
return _index.classExpression;
}
});
Object.defineProperty(exports, "ClassImplements", {
enumerable: true,
get: function () {
return _index.classImplements;
}
});
Object.defineProperty(exports, "ClassMethod", {
enumerable: true,
get: function () {
return _index.classMethod;
}
});
Object.defineProperty(exports, "ClassPrivateMethod", {
enumerable: true,
get: function () {
return _index.classPrivateMethod;
}
});
Object.defineProperty(exports, "ClassPrivateProperty", {
enumerable: true,
get: function () {
return _index.classPrivateProperty;
}
});
Object.defineProperty(exports, "ClassProperty", {
enumerable: true,
get: function () {
return _index.classProperty;
}
});
Object.defineProperty(exports, "ConditionalExpression", {
enumerable: true,
get: function () {
return _index.conditionalExpression;
}
});
Object.defineProperty(exports, "ContinueStatement", {
enumerable: true,
get: function () {
return _index.continueStatement;
}
});
Object.defineProperty(exports, "DebuggerStatement", {
enumerable: true,
get: function () {
return _index.debuggerStatement;
}
});
Object.defineProperty(exports, "DecimalLiteral", {
enumerable: true,
get: function () {
return _index.decimalLiteral;
}
});
Object.defineProperty(exports, "DeclareClass", {
enumerable: true,
get: function () {
return _index.declareClass;
}
});
Object.defineProperty(exports, "DeclareExportAllDeclaration", {
enumerable: true,
get: function () {
return _index.declareExportAllDeclaration;
}
});
Object.defineProperty(exports, "DeclareExportDeclaration", {
enumerable: true,
get: function () {
return _index.declareExportDeclaration;
}
});
Object.defineProperty(exports, "DeclareFunction", {
enumerable: true,
get: function () {
return _index.declareFunction;
}
});
Object.defineProperty(exports, "DeclareInterface", {
enumerable: true,
get: function () {
return _index.declareInterface;
}
});
Object.defineProperty(exports, "DeclareModule", {
enumerable: true,
get: function () {
return _index.declareModule;
}
});
Object.defineProperty(exports, "DeclareModuleExports", {
enumerable: true,
get: function () {
return _index.declareModuleExports;
}
});
Object.defineProperty(exports, "DeclareOpaqueType", {
enumerable: true,
get: function () {
return _index.declareOpaqueType;
}
});
Object.defineProperty(exports, "DeclareTypeAlias", {
enumerable: true,
get: function () {
return _index.declareTypeAlias;
}
});
Object.defineProperty(exports, "DeclareVariable", {
enumerable: true,
get: function () {
return _index.declareVariable;
}
});
Object.defineProperty(exports, "DeclaredPredicate", {
enumerable: true,
get: function () {
return _index.declaredPredicate;
}
});
Object.defineProperty(exports, "Decorator", {
enumerable: true,
get: function () {
return _index.decorator;
}
});
Object.defineProperty(exports, "Directive", {
enumerable: true,
get: function () {
return _index.directive;
}
});
Object.defineProperty(exports, "DirectiveLiteral", {
enumerable: true,
get: function () {
return _index.directiveLiteral;
}
});
Object.defineProperty(exports, "DoExpression", {
enumerable: true,
get: function () {
return _index.doExpression;
}
});
Object.defineProperty(exports, "DoWhileStatement", {
enumerable: true,
get: function () {
return _index.doWhileStatement;
}
});
Object.defineProperty(exports, "EmptyStatement", {
enumerable: true,
get: function () {
return _index.emptyStatement;
}
});
Object.defineProperty(exports, "EmptyTypeAnnotation", {
enumerable: true,
get: function () {
return _index.emptyTypeAnnotation;
}
});
Object.defineProperty(exports, "EnumBooleanBody", {
enumerable: true,
get: function () {
return _index.enumBooleanBody;
}
});
Object.defineProperty(exports, "EnumBooleanMember", {
enumerable: true,
get: function () {
return _index.enumBooleanMember;
}
});
Object.defineProperty(exports, "EnumDeclaration", {
enumerable: true,
get: function () {
return _index.enumDeclaration;
}
});
Object.defineProperty(exports, "EnumDefaultedMember", {
enumerable: true,
get: function () {
return _index.enumDefaultedMember;
}
});
Object.defineProperty(exports, "EnumNumberBody", {
enumerable: true,
get: function () {
return _index.enumNumberBody;
}
});
Object.defineProperty(exports, "EnumNumberMember", {
enumerable: true,
get: function () {
return _index.enumNumberMember;
}
});
Object.defineProperty(exports, "EnumStringBody", {
enumerable: true,
get: function () {
return _index.enumStringBody;
}
});
Object.defineProperty(exports, "EnumStringMember", {
enumerable: true,
get: function () {
return _index.enumStringMember;
}
});
Object.defineProperty(exports, "EnumSymbolBody", {
enumerable: true,
get: function () {
return _index.enumSymbolBody;
}
});
Object.defineProperty(exports, "ExistsTypeAnnotation", {
enumerable: true,
get: function () {
return _index.existsTypeAnnotation;
}
});
Object.defineProperty(exports, "ExportAllDeclaration", {
enumerable: true,
get: function () {
return _index.exportAllDeclaration;
}
});
Object.defineProperty(exports, "ExportDefaultDeclaration", {
enumerable: true,
get: function () {
return _index.exportDefaultDeclaration;
}
});
Object.defineProperty(exports, "ExportDefaultSpecifier", {
enumerable: true,
get: function () {
return _index.exportDefaultSpecifier;
}
});
Object.defineProperty(exports, "ExportNamedDeclaration", {
enumerable: true,
get: function () {
return _index.exportNamedDeclaration;
}
});
Object.defineProperty(exports, "ExportNamespaceSpecifier", {
enumerable: true,
get: function () {
return _index.exportNamespaceSpecifier;
}
});
Object.defineProperty(exports, "ExportSpecifier", {
enumerable: true,
get: function () {
return _index.exportSpecifier;
}
});
Object.defineProperty(exports, "ExpressionStatement", {
enumerable: true,
get: function () {
return _index.expressionStatement;
}
});
Object.defineProperty(exports, "File", {
enumerable: true,
get: function () {
return _index.file;
}
});
Object.defineProperty(exports, "ForInStatement", {
enumerable: true,
get: function () {
return _index.forInStatement;
}
});
Object.defineProperty(exports, "ForOfStatement", {
enumerable: true,
get: function () {
return _index.forOfStatement;
}
});
Object.defineProperty(exports, "ForStatement", {
enumerable: true,
get: function () {
return _index.forStatement;
}
});
Object.defineProperty(exports, "FunctionDeclaration", {
enumerable: true,
get: function () {
return _index.functionDeclaration;
}
});
Object.defineProperty(exports, "FunctionExpression", {
enumerable: true,
get: function () {
return _index.functionExpression;
}
});
Object.defineProperty(exports, "FunctionTypeAnnotation", {
enumerable: true,
get: function () {
return _index.functionTypeAnnotation;
}
});
Object.defineProperty(exports, "FunctionTypeParam", {
enumerable: true,
get: function () {
return _index.functionTypeParam;
}
});
Object.defineProperty(exports, "GenericTypeAnnotation", {
enumerable: true,
get: function () {
return _index.genericTypeAnnotation;
}
});
Object.defineProperty(exports, "Identifier", {
enumerable: true,
get: function () {
return _index.identifier;
}
});
Object.defineProperty(exports, "IfStatement", {
enumerable: true,
get: function () {
return _index.ifStatement;
}
});
Object.defineProperty(exports, "Import", {
enumerable: true,
get: function () {
return _index.import;
}
});
Object.defineProperty(exports, "ImportAttribute", {
enumerable: true,
get: function () {
return _index.importAttribute;
}
});
Object.defineProperty(exports, "ImportDeclaration", {
enumerable: true,
get: function () {
return _index.importDeclaration;
}
});
Object.defineProperty(exports, "ImportDefaultSpecifier", {
enumerable: true,
get: function () {
return _index.importDefaultSpecifier;
}
});
Object.defineProperty(exports, "ImportExpression", {
enumerable: true,
get: function () {
return _index.importExpression;
}
});
Object.defineProperty(exports, "ImportNamespaceSpecifier", {
enumerable: true,
get: function () {
return _index.importNamespaceSpecifier;
}
});
Object.defineProperty(exports, "ImportSpecifier", {
enumerable: true,
get: function () {
return _index.importSpecifier;
}
});
Object.defineProperty(exports, "IndexedAccessType", {
enumerable: true,
get: function () {
return _index.indexedAccessType;
}
});
Object.defineProperty(exports, "InferredPredicate", {
enumerable: true,
get: function () {
return _index.inferredPredicate;
}
});
Object.defineProperty(exports, "InterfaceDeclaration", {
enumerable: true,
get: function () {
return _index.interfaceDeclaration;
}
});
Object.defineProperty(exports, "InterfaceExtends", {
enumerable: true,
get: function () {
return _index.interfaceExtends;
}
});
Object.defineProperty(exports, "InterfaceTypeAnnotation", {
enumerable: true,
get: function () {
return _index.interfaceTypeAnnotation;
}
});
Object.defineProperty(exports, "InterpreterDirective", {
enumerable: true,
get: function () {
return _index.interpreterDirective;
}
});
Object.defineProperty(exports, "IntersectionTypeAnnotation", {
enumerable: true,
get: function () {
return _index.intersectionTypeAnnotation;
}
});
Object.defineProperty(exports, "JSXAttribute", {
enumerable: true,
get: function () {
return _index.jsxAttribute;
}
});
Object.defineProperty(exports, "JSXClosingElement", {
enumerable: true,
get: function () {
return _index.jsxClosingElement;
}
});
Object.defineProperty(exports, "JSXClosingFragment", {
enumerable: true,
get: function () {
return _index.jsxClosingFragment;
}
});
Object.defineProperty(exports, "JSXElement", {
enumerable: true,
get: function () {
return _index.jsxElement;
}
});
Object.defineProperty(exports, "JSXEmptyExpression", {
enumerable: true,
get: function () {
return _index.jsxEmptyExpression;
}
});
Object.defineProperty(exports, "JSXExpressionContainer", {
enumerable: true,
get: function () {
return _index.jsxExpressionContainer;
}
});
Object.defineProperty(exports, "JSXFragment", {
enumerable: true,
get: function () {
return _index.jsxFragment;
}
});
Object.defineProperty(exports, "JSXIdentifier", {
enumerable: true,
get: function () {
return _index.jsxIdentifier;
}
});
Object.defineProperty(exports, "JSXMemberExpression", {
enumerable: true,
get: function () {
return _index.jsxMemberExpression;
}
});
Object.defineProperty(exports, "JSXNamespacedName", {
enumerable: true,
get: function () {
return _index.jsxNamespacedName;
}
});
Object.defineProperty(exports, "JSXOpeningElement", {
enumerable: true,
get: function () {
return _index.jsxOpeningElement;
}
});
Object.defineProperty(exports, "JSXOpeningFragment", {
enumerable: true,
get: function () {
return _index.jsxOpeningFragment;
}
});
Object.defineProperty(exports, "JSXSpreadAttribute", {
enumerable: true,
get: function () {
return _index.jsxSpreadAttribute;
}
});
Object.defineProperty(exports, "JSXSpreadChild", {
enumerable: true,
get: function () {
return _index.jsxSpreadChild;
}
});
Object.defineProperty(exports, "JSXText", {
enumerable: true,
get: function () {
return _index.jsxText;
}
});
Object.defineProperty(exports, "LabeledStatement", {
enumerable: true,
get: function () {
return _index.labeledStatement;
}
});
Object.defineProperty(exports, "LogicalExpression", {
enumerable: true,
get: function () {
return _index.logicalExpression;
}
});
Object.defineProperty(exports, "MemberExpression", {
enumerable: true,
get: function () {
return _index.memberExpression;
}
});
Object.defineProperty(exports, "MetaProperty", {
enumerable: true,
get: function () {
return _index.metaProperty;
}
});
Object.defineProperty(exports, "MixedTypeAnnotation", {
enumerable: true,
get: function () {
return _index.mixedTypeAnnotation;
}
});
Object.defineProperty(exports, "ModuleExpression", {
enumerable: true,
get: function () {
return _index.moduleExpression;
}
});
Object.defineProperty(exports, "NewExpression", {
enumerable: true,
get: function () {
return _index.newExpression;
}
});
Object.defineProperty(exports, "Noop", {
enumerable: true,
get: function () {
return _index.noop;
}
});
Object.defineProperty(exports, "NullLiteral", {
enumerable: true,
get: function () {
return _index.nullLiteral;
}
});
Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _index.nullLiteralTypeAnnotation;
}
});
Object.defineProperty(exports, "NullableTypeAnnotation", {
enumerable: true,
get: function () {
return _index.nullableTypeAnnotation;
}
});
Object.defineProperty(exports, "NumberLiteral", {
enumerable: true,
get: function () {
return _index.numberLiteral;
}
});
Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _index.numberLiteralTypeAnnotation;
}
});
Object.defineProperty(exports, "NumberTypeAnnotation", {
enumerable: true,
get: function () {
return _index.numberTypeAnnotation;
}
});
Object.defineProperty(exports, "NumericLiteral", {
enumerable: true,
get: function () {
return _index.numericLiteral;
}
});
Object.defineProperty(exports, "ObjectExpression", {
enumerable: true,
get: function () {
return _index.objectExpression;
}
});
Object.defineProperty(exports, "ObjectMethod", {
enumerable: true,
get: function () {
return _index.objectMethod;
}
});
Object.defineProperty(exports, "ObjectPattern", {
enumerable: true,
get: function () {
return _index.objectPattern;
}
});
Object.defineProperty(exports, "ObjectProperty", {
enumerable: true,
get: function () {
return _index.objectProperty;
}
});
Object.defineProperty(exports, "ObjectTypeAnnotation", {
enumerable: true,
get: function () {
return _index.objectTypeAnnotation;
}
});
Object.defineProperty(exports, "ObjectTypeCallProperty", {
enumerable: true,
get: function () {
return _index.objectTypeCallProperty;
}
});
Object.defineProperty(exports, "ObjectTypeIndexer", {
enumerable: true,
get: function () {
return _index.objectTypeIndexer;
}
});
Object.defineProperty(exports, "ObjectTypeInternalSlot", {
enumerable: true,
get: function () {
return _index.objectTypeInternalSlot;
}
});
Object.defineProperty(exports, "ObjectTypeProperty", {
enumerable: true,
get: function () {
return _index.objectTypeProperty;
}
});
Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
enumerable: true,
get: function () {
return _index.objectTypeSpreadProperty;
}
});
Object.defineProperty(exports, "OpaqueType", {
enumerable: true,
get: function () {
return _index.opaqueType;
}
});
Object.defineProperty(exports, "OptionalCallExpression", {
enumerable: true,
get: function () {
return _index.optionalCallExpression;
}
});
Object.defineProperty(exports, "OptionalIndexedAccessType", {
enumerable: true,
get: function () {
return _index.optionalIndexedAccessType;
}
});
Object.defineProperty(exports, "OptionalMemberExpression", {
enumerable: true,
get: function () {
return _index.optionalMemberExpression;
}
});
Object.defineProperty(exports, "ParenthesizedExpression", {
enumerable: true,
get: function () {
return _index.parenthesizedExpression;
}
});
Object.defineProperty(exports, "PipelineBareFunction", {
enumerable: true,
get: function () {
return _index.pipelineBareFunction;
}
});
Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
enumerable: true,
get: function () {
return _index.pipelinePrimaryTopicReference;
}
});
Object.defineProperty(exports, "PipelineTopicExpression", {
enumerable: true,
get: function () {
return _index.pipelineTopicExpression;
}
});
Object.defineProperty(exports, "Placeholder", {
enumerable: true,
get: function () {
return _index.placeholder;
}
});
Object.defineProperty(exports, "PrivateName", {
enumerable: true,
get: function () {
return _index.privateName;
}
});
Object.defineProperty(exports, "Program", {
enumerable: true,
get: function () {
return _index.program;
}
});
Object.defineProperty(exports, "QualifiedTypeIdentifier", {
enumerable: true,
get: function () {
return _index.qualifiedTypeIdentifier;
}
});
Object.defineProperty(exports, "RecordExpression", {
enumerable: true,
get: function () {
return _index.recordExpression;
}
});
Object.defineProperty(exports, "RegExpLiteral", {
enumerable: true,
get: function () {
return _index.regExpLiteral;
}
});
Object.defineProperty(exports, "RegexLiteral", {
enumerable: true,
get: function () {
return _index.regexLiteral;
}
});
Object.defineProperty(exports, "RestElement", {
enumerable: true,
get: function () {
return _index.restElement;
}
});
Object.defineProperty(exports, "RestProperty", {
enumerable: true,
get: function () {
return _index.restProperty;
}
});
Object.defineProperty(exports, "ReturnStatement", {
enumerable: true,
get: function () {
return _index.returnStatement;
}
});
Object.defineProperty(exports, "SequenceExpression", {
enumerable: true,
get: function () {
return _index.sequenceExpression;
}
});
Object.defineProperty(exports, "SpreadElement", {
enumerable: true,
get: function () {
return _index.spreadElement;
}
});
Object.defineProperty(exports, "SpreadProperty", {
enumerable: true,
get: function () {
return _index.spreadProperty;
}
});
Object.defineProperty(exports, "StaticBlock", {
enumerable: true,
get: function () {
return _index.staticBlock;
}
});
Object.defineProperty(exports, "StringLiteral", {
enumerable: true,
get: function () {
return _index.stringLiteral;
}
});
Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _index.stringLiteralTypeAnnotation;
}
});
Object.defineProperty(exports, "StringTypeAnnotation", {
enumerable: true,
get: function () {
return _index.stringTypeAnnotation;
}
});
Object.defineProperty(exports, "Super", {
enumerable: true,
get: function () {
return _index.super;
}
});
Object.defineProperty(exports, "SwitchCase", {
enumerable: true,
get: function () {
return _index.switchCase;
}
});
Object.defineProperty(exports, "SwitchStatement", {
enumerable: true,
get: function () {
return _index.switchStatement;
}
});
Object.defineProperty(exports, "SymbolTypeAnnotation", {
enumerable: true,
get: function () {
return _index.symbolTypeAnnotation;
}
});
Object.defineProperty(exports, "TSAnyKeyword", {
enumerable: true,
get: function () {
return _index.tsAnyKeyword;
}
});
Object.defineProperty(exports, "TSArrayType", {
enumerable: true,
get: function () {
return _index.tsArrayType;
}
});
Object.defineProperty(exports, "TSAsExpression", {
enumerable: true,
get: function () {
return _index.tsAsExpression;
}
});
Object.defineProperty(exports, "TSBigIntKeyword", {
enumerable: true,
get: function () {
return _index.tsBigIntKeyword;
}
});
Object.defineProperty(exports, "TSBooleanKeyword", {
enumerable: true,
get: function () {
return _index.tsBooleanKeyword;
}
});
Object.defineProperty(exports, "TSCallSignatureDeclaration", {
enumerable: true,
get: function () {
return _index.tsCallSignatureDeclaration;
}
});
Object.defineProperty(exports, "TSConditionalType", {
enumerable: true,
get: function () {
return _index.tsConditionalType;
}
});
Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
enumerable: true,
get: function () {
return _index.tsConstructSignatureDeclaration;
}
});
Object.defineProperty(exports, "TSConstructorType", {
enumerable: true,
get: function () {
return _index.tsConstructorType;
}
});
Object.defineProperty(exports, "TSDeclareFunction", {
enumerable: true,
get: function () {
return _index.tsDeclareFunction;
}
});
Object.defineProperty(exports, "TSDeclareMethod", {
enumerable: true,
get: function () {
return _index.tsDeclareMethod;
}
});
Object.defineProperty(exports, "TSEnumDeclaration", {
enumerable: true,
get: function () {
return _index.tsEnumDeclaration;
}
});
Object.defineProperty(exports, "TSEnumMember", {
enumerable: true,
get: function () {
return _index.tsEnumMember;
}
});
Object.defineProperty(exports, "TSExportAssignment", {
enumerable: true,
get: function () {
return _index.tsExportAssignment;
}
});
Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
enumerable: true,
get: function () {
return _index.tsExpressionWithTypeArguments;
}
});
Object.defineProperty(exports, "TSExternalModuleReference", {
enumerable: true,
get: function () {
return _index.tsExternalModuleReference;
}
});
Object.defineProperty(exports, "TSFunctionType", {
enumerable: true,
get: function () {
return _index.tsFunctionType;
}
});
Object.defineProperty(exports, "TSImportEqualsDeclaration", {
enumerable: true,
get: function () {
return _index.tsImportEqualsDeclaration;
}
});
Object.defineProperty(exports, "TSImportType", {
enumerable: true,
get: function () {
return _index.tsImportType;
}
});
Object.defineProperty(exports, "TSIndexSignature", {
enumerable: true,
get: function () {
return _index.tsIndexSignature;
}
});
Object.defineProperty(exports, "TSIndexedAccessType", {
enumerable: true,
get: function () {
return _index.tsIndexedAccessType;
}
});
Object.defineProperty(exports, "TSInferType", {
enumerable: true,
get: function () {
return _index.tsInferType;
}
});
Object.defineProperty(exports, "TSInstantiationExpression", {
enumerable: true,
get: function () {
return _index.tsInstantiationExpression;
}
});
Object.defineProperty(exports, "TSInterfaceBody", {
enumerable: true,
get: function () {
return _index.tsInterfaceBody;
}
});
Object.defineProperty(exports, "TSInterfaceDeclaration", {
enumerable: true,
get: function () {
return _index.tsInterfaceDeclaration;
}
});
Object.defineProperty(exports, "TSIntersectionType", {
enumerable: true,
get: function () {
return _index.tsIntersectionType;
}
});
Object.defineProperty(exports, "TSIntrinsicKeyword", {
enumerable: true,
get: function () {
return _index.tsIntrinsicKeyword;
}
});
Object.defineProperty(exports, "TSLiteralType", {
enumerable: true,
get: function () {
return _index.tsLiteralType;
}
});
Object.defineProperty(exports, "TSMappedType", {
enumerable: true,
get: function () {
return _index.tsMappedType;
}
});
Object.defineProperty(exports, "TSMethodSignature", {
enumerable: true,
get: function () {
return _index.tsMethodSignature;
}
});
Object.defineProperty(exports, "TSModuleBlock", {
enumerable: true,
get: function () {
return _index.tsModuleBlock;
}
});
Object.defineProperty(exports, "TSModuleDeclaration", {
enumerable: true,
get: function () {
return _index.tsModuleDeclaration;
}
});
Object.defineProperty(exports, "TSNamedTupleMember", {
enumerable: true,
get: function () {
return _index.tsNamedTupleMember;
}
});
Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
enumerable: true,
get: function () {
return _index.tsNamespaceExportDeclaration;
}
});
Object.defineProperty(exports, "TSNeverKeyword", {
enumerable: true,
get: function () {
return _index.tsNeverKeyword;
}
});
Object.defineProperty(exports, "TSNonNullExpression", {
enumerable: true,
get: function () {
return _index.tsNonNullExpression;
}
});
Object.defineProperty(exports, "TSNullKeyword", {
enumerable: true,
get: function () {
return _index.tsNullKeyword;
}
});
Object.defineProperty(exports, "TSNumberKeyword", {
enumerable: true,
get: function () {
return _index.tsNumberKeyword;
}
});
Object.defineProperty(exports, "TSObjectKeyword", {
enumerable: true,
get: function () {
return _index.tsObjectKeyword;
}
});
Object.defineProperty(exports, "TSOptionalType", {
enumerable: true,
get: function () {
return _index.tsOptionalType;
}
});
Object.defineProperty(exports, "TSParameterProperty", {
enumerable: true,
get: function () {
return _index.tsParameterProperty;
}
});
Object.defineProperty(exports, "TSParenthesizedType", {
enumerable: true,
get: function () {
return _index.tsParenthesizedType;
}
});
Object.defineProperty(exports, "TSPropertySignature", {
enumerable: true,
get: function () {
return _index.tsPropertySignature;
}
});
Object.defineProperty(exports, "TSQualifiedName", {
enumerable: true,
get: function () {
return _index.tsQualifiedName;
}
});
Object.defineProperty(exports, "TSRestType", {
enumerable: true,
get: function () {
return _index.tsRestType;
}
});
Object.defineProperty(exports, "TSSatisfiesExpression", {
enumerable: true,
get: function () {
return _index.tsSatisfiesExpression;
}
});
Object.defineProperty(exports, "TSStringKeyword", {
enumerable: true,
get: function () {
return _index.tsStringKeyword;
}
});
Object.defineProperty(exports, "TSSymbolKeyword", {
enumerable: true,
get: function () {
return _index.tsSymbolKeyword;
}
});
Object.defineProperty(exports, "TSThisType", {
enumerable: true,
get: function () {
return _index.tsThisType;
}
});
Object.defineProperty(exports, "TSTupleType", {
enumerable: true,
get: function () {
return _index.tsTupleType;
}
});
Object.defineProperty(exports, "TSTypeAliasDeclaration", {
enumerable: true,
get: function () {
return _index.tsTypeAliasDeclaration;
}
});
Object.defineProperty(exports, "TSTypeAnnotation", {
enumerable: true,
get: function () {
return _index.tsTypeAnnotation;
}
});
Object.defineProperty(exports, "TSTypeAssertion", {
enumerable: true,
get: function () {
return _index.tsTypeAssertion;
}
});
Object.defineProperty(exports, "TSTypeLiteral", {
enumerable: true,
get: function () {
return _index.tsTypeLiteral;
}
});
Object.defineProperty(exports, "TSTypeOperator", {
enumerable: true,
get: function () {
return _index.tsTypeOperator;
}
});
Object.defineProperty(exports, "TSTypeParameter", {
enumerable: true,
get: function () {
return _index.tsTypeParameter;
}
});
Object.defineProperty(exports, "TSTypeParameterDeclaration", {
enumerable: true,
get: function () {
return _index.tsTypeParameterDeclaration;
}
});
Object.defineProperty(exports, "TSTypeParameterInstantiation", {
enumerable: true,
get: function () {
return _index.tsTypeParameterInstantiation;
}
});
Object.defineProperty(exports, "TSTypePredicate", {
enumerable: true,
get: function () {
return _index.tsTypePredicate;
}
});
Object.defineProperty(exports, "TSTypeQuery", {
enumerable: true,
get: function () {
return _index.tsTypeQuery;
}
});
Object.defineProperty(exports, "TSTypeReference", {
enumerable: true,
get: function () {
return _index.tsTypeReference;
}
});
Object.defineProperty(exports, "TSUndefinedKeyword", {
enumerable: true,
get: function () {
return _index.tsUndefinedKeyword;
}
});
Object.defineProperty(exports, "TSUnionType", {
enumerable: true,
get: function () {
return _index.tsUnionType;
}
});
Object.defineProperty(exports, "TSUnknownKeyword", {
enumerable: true,
get: function () {
return _index.tsUnknownKeyword;
}
});
Object.defineProperty(exports, "TSVoidKeyword", {
enumerable: true,
get: function () {
return _index.tsVoidKeyword;
}
});
Object.defineProperty(exports, "TaggedTemplateExpression", {
enumerable: true,
get: function () {
return _index.taggedTemplateExpression;
}
});
Object.defineProperty(exports, "TemplateElement", {
enumerable: true,
get: function () {
return _index.templateElement;
}
});
Object.defineProperty(exports, "TemplateLiteral", {
enumerable: true,
get: function () {
return _index.templateLiteral;
}
});
Object.defineProperty(exports, "ThisExpression", {
enumerable: true,
get: function () {
return _index.thisExpression;
}
});
Object.defineProperty(exports, "ThisTypeAnnotation", {
enumerable: true,
get: function () {
return _index.thisTypeAnnotation;
}
});
Object.defineProperty(exports, "ThrowStatement", {
enumerable: true,
get: function () {
return _index.throwStatement;
}
});
Object.defineProperty(exports, "TopicReference", {
enumerable: true,
get: function () {
return _index.topicReference;
}
});
Object.defineProperty(exports, "TryStatement", {
enumerable: true,
get: function () {
return _index.tryStatement;
}
});
Object.defineProperty(exports, "TupleExpression", {
enumerable: true,
get: function () {
return _index.tupleExpression;
}
});
Object.defineProperty(exports, "TupleTypeAnnotation", {
enumerable: true,
get: function () {
return _index.tupleTypeAnnotation;
}
});
Object.defineProperty(exports, "TypeAlias", {
enumerable: true,
get: function () {
return _index.typeAlias;
}
});
Object.defineProperty(exports, "TypeAnnotation", {
enumerable: true,
get: function () {
return _index.typeAnnotation;
}
});
Object.defineProperty(exports, "TypeCastExpression", {
enumerable: true,
get: function () {
return _index.typeCastExpression;
}
});
Object.defineProperty(exports, "TypeParameter", {
enumerable: true,
get: function () {
return _index.typeParameter;
}
});
Object.defineProperty(exports, "TypeParameterDeclaration", {
enumerable: true,
get: function () {
return _index.typeParameterDeclaration;
}
});
Object.defineProperty(exports, "TypeParameterInstantiation", {
enumerable: true,
get: function () {
return _index.typeParameterInstantiation;
}
});
Object.defineProperty(exports, "TypeofTypeAnnotation", {
enumerable: true,
get: function () {
return _index.typeofTypeAnnotation;
}
});
Object.defineProperty(exports, "UnaryExpression", {
enumerable: true,
get: function () {
return _index.unaryExpression;
}
});
Object.defineProperty(exports, "UnionTypeAnnotation", {
enumerable: true,
get: function () {
return _index.unionTypeAnnotation;
}
});
Object.defineProperty(exports, "UpdateExpression", {
enumerable: true,
get: function () {
return _index.updateExpression;
}
});
Object.defineProperty(exports, "V8IntrinsicIdentifier", {
enumerable: true,
get: function () {
return _index.v8IntrinsicIdentifier;
}
});
Object.defineProperty(exports, "VariableDeclaration", {
enumerable: true,
get: function () {
return _index.variableDeclaration;
}
});
Object.defineProperty(exports, "VariableDeclarator", {
enumerable: true,
get: function () {
return _index.variableDeclarator;
}
});
Object.defineProperty(exports, "Variance", {
enumerable: true,
get: function () {
return _index.variance;
}
});
Object.defineProperty(exports, "VoidTypeAnnotation", {
enumerable: true,
get: function () {
return _index.voidTypeAnnotation;
}
});
Object.defineProperty(exports, "WhileStatement", {
enumerable: true,
get: function () {
return _index.whileStatement;
}
});
Object.defineProperty(exports, "WithStatement", {
enumerable: true,
get: function () {
return _index.withStatement;
}
});
Object.defineProperty(exports, "YieldExpression", {
enumerable: true,
get: function () {
return _index.yieldExpression;
}
});
var _index = requireGenerated$2();
} (uppercase));
return uppercase;
}
var productions = {};
var hasRequiredProductions;
function requireProductions () {
if (hasRequiredProductions) return productions;
hasRequiredProductions = 1;
Object.defineProperty(productions, "__esModule", {
value: true
});
productions.buildUndefinedNode = buildUndefinedNode;
var _index = requireGenerated$2();
function buildUndefinedNode() {
return (0, _index.unaryExpression)("void", (0, _index.numericLiteral)(0), true);
}
return productions;
}
var cloneNode = {};
var hasRequiredCloneNode;
function requireCloneNode () {
if (hasRequiredCloneNode) return cloneNode;
hasRequiredCloneNode = 1;
Object.defineProperty(cloneNode, "__esModule", {
value: true
});
cloneNode.default = cloneNode$1;
var _index = requireDefinitions();
var _index2 = requireGenerated$3();
const has = Function.call.bind(Object.prototype.hasOwnProperty);
function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
if (obj && typeof obj.type === "string") {
return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
}
return obj;
}
function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
if (Array.isArray(obj)) {
return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
}
return cloneIfNode(obj, deep, withoutLoc, commentsCache);
}
function cloneNode$1(node, deep = true, withoutLoc = false) {
return cloneNodeInternal(node, deep, withoutLoc, new Map());
}
function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
if (!node) return node;
const {
type
} = node;
const newNode = {
type: node.type
};
if ((0, _index2.isIdentifier)(node)) {
newNode.name = node.name;
if (has(node, "optional") && typeof node.optional === "boolean") {
newNode.optional = node.optional;
}
if (has(node, "typeAnnotation")) {
newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
}
} else if (!has(_index.NODE_FIELDS, type)) {
throw new Error(`Unknown node type: "${type}"`);
} else {
for (const field of Object.keys(_index.NODE_FIELDS[type])) {
if (has(node, field)) {
if (deep) {
newNode[field] = (0, _index2.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
} else {
newNode[field] = node[field];
}
}
}
}
if (has(node, "loc")) {
if (withoutLoc) {
newNode.loc = null;
} else {
newNode.loc = node.loc;
}
}
if (has(node, "leadingComments")) {
newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
}
if (has(node, "innerComments")) {
newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
}
if (has(node, "trailingComments")) {
newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
}
if (has(node, "extra")) {
newNode.extra = Object.assign({}, node.extra);
}
return newNode;
}
function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
if (!comments || !deep) {
return comments;
}
return comments.map(comment => {
const cache = commentsCache.get(comment);
if (cache) return cache;
const {
type,
value,
loc
} = comment;
const ret = {
type,
value,
loc
};
if (withoutLoc) {
ret.loc = null;
}
commentsCache.set(comment, ret);
return ret;
});
}
return cloneNode;
}
var clone = {};
var hasRequiredClone;
function requireClone () {
if (hasRequiredClone) return clone;
hasRequiredClone = 1;
Object.defineProperty(clone, "__esModule", {
value: true
});
clone.default = clone$1;
var _cloneNode = requireCloneNode();
function clone$1(node) {
return (0, _cloneNode.default)(node, false);
}
return clone;
}
var cloneDeep = {};
var hasRequiredCloneDeep;
function requireCloneDeep () {
if (hasRequiredCloneDeep) return cloneDeep;
hasRequiredCloneDeep = 1;
Object.defineProperty(cloneDeep, "__esModule", {
value: true
});
cloneDeep.default = cloneDeep$1;
var _cloneNode = requireCloneNode();
function cloneDeep$1(node) {
return (0, _cloneNode.default)(node);
}
return cloneDeep;
}
var cloneDeepWithoutLoc = {};
var hasRequiredCloneDeepWithoutLoc;
function requireCloneDeepWithoutLoc () {
if (hasRequiredCloneDeepWithoutLoc) return cloneDeepWithoutLoc;
hasRequiredCloneDeepWithoutLoc = 1;
Object.defineProperty(cloneDeepWithoutLoc, "__esModule", {
value: true
});
cloneDeepWithoutLoc.default = cloneDeepWithoutLoc$1;
var _cloneNode = requireCloneNode();
function cloneDeepWithoutLoc$1(node) {
return (0, _cloneNode.default)(node, true, true);
}
return cloneDeepWithoutLoc;
}
var cloneWithoutLoc = {};
var hasRequiredCloneWithoutLoc;
function requireCloneWithoutLoc () {
if (hasRequiredCloneWithoutLoc) return cloneWithoutLoc;
hasRequiredCloneWithoutLoc = 1;
Object.defineProperty(cloneWithoutLoc, "__esModule", {
value: true
});
cloneWithoutLoc.default = cloneWithoutLoc$1;
var _cloneNode = requireCloneNode();
function cloneWithoutLoc$1(node) {
return (0, _cloneNode.default)(node, false, true);
}
return cloneWithoutLoc;
}
var addComment = {};
var addComments = {};
var hasRequiredAddComments;
function requireAddComments () {
if (hasRequiredAddComments) return addComments;
hasRequiredAddComments = 1;
Object.defineProperty(addComments, "__esModule", {
value: true
});
addComments.default = addComments$1;
function addComments$1(node, type, comments) {
if (!comments || !node) return node;
const key = `${type}Comments`;
if (node[key]) {
if (type === "leading") {
node[key] = comments.concat(node[key]);
} else {
node[key].push(...comments);
}
} else {
node[key] = comments;
}
return node;
}
return addComments;
}
var hasRequiredAddComment;
function requireAddComment () {
if (hasRequiredAddComment) return addComment;
hasRequiredAddComment = 1;
Object.defineProperty(addComment, "__esModule", {
value: true
});
addComment.default = addComment$1;
var _addComments = requireAddComments();
function addComment$1(node, type, content, line) {
return (0, _addComments.default)(node, type, [{
type: line ? "CommentLine" : "CommentBlock",
value: content
}]);
}
return addComment;
}
var inheritInnerComments = {};
var inherit = {};
var hasRequiredInherit;
function requireInherit () {
if (hasRequiredInherit) return inherit;
hasRequiredInherit = 1;
Object.defineProperty(inherit, "__esModule", {
value: true
});
inherit.default = inherit$1;
function inherit$1(key, child, parent) {
if (child && parent) {
child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
}
}
return inherit;
}
var hasRequiredInheritInnerComments;
function requireInheritInnerComments () {
if (hasRequiredInheritInnerComments) return inheritInnerComments;
hasRequiredInheritInnerComments = 1;
Object.defineProperty(inheritInnerComments, "__esModule", {
value: true
});
inheritInnerComments.default = inheritInnerComments$1;
var _inherit = requireInherit();
function inheritInnerComments$1(child, parent) {
(0, _inherit.default)("innerComments", child, parent);
}
return inheritInnerComments;
}
var inheritLeadingComments = {};
var hasRequiredInheritLeadingComments;
function requireInheritLeadingComments () {
if (hasRequiredInheritLeadingComments) return inheritLeadingComments;
hasRequiredInheritLeadingComments = 1;
Object.defineProperty(inheritLeadingComments, "__esModule", {
value: true
});
inheritLeadingComments.default = inheritLeadingComments$1;
var _inherit = requireInherit();
function inheritLeadingComments$1(child, parent) {
(0, _inherit.default)("leadingComments", child, parent);
}
return inheritLeadingComments;
}
var inheritsComments = {};
var inheritTrailingComments = {};
var hasRequiredInheritTrailingComments;
function requireInheritTrailingComments () {
if (hasRequiredInheritTrailingComments) return inheritTrailingComments;
hasRequiredInheritTrailingComments = 1;
Object.defineProperty(inheritTrailingComments, "__esModule", {
value: true
});
inheritTrailingComments.default = inheritTrailingComments$1;
var _inherit = requireInherit();
function inheritTrailingComments$1(child, parent) {
(0, _inherit.default)("trailingComments", child, parent);
}
return inheritTrailingComments;
}
var hasRequiredInheritsComments;
function requireInheritsComments () {
if (hasRequiredInheritsComments) return inheritsComments;
hasRequiredInheritsComments = 1;
Object.defineProperty(inheritsComments, "__esModule", {
value: true
});
inheritsComments.default = inheritsComments$1;
var _inheritTrailingComments = requireInheritTrailingComments();
var _inheritLeadingComments = requireInheritLeadingComments();
var _inheritInnerComments = requireInheritInnerComments();
function inheritsComments$1(child, parent) {
(0, _inheritTrailingComments.default)(child, parent);
(0, _inheritLeadingComments.default)(child, parent);
(0, _inheritInnerComments.default)(child, parent);
return child;
}
return inheritsComments;
}
var removeComments = {};
var hasRequiredRemoveComments;
function requireRemoveComments () {
if (hasRequiredRemoveComments) return removeComments;
hasRequiredRemoveComments = 1;
Object.defineProperty(removeComments, "__esModule", {
value: true
});
removeComments.default = removeComments$1;
var _index = requireConstants();
function removeComments$1(node) {
_index.COMMENT_KEYS.forEach(key => {
node[key] = null;
});
return node;
}
return removeComments;
}
var generated = {};
var hasRequiredGenerated;
function requireGenerated () {
if (hasRequiredGenerated) return generated;
hasRequiredGenerated = 1;
Object.defineProperty(generated, "__esModule", {
value: true
});
generated.WHILE_TYPES = generated.USERWHITESPACABLE_TYPES = generated.UNARYLIKE_TYPES = generated.TYPESCRIPT_TYPES = generated.TSTYPE_TYPES = generated.TSTYPEELEMENT_TYPES = generated.TSENTITYNAME_TYPES = generated.TSBASETYPE_TYPES = generated.TERMINATORLESS_TYPES = generated.STATEMENT_TYPES = generated.STANDARDIZED_TYPES = generated.SCOPABLE_TYPES = generated.PUREISH_TYPES = generated.PROPERTY_TYPES = generated.PRIVATE_TYPES = generated.PATTERN_TYPES = generated.PATTERNLIKE_TYPES = generated.OBJECTMEMBER_TYPES = generated.MODULESPECIFIER_TYPES = generated.MODULEDECLARATION_TYPES = generated.MISCELLANEOUS_TYPES = generated.METHOD_TYPES = generated.LVAL_TYPES = generated.LOOP_TYPES = generated.LITERAL_TYPES = generated.JSX_TYPES = generated.IMPORTOREXPORTDECLARATION_TYPES = generated.IMMUTABLE_TYPES = generated.FUNCTION_TYPES = generated.FUNCTIONPARENT_TYPES = generated.FOR_TYPES = generated.FORXSTATEMENT_TYPES = generated.FLOW_TYPES = generated.FLOWTYPE_TYPES = generated.FLOWPREDICATE_TYPES = generated.FLOWDECLARATION_TYPES = generated.FLOWBASEANNOTATION_TYPES = generated.EXPRESSION_TYPES = generated.EXPRESSIONWRAPPER_TYPES = generated.EXPORTDECLARATION_TYPES = generated.ENUMMEMBER_TYPES = generated.ENUMBODY_TYPES = generated.DECLARATION_TYPES = generated.CONDITIONAL_TYPES = generated.COMPLETIONSTATEMENT_TYPES = generated.CLASS_TYPES = generated.BLOCK_TYPES = generated.BLOCKPARENT_TYPES = generated.BINARY_TYPES = generated.ACCESSOR_TYPES = void 0;
var _index = requireDefinitions();
const STANDARDIZED_TYPES = _index.FLIPPED_ALIAS_KEYS["Standardized"];
generated.STANDARDIZED_TYPES = STANDARDIZED_TYPES;
const EXPRESSION_TYPES = _index.FLIPPED_ALIAS_KEYS["Expression"];
generated.EXPRESSION_TYPES = EXPRESSION_TYPES;
const BINARY_TYPES = _index.FLIPPED_ALIAS_KEYS["Binary"];
generated.BINARY_TYPES = BINARY_TYPES;
const SCOPABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Scopable"];
generated.SCOPABLE_TYPES = SCOPABLE_TYPES;
const BLOCKPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["BlockParent"];
generated.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
const BLOCK_TYPES = _index.FLIPPED_ALIAS_KEYS["Block"];
generated.BLOCK_TYPES = BLOCK_TYPES;
const STATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["Statement"];
generated.STATEMENT_TYPES = STATEMENT_TYPES;
const TERMINATORLESS_TYPES = _index.FLIPPED_ALIAS_KEYS["Terminatorless"];
generated.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
const COMPLETIONSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["CompletionStatement"];
generated.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
const CONDITIONAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Conditional"];
generated.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
const LOOP_TYPES = _index.FLIPPED_ALIAS_KEYS["Loop"];
generated.LOOP_TYPES = LOOP_TYPES;
const WHILE_TYPES = _index.FLIPPED_ALIAS_KEYS["While"];
generated.WHILE_TYPES = WHILE_TYPES;
const EXPRESSIONWRAPPER_TYPES = _index.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
generated.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
const FOR_TYPES = _index.FLIPPED_ALIAS_KEYS["For"];
generated.FOR_TYPES = FOR_TYPES;
const FORXSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["ForXStatement"];
generated.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
const FUNCTION_TYPES = _index.FLIPPED_ALIAS_KEYS["Function"];
generated.FUNCTION_TYPES = FUNCTION_TYPES;
const FUNCTIONPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParent"];
generated.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
const PUREISH_TYPES = _index.FLIPPED_ALIAS_KEYS["Pureish"];
generated.PUREISH_TYPES = PUREISH_TYPES;
const DECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["Declaration"];
generated.DECLARATION_TYPES = DECLARATION_TYPES;
const PATTERNLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["PatternLike"];
generated.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
const LVAL_TYPES = _index.FLIPPED_ALIAS_KEYS["LVal"];
generated.LVAL_TYPES = LVAL_TYPES;
const TSENTITYNAME_TYPES = _index.FLIPPED_ALIAS_KEYS["TSEntityName"];
generated.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
const LITERAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Literal"];
generated.LITERAL_TYPES = LITERAL_TYPES;
const IMMUTABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Immutable"];
generated.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
const USERWHITESPACABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
generated.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
const METHOD_TYPES = _index.FLIPPED_ALIAS_KEYS["Method"];
generated.METHOD_TYPES = METHOD_TYPES;
const OBJECTMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["ObjectMember"];
generated.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
const PROPERTY_TYPES = _index.FLIPPED_ALIAS_KEYS["Property"];
generated.PROPERTY_TYPES = PROPERTY_TYPES;
const UNARYLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["UnaryLike"];
generated.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
const PATTERN_TYPES = _index.FLIPPED_ALIAS_KEYS["Pattern"];
generated.PATTERN_TYPES = PATTERN_TYPES;
const CLASS_TYPES = _index.FLIPPED_ALIAS_KEYS["Class"];
generated.CLASS_TYPES = CLASS_TYPES;
const IMPORTOREXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
generated.IMPORTOREXPORTDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
const EXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
generated.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
const MODULESPECIFIER_TYPES = _index.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
generated.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
const ACCESSOR_TYPES = _index.FLIPPED_ALIAS_KEYS["Accessor"];
generated.ACCESSOR_TYPES = ACCESSOR_TYPES;
const PRIVATE_TYPES = _index.FLIPPED_ALIAS_KEYS["Private"];
generated.PRIVATE_TYPES = PRIVATE_TYPES;
const FLOW_TYPES = _index.FLIPPED_ALIAS_KEYS["Flow"];
generated.FLOW_TYPES = FLOW_TYPES;
const FLOWTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowType"];
generated.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
const FLOWBASEANNOTATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
generated.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
const FLOWDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
generated.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
const FLOWPREDICATE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowPredicate"];
generated.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
const ENUMBODY_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumBody"];
generated.ENUMBODY_TYPES = ENUMBODY_TYPES;
const ENUMMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumMember"];
generated.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
const JSX_TYPES = _index.FLIPPED_ALIAS_KEYS["JSX"];
generated.JSX_TYPES = JSX_TYPES;
const MISCELLANEOUS_TYPES = _index.FLIPPED_ALIAS_KEYS["Miscellaneous"];
generated.MISCELLANEOUS_TYPES = MISCELLANEOUS_TYPES;
const TYPESCRIPT_TYPES = _index.FLIPPED_ALIAS_KEYS["TypeScript"];
generated.TYPESCRIPT_TYPES = TYPESCRIPT_TYPES;
const TSTYPEELEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["TSTypeElement"];
generated.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
const TSTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSType"];
generated.TSTYPE_TYPES = TSTYPE_TYPES;
const TSBASETYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSBaseType"];
generated.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
const MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
generated.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
return generated;
}
var ensureBlock = {};
var toBlock = {};
var hasRequiredToBlock;
function requireToBlock () {
if (hasRequiredToBlock) return toBlock;
hasRequiredToBlock = 1;
Object.defineProperty(toBlock, "__esModule", {
value: true
});
toBlock.default = toBlock$1;
var _index = requireGenerated$3();
var _index2 = requireGenerated$2();
function toBlock$1(node, parent) {
if ((0, _index.isBlockStatement)(node)) {
return node;
}
let blockNodes = [];
if ((0, _index.isEmptyStatement)(node)) {
blockNodes = [];
} else {
if (!(0, _index.isStatement)(node)) {
if ((0, _index.isFunction)(parent)) {
node = (0, _index2.returnStatement)(node);
} else {
node = (0, _index2.expressionStatement)(node);
}
}
blockNodes = [node];
}
return (0, _index2.blockStatement)(blockNodes);
}
return toBlock;
}
var hasRequiredEnsureBlock;
function requireEnsureBlock () {
if (hasRequiredEnsureBlock) return ensureBlock;
hasRequiredEnsureBlock = 1;
Object.defineProperty(ensureBlock, "__esModule", {
value: true
});
ensureBlock.default = ensureBlock$1;
var _toBlock = requireToBlock();
function ensureBlock$1(node, key = "body") {
const result = (0, _toBlock.default)(node[key], node);
node[key] = result;
return result;
}
return ensureBlock;
}
var toBindingIdentifierName = {};
var toIdentifier = {};
var hasRequiredToIdentifier;
function requireToIdentifier () {
if (hasRequiredToIdentifier) return toIdentifier;
hasRequiredToIdentifier = 1;
Object.defineProperty(toIdentifier, "__esModule", {
value: true
});
toIdentifier.default = toIdentifier$1;
var _isValidIdentifier = requireIsValidIdentifier();
var _helperValidatorIdentifier = requireLib$4();
function toIdentifier$1(input) {
input = input + "";
let name = "";
for (const c of input) {
name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
}
name = name.replace(/^[-0-9]+/, "");
name = name.replace(/[-\s]+(.)?/g, function (match, c) {
return c ? c.toUpperCase() : "";
});
if (!(0, _isValidIdentifier.default)(name)) {
name = `_${name}`;
}
return name || "_";
}
return toIdentifier;
}
var hasRequiredToBindingIdentifierName;
function requireToBindingIdentifierName () {
if (hasRequiredToBindingIdentifierName) return toBindingIdentifierName;
hasRequiredToBindingIdentifierName = 1;
Object.defineProperty(toBindingIdentifierName, "__esModule", {
value: true
});
toBindingIdentifierName.default = toBindingIdentifierName$1;
var _toIdentifier = requireToIdentifier();
function toBindingIdentifierName$1(name) {
name = (0, _toIdentifier.default)(name);
if (name === "eval" || name === "arguments") name = "_" + name;
return name;
}
return toBindingIdentifierName;
}
var toComputedKey = {};
var hasRequiredToComputedKey;
function requireToComputedKey () {
if (hasRequiredToComputedKey) return toComputedKey;
hasRequiredToComputedKey = 1;
Object.defineProperty(toComputedKey, "__esModule", {
value: true
});
toComputedKey.default = toComputedKey$1;
var _index = requireGenerated$3();
var _index2 = requireGenerated$2();
function toComputedKey$1(node, key = node.key || node.property) {
if (!node.computed && (0, _index.isIdentifier)(key)) key = (0, _index2.stringLiteral)(key.name);
return key;
}
return toComputedKey;
}
var toExpression = {};
var hasRequiredToExpression;
function requireToExpression () {
if (hasRequiredToExpression) return toExpression;
hasRequiredToExpression = 1;
Object.defineProperty(toExpression, "__esModule", {
value: true
});
toExpression.default = void 0;
var _index = requireGenerated$3();
var _default = toExpression$1;
toExpression.default = _default;
function toExpression$1(node) {
if ((0, _index.isExpressionStatement)(node)) {
node = node.expression;
}
if ((0, _index.isExpression)(node)) {
return node;
}
if ((0, _index.isClass)(node)) {
node.type = "ClassExpression";
} else if ((0, _index.isFunction)(node)) {
node.type = "FunctionExpression";
}
if (!(0, _index.isExpression)(node)) {
throw new Error(`cannot turn ${node.type} to an expression`);
}
return node;
}
return toExpression;
}
var toKeyAlias = {};
var removePropertiesDeep = {};
var traverseFast = {};
var hasRequiredTraverseFast;
function requireTraverseFast () {
if (hasRequiredTraverseFast) return traverseFast;
hasRequiredTraverseFast = 1;
Object.defineProperty(traverseFast, "__esModule", {
value: true
});
traverseFast.default = traverseFast$1;
var _index = requireDefinitions();
function traverseFast$1(node, enter, opts) {
if (!node) return;
const keys = _index.VISITOR_KEYS[node.type];
if (!keys) return;
opts = opts || {};
enter(node, opts);
for (const key of keys) {
const subNode = node[key];
if (Array.isArray(subNode)) {
for (const node of subNode) {
traverseFast$1(node, enter, opts);
}
} else {
traverseFast$1(subNode, enter, opts);
}
}
}
return traverseFast;
}
var removeProperties = {};
var hasRequiredRemoveProperties;
function requireRemoveProperties () {
if (hasRequiredRemoveProperties) return removeProperties;
hasRequiredRemoveProperties = 1;
Object.defineProperty(removeProperties, "__esModule", {
value: true
});
removeProperties.default = removeProperties$1;
var _index = requireConstants();
const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
const CLEAR_KEYS_PLUS_COMMENTS = [..._index.COMMENT_KEYS, "comments", ...CLEAR_KEYS];
function removeProperties$1(node, opts = {}) {
const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
for (const key of map) {
if (node[key] != null) node[key] = undefined;
}
for (const key of Object.keys(node)) {
if (key[0] === "_" && node[key] != null) node[key] = undefined;
}
const symbols = Object.getOwnPropertySymbols(node);
for (const sym of symbols) {
node[sym] = null;
}
}
return removeProperties;
}
var hasRequiredRemovePropertiesDeep;
function requireRemovePropertiesDeep () {
if (hasRequiredRemovePropertiesDeep) return removePropertiesDeep;
hasRequiredRemovePropertiesDeep = 1;
Object.defineProperty(removePropertiesDeep, "__esModule", {
value: true
});
removePropertiesDeep.default = removePropertiesDeep$1;
var _traverseFast = requireTraverseFast();
var _removeProperties = requireRemoveProperties();
function removePropertiesDeep$1(tree, opts) {
(0, _traverseFast.default)(tree, _removeProperties.default, opts);
return tree;
}
return removePropertiesDeep;
}
var hasRequiredToKeyAlias;
function requireToKeyAlias () {
if (hasRequiredToKeyAlias) return toKeyAlias;
hasRequiredToKeyAlias = 1;
Object.defineProperty(toKeyAlias, "__esModule", {
value: true
});
toKeyAlias.default = toKeyAlias$1;
var _index = requireGenerated$3();
var _cloneNode = requireCloneNode();
var _removePropertiesDeep = requireRemovePropertiesDeep();
function toKeyAlias$1(node, key = node.key) {
let alias;
if (node.kind === "method") {
return toKeyAlias$1.increment() + "";
} else if ((0, _index.isIdentifier)(key)) {
alias = key.name;
} else if ((0, _index.isStringLiteral)(key)) {
alias = JSON.stringify(key.value);
} else {
alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
}
if (node.computed) {
alias = `[${alias}]`;
}
if (node.static) {
alias = `static:${alias}`;
}
return alias;
}
toKeyAlias$1.uid = 0;
toKeyAlias$1.increment = function () {
if (toKeyAlias$1.uid >= Number.MAX_SAFE_INTEGER) {
return toKeyAlias$1.uid = 0;
} else {
return toKeyAlias$1.uid++;
}
};
return toKeyAlias;
}
var toSequenceExpression = {};
var gatherSequenceExpressions = {};
var getBindingIdentifiers = {};
var hasRequiredGetBindingIdentifiers;
function requireGetBindingIdentifiers () {
if (hasRequiredGetBindingIdentifiers) return getBindingIdentifiers;
hasRequiredGetBindingIdentifiers = 1;
Object.defineProperty(getBindingIdentifiers, "__esModule", {
value: true
});
getBindingIdentifiers.default = getBindingIdentifiers$1;
var _index = requireGenerated$3();
function getBindingIdentifiers$1(node, duplicates, outerOnly) {
const search = [].concat(node);
const ids = Object.create(null);
while (search.length) {
const id = search.shift();
if (!id) continue;
const keys = getBindingIdentifiers$1.keys[id.type];
if ((0, _index.isIdentifier)(id)) {
if (duplicates) {
const _ids = ids[id.name] = ids[id.name] || [];
_ids.push(id);
} else {
ids[id.name] = id;
}
continue;
}
if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) {
if ((0, _index.isDeclaration)(id.declaration)) {
search.push(id.declaration);
}
continue;
}
if (outerOnly) {
if ((0, _index.isFunctionDeclaration)(id)) {
search.push(id.id);
continue;
}
if ((0, _index.isFunctionExpression)(id)) {
continue;
}
}
if (keys) {
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
const nodes = id[key];
if (nodes) {
Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes);
}
}
}
}
return ids;
}
getBindingIdentifiers$1.keys = {
DeclareClass: ["id"],
DeclareFunction: ["id"],
DeclareModule: ["id"],
DeclareVariable: ["id"],
DeclareInterface: ["id"],
DeclareTypeAlias: ["id"],
DeclareOpaqueType: ["id"],
InterfaceDeclaration: ["id"],
TypeAlias: ["id"],
OpaqueType: ["id"],
CatchClause: ["param"],
LabeledStatement: ["label"],
UnaryExpression: ["argument"],
AssignmentExpression: ["left"],
ImportSpecifier: ["local"],
ImportNamespaceSpecifier: ["local"],
ImportDefaultSpecifier: ["local"],
ImportDeclaration: ["specifiers"],
ExportSpecifier: ["exported"],
ExportNamespaceSpecifier: ["exported"],
ExportDefaultSpecifier: ["exported"],
FunctionDeclaration: ["id", "params"],
FunctionExpression: ["id", "params"],
ArrowFunctionExpression: ["params"],
ObjectMethod: ["params"],
ClassMethod: ["params"],
ClassPrivateMethod: ["params"],
ForInStatement: ["left"],
ForOfStatement: ["left"],
ClassDeclaration: ["id"],
ClassExpression: ["id"],
RestElement: ["argument"],
UpdateExpression: ["argument"],
ObjectProperty: ["value"],
AssignmentPattern: ["left"],
ArrayPattern: ["elements"],
ObjectPattern: ["properties"],
VariableDeclaration: ["declarations"],
VariableDeclarator: ["id"]
};
return getBindingIdentifiers;
}
var hasRequiredGatherSequenceExpressions;
function requireGatherSequenceExpressions () {
if (hasRequiredGatherSequenceExpressions) return gatherSequenceExpressions;
hasRequiredGatherSequenceExpressions = 1;
Object.defineProperty(gatherSequenceExpressions, "__esModule", {
value: true
});
gatherSequenceExpressions.default = gatherSequenceExpressions$1;
var _getBindingIdentifiers = requireGetBindingIdentifiers();
var _index = requireGenerated$3();
var _index2 = requireGenerated$2();
var _cloneNode = requireCloneNode();
function gatherSequenceExpressions$1(nodes, scope, declars) {
const exprs = [];
let ensureLastUndefined = true;
for (const node of nodes) {
if (!(0, _index.isEmptyStatement)(node)) {
ensureLastUndefined = false;
}
if ((0, _index.isExpression)(node)) {
exprs.push(node);
} else if ((0, _index.isExpressionStatement)(node)) {
exprs.push(node.expression);
} else if ((0, _index.isVariableDeclaration)(node)) {
if (node.kind !== "var") return;
for (const declar of node.declarations) {
const bindings = (0, _getBindingIdentifiers.default)(declar);
for (const key of Object.keys(bindings)) {
declars.push({
kind: node.kind,
id: (0, _cloneNode.default)(bindings[key])
});
}
if (declar.init) {
exprs.push((0, _index2.assignmentExpression)("=", declar.id, declar.init));
}
}
ensureLastUndefined = true;
} else if ((0, _index.isIfStatement)(node)) {
const consequent = node.consequent ? gatherSequenceExpressions$1([node.consequent], scope, declars) : scope.buildUndefinedNode();
const alternate = node.alternate ? gatherSequenceExpressions$1([node.alternate], scope, declars) : scope.buildUndefinedNode();
if (!consequent || !alternate) return;
exprs.push((0, _index2.conditionalExpression)(node.test, consequent, alternate));
} else if ((0, _index.isBlockStatement)(node)) {
const body = gatherSequenceExpressions$1(node.body, scope, declars);
if (!body) return;
exprs.push(body);
} else if ((0, _index.isEmptyStatement)(node)) {
if (nodes.indexOf(node) === 0) {
ensureLastUndefined = true;
}
} else {
return;
}
}
if (ensureLastUndefined) {
exprs.push(scope.buildUndefinedNode());
}
if (exprs.length === 1) {
return exprs[0];
} else {
return (0, _index2.sequenceExpression)(exprs);
}
}
return gatherSequenceExpressions;
}
var hasRequiredToSequenceExpression;
function requireToSequenceExpression () {
if (hasRequiredToSequenceExpression) return toSequenceExpression;
hasRequiredToSequenceExpression = 1;
Object.defineProperty(toSequenceExpression, "__esModule", {
value: true
});
toSequenceExpression.default = toSequenceExpression$1;
var _gatherSequenceExpressions = requireGatherSequenceExpressions();
function toSequenceExpression$1(nodes, scope) {
if (!(nodes != null && nodes.length)) return;
const declars = [];
const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
if (!result) return;
for (const declar of declars) {
scope.push(declar);
}
return result;
}
return toSequenceExpression;
}
var toStatement = {};
var hasRequiredToStatement;
function requireToStatement () {
if (hasRequiredToStatement) return toStatement;
hasRequiredToStatement = 1;
Object.defineProperty(toStatement, "__esModule", {
value: true
});
toStatement.default = void 0;
var _index = requireGenerated$3();
var _index2 = requireGenerated$2();
var _default = toStatement$1;
toStatement.default = _default;
function toStatement$1(node, ignore) {
if ((0, _index.isStatement)(node)) {
return node;
}
let mustHaveId = false;
let newType;
if ((0, _index.isClass)(node)) {
mustHaveId = true;
newType = "ClassDeclaration";
} else if ((0, _index.isFunction)(node)) {
mustHaveId = true;
newType = "FunctionDeclaration";
} else if ((0, _index.isAssignmentExpression)(node)) {
return (0, _index2.expressionStatement)(node);
}
if (mustHaveId && !node.id) {
newType = false;
}
if (!newType) {
if (ignore) {
return false;
} else {
throw new Error(`cannot turn ${node.type} to a statement`);
}
}
node.type = newType;
return node;
}
return toStatement;
}
var valueToNode = {};
var hasRequiredValueToNode;
function requireValueToNode () {
if (hasRequiredValueToNode) return valueToNode;
hasRequiredValueToNode = 1;
Object.defineProperty(valueToNode, "__esModule", {
value: true
});
valueToNode.default = void 0;
var _isValidIdentifier = requireIsValidIdentifier();
var _index = requireGenerated$2();
var _default = valueToNode$1;
valueToNode.default = _default;
const objectToString = Function.call.bind(Object.prototype.toString);
function isRegExp(value) {
return objectToString(value) === "[object RegExp]";
}
function isPlainObject(value) {
if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
return false;
}
const proto = Object.getPrototypeOf(value);
return proto === null || Object.getPrototypeOf(proto) === null;
}
function valueToNode$1(value) {
if (value === undefined) {
return (0, _index.identifier)("undefined");
}
if (value === true || value === false) {
return (0, _index.booleanLiteral)(value);
}
if (value === null) {
return (0, _index.nullLiteral)();
}
if (typeof value === "string") {
return (0, _index.stringLiteral)(value);
}
if (typeof value === "number") {
let result;
if (Number.isFinite(value)) {
result = (0, _index.numericLiteral)(Math.abs(value));
} else {
let numerator;
if (Number.isNaN(value)) {
numerator = (0, _index.numericLiteral)(0);
} else {
numerator = (0, _index.numericLiteral)(1);
}
result = (0, _index.binaryExpression)("/", numerator, (0, _index.numericLiteral)(0));
}
if (value < 0 || Object.is(value, -0)) {
result = (0, _index.unaryExpression)("-", result);
}
return result;
}
if (isRegExp(value)) {
const pattern = value.source;
const flags = value.toString().match(/\/([a-z]+|)$/)[1];
return (0, _index.regExpLiteral)(pattern, flags);
}
if (Array.isArray(value)) {
return (0, _index.arrayExpression)(value.map(valueToNode$1));
}
if (isPlainObject(value)) {
const props = [];
for (const key of Object.keys(value)) {
let nodeKey;
if ((0, _isValidIdentifier.default)(key)) {
nodeKey = (0, _index.identifier)(key);
} else {
nodeKey = (0, _index.stringLiteral)(key);
}
props.push((0, _index.objectProperty)(nodeKey, valueToNode$1(value[key])));
}
return (0, _index.objectExpression)(props);
}
throw new Error("don't know how to turn this value into a node");
}
return valueToNode;
}
var appendToMemberExpression = {};
var hasRequiredAppendToMemberExpression;
function requireAppendToMemberExpression () {
if (hasRequiredAppendToMemberExpression) return appendToMemberExpression;
hasRequiredAppendToMemberExpression = 1;
Object.defineProperty(appendToMemberExpression, "__esModule", {
value: true
});
appendToMemberExpression.default = appendToMemberExpression$1;
var _index = requireGenerated$2();
function appendToMemberExpression$1(member, append, computed = false) {
member.object = (0, _index.memberExpression)(member.object, member.property, member.computed);
member.property = append;
member.computed = !!computed;
return member;
}
return appendToMemberExpression;
}
var inherits = {};
var hasRequiredInherits;
function requireInherits () {
if (hasRequiredInherits) return inherits;
hasRequiredInherits = 1;
Object.defineProperty(inherits, "__esModule", {
value: true
});
inherits.default = inherits$1;
var _index = requireConstants();
var _inheritsComments = requireInheritsComments();
function inherits$1(child, parent) {
if (!child || !parent) return child;
for (const key of _index.INHERIT_KEYS.optional) {
if (child[key] == null) {
child[key] = parent[key];
}
}
for (const key of Object.keys(parent)) {
if (key[0] === "_" && key !== "__clone") {
child[key] = parent[key];
}
}
for (const key of _index.INHERIT_KEYS.force) {
child[key] = parent[key];
}
(0, _inheritsComments.default)(child, parent);
return child;
}
return inherits;
}
var prependToMemberExpression = {};
var hasRequiredPrependToMemberExpression;
function requirePrependToMemberExpression () {
if (hasRequiredPrependToMemberExpression) return prependToMemberExpression;
hasRequiredPrependToMemberExpression = 1;
Object.defineProperty(prependToMemberExpression, "__esModule", {
value: true
});
prependToMemberExpression.default = prependToMemberExpression$1;
var _index = requireGenerated$2();
var _index2 = requireLib$2();
function prependToMemberExpression$1(member, prepend) {
if ((0, _index2.isSuper)(member.object)) {
throw new Error("Cannot prepend node to super property access (`super.foo`).");
}
member.object = (0, _index.memberExpression)(prepend, member.object);
return member;
}
return prependToMemberExpression;
}
var getOuterBindingIdentifiers = {};
var hasRequiredGetOuterBindingIdentifiers;
function requireGetOuterBindingIdentifiers () {
if (hasRequiredGetOuterBindingIdentifiers) return getOuterBindingIdentifiers;
hasRequiredGetOuterBindingIdentifiers = 1;
Object.defineProperty(getOuterBindingIdentifiers, "__esModule", {
value: true
});
getOuterBindingIdentifiers.default = void 0;
var _getBindingIdentifiers = requireGetBindingIdentifiers();
var _default = getOuterBindingIdentifiers$1;
getOuterBindingIdentifiers.default = _default;
function getOuterBindingIdentifiers$1(node, duplicates) {
return (0, _getBindingIdentifiers.default)(node, duplicates, true);
}
return getOuterBindingIdentifiers;
}
var traverse = {};
var hasRequiredTraverse;
function requireTraverse () {
if (hasRequiredTraverse) return traverse;
hasRequiredTraverse = 1;
Object.defineProperty(traverse, "__esModule", {
value: true
});
traverse.default = traverse$1;
var _index = requireDefinitions();
function traverse$1(node, handlers, state) {
if (typeof handlers === "function") {
handlers = {
enter: handlers
};
}
const {
enter,
exit
} = handlers;
traverseSimpleImpl(node, enter, exit, state, []);
}
function traverseSimpleImpl(node, enter, exit, state, ancestors) {
const keys = _index.VISITOR_KEYS[node.type];
if (!keys) return;
if (enter) enter(node, ancestors, state);
for (const key of keys) {
const subNode = node[key];
if (Array.isArray(subNode)) {
for (let i = 0; i < subNode.length; i++) {
const child = subNode[i];
if (!child) continue;
ancestors.push({
node,
key,
index: i
});
traverseSimpleImpl(child, enter, exit, state, ancestors);
ancestors.pop();
}
} else if (subNode) {
ancestors.push({
node,
key
});
traverseSimpleImpl(subNode, enter, exit, state, ancestors);
ancestors.pop();
}
}
if (exit) exit(node, ancestors, state);
}
return traverse;
}
var isBinding = {};
var hasRequiredIsBinding;
function requireIsBinding () {
if (hasRequiredIsBinding) return isBinding;
hasRequiredIsBinding = 1;
Object.defineProperty(isBinding, "__esModule", {
value: true
});
isBinding.default = isBinding$1;
var _getBindingIdentifiers = requireGetBindingIdentifiers();
function isBinding$1(node, parent, grandparent) {
if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
return false;
}
const keys = _getBindingIdentifiers.default.keys[parent.type];
if (keys) {
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
const val = parent[key];
if (Array.isArray(val)) {
if (val.indexOf(node) >= 0) return true;
} else {
if (val === node) return true;
}
}
}
return false;
}
return isBinding;
}
var isBlockScoped = {};
var isLet = {};
var hasRequiredIsLet;
function requireIsLet () {
if (hasRequiredIsLet) return isLet;
hasRequiredIsLet = 1;
Object.defineProperty(isLet, "__esModule", {
value: true
});
isLet.default = isLet$1;
var _index = requireGenerated$3();
var _index2 = requireConstants();
function isLet$1(node) {
return (0, _index.isVariableDeclaration)(node) && (node.kind !== "var" || node[_index2.BLOCK_SCOPED_SYMBOL]);
}
return isLet;
}
var hasRequiredIsBlockScoped;
function requireIsBlockScoped () {
if (hasRequiredIsBlockScoped) return isBlockScoped;
hasRequiredIsBlockScoped = 1;
Object.defineProperty(isBlockScoped, "__esModule", {
value: true
});
isBlockScoped.default = isBlockScoped$1;
var _index = requireGenerated$3();
var _isLet = requireIsLet();
function isBlockScoped$1(node) {
return (0, _index.isFunctionDeclaration)(node) || (0, _index.isClassDeclaration)(node) || (0, _isLet.default)(node);
}
return isBlockScoped;
}
var isImmutable = {};
var hasRequiredIsImmutable;
function requireIsImmutable () {
if (hasRequiredIsImmutable) return isImmutable;
hasRequiredIsImmutable = 1;
Object.defineProperty(isImmutable, "__esModule", {
value: true
});
isImmutable.default = isImmutable$1;
var _isType = requireIsType();
var _index = requireGenerated$3();
function isImmutable$1(node) {
if ((0, _isType.default)(node.type, "Immutable")) return true;
if ((0, _index.isIdentifier)(node)) {
if (node.name === "undefined") {
return true;
} else {
return false;
}
}
return false;
}
return isImmutable;
}
var isNodesEquivalent = {};
var hasRequiredIsNodesEquivalent;
function requireIsNodesEquivalent () {
if (hasRequiredIsNodesEquivalent) return isNodesEquivalent;
hasRequiredIsNodesEquivalent = 1;
Object.defineProperty(isNodesEquivalent, "__esModule", {
value: true
});
isNodesEquivalent.default = isNodesEquivalent$1;
var _index = requireDefinitions();
function isNodesEquivalent$1(a, b) {
if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
return a === b;
}
if (a.type !== b.type) {
return false;
}
const fields = Object.keys(_index.NODE_FIELDS[a.type] || a.type);
const visitorKeys = _index.VISITOR_KEYS[a.type];
for (const field of fields) {
const val_a = a[field];
const val_b = b[field];
if (typeof val_a !== typeof val_b) {
return false;
}
if (val_a == null && val_b == null) {
continue;
} else if (val_a == null || val_b == null) {
return false;
}
if (Array.isArray(val_a)) {
if (!Array.isArray(val_b)) {
return false;
}
if (val_a.length !== val_b.length) {
return false;
}
for (let i = 0; i < val_a.length; i++) {
if (!isNodesEquivalent$1(val_a[i], val_b[i])) {
return false;
}
}
continue;
}
if (typeof val_a === "object" && !(visitorKeys != null && visitorKeys.includes(field))) {
for (const key of Object.keys(val_a)) {
if (val_a[key] !== val_b[key]) {
return false;
}
}
continue;
}
if (!isNodesEquivalent$1(val_a, val_b)) {
return false;
}
}
return true;
}
return isNodesEquivalent;
}
var isReferenced = {};
var hasRequiredIsReferenced;
function requireIsReferenced () {
if (hasRequiredIsReferenced) return isReferenced;
hasRequiredIsReferenced = 1;
Object.defineProperty(isReferenced, "__esModule", {
value: true
});
isReferenced.default = isReferenced$1;
function isReferenced$1(node, parent, grandparent) {
switch (parent.type) {
case "MemberExpression":
case "OptionalMemberExpression":
if (parent.property === node) {
return !!parent.computed;
}
return parent.object === node;
case "JSXMemberExpression":
return parent.object === node;
case "VariableDeclarator":
return parent.init === node;
case "ArrowFunctionExpression":
return parent.body === node;
case "PrivateName":
return false;
case "ClassMethod":
case "ClassPrivateMethod":
case "ObjectMethod":
if (parent.key === node) {
return !!parent.computed;
}
return false;
case "ObjectProperty":
if (parent.key === node) {
return !!parent.computed;
}
return !grandparent || grandparent.type !== "ObjectPattern";
case "ClassProperty":
case "ClassAccessorProperty":
if (parent.key === node) {
return !!parent.computed;
}
return true;
case "ClassPrivateProperty":
return parent.key !== node;
case "ClassDeclaration":
case "ClassExpression":
return parent.superClass === node;
case "AssignmentExpression":
return parent.right === node;
case "AssignmentPattern":
return parent.right === node;
case "LabeledStatement":
return false;
case "CatchClause":
return false;
case "RestElement":
return false;
case "BreakStatement":
case "ContinueStatement":
return false;
case "FunctionDeclaration":
case "FunctionExpression":
return false;
case "ExportNamespaceSpecifier":
case "ExportDefaultSpecifier":
return false;
case "ExportSpecifier":
if (grandparent != null && grandparent.source) {
return false;
}
return parent.local === node;
case "ImportDefaultSpecifier":
case "ImportNamespaceSpecifier":
case "ImportSpecifier":
return false;
case "ImportAttribute":
return false;
case "JSXAttribute":
return false;
case "ObjectPattern":
case "ArrayPattern":
return false;
case "MetaProperty":
return false;
case "ObjectTypeProperty":
return parent.key !== node;
case "TSEnumMember":
return parent.id !== node;
case "TSPropertySignature":
if (parent.key === node) {
return !!parent.computed;
}
return true;
}
return true;
}
return isReferenced;
}
var isScope = {};
var hasRequiredIsScope;
function requireIsScope () {
if (hasRequiredIsScope) return isScope;
hasRequiredIsScope = 1;
Object.defineProperty(isScope, "__esModule", {
value: true
});
isScope.default = isScope$1;
var _index = requireGenerated$3();
function isScope$1(node, parent) {
if ((0, _index.isBlockStatement)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) {
return false;
}
if ((0, _index.isPattern)(node) && ((0, _index.isFunction)(parent) || (0, _index.isCatchClause)(parent))) {
return true;
}
return (0, _index.isScopable)(node);
}
return isScope;
}
var isSpecifierDefault = {};
var hasRequiredIsSpecifierDefault;
function requireIsSpecifierDefault () {
if (hasRequiredIsSpecifierDefault) return isSpecifierDefault;
hasRequiredIsSpecifierDefault = 1;
Object.defineProperty(isSpecifierDefault, "__esModule", {
value: true
});
isSpecifierDefault.default = isSpecifierDefault$1;
var _index = requireGenerated$3();
function isSpecifierDefault$1(specifier) {
return (0, _index.isImportDefaultSpecifier)(specifier) || (0, _index.isIdentifier)(specifier.imported || specifier.exported, {
name: "default"
});
}
return isSpecifierDefault;
}
var isValidES3Identifier = {};
var hasRequiredIsValidES3Identifier;
function requireIsValidES3Identifier () {
if (hasRequiredIsValidES3Identifier) return isValidES3Identifier;
hasRequiredIsValidES3Identifier = 1;
Object.defineProperty(isValidES3Identifier, "__esModule", {
value: true
});
isValidES3Identifier.default = isValidES3Identifier$1;
var _isValidIdentifier = requireIsValidIdentifier();
const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
function isValidES3Identifier$1(name) {
return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
}
return isValidES3Identifier;
}
var isVar = {};
var hasRequiredIsVar;
function requireIsVar () {
if (hasRequiredIsVar) return isVar;
hasRequiredIsVar = 1;
Object.defineProperty(isVar, "__esModule", {
value: true
});
isVar.default = isVar$1;
var _index = requireGenerated$3();
var _index2 = requireConstants();
function isVar$1(node) {
return (0, _index.isVariableDeclaration)(node, {
kind: "var"
}) && !node[_index2.BLOCK_SCOPED_SYMBOL];
}
return isVar;
}
var hasRequiredLib$2;
function requireLib$2 () {
if (hasRequiredLib$2) return lib$4;
hasRequiredLib$2 = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _exportNames = {
react: true,
assertNode: true,
createTypeAnnotationBasedOnTypeof: true,
createUnionTypeAnnotation: true,
createFlowUnionType: true,
createTSUnionType: true,
cloneNode: true,
clone: true,
cloneDeep: true,
cloneDeepWithoutLoc: true,
cloneWithoutLoc: true,
addComment: true,
addComments: true,
inheritInnerComments: true,
inheritLeadingComments: true,
inheritsComments: true,
inheritTrailingComments: true,
removeComments: true,
ensureBlock: true,
toBindingIdentifierName: true,
toBlock: true,
toComputedKey: true,
toExpression: true,
toIdentifier: true,
toKeyAlias: true,
toSequenceExpression: true,
toStatement: true,
valueToNode: true,
appendToMemberExpression: true,
inherits: true,
prependToMemberExpression: true,
removeProperties: true,
removePropertiesDeep: true,
removeTypeDuplicates: true,
getBindingIdentifiers: true,
getOuterBindingIdentifiers: true,
traverse: true,
traverseFast: true,
shallowEqual: true,
is: true,
isBinding: true,
isBlockScoped: true,
isImmutable: true,
isLet: true,
isNode: true,
isNodesEquivalent: true,
isPlaceholderType: true,
isReferenced: true,
isScope: true,
isSpecifierDefault: true,
isType: true,
isValidES3Identifier: true,
isValidIdentifier: true,
isVar: true,
matchesPattern: true,
validate: true,
buildMatchMemberExpression: true,
__internal__deprecationWarning: true
};
Object.defineProperty(exports, "__internal__deprecationWarning", {
enumerable: true,
get: function () {
return _deprecationWarning.default;
}
});
Object.defineProperty(exports, "addComment", {
enumerable: true,
get: function () {
return _addComment.default;
}
});
Object.defineProperty(exports, "addComments", {
enumerable: true,
get: function () {
return _addComments.default;
}
});
Object.defineProperty(exports, "appendToMemberExpression", {
enumerable: true,
get: function () {
return _appendToMemberExpression.default;
}
});
Object.defineProperty(exports, "assertNode", {
enumerable: true,
get: function () {
return _assertNode.default;
}
});
Object.defineProperty(exports, "buildMatchMemberExpression", {
enumerable: true,
get: function () {
return _buildMatchMemberExpression.default;
}
});
Object.defineProperty(exports, "clone", {
enumerable: true,
get: function () {
return _clone.default;
}
});
Object.defineProperty(exports, "cloneDeep", {
enumerable: true,
get: function () {
return _cloneDeep.default;
}
});
Object.defineProperty(exports, "cloneDeepWithoutLoc", {
enumerable: true,
get: function () {
return _cloneDeepWithoutLoc.default;
}
});
Object.defineProperty(exports, "cloneNode", {
enumerable: true,
get: function () {
return _cloneNode.default;
}
});
Object.defineProperty(exports, "cloneWithoutLoc", {
enumerable: true,
get: function () {
return _cloneWithoutLoc.default;
}
});
Object.defineProperty(exports, "createFlowUnionType", {
enumerable: true,
get: function () {
return _createFlowUnionType.default;
}
});
Object.defineProperty(exports, "createTSUnionType", {
enumerable: true,
get: function () {
return _createTSUnionType.default;
}
});
Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
enumerable: true,
get: function () {
return _createTypeAnnotationBasedOnTypeof.default;
}
});
Object.defineProperty(exports, "createUnionTypeAnnotation", {
enumerable: true,
get: function () {
return _createFlowUnionType.default;
}
});
Object.defineProperty(exports, "ensureBlock", {
enumerable: true,
get: function () {
return _ensureBlock.default;
}
});
Object.defineProperty(exports, "getBindingIdentifiers", {
enumerable: true,
get: function () {
return _getBindingIdentifiers.default;
}
});
Object.defineProperty(exports, "getOuterBindingIdentifiers", {
enumerable: true,
get: function () {
return _getOuterBindingIdentifiers.default;
}
});
Object.defineProperty(exports, "inheritInnerComments", {
enumerable: true,
get: function () {
return _inheritInnerComments.default;
}
});
Object.defineProperty(exports, "inheritLeadingComments", {
enumerable: true,
get: function () {
return _inheritLeadingComments.default;
}
});
Object.defineProperty(exports, "inheritTrailingComments", {
enumerable: true,
get: function () {
return _inheritTrailingComments.default;
}
});
Object.defineProperty(exports, "inherits", {
enumerable: true,
get: function () {
return _inherits.default;
}
});
Object.defineProperty(exports, "inheritsComments", {
enumerable: true,
get: function () {
return _inheritsComments.default;
}
});
Object.defineProperty(exports, "is", {
enumerable: true,
get: function () {
return _is.default;
}
});
Object.defineProperty(exports, "isBinding", {
enumerable: true,
get: function () {
return _isBinding.default;
}
});
Object.defineProperty(exports, "isBlockScoped", {
enumerable: true,
get: function () {
return _isBlockScoped.default;
}
});
Object.defineProperty(exports, "isImmutable", {
enumerable: true,
get: function () {
return _isImmutable.default;
}
});
Object.defineProperty(exports, "isLet", {
enumerable: true,
get: function () {
return _isLet.default;
}
});
Object.defineProperty(exports, "isNode", {
enumerable: true,
get: function () {
return _isNode.default;
}
});
Object.defineProperty(exports, "isNodesEquivalent", {
enumerable: true,
get: function () {
return _isNodesEquivalent.default;
}
});
Object.defineProperty(exports, "isPlaceholderType", {
enumerable: true,
get: function () {
return _isPlaceholderType.default;
}
});
Object.defineProperty(exports, "isReferenced", {
enumerable: true,
get: function () {
return _isReferenced.default;
}
});
Object.defineProperty(exports, "isScope", {
enumerable: true,
get: function () {
return _isScope.default;
}
});
Object.defineProperty(exports, "isSpecifierDefault", {
enumerable: true,
get: function () {
return _isSpecifierDefault.default;
}
});
Object.defineProperty(exports, "isType", {
enumerable: true,
get: function () {
return _isType.default;
}
});
Object.defineProperty(exports, "isValidES3Identifier", {
enumerable: true,
get: function () {
return _isValidES3Identifier.default;
}
});
Object.defineProperty(exports, "isValidIdentifier", {
enumerable: true,
get: function () {
return _isValidIdentifier.default;
}
});
Object.defineProperty(exports, "isVar", {
enumerable: true,
get: function () {
return _isVar.default;
}
});
Object.defineProperty(exports, "matchesPattern", {
enumerable: true,
get: function () {
return _matchesPattern.default;
}
});
Object.defineProperty(exports, "prependToMemberExpression", {
enumerable: true,
get: function () {
return _prependToMemberExpression.default;
}
});
exports.react = void 0;
Object.defineProperty(exports, "removeComments", {
enumerable: true,
get: function () {
return _removeComments.default;
}
});
Object.defineProperty(exports, "removeProperties", {
enumerable: true,
get: function () {
return _removeProperties.default;
}
});
Object.defineProperty(exports, "removePropertiesDeep", {
enumerable: true,
get: function () {
return _removePropertiesDeep.default;
}
});
Object.defineProperty(exports, "removeTypeDuplicates", {
enumerable: true,
get: function () {
return _removeTypeDuplicates.default;
}
});
Object.defineProperty(exports, "shallowEqual", {
enumerable: true,
get: function () {
return _shallowEqual.default;
}
});
Object.defineProperty(exports, "toBindingIdentifierName", {
enumerable: true,
get: function () {
return _toBindingIdentifierName.default;
}
});
Object.defineProperty(exports, "toBlock", {
enumerable: true,
get: function () {
return _toBlock.default;
}
});
Object.defineProperty(exports, "toComputedKey", {
enumerable: true,
get: function () {
return _toComputedKey.default;
}
});
Object.defineProperty(exports, "toExpression", {
enumerable: true,
get: function () {
return _toExpression.default;
}
});
Object.defineProperty(exports, "toIdentifier", {
enumerable: true,
get: function () {
return _toIdentifier.default;
}
});
Object.defineProperty(exports, "toKeyAlias", {
enumerable: true,
get: function () {
return _toKeyAlias.default;
}
});
Object.defineProperty(exports, "toSequenceExpression", {
enumerable: true,
get: function () {
return _toSequenceExpression.default;
}
});
Object.defineProperty(exports, "toStatement", {
enumerable: true,
get: function () {
return _toStatement.default;
}
});
Object.defineProperty(exports, "traverse", {
enumerable: true,
get: function () {
return _traverse.default;
}
});
Object.defineProperty(exports, "traverseFast", {
enumerable: true,
get: function () {
return _traverseFast.default;
}
});
Object.defineProperty(exports, "validate", {
enumerable: true,
get: function () {
return _validate.default;
}
});
Object.defineProperty(exports, "valueToNode", {
enumerable: true,
get: function () {
return _valueToNode.default;
}
});
var _isReactComponent = requireIsReactComponent();
var _isCompatTag = requireIsCompatTag();
var _buildChildren = requireBuildChildren();
var _assertNode = requireAssertNode();
var _index = requireGenerated$1();
Object.keys(_index).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index[key];
}
});
});
var _createTypeAnnotationBasedOnTypeof = requireCreateTypeAnnotationBasedOnTypeof();
var _createFlowUnionType = requireCreateFlowUnionType();
var _createTSUnionType = requireCreateTSUnionType();
var _index2 = requireGenerated$2();
Object.keys(_index2).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index2[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index2[key];
}
});
});
var _uppercase = requireUppercase();
Object.keys(_uppercase).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _uppercase[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _uppercase[key];
}
});
});
var _productions = requireProductions();
Object.keys(_productions).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _productions[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _productions[key];
}
});
});
var _cloneNode = requireCloneNode();
var _clone = requireClone();
var _cloneDeep = requireCloneDeep();
var _cloneDeepWithoutLoc = requireCloneDeepWithoutLoc();
var _cloneWithoutLoc = requireCloneWithoutLoc();
var _addComment = requireAddComment();
var _addComments = requireAddComments();
var _inheritInnerComments = requireInheritInnerComments();
var _inheritLeadingComments = requireInheritLeadingComments();
var _inheritsComments = requireInheritsComments();
var _inheritTrailingComments = requireInheritTrailingComments();
var _removeComments = requireRemoveComments();
var _index3 = requireGenerated();
Object.keys(_index3).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index3[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index3[key];
}
});
});
var _index4 = requireConstants();
Object.keys(_index4).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index4[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index4[key];
}
});
});
var _ensureBlock = requireEnsureBlock();
var _toBindingIdentifierName = requireToBindingIdentifierName();
var _toBlock = requireToBlock();
var _toComputedKey = requireToComputedKey();
var _toExpression = requireToExpression();
var _toIdentifier = requireToIdentifier();
var _toKeyAlias = requireToKeyAlias();
var _toSequenceExpression = requireToSequenceExpression();
var _toStatement = requireToStatement();
var _valueToNode = requireValueToNode();
var _index5 = requireDefinitions();
Object.keys(_index5).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index5[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index5[key];
}
});
});
var _appendToMemberExpression = requireAppendToMemberExpression();
var _inherits = requireInherits();
var _prependToMemberExpression = requirePrependToMemberExpression();
var _removeProperties = requireRemoveProperties();
var _removePropertiesDeep = requireRemovePropertiesDeep();
var _removeTypeDuplicates = requireRemoveTypeDuplicates$1();
var _getBindingIdentifiers = requireGetBindingIdentifiers();
var _getOuterBindingIdentifiers = requireGetOuterBindingIdentifiers();
var _traverse = requireTraverse();
Object.keys(_traverse).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _traverse[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _traverse[key];
}
});
});
var _traverseFast = requireTraverseFast();
var _shallowEqual = requireShallowEqual();
var _is = requireIs();
var _isBinding = requireIsBinding();
var _isBlockScoped = requireIsBlockScoped();
var _isImmutable = requireIsImmutable();
var _isLet = requireIsLet();
var _isNode = requireIsNode();
var _isNodesEquivalent = requireIsNodesEquivalent();
var _isPlaceholderType = requireIsPlaceholderType();
var _isReferenced = requireIsReferenced();
var _isScope = requireIsScope();
var _isSpecifierDefault = requireIsSpecifierDefault();
var _isType = requireIsType();
var _isValidES3Identifier = requireIsValidES3Identifier();
var _isValidIdentifier = requireIsValidIdentifier();
var _isVar = requireIsVar();
var _matchesPattern = requireMatchesPattern();
var _validate = requireValidate();
var _buildMatchMemberExpression = requireBuildMatchMemberExpression();
var _index6 = requireGenerated$3();
Object.keys(_index6).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _index6[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _index6[key];
}
});
});
var _deprecationWarning = requireDeprecationWarning();
const react = {
isReactComponent: _isReactComponent.default,
isCompatTag: _isCompatTag.default,
buildChildren: _buildChildren.default
};
exports.react = react;
} (lib$4));
return lib$4;
}
var libExports$2 = requireLib$2();
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
function createSimplePath(ancestors) {
if (ancestors.length === 0) {
return null;
}
// Slice the array because babel-types traverse may continue mutating
// the ancestors array in later traversal logic.
return new SimplePath(ancestors.slice());
}
/**
* Mimics @babel/traverse's NodePath API in a simpler fashion that isn't as
* heavy, but still allows the ease of passing paths around to process nested
* AST structures.
*/
class SimplePath {
_index;
_ancestors;
_ancestor;
_parentPath;
constructor(ancestors, index = ancestors.length - 1) {
if (index < 0 || index >= ancestors.length) {
console.error(ancestors);
throw new Error("Created invalid path");
}
this._ancestors = ancestors;
this._ancestor = ancestors[index];
this._index = index;
}
get parentPath() {
let path = this._parentPath;
if (path === undefined) {
if (this._index === 0) {
path = null;
} else {
path = new SimplePath(this._ancestors, this._index - 1);
}
this._parentPath = path;
}
return path;
}
get parent() {
return this._ancestor.node;
}
get node() {
const { node, key, index } = this._ancestor;
if (typeof index === "number") {
return node[key][index];
}
return node[key];
}
get key() {
return this._ancestor.key;
}
get type() {
return this.node.type;
}
get inList() {
return typeof this._ancestor.index === "number";
}
get containerIndex() {
const { index } = this._ancestor;
if (typeof index !== "number") {
throw new Error("Cannot get index of non-array node");
}
return index;
}
find(predicate) {
for (let path = this; path; path = path.parentPath) {
if (predicate(path)) {
return path;
}
}
return null;
}
findParent(predicate) {
if (!this.parentPath) {
throw new Error("Cannot use findParent on root path");
}
return this.parentPath.find(predicate);
}
}
var lib$1 = {};
var hasRequiredLib$1;
function requireLib$1 () {
if (hasRequiredLib$1) return lib$1;
hasRequiredLib$1 = 1;
Object.defineProperty(lib$1, '__esModule', {
value: true
});
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
class Position {
constructor(line, col, index) {
this.line = void 0;
this.column = void 0;
this.index = void 0;
this.line = line;
this.column = col;
this.index = index;
}
}
class SourceLocation {
constructor(start, end) {
this.start = void 0;
this.end = void 0;
this.filename = void 0;
this.identifierName = void 0;
this.start = start;
this.end = end;
}
}
function createPositionWithColumnOffset(position, columnOffset) {
const {
line,
column,
index
} = position;
return new Position(line, column + columnOffset, index + columnOffset);
}
const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
var ModuleErrors = {
ImportMetaOutsideModule: {
message: `import.meta may appear only with 'sourceType: "module"'`,
code
},
ImportOutsideModule: {
message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
code
}
};
const NodeDescriptions = {
ArrayPattern: "array destructuring pattern",
AssignmentExpression: "assignment expression",
AssignmentPattern: "assignment expression",
ArrowFunctionExpression: "arrow function expression",
ConditionalExpression: "conditional expression",
CatchClause: "catch clause",
ForOfStatement: "for-of statement",
ForInStatement: "for-in statement",
ForStatement: "for-loop",
FormalParameters: "function parameter list",
Identifier: "identifier",
ImportSpecifier: "import specifier",
ImportDefaultSpecifier: "import default specifier",
ImportNamespaceSpecifier: "import namespace specifier",
ObjectPattern: "object destructuring pattern",
ParenthesizedExpression: "parenthesized expression",
RestElement: "rest element",
UpdateExpression: {
true: "prefix operation",
false: "postfix operation"
},
VariableDeclarator: "variable declaration",
YieldExpression: "yield expression"
};
const toNodeDescription = ({
type,
prefix
}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
var StandardErrors = {
AccessorIsGenerator: ({
kind
}) => `A ${kind}ter cannot be a generator.`,
ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
BadGetterArity: "A 'get' accessor must not have any formal parameters.",
BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
ConstructorClassField: "Classes may not have a field named 'constructor'.",
ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
ConstructorIsAccessor: "Class constructor may not be an accessor.",
ConstructorIsAsync: "Constructor can't be an async function.",
ConstructorIsGenerator: "Constructor can't be a generator.",
DeclarationMissingInitializer: ({
kind
}) => `Missing initializer in ${kind} declaration.`,
DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
DecoratorStaticBlock: "Decorators can't be used with a static block.",
DeferImportRequiresNamespace: 'Only `import defer * as x from "./module"` is valid.',
DeletePrivateField: "Deleting a private field is not allowed.",
DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
DuplicateConstructor: "Duplicate constructor in the same class.",
DuplicateDefaultExport: "Only one default export allowed per module.",
DuplicateExport: ({
exportName
}) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
DuplicateProto: "Redefinition of __proto__ property.",
DuplicateRegExpFlags: "Duplicate regular expression flag.",
DynamicImportPhaseRequiresImportExpressions: ({
phase
}) => `'import.${phase}(...)' can only be parsed when using the 'createImportExpressions' option.`,
ElementAfterRest: "Rest element must be last element.",
EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
ExportBindingIsString: ({
localName,
exportName
}) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
ForInOfLoopInitializer: ({
type
}) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
ForInUsing: "For-in loop may not start with 'using' declaration.",
ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
IllegalBreakContinue: ({
type
}) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
IllegalReturn: "'return' outside of function.",
ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedAssertSyntax: true` option in the import attributes plugin to suppress this error.",
ImportBindingIsString: ({
importName
}) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
ImportCallArity: ({
maxArgumentCount
}) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
ImportCallNotNewExpression: "Cannot use new with import(...).",
ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
InvalidBigIntLiteral: "Invalid BigIntLiteral.",
InvalidCodePoint: "Code point out of bounds.",
InvalidCoverInitializedName: "Invalid shorthand property initializer.",
InvalidDecimal: "Invalid decimal.",
InvalidDigit: ({
radix
}) => `Expected number in radix ${radix}.`,
InvalidEscapeSequence: "Bad character escape sequence.",
InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
InvalidEscapedReservedWord: ({
reservedWord
}) => `Escape sequence in keyword ${reservedWord}.`,
InvalidIdentifier: ({
identifierName
}) => `Invalid identifier ${identifierName}.`,
InvalidLhs: ({
ancestor
}) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
InvalidLhsBinding: ({
ancestor
}) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
InvalidLhsOptionalChaining: ({
ancestor
}) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
InvalidNumber: "Invalid number.",
InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
InvalidOrUnexpectedToken: ({
unexpected
}) => `Unexpected character '${unexpected}'.`,
InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
InvalidPrivateFieldResolution: ({
identifierName
}) => `Private name #${identifierName} is not defined.`,
InvalidPropertyBindingPattern: "Binding member expression.",
InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.",
InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
LabelRedeclaration: ({
labelName
}) => `Label '${labelName}' is already declared.`,
LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
MalformedRegExpFlags: "Invalid regular expression flag.",
MissingClassName: "A class name is required.",
MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
MissingSemicolon: "Missing semicolon.",
MissingPlugin: ({
missingPlugin
}) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
MissingOneOfPlugins: ({
missingPlugin
}) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.",
ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
ModuleAttributesWithDuplicateKeys: ({
key
}) => `Duplicate key "${key}" is not allowed in module attributes.`,
ModuleExportNameHasLoneSurrogate: ({
surrogateCharCode
}) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
ModuleExportUndefined: ({
localName
}) => `Export '${localName}' is not defined.`,
MultipleDefaultsInSwitch: "Multiple default clauses.",
NewlineAfterThrow: "Illegal newline after throw.",
NoCatchOrFinally: "Missing catch or finally clause.",
NumberIdentifier: "Identifier directly after number.",
NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
ParamDupe: "Argument name clash.",
PatternHasAccessor: "Object pattern can't contain getter or setter.",
PatternHasMethod: "Object pattern can't contain methods.",
PrivateInExpectedIn: ({
identifierName
}) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
PrivateNameRedeclaration: ({
identifierName
}) => `Duplicate private name #${identifierName}.`,
RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
RecordNoProto: "'__proto__' is not allowed in Record expressions.",
RestTrailingComma: "Unexpected trailing comma after rest element.",
SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
SourcePhaseImportRequiresDefault: 'Only `import source x from "./module"` is valid.',
StaticPrototype: "Classes may not have static property named prototype.",
SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
SuperPrivateField: "Private fields can't be accessed on super.",
TrailingDecorator: "Decorators must be attached to a class element.",
TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
UnexpectedKeyword: ({
keyword
}) => `Unexpected keyword '${keyword}'.`,
UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
UnexpectedPrivateField: "Unexpected private name.",
UnexpectedReservedWord: ({
reservedWord
}) => `Unexpected reserved word '${reservedWord}'.`,
UnexpectedSuper: "'super' is only allowed in object methods and classes.",
UnexpectedToken: ({
expected,
unexpected
}) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
UnsupportedBind: "Binding should be performed on object property.",
UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
UnsupportedMetaProperty: ({
target,
onlyValidPropertyName
}) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
UnterminatedComment: "Unterminated comment.",
UnterminatedRegExp: "Unterminated regular expression.",
UnterminatedString: "Unterminated string constant.",
UnterminatedTemplate: "Unterminated template.",
UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
VarRedeclaration: ({
identifierName
}) => `Identifier '${identifierName}' has already been declared.`,
YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
YieldInParameter: "Yield expression is not allowed in formal parameters.",
ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
};
var StrictModeErrors = {
StrictDelete: "Deleting local variable in strict mode.",
StrictEvalArguments: ({
referenceName
}) => `Assigning to '${referenceName}' in strict mode.`,
StrictEvalArgumentsBinding: ({
bindingName
}) => `Binding '${bindingName}' in strict mode.`,
StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
StrictWith: "'with' in strict mode."
};
const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
var PipelineOperatorErrors = {
PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
PipeTopicUnconfiguredToken: ({
token
}) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
PipeUnparenthesizedBody: ({
type
}) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
type
})}; please wrap it in parentheses.`,
PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
};
const _excluded$1 = ["toMessage"],
_excluded2$1 = ["message"];
function defineHidden(obj, key, value) {
Object.defineProperty(obj, key, {
enumerable: false,
configurable: true,
value
});
}
function toParseErrorConstructor(_ref) {
let {
toMessage
} = _ref,
properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
return function constructor({
loc,
details
}) {
const error = new SyntaxError();
Object.assign(error, properties, {
loc,
pos: loc.index
});
if ("missingPlugin" in details) {
Object.assign(error, {
missingPlugin: details.missingPlugin
});
}
defineHidden(error, "clone", function clone(overrides = {}) {
var _overrides$loc;
const {
line,
column,
index
} = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc;
return constructor({
loc: new Position(line, column, index),
details: Object.assign({}, details, overrides.details)
});
});
defineHidden(error, "details", details);
Object.defineProperty(error, "message", {
configurable: true,
get() {
const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
this.message = message;
return message;
},
set(value) {
Object.defineProperty(this, "message", {
value,
writable: true
});
}
});
return error;
};
}
function ParseErrorEnum(argument, syntaxPlugin) {
if (Array.isArray(argument)) {
return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);
}
const ParseErrorConstructors = {};
for (const reasonCode of Object.keys(argument)) {
const template = argument[reasonCode];
const _ref2 = typeof template === "string" ? {
message: () => template
} : typeof template === "function" ? {
message: template
} : template,
{
message
} = _ref2,
rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
const toMessage = typeof message === "string" ? () => message : message;
ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
code: "BABEL_PARSER_SYNTAX_ERROR",
reasonCode,
toMessage
}, syntaxPlugin ? {
syntaxPlugin
} : {}, rest));
}
return ParseErrorConstructors;
}
const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
const {
defineProperty
} = Object;
const toUnenumerable = (object, key) => defineProperty(object, key, {
enumerable: false,
value: object[key]
});
function toESTreeLocation(node) {
node.loc.start && toUnenumerable(node.loc.start, "index");
node.loc.end && toUnenumerable(node.loc.end, "index");
return node;
}
var estree = superClass => class ESTreeParserMixin extends superClass {
parse() {
const file = toESTreeLocation(super.parse());
if (this.options.tokens) {
file.tokens = file.tokens.map(toESTreeLocation);
}
return file;
}
parseRegExpLiteral({
pattern,
flags
}) {
let regex = null;
try {
regex = new RegExp(pattern, flags);
} catch (e) {}
const node = this.estreeParseLiteral(regex);
node.regex = {
pattern,
flags
};
return node;
}
parseBigIntLiteral(value) {
let bigInt;
try {
bigInt = BigInt(value);
} catch (_unused) {
bigInt = null;
}
const node = this.estreeParseLiteral(bigInt);
node.bigint = String(node.value || value);
return node;
}
parseDecimalLiteral(value) {
const decimal = null;
const node = this.estreeParseLiteral(decimal);
node.decimal = String(node.value || value);
return node;
}
estreeParseLiteral(value) {
return this.parseLiteral(value, "Literal");
}
parseStringLiteral(value) {
return this.estreeParseLiteral(value);
}
parseNumericLiteral(value) {
return this.estreeParseLiteral(value);
}
parseNullLiteral() {
return this.estreeParseLiteral(null);
}
parseBooleanLiteral(value) {
return this.estreeParseLiteral(value);
}
directiveToStmt(directive) {
const expression = directive.value;
delete directive.value;
expression.type = "Literal";
expression.raw = expression.extra.raw;
expression.value = expression.extra.expressionValue;
const stmt = directive;
stmt.type = "ExpressionStatement";
stmt.expression = expression;
stmt.directive = expression.extra.rawValue;
delete expression.extra;
return stmt;
}
initFunction(node, isAsync) {
super.initFunction(node, isAsync);
node.expression = false;
}
checkDeclaration(node) {
if (node != null && this.isObjectProperty(node)) {
this.checkDeclaration(node.value);
} else {
super.checkDeclaration(node);
}
}
getObjectOrClassMethodParams(method) {
return method.value.params;
}
isValidDirective(stmt) {
var _stmt$expression$extr;
return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);
}
parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);
const directiveStatements = node.directives.map(d => this.directiveToStmt(d));
node.body = directiveStatements.concat(node.body);
delete node.directives;
}
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
if (method.typeParameters) {
method.value.typeParameters = method.typeParameters;
delete method.typeParameters;
}
classBody.body.push(method);
}
parsePrivateName() {
const node = super.parsePrivateName();
{
if (!this.getPluginOption("estree", "classFeatures")) {
return node;
}
}
return this.convertPrivateNameToPrivateIdentifier(node);
}
convertPrivateNameToPrivateIdentifier(node) {
const name = super.getPrivateNameSV(node);
node = node;
delete node.id;
node.name = name;
node.type = "PrivateIdentifier";
return node;
}
isPrivateName(node) {
{
if (!this.getPluginOption("estree", "classFeatures")) {
return super.isPrivateName(node);
}
}
return node.type === "PrivateIdentifier";
}
getPrivateNameSV(node) {
{
if (!this.getPluginOption("estree", "classFeatures")) {
return super.getPrivateNameSV(node);
}
}
return node.name;
}
parseLiteral(value, type) {
const node = super.parseLiteral(value, type);
node.raw = node.extra.raw;
delete node.extra;
return node;
}
parseFunctionBody(node, allowExpression, isMethod = false) {
super.parseFunctionBody(node, allowExpression, isMethod);
node.expression = node.body.type !== "BlockStatement";
}
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
let funcNode = this.startNode();
funcNode.kind = node.kind;
funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
funcNode.type = "FunctionExpression";
delete funcNode.kind;
node.value = funcNode;
if (type === "ClassPrivateMethod") {
node.computed = false;
}
return this.finishNode(node, "MethodDefinition");
}
parseClassProperty(...args) {
const propertyNode = super.parseClassProperty(...args);
{
if (!this.getPluginOption("estree", "classFeatures")) {
return propertyNode;
}
}
propertyNode.type = "PropertyDefinition";
return propertyNode;
}
parseClassPrivateProperty(...args) {
const propertyNode = super.parseClassPrivateProperty(...args);
{
if (!this.getPluginOption("estree", "classFeatures")) {
return propertyNode;
}
}
propertyNode.type = "PropertyDefinition";
propertyNode.computed = false;
return propertyNode;
}
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);
if (node) {
node.type = "Property";
if (node.kind === "method") {
node.kind = "init";
}
node.shorthand = false;
}
return node;
}
parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
if (node) {
node.kind = "init";
node.type = "Property";
}
return node;
}
isValidLVal(type, isUnparenthesizedInAssign, binding) {
return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);
}
isAssignable(node, isBinding) {
if (node != null && this.isObjectProperty(node)) {
return this.isAssignable(node.value, isBinding);
}
return super.isAssignable(node, isBinding);
}
toAssignable(node, isLHS = false) {
if (node != null && this.isObjectProperty(node)) {
const {
key,
value
} = node;
if (this.isPrivateName(key)) {
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
}
this.toAssignable(value, isLHS);
} else {
super.toAssignable(node, isLHS);
}
}
toAssignableObjectExpressionProp(prop, isLast, isLHS) {
if (prop.kind === "get" || prop.kind === "set") {
this.raise(Errors.PatternHasAccessor, {
at: prop.key
});
} else if (prop.method) {
this.raise(Errors.PatternHasMethod, {
at: prop.key
});
} else {
super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
}
}
finishCallExpression(unfinished, optional) {
const node = super.finishCallExpression(unfinished, optional);
if (node.callee.type === "Import") {
node.type = "ImportExpression";
node.source = node.arguments[0];
if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
var _node$arguments$, _node$arguments$2;
node.options = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
node.attributes = (_node$arguments$2 = node.arguments[1]) != null ? _node$arguments$2 : null;
}
delete node.arguments;
delete node.callee;
}
return node;
}
toReferencedArguments(node) {
if (node.type === "ImportExpression") {
return;
}
super.toReferencedArguments(node);
}
parseExport(unfinished, decorators) {
const exportStartLoc = this.state.lastTokStartLoc;
const node = super.parseExport(unfinished, decorators);
switch (node.type) {
case "ExportAllDeclaration":
node.exported = null;
break;
case "ExportNamedDeclaration":
if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
node.type = "ExportAllDeclaration";
node.exported = node.specifiers[0].exported;
delete node.specifiers;
}
case "ExportDefaultDeclaration":
{
var _declaration$decorato;
const {
declaration
} = node;
if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
this.resetStartLocation(node, exportStartLoc);
}
}
break;
}
return node;
}
parseSubscript(base, startLoc, noCalls, state) {
const node = super.parseSubscript(base, startLoc, noCalls, state);
if (state.optionalChainMember) {
if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
node.type = node.type.substring(8);
}
if (state.stop) {
const chain = this.startNodeAtNode(node);
chain.expression = node;
return this.finishNode(chain, "ChainExpression");
}
} else if (node.type === "MemberExpression" || node.type === "CallExpression") {
node.optional = false;
}
return node;
}
isOptionalMemberExpression(node) {
if (node.type === "ChainExpression") {
return node.expression.type === "MemberExpression";
}
return super.isOptionalMemberExpression(node);
}
hasPropertyAsPrivateName(node) {
if (node.type === "ChainExpression") {
node = node.expression;
}
return super.hasPropertyAsPrivateName(node);
}
isObjectProperty(node) {
return node.type === "Property" && node.kind === "init" && !node.method;
}
isObjectMethod(node) {
return node.method || node.kind === "get" || node.kind === "set";
}
finishNodeAt(node, type, endLoc) {
return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
}
resetStartLocation(node, startLoc) {
super.resetStartLocation(node, startLoc);
toESTreeLocation(node);
}
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
super.resetEndLocation(node, endLoc);
toESTreeLocation(node);
}
};
class TokContext {
constructor(token, preserveSpace) {
this.token = void 0;
this.preserveSpace = void 0;
this.token = token;
this.preserveSpace = !!preserveSpace;
}
}
const types = {
brace: new TokContext("{"),
j_oTag: new TokContext("<tag"),
j_cTag: new TokContext("</tag"),
j_expr: new TokContext("<tag>...</tag>", true)
};
{
types.template = new TokContext("`", true);
}
const beforeExpr = true;
const startsExpr = true;
const isLoop = true;
const isAssign = true;
const prefix = true;
const postfix = true;
class ExportedTokenType {
constructor(label, conf = {}) {
this.label = void 0;
this.keyword = void 0;
this.beforeExpr = void 0;
this.startsExpr = void 0;
this.rightAssociative = void 0;
this.isLoop = void 0;
this.isAssign = void 0;
this.prefix = void 0;
this.postfix = void 0;
this.binop = void 0;
this.label = label;
this.keyword = conf.keyword;
this.beforeExpr = !!conf.beforeExpr;
this.startsExpr = !!conf.startsExpr;
this.rightAssociative = !!conf.rightAssociative;
this.isLoop = !!conf.isLoop;
this.isAssign = !!conf.isAssign;
this.prefix = !!conf.prefix;
this.postfix = !!conf.postfix;
this.binop = conf.binop != null ? conf.binop : null;
{
this.updateContext = null;
}
}
}
const keywords$1 = new Map();
function createKeyword(name, options = {}) {
options.keyword = name;
const token = createToken(name, options);
keywords$1.set(name, token);
return token;
}
function createBinop(name, binop) {
return createToken(name, {
beforeExpr,
binop
});
}
let tokenTypeCounter = -1;
const tokenTypes = [];
const tokenLabels = [];
const tokenBinops = [];
const tokenBeforeExprs = [];
const tokenStartsExprs = [];
const tokenPrefixes = [];
function createToken(name, options = {}) {
var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
++tokenTypeCounter;
tokenLabels.push(name);
tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
tokenTypes.push(new ExportedTokenType(name, options));
return tokenTypeCounter;
}
function createKeywordLike(name, options = {}) {
var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
++tokenTypeCounter;
keywords$1.set(name, tokenTypeCounter);
tokenLabels.push(name);
tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
tokenTypes.push(new ExportedTokenType("name", options));
return tokenTypeCounter;
}
const tt = {
bracketL: createToken("[", {
beforeExpr,
startsExpr
}),
bracketHashL: createToken("#[", {
beforeExpr,
startsExpr
}),
bracketBarL: createToken("[|", {
beforeExpr,
startsExpr
}),
bracketR: createToken("]"),
bracketBarR: createToken("|]"),
braceL: createToken("{", {
beforeExpr,
startsExpr
}),
braceBarL: createToken("{|", {
beforeExpr,
startsExpr
}),
braceHashL: createToken("#{", {
beforeExpr,
startsExpr
}),
braceR: createToken("}"),
braceBarR: createToken("|}"),
parenL: createToken("(", {
beforeExpr,
startsExpr
}),
parenR: createToken(")"),
comma: createToken(",", {
beforeExpr
}),
semi: createToken(";", {
beforeExpr
}),
colon: createToken(":", {
beforeExpr
}),
doubleColon: createToken("::", {
beforeExpr
}),
dot: createToken("."),
question: createToken("?", {
beforeExpr
}),
questionDot: createToken("?."),
arrow: createToken("=>", {
beforeExpr
}),
template: createToken("template"),
ellipsis: createToken("...", {
beforeExpr
}),
backQuote: createToken("`", {
startsExpr
}),
dollarBraceL: createToken("${", {
beforeExpr,
startsExpr
}),
templateTail: createToken("...`", {
startsExpr
}),
templateNonTail: createToken("...${", {
beforeExpr,
startsExpr
}),
at: createToken("@"),
hash: createToken("#", {
startsExpr
}),
interpreterDirective: createToken("#!..."),
eq: createToken("=", {
beforeExpr,
isAssign
}),
assign: createToken("_=", {
beforeExpr,
isAssign
}),
slashAssign: createToken("_=", {
beforeExpr,
isAssign
}),
xorAssign: createToken("_=", {
beforeExpr,
isAssign
}),
moduloAssign: createToken("_=", {
beforeExpr,
isAssign
}),
incDec: createToken("++/--", {
prefix,
postfix,
startsExpr
}),
bang: createToken("!", {
beforeExpr,
prefix,
startsExpr
}),
tilde: createToken("~", {
beforeExpr,
prefix,
startsExpr
}),
doubleCaret: createToken("^^", {
startsExpr
}),
doubleAt: createToken("@@", {
startsExpr
}),
pipeline: createBinop("|>", 0),
nullishCoalescing: createBinop("??", 1),
logicalOR: createBinop("||", 1),
logicalAND: createBinop("&&", 2),
bitwiseOR: createBinop("|", 3),
bitwiseXOR: createBinop("^", 4),
bitwiseAND: createBinop("&", 5),
equality: createBinop("==/!=/===/!==", 6),
lt: createBinop("</>/<=/>=", 7),
gt: createBinop("</>/<=/>=", 7),
relational: createBinop("</>/<=/>=", 7),
bitShift: createBinop("<</>>/>>>", 8),
bitShiftL: createBinop("<</>>/>>>", 8),
bitShiftR: createBinop("<</>>/>>>", 8),
plusMin: createToken("+/-", {
beforeExpr,
binop: 9,
prefix,
startsExpr
}),
modulo: createToken("%", {
binop: 10,
startsExpr
}),
star: createToken("*", {
binop: 10
}),
slash: createBinop("/", 10),
exponent: createToken("**", {
beforeExpr,
binop: 11,
rightAssociative: true
}),
_in: createKeyword("in", {
beforeExpr,
binop: 7
}),
_instanceof: createKeyword("instanceof", {
beforeExpr,
binop: 7
}),
_break: createKeyword("break"),
_case: createKeyword("case", {
beforeExpr
}),
_catch: createKeyword("catch"),
_continue: createKeyword("continue"),
_debugger: createKeyword("debugger"),
_default: createKeyword("default", {
beforeExpr
}),
_else: createKeyword("else", {
beforeExpr
}),
_finally: createKeyword("finally"),
_function: createKeyword("function", {
startsExpr
}),
_if: createKeyword("if"),
_return: createKeyword("return", {
beforeExpr
}),
_switch: createKeyword("switch"),
_throw: createKeyword("throw", {
beforeExpr,
prefix,
startsExpr
}),
_try: createKeyword("try"),
_var: createKeyword("var"),
_const: createKeyword("const"),
_with: createKeyword("with"),
_new: createKeyword("new", {
beforeExpr,
startsExpr
}),
_this: createKeyword("this", {
startsExpr
}),
_super: createKeyword("super", {
startsExpr
}),
_class: createKeyword("class", {
startsExpr
}),
_extends: createKeyword("extends", {
beforeExpr
}),
_export: createKeyword("export"),
_import: createKeyword("import", {
startsExpr
}),
_null: createKeyword("null", {
startsExpr
}),
_true: createKeyword("true", {
startsExpr
}),
_false: createKeyword("false", {
startsExpr
}),
_typeof: createKeyword("typeof", {
beforeExpr,
prefix,
startsExpr
}),
_void: createKeyword("void", {
beforeExpr,
prefix,
startsExpr
}),
_delete: createKeyword("delete", {
beforeExpr,
prefix,
startsExpr
}),
_do: createKeyword("do", {
isLoop,
beforeExpr
}),
_for: createKeyword("for", {
isLoop
}),
_while: createKeyword("while", {
isLoop
}),
_as: createKeywordLike("as", {
startsExpr
}),
_assert: createKeywordLike("assert", {
startsExpr
}),
_async: createKeywordLike("async", {
startsExpr
}),
_await: createKeywordLike("await", {
startsExpr
}),
_defer: createKeywordLike("defer", {
startsExpr
}),
_from: createKeywordLike("from", {
startsExpr
}),
_get: createKeywordLike("get", {
startsExpr
}),
_let: createKeywordLike("let", {
startsExpr
}),
_meta: createKeywordLike("meta", {
startsExpr
}),
_of: createKeywordLike("of", {
startsExpr
}),
_sent: createKeywordLike("sent", {
startsExpr
}),
_set: createKeywordLike("set", {
startsExpr
}),
_source: createKeywordLike("source", {
startsExpr
}),
_static: createKeywordLike("static", {
startsExpr
}),
_using: createKeywordLike("using", {
startsExpr
}),
_yield: createKeywordLike("yield", {
startsExpr
}),
_asserts: createKeywordLike("asserts", {
startsExpr
}),
_checks: createKeywordLike("checks", {
startsExpr
}),
_exports: createKeywordLike("exports", {
startsExpr
}),
_global: createKeywordLike("global", {
startsExpr
}),
_implements: createKeywordLike("implements", {
startsExpr
}),
_intrinsic: createKeywordLike("intrinsic", {
startsExpr
}),
_infer: createKeywordLike("infer", {
startsExpr
}),
_is: createKeywordLike("is", {
startsExpr
}),
_mixins: createKeywordLike("mixins", {
startsExpr
}),
_proto: createKeywordLike("proto", {
startsExpr
}),
_require: createKeywordLike("require", {
startsExpr
}),
_satisfies: createKeywordLike("satisfies", {
startsExpr
}),
_keyof: createKeywordLike("keyof", {
startsExpr
}),
_readonly: createKeywordLike("readonly", {
startsExpr
}),
_unique: createKeywordLike("unique", {
startsExpr
}),
_abstract: createKeywordLike("abstract", {
startsExpr
}),
_declare: createKeywordLike("declare", {
startsExpr
}),
_enum: createKeywordLike("enum", {
startsExpr
}),
_module: createKeywordLike("module", {
startsExpr
}),
_namespace: createKeywordLike("namespace", {
startsExpr
}),
_interface: createKeywordLike("interface", {
startsExpr
}),
_type: createKeywordLike("type", {
startsExpr
}),
_opaque: createKeywordLike("opaque", {
startsExpr
}),
name: createToken("name", {
startsExpr
}),
string: createToken("string", {
startsExpr
}),
num: createToken("num", {
startsExpr
}),
bigint: createToken("bigint", {
startsExpr
}),
decimal: createToken("decimal", {
startsExpr
}),
regexp: createToken("regexp", {
startsExpr
}),
privateName: createToken("#name", {
startsExpr
}),
eof: createToken("eof"),
jsxName: createToken("jsxName"),
jsxText: createToken("jsxText", {
beforeExpr: true
}),
jsxTagStart: createToken("jsxTagStart", {
startsExpr: true
}),
jsxTagEnd: createToken("jsxTagEnd"),
placeholder: createToken("%%", {
startsExpr: true
})
};
function tokenIsIdentifier(token) {
return token >= 93 && token <= 132;
}
function tokenKeywordOrIdentifierIsKeyword(token) {
return token <= 92;
}
function tokenIsKeywordOrIdentifier(token) {
return token >= 58 && token <= 132;
}
function tokenIsLiteralPropertyName(token) {
return token >= 58 && token <= 136;
}
function tokenComesBeforeExpression(token) {
return tokenBeforeExprs[token];
}
function tokenCanStartExpression(token) {
return tokenStartsExprs[token];
}
function tokenIsAssignment(token) {
return token >= 29 && token <= 33;
}
function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
return token >= 129 && token <= 131;
}
function tokenIsLoop(token) {
return token >= 90 && token <= 92;
}
function tokenIsKeyword(token) {
return token >= 58 && token <= 92;
}
function tokenIsOperator(token) {
return token >= 39 && token <= 59;
}
function tokenIsPostfix(token) {
return token === 34;
}
function tokenIsPrefix(token) {
return tokenPrefixes[token];
}
function tokenIsTSTypeOperator(token) {
return token >= 121 && token <= 123;
}
function tokenIsTSDeclarationStart(token) {
return token >= 124 && token <= 130;
}
function tokenLabelName(token) {
return tokenLabels[token];
}
function tokenOperatorPrecedence(token) {
return tokenBinops[token];
}
function tokenIsRightAssociative(token) {
return token === 57;
}
function tokenIsTemplate(token) {
return token >= 24 && token <= 25;
}
function getExportedToken(token) {
return tokenTypes[token];
}
{
tokenTypes[8].updateContext = context => {
context.pop();
};
tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = context => {
context.push(types.brace);
};
tokenTypes[22].updateContext = context => {
if (context[context.length - 1] === types.template) {
context.pop();
} else {
context.push(types.template);
}
};
tokenTypes[142].updateContext = context => {
context.push(types.j_expr, types.j_oTag);
};
}
let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
function isInAstralSet(code, set) {
let pos = 0x10000;
for (let i = 0, length = set.length; i < length; i += 2) {
pos += set[i];
if (pos > code) return false;
pos += set[i + 1];
if (pos >= code) return true;
}
return false;
}
function isIdentifierStart(code) {
if (code < 65) return code === 36;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 0xffff) {
return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
}
return isInAstralSet(code, astralIdentifierStartCodes);
}
function isIdentifierChar(code) {
if (code < 48) return code === 36;
if (code < 58) return true;
if (code < 65) return false;
if (code <= 90) return true;
if (code < 97) return code === 95;
if (code <= 122) return true;
if (code <= 0xffff) {
return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
}
return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
}
const reservedWords = {
keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
strictBind: ["eval", "arguments"]
};
const keywords = new Set(reservedWords.keyword);
const reservedWordsStrictSet = new Set(reservedWords.strict);
const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
function isReservedWord(word, inModule) {
return inModule && word === "await" || word === "enum";
}
function isStrictReservedWord(word, inModule) {
return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
}
function isStrictBindOnlyReservedWord(word) {
return reservedWordsStrictBindSet.has(word);
}
function isStrictBindReservedWord(word, inModule) {
return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
}
function isKeyword(word) {
return keywords.has(word);
}
function isIteratorStart(current, next, next2) {
return current === 64 && next === 64 && isIdentifierStart(next2);
}
const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]);
function canBeReservedWord(word) {
return reservedWordLikeSet.has(word);
}
class Scope {
constructor(flags) {
this.var = new Set();
this.lexical = new Set();
this.functions = new Set();
this.flags = flags;
}
}
class ScopeHandler {
constructor(parser, inModule) {
this.parser = void 0;
this.scopeStack = [];
this.inModule = void 0;
this.undefinedExports = new Map();
this.parser = parser;
this.inModule = inModule;
}
get inTopLevel() {
return (this.currentScope().flags & 1) > 0;
}
get inFunction() {
return (this.currentVarScopeFlags() & 2) > 0;
}
get allowSuper() {
return (this.currentThisScopeFlags() & 16) > 0;
}
get allowDirectSuper() {
return (this.currentThisScopeFlags() & 32) > 0;
}
get inClass() {
return (this.currentThisScopeFlags() & 64) > 0;
}
get inClassAndNotInNonArrowFunction() {
const flags = this.currentThisScopeFlags();
return (flags & 64) > 0 && (flags & 2) === 0;
}
get inStaticBlock() {
for (let i = this.scopeStack.length - 1;; i--) {
const {
flags
} = this.scopeStack[i];
if (flags & 128) {
return true;
}
if (flags & (387 | 64)) {
return false;
}
}
}
get inNonArrowFunction() {
return (this.currentThisScopeFlags() & 2) > 0;
}
get treatFunctionsAsVar() {
return this.treatFunctionsAsVarInScope(this.currentScope());
}
createScope(flags) {
return new Scope(flags);
}
enter(flags) {
this.scopeStack.push(this.createScope(flags));
}
exit() {
const scope = this.scopeStack.pop();
return scope.flags;
}
treatFunctionsAsVarInScope(scope) {
return !!(scope.flags & (2 | 128) || !this.parser.inModule && scope.flags & 1);
}
declareName(name, bindingType, loc) {
let scope = this.currentScope();
if (bindingType & 8 || bindingType & 16) {
this.checkRedeclarationInScope(scope, name, bindingType, loc);
if (bindingType & 16) {
scope.functions.add(name);
} else {
scope.lexical.add(name);
}
if (bindingType & 8) {
this.maybeExportDefined(scope, name);
}
} else if (bindingType & 4) {
for (let i = this.scopeStack.length - 1; i >= 0; --i) {
scope = this.scopeStack[i];
this.checkRedeclarationInScope(scope, name, bindingType, loc);
scope.var.add(name);
this.maybeExportDefined(scope, name);
if (scope.flags & 387) break;
}
}
if (this.parser.inModule && scope.flags & 1) {
this.undefinedExports.delete(name);
}
}
maybeExportDefined(scope, name) {
if (this.parser.inModule && scope.flags & 1) {
this.undefinedExports.delete(name);
}
}
checkRedeclarationInScope(scope, name, bindingType, loc) {
if (this.isRedeclaredInScope(scope, name, bindingType)) {
this.parser.raise(Errors.VarRedeclaration, {
at: loc,
identifierName: name
});
}
}
isRedeclaredInScope(scope, name, bindingType) {
if (!(bindingType & 1)) return false;
if (bindingType & 8) {
return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
}
if (bindingType & 16) {
return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
}
return scope.lexical.has(name) && !(scope.flags & 8 && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name);
}
checkLocalExport(id) {
const {
name
} = id;
const topLevelScope = this.scopeStack[0];
if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
this.undefinedExports.set(name, id.loc.start);
}
}
currentScope() {
return this.scopeStack[this.scopeStack.length - 1];
}
currentVarScopeFlags() {
for (let i = this.scopeStack.length - 1;; i--) {
const {
flags
} = this.scopeStack[i];
if (flags & 387) {
return flags;
}
}
}
currentThisScopeFlags() {
for (let i = this.scopeStack.length - 1;; i--) {
const {
flags
} = this.scopeStack[i];
if (flags & (387 | 64) && !(flags & 4)) {
return flags;
}
}
}
}
class FlowScope extends Scope {
constructor(...args) {
super(...args);
this.declareFunctions = new Set();
}
}
class FlowScopeHandler extends ScopeHandler {
createScope(flags) {
return new FlowScope(flags);
}
declareName(name, bindingType, loc) {
const scope = this.currentScope();
if (bindingType & 2048) {
this.checkRedeclarationInScope(scope, name, bindingType, loc);
this.maybeExportDefined(scope, name);
scope.declareFunctions.add(name);
return;
}
super.declareName(name, bindingType, loc);
}
isRedeclaredInScope(scope, name, bindingType) {
if (super.isRedeclaredInScope(scope, name, bindingType)) return true;
if (bindingType & 2048) {
return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name));
}
return false;
}
checkLocalExport(id) {
if (!this.scopeStack[0].declareFunctions.has(id.name)) {
super.checkLocalExport(id);
}
}
}
class BaseParser {
constructor() {
this.sawUnambiguousESM = false;
this.ambiguousScriptDifferentAst = false;
}
hasPlugin(pluginConfig) {
if (typeof pluginConfig === "string") {
return this.plugins.has(pluginConfig);
} else {
const [pluginName, pluginOptions] = pluginConfig;
if (!this.hasPlugin(pluginName)) {
return false;
}
const actualOptions = this.plugins.get(pluginName);
for (const key of Object.keys(pluginOptions)) {
if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) {
return false;
}
}
return true;
}
}
getPluginOption(plugin, name) {
var _this$plugins$get;
return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];
}
}
function setTrailingComments(node, comments) {
if (node.trailingComments === undefined) {
node.trailingComments = comments;
} else {
node.trailingComments.unshift(...comments);
}
}
function setLeadingComments(node, comments) {
if (node.leadingComments === undefined) {
node.leadingComments = comments;
} else {
node.leadingComments.unshift(...comments);
}
}
function setInnerComments(node, comments) {
if (node.innerComments === undefined) {
node.innerComments = comments;
} else {
node.innerComments.unshift(...comments);
}
}
function adjustInnerComments(node, elements, commentWS) {
let lastElement = null;
let i = elements.length;
while (lastElement === null && i > 0) {
lastElement = elements[--i];
}
if (lastElement === null || lastElement.start > commentWS.start) {
setInnerComments(node, commentWS.comments);
} else {
setTrailingComments(lastElement, commentWS.comments);
}
}
class CommentsParser extends BaseParser {
addComment(comment) {
if (this.filename) comment.loc.filename = this.filename;
this.state.comments.push(comment);
}
processComment(node) {
const {
commentStack
} = this.state;
const commentStackLength = commentStack.length;
if (commentStackLength === 0) return;
let i = commentStackLength - 1;
const lastCommentWS = commentStack[i];
if (lastCommentWS.start === node.end) {
lastCommentWS.leadingNode = node;
i--;
}
const {
start: nodeStart
} = node;
for (; i >= 0; i--) {
const commentWS = commentStack[i];
const commentEnd = commentWS.end;
if (commentEnd > nodeStart) {
commentWS.containingNode = node;
this.finalizeComment(commentWS);
commentStack.splice(i, 1);
} else {
if (commentEnd === nodeStart) {
commentWS.trailingNode = node;
}
break;
}
}
}
finalizeComment(commentWS) {
const {
comments
} = commentWS;
if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {
if (commentWS.leadingNode !== null) {
setTrailingComments(commentWS.leadingNode, comments);
}
if (commentWS.trailingNode !== null) {
setLeadingComments(commentWS.trailingNode, comments);
}
} else {
const {
containingNode: node,
start: commentStart
} = commentWS;
if (this.input.charCodeAt(commentStart - 1) === 44) {
switch (node.type) {
case "ObjectExpression":
case "ObjectPattern":
case "RecordExpression":
adjustInnerComments(node, node.properties, commentWS);
break;
case "CallExpression":
case "OptionalCallExpression":
adjustInnerComments(node, node.arguments, commentWS);
break;
case "FunctionDeclaration":
case "FunctionExpression":
case "ArrowFunctionExpression":
case "ObjectMethod":
case "ClassMethod":
case "ClassPrivateMethod":
adjustInnerComments(node, node.params, commentWS);
break;
case "ArrayExpression":
case "ArrayPattern":
case "TupleExpression":
adjustInnerComments(node, node.elements, commentWS);
break;
case "ExportNamedDeclaration":
case "ImportDeclaration":
adjustInnerComments(node, node.specifiers, commentWS);
break;
default:
{
setInnerComments(node, comments);
}
}
} else {
setInnerComments(node, comments);
}
}
}
finalizeRemainingComments() {
const {
commentStack
} = this.state;
for (let i = commentStack.length - 1; i >= 0; i--) {
this.finalizeComment(commentStack[i]);
}
this.state.commentStack = [];
}
resetPreviousNodeTrailingComments(node) {
const {
commentStack
} = this.state;
const {
length
} = commentStack;
if (length === 0) return;
const commentWS = commentStack[length - 1];
if (commentWS.leadingNode === node) {
commentWS.leadingNode = null;
}
}
resetPreviousIdentifierLeadingComments(node) {
const {
commentStack
} = this.state;
const {
length
} = commentStack;
if (length === 0) return;
if (commentStack[length - 1].trailingNode === node) {
commentStack[length - 1].trailingNode = null;
} else if (length >= 2 && commentStack[length - 2].trailingNode === node) {
commentStack[length - 2].trailingNode = null;
}
}
takeSurroundingComments(node, start, end) {
const {
commentStack
} = this.state;
const commentStackLength = commentStack.length;
if (commentStackLength === 0) return;
let i = commentStackLength - 1;
for (; i >= 0; i--) {
const commentWS = commentStack[i];
const commentEnd = commentWS.end;
const commentStart = commentWS.start;
if (commentStart === end) {
commentWS.leadingNode = node;
} else if (commentEnd === start) {
commentWS.trailingNode = node;
} else if (commentEnd < start) {
break;
}
}
}
}
const lineBreak = /\r\n?|[\n\u2028\u2029]/;
const lineBreakG = new RegExp(lineBreak.source, "g");
function isNewLine(code) {
switch (code) {
case 10:
case 13:
case 8232:
case 8233:
return true;
default:
return false;
}
}
const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
function isWhitespace(code) {
switch (code) {
case 0x0009:
case 0x000b:
case 0x000c:
case 32:
case 160:
case 5760:
case 0x2000:
case 0x2001:
case 0x2002:
case 0x2003:
case 0x2004:
case 0x2005:
case 0x2006:
case 0x2007:
case 0x2008:
case 0x2009:
case 0x200a:
case 0x202f:
case 0x205f:
case 0x3000:
case 0xfeff:
return true;
default:
return false;
}
}
class State {
constructor() {
this.strict = void 0;
this.curLine = void 0;
this.lineStart = void 0;
this.startLoc = void 0;
this.endLoc = void 0;
this.errors = [];
this.potentialArrowAt = -1;
this.noArrowAt = [];
this.noArrowParamsConversionAt = [];
this.maybeInArrowParameters = false;
this.inType = false;
this.noAnonFunctionType = false;
this.hasFlowComment = false;
this.isAmbientContext = false;
this.inAbstractClass = false;
this.inDisallowConditionalTypesContext = false;
this.topicContext = {
maxNumOfResolvableTopics: 0,
maxTopicIndex: null
};
this.soloAwait = false;
this.inFSharpPipelineDirectBody = false;
this.labels = [];
this.comments = [];
this.commentStack = [];
this.pos = 0;
this.type = 139;
this.value = null;
this.start = 0;
this.end = 0;
this.lastTokEndLoc = null;
this.lastTokStartLoc = null;
this.lastTokStart = 0;
this.context = [types.brace];
this.canStartJSXElement = true;
this.containsEsc = false;
this.firstInvalidTemplateEscapePos = null;
this.strictErrors = new Map();
this.tokensLength = 0;
}
init({
strictMode,
sourceType,
startLine,
startColumn
}) {
this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
this.curLine = startLine;
this.lineStart = -startColumn;
this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);
}
curPosition() {
return new Position(this.curLine, this.pos - this.lineStart, this.pos);
}
clone(skipArrays) {
const state = new State();
const keys = Object.keys(this);
for (let i = 0, length = keys.length; i < length; i++) {
const key = keys[i];
let val = this[key];
if (!skipArrays && Array.isArray(val)) {
val = val.slice();
}
state[key] = val;
}
return state;
}
}
var _isDigit = function isDigit(code) {
return code >= 48 && code <= 57;
};
const forbiddenNumericSeparatorSiblings = {
decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
hex: new Set([46, 88, 95, 120])
};
const isAllowedNumericSeparatorSibling = {
bin: ch => ch === 48 || ch === 49,
oct: ch => ch >= 48 && ch <= 55,
dec: ch => ch >= 48 && ch <= 57,
hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
};
function readStringContents(type, input, pos, lineStart, curLine, errors) {
const initialPos = pos;
const initialLineStart = lineStart;
const initialCurLine = curLine;
let out = "";
let firstInvalidLoc = null;
let chunkStart = pos;
const {
length
} = input;
for (;;) {
if (pos >= length) {
errors.unterminated(initialPos, initialLineStart, initialCurLine);
out += input.slice(chunkStart, pos);
break;
}
const ch = input.charCodeAt(pos);
if (isStringEnd(type, ch, input, pos)) {
out += input.slice(chunkStart, pos);
break;
}
if (ch === 92) {
out += input.slice(chunkStart, pos);
const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
if (res.ch === null && !firstInvalidLoc) {
firstInvalidLoc = {
pos,
lineStart,
curLine
};
} else {
out += res.ch;
}
({
pos,
lineStart,
curLine
} = res);
chunkStart = pos;
} else if (ch === 8232 || ch === 8233) {
++pos;
++curLine;
lineStart = pos;
} else if (ch === 10 || ch === 13) {
if (type === "template") {
out += input.slice(chunkStart, pos) + "\n";
++pos;
if (ch === 13 && input.charCodeAt(pos) === 10) {
++pos;
}
++curLine;
chunkStart = lineStart = pos;
} else {
errors.unterminated(initialPos, initialLineStart, initialCurLine);
}
} else {
++pos;
}
}
return {
pos,
str: out,
firstInvalidLoc,
lineStart,
curLine,
containsInvalid: !!firstInvalidLoc
};
}
function isStringEnd(type, ch, input, pos) {
if (type === "template") {
return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
}
return ch === (type === "double" ? 34 : 39);
}
function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
const throwOnInvalid = !inTemplate;
pos++;
const res = ch => ({
pos,
ch,
lineStart,
curLine
});
const ch = input.charCodeAt(pos++);
switch (ch) {
case 110:
return res("\n");
case 114:
return res("\r");
case 120:
{
let code;
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
return res(code === null ? null : String.fromCharCode(code));
}
case 117:
{
let code;
({
code,
pos
} = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
return res(code === null ? null : String.fromCodePoint(code));
}
case 116:
return res("\t");
case 98:
return res("\b");
case 118:
return res("\u000b");
case 102:
return res("\f");
case 13:
if (input.charCodeAt(pos) === 10) {
++pos;
}
case 10:
lineStart = pos;
++curLine;
case 8232:
case 8233:
return res("");
case 56:
case 57:
if (inTemplate) {
return res(null);
} else {
errors.strictNumericEscape(pos - 1, lineStart, curLine);
}
default:
if (ch >= 48 && ch <= 55) {
const startPos = pos - 1;
const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
let octalStr = match[0];
let octal = parseInt(octalStr, 8);
if (octal > 255) {
octalStr = octalStr.slice(0, -1);
octal = parseInt(octalStr, 8);
}
pos += octalStr.length - 1;
const next = input.charCodeAt(pos);
if (octalStr !== "0" || next === 56 || next === 57) {
if (inTemplate) {
return res(null);
} else {
errors.strictNumericEscape(startPos, lineStart, curLine);
}
}
return res(String.fromCharCode(octal));
}
return res(String.fromCharCode(ch));
}
}
function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
const initialPos = pos;
let n;
({
n,
pos
} = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
if (n === null) {
if (throwOnInvalid) {
errors.invalidEscapeSequence(initialPos, lineStart, curLine);
} else {
pos = initialPos - 1;
}
}
return {
code: n,
pos
};
}
function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
const start = pos;
const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
let invalid = false;
let total = 0;
for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
const code = input.charCodeAt(pos);
let val;
if (code === 95 && allowNumSeparator !== "bail") {
const prev = input.charCodeAt(pos - 1);
const next = input.charCodeAt(pos + 1);
if (!allowNumSeparator) {
if (bailOnError) return {
n: null,
pos
};
errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
if (bailOnError) return {
n: null,
pos
};
errors.unexpectedNumericSeparator(pos, lineStart, curLine);
}
++pos;
continue;
}
if (code >= 97) {
val = code - 97 + 10;
} else if (code >= 65) {
val = code - 65 + 10;
} else if (_isDigit(code)) {
val = code - 48;
} else {
val = Infinity;
}
if (val >= radix) {
if (val <= 9 && bailOnError) {
return {
n: null,
pos
};
} else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
val = 0;
} else if (forceLen) {
val = 0;
invalid = true;
} else {
break;
}
}
++pos;
total = total * radix + val;
}
if (pos === start || len != null && pos - start !== len || invalid) {
return {
n: null,
pos
};
}
return {
n: total,
pos
};
}
function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
const ch = input.charCodeAt(pos);
let code;
if (ch === 123) {
++pos;
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
++pos;
if (code !== null && code > 0x10ffff) {
if (throwOnInvalid) {
errors.invalidCodePoint(pos, lineStart, curLine);
} else {
return {
code: null,
pos
};
}
}
} else {
({
code,
pos
} = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
}
return {
code,
pos
};
}
const _excluded = ["at"],
_excluded2 = ["at"];
function buildPosition(pos, lineStart, curLine) {
return new Position(curLine, pos - lineStart, pos);
}
const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
class Token {
constructor(state) {
this.type = state.type;
this.value = state.value;
this.start = state.start;
this.end = state.end;
this.loc = new SourceLocation(state.startLoc, state.endLoc);
}
}
class Tokenizer extends CommentsParser {
constructor(options, input) {
super();
this.isLookahead = void 0;
this.tokens = [];
this.errorHandlers_readInt = {
invalidDigit: (pos, lineStart, curLine, radix) => {
if (!this.options.errorRecovery) return false;
this.raise(Errors.InvalidDigit, {
at: buildPosition(pos, lineStart, curLine),
radix
});
return true;
},
numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
};
this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
});
this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
strictNumericEscape: (pos, lineStart, curLine) => {
this.recordStrictModeErrors(Errors.StrictNumericEscape, {
at: buildPosition(pos, lineStart, curLine)
});
},
unterminated: (pos, lineStart, curLine) => {
throw this.raise(Errors.UnterminatedString, {
at: buildPosition(pos - 1, lineStart, curLine)
});
}
});
this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
unterminated: (pos, lineStart, curLine) => {
throw this.raise(Errors.UnterminatedTemplate, {
at: buildPosition(pos, lineStart, curLine)
});
}
});
this.state = new State();
this.state.init(options);
this.input = input;
this.length = input.length;
this.isLookahead = false;
}
pushToken(token) {
this.tokens.length = this.state.tokensLength;
this.tokens.push(token);
++this.state.tokensLength;
}
next() {
this.checkKeywordEscapes();
if (this.options.tokens) {
this.pushToken(new Token(this.state));
}
this.state.lastTokStart = this.state.start;
this.state.lastTokEndLoc = this.state.endLoc;
this.state.lastTokStartLoc = this.state.startLoc;
this.nextToken();
}
eat(type) {
if (this.match(type)) {
this.next();
return true;
} else {
return false;
}
}
match(type) {
return this.state.type === type;
}
createLookaheadState(state) {
return {
pos: state.pos,
value: null,
type: state.type,
start: state.start,
end: state.end,
context: [this.curContext()],
inType: state.inType,
startLoc: state.startLoc,
lastTokEndLoc: state.lastTokEndLoc,
curLine: state.curLine,
lineStart: state.lineStart,
curPosition: state.curPosition
};
}
lookahead() {
const old = this.state;
this.state = this.createLookaheadState(old);
this.isLookahead = true;
this.nextToken();
this.isLookahead = false;
const curr = this.state;
this.state = old;
return curr;
}
nextTokenStart() {
return this.nextTokenStartSince(this.state.pos);
}
nextTokenStartSince(pos) {
skipWhiteSpace.lastIndex = pos;
return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;
}
lookaheadCharCode() {
return this.input.charCodeAt(this.nextTokenStart());
}
nextTokenInLineStart() {
return this.nextTokenInLineStartSince(this.state.pos);
}
nextTokenInLineStartSince(pos) {
skipWhiteSpaceInLine.lastIndex = pos;
return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos;
}
lookaheadInLineCharCode() {
return this.input.charCodeAt(this.nextTokenInLineStart());
}
codePointAtPos(pos) {
let cp = this.input.charCodeAt(pos);
if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {
const trail = this.input.charCodeAt(pos);
if ((trail & 0xfc00) === 0xdc00) {
cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
}
}
return cp;
}
setStrict(strict) {
this.state.strict = strict;
if (strict) {
this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, {
at
}));
this.state.strictErrors.clear();
}
}
curContext() {
return this.state.context[this.state.context.length - 1];
}
nextToken() {
this.skipSpace();
this.state.start = this.state.pos;
if (!this.isLookahead) this.state.startLoc = this.state.curPosition();
if (this.state.pos >= this.length) {
this.finishToken(139);
return;
}
this.getTokenFromCode(this.codePointAtPos(this.state.pos));
}
skipBlockComment(commentEnd) {
let startLoc;
if (!this.isLookahead) startLoc = this.state.curPosition();
const start = this.state.pos;
const end = this.input.indexOf(commentEnd, start + 2);
if (end === -1) {
throw this.raise(Errors.UnterminatedComment, {
at: this.state.curPosition()
});
}
this.state.pos = end + commentEnd.length;
lineBreakG.lastIndex = start + 2;
while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {
++this.state.curLine;
this.state.lineStart = lineBreakG.lastIndex;
}
if (this.isLookahead) return;
const comment = {
type: "CommentBlock",
value: this.input.slice(start + 2, end),
start,
end: end + commentEnd.length,
loc: new SourceLocation(startLoc, this.state.curPosition())
};
if (this.options.tokens) this.pushToken(comment);
return comment;
}
skipLineComment(startSkip) {
const start = this.state.pos;
let startLoc;
if (!this.isLookahead) startLoc = this.state.curPosition();
let ch = this.input.charCodeAt(this.state.pos += startSkip);
if (this.state.pos < this.length) {
while (!isNewLine(ch) && ++this.state.pos < this.length) {
ch = this.input.charCodeAt(this.state.pos);
}
}
if (this.isLookahead) return;
const end = this.state.pos;
const value = this.input.slice(start + startSkip, end);
const comment = {
type: "CommentLine",
value,
start,
end,
loc: new SourceLocation(startLoc, this.state.curPosition())
};
if (this.options.tokens) this.pushToken(comment);
return comment;
}
skipSpace() {
const spaceStart = this.state.pos;
const comments = [];
loop: while (this.state.pos < this.length) {
const ch = this.input.charCodeAt(this.state.pos);
switch (ch) {
case 32:
case 160:
case 9:
++this.state.pos;
break;
case 13:
if (this.input.charCodeAt(this.state.pos + 1) === 10) {
++this.state.pos;
}
case 10:
case 8232:
case 8233:
++this.state.pos;
++this.state.curLine;
this.state.lineStart = this.state.pos;
break;
case 47:
switch (this.input.charCodeAt(this.state.pos + 1)) {
case 42:
{
const comment = this.skipBlockComment("*/");
if (comment !== undefined) {
this.addComment(comment);
if (this.options.attachComment) comments.push(comment);
}
break;
}
case 47:
{
const comment = this.skipLineComment(2);
if (comment !== undefined) {
this.addComment(comment);
if (this.options.attachComment) comments.push(comment);
}
break;
}
default:
break loop;
}
break;
default:
if (isWhitespace(ch)) {
++this.state.pos;
} else if (ch === 45 && !this.inModule && this.options.annexB) {
const pos = this.state.pos;
if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
const comment = this.skipLineComment(3);
if (comment !== undefined) {
this.addComment(comment);
if (this.options.attachComment) comments.push(comment);
}
} else {
break loop;
}
} else if (ch === 60 && !this.inModule && this.options.annexB) {
const pos = this.state.pos;
if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
const comment = this.skipLineComment(4);
if (comment !== undefined) {
this.addComment(comment);
if (this.options.attachComment) comments.push(comment);
}
} else {
break loop;
}
} else {
break loop;
}
}
}
if (comments.length > 0) {
const end = this.state.pos;
const commentWhitespace = {
start: spaceStart,
end,
comments,
leadingNode: null,
trailingNode: null,
containingNode: null
};
this.state.commentStack.push(commentWhitespace);
}
}
finishToken(type, val) {
this.state.end = this.state.pos;
this.state.endLoc = this.state.curPosition();
const prevType = this.state.type;
this.state.type = type;
this.state.value = val;
if (!this.isLookahead) {
this.updateContext(prevType);
}
}
replaceToken(type) {
this.state.type = type;
this.updateContext();
}
readToken_numberSign() {
if (this.state.pos === 0 && this.readToken_interpreter()) {
return;
}
const nextPos = this.state.pos + 1;
const next = this.codePointAtPos(nextPos);
if (next >= 48 && next <= 57) {
throw this.raise(Errors.UnexpectedDigitAfterHash, {
at: this.state.curPosition()
});
}
if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
this.expectPlugin("recordAndTuple");
if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, {
at: this.state.curPosition()
});
}
this.state.pos += 2;
if (next === 123) {
this.finishToken(7);
} else {
this.finishToken(1);
}
} else if (isIdentifierStart(next)) {
++this.state.pos;
this.finishToken(138, this.readWord1(next));
} else if (next === 92) {
++this.state.pos;
this.finishToken(138, this.readWord1());
} else {
this.finishOp(27, 1);
}
}
readToken_dot() {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next >= 48 && next <= 57) {
this.readNumber(true);
return;
}
if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
this.state.pos += 3;
this.finishToken(21);
} else {
++this.state.pos;
this.finishToken(16);
}
}
readToken_slash() {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === 61) {
this.finishOp(31, 2);
} else {
this.finishOp(56, 1);
}
}
readToken_interpreter() {
if (this.state.pos !== 0 || this.length < 2) return false;
let ch = this.input.charCodeAt(this.state.pos + 1);
if (ch !== 33) return false;
const start = this.state.pos;
this.state.pos += 1;
while (!isNewLine(ch) && ++this.state.pos < this.length) {
ch = this.input.charCodeAt(this.state.pos);
}
const value = this.input.slice(start + 2, this.state.pos);
this.finishToken(28, value);
return true;
}
readToken_mult_modulo(code) {
let type = code === 42 ? 55 : 54;
let width = 1;
let next = this.input.charCodeAt(this.state.pos + 1);
if (code === 42 && next === 42) {
width++;
next = this.input.charCodeAt(this.state.pos + 2);
type = 57;
}
if (next === 61 && !this.state.inType) {
width++;
type = code === 37 ? 33 : 30;
}
this.finishOp(type, width);
}
readToken_pipe_amp(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === code) {
if (this.input.charCodeAt(this.state.pos + 2) === 61) {
this.finishOp(30, 3);
} else {
this.finishOp(code === 124 ? 41 : 42, 2);
}
return;
}
if (code === 124) {
if (next === 62) {
this.finishOp(39, 2);
return;
}
if (this.hasPlugin("recordAndTuple") && next === 125) {
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {
at: this.state.curPosition()
});
}
this.state.pos += 2;
this.finishToken(9);
return;
}
if (this.hasPlugin("recordAndTuple") && next === 93) {
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {
at: this.state.curPosition()
});
}
this.state.pos += 2;
this.finishToken(4);
return;
}
}
if (next === 61) {
this.finishOp(30, 2);
return;
}
this.finishOp(code === 124 ? 43 : 45, 1);
}
readToken_caret() {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === 61 && !this.state.inType) {
this.finishOp(32, 2);
} else if (next === 94 && this.hasPlugin(["pipelineOperator", {
proposal: "hack",
topicToken: "^^"
}])) {
this.finishOp(37, 2);
const lookaheadCh = this.input.codePointAt(this.state.pos);
if (lookaheadCh === 94) {
this.unexpected();
}
} else {
this.finishOp(44, 1);
}
}
readToken_atSign() {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === 64 && this.hasPlugin(["pipelineOperator", {
proposal: "hack",
topicToken: "@@"
}])) {
this.finishOp(38, 2);
} else {
this.finishOp(26, 1);
}
}
readToken_plus_min(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === code) {
this.finishOp(34, 2);
return;
}
if (next === 61) {
this.finishOp(30, 2);
} else {
this.finishOp(53, 1);
}
}
readToken_lt() {
const {
pos
} = this.state;
const next = this.input.charCodeAt(pos + 1);
if (next === 60) {
if (this.input.charCodeAt(pos + 2) === 61) {
this.finishOp(30, 3);
return;
}
this.finishOp(51, 2);
return;
}
if (next === 61) {
this.finishOp(49, 2);
return;
}
this.finishOp(47, 1);
}
readToken_gt() {
const {
pos
} = this.state;
const next = this.input.charCodeAt(pos + 1);
if (next === 62) {
const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;
if (this.input.charCodeAt(pos + size) === 61) {
this.finishOp(30, size + 1);
return;
}
this.finishOp(52, size);
return;
}
if (next === 61) {
this.finishOp(49, 2);
return;
}
this.finishOp(48, 1);
}
readToken_eq_excl(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === 61) {
this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
return;
}
if (code === 61 && next === 62) {
this.state.pos += 2;
this.finishToken(19);
return;
}
this.finishOp(code === 61 ? 29 : 35, 1);
}
readToken_question() {
const next = this.input.charCodeAt(this.state.pos + 1);
const next2 = this.input.charCodeAt(this.state.pos + 2);
if (next === 63) {
if (next2 === 61) {
this.finishOp(30, 3);
} else {
this.finishOp(40, 2);
}
} else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
this.state.pos += 2;
this.finishToken(18);
} else {
++this.state.pos;
this.finishToken(17);
}
}
getTokenFromCode(code) {
switch (code) {
case 46:
this.readToken_dot();
return;
case 40:
++this.state.pos;
this.finishToken(10);
return;
case 41:
++this.state.pos;
this.finishToken(11);
return;
case 59:
++this.state.pos;
this.finishToken(13);
return;
case 44:
++this.state.pos;
this.finishToken(12);
return;
case 91:
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, {
at: this.state.curPosition()
});
}
this.state.pos += 2;
this.finishToken(2);
} else {
++this.state.pos;
this.finishToken(0);
}
return;
case 93:
++this.state.pos;
this.finishToken(3);
return;
case 123:
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, {
at: this.state.curPosition()
});
}
this.state.pos += 2;
this.finishToken(6);
} else {
++this.state.pos;
this.finishToken(5);
}
return;
case 125:
++this.state.pos;
this.finishToken(8);
return;
case 58:
if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) {
this.finishOp(15, 2);
} else {
++this.state.pos;
this.finishToken(14);
}
return;
case 63:
this.readToken_question();
return;
case 96:
this.readTemplateToken();
return;
case 48:
{
const next = this.input.charCodeAt(this.state.pos + 1);
if (next === 120 || next === 88) {
this.readRadixNumber(16);
return;
}
if (next === 111 || next === 79) {
this.readRadixNumber(8);
return;
}
if (next === 98 || next === 66) {
this.readRadixNumber(2);
return;
}
}
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
this.readNumber(false);
return;
case 34:
case 39:
this.readString(code);
return;
case 47:
this.readToken_slash();
return;
case 37:
case 42:
this.readToken_mult_modulo(code);
return;
case 124:
case 38:
this.readToken_pipe_amp(code);
return;
case 94:
this.readToken_caret();
return;
case 43:
case 45:
this.readToken_plus_min(code);
return;
case 60:
this.readToken_lt();
return;
case 62:
this.readToken_gt();
return;
case 61:
case 33:
this.readToken_eq_excl(code);
return;
case 126:
this.finishOp(36, 1);
return;
case 64:
this.readToken_atSign();
return;
case 35:
this.readToken_numberSign();
return;
case 92:
this.readWord();
return;
default:
if (isIdentifierStart(code)) {
this.readWord(code);
return;
}
}
throw this.raise(Errors.InvalidOrUnexpectedToken, {
at: this.state.curPosition(),
unexpected: String.fromCodePoint(code)
});
}
finishOp(type, size) {
const str = this.input.slice(this.state.pos, this.state.pos + size);
this.state.pos += size;
this.finishToken(type, str);
}
readRegexp() {
const startLoc = this.state.startLoc;
const start = this.state.start + 1;
let escaped, inClass;
let {
pos
} = this.state;
for (;; ++pos) {
if (pos >= this.length) {
throw this.raise(Errors.UnterminatedRegExp, {
at: createPositionWithColumnOffset(startLoc, 1)
});
}
const ch = this.input.charCodeAt(pos);
if (isNewLine(ch)) {
throw this.raise(Errors.UnterminatedRegExp, {
at: createPositionWithColumnOffset(startLoc, 1)
});
}
if (escaped) {
escaped = false;
} else {
if (ch === 91) {
inClass = true;
} else if (ch === 93 && inClass) {
inClass = false;
} else if (ch === 47 && !inClass) {
break;
}
escaped = ch === 92;
}
}
const content = this.input.slice(start, pos);
++pos;
let mods = "";
const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);
while (pos < this.length) {
const cp = this.codePointAtPos(pos);
const char = String.fromCharCode(cp);
if (VALID_REGEX_FLAGS.has(cp)) {
if (cp === 118) {
if (mods.includes("u")) {
this.raise(Errors.IncompatibleRegExpUVFlags, {
at: nextPos()
});
}
} else if (cp === 117) {
if (mods.includes("v")) {
this.raise(Errors.IncompatibleRegExpUVFlags, {
at: nextPos()
});
}
}
if (mods.includes(char)) {
this.raise(Errors.DuplicateRegExpFlags, {
at: nextPos()
});
}
} else if (isIdentifierChar(cp) || cp === 92) {
this.raise(Errors.MalformedRegExpFlags, {
at: nextPos()
});
} else {
break;
}
++pos;
mods += char;
}
this.state.pos = pos;
this.finishToken(137, {
pattern: content,
flags: mods
});
}
readInt(radix, len, forceLen = false, allowNumSeparator = true) {
const {
n,
pos
} = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
this.state.pos = pos;
return n;
}
readRadixNumber(radix) {
const startLoc = this.state.curPosition();
let isBigInt = false;
this.state.pos += 2;
const val = this.readInt(radix);
if (val == null) {
this.raise(Errors.InvalidDigit, {
at: createPositionWithColumnOffset(startLoc, 2),
radix
});
}
const next = this.input.charCodeAt(this.state.pos);
if (next === 110) {
++this.state.pos;
isBigInt = true;
} else if (next === 109) {
throw this.raise(Errors.InvalidDecimal, {
at: startLoc
});
}
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
throw this.raise(Errors.NumberIdentifier, {
at: this.state.curPosition()
});
}
if (isBigInt) {
const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
this.finishToken(135, str);
return;
}
this.finishToken(134, val);
}
readNumber(startsWithDot) {
const start = this.state.pos;
const startLoc = this.state.curPosition();
let isFloat = false;
let isBigInt = false;
let isDecimal = false;
let hasExponent = false;
let isOctal = false;
if (!startsWithDot && this.readInt(10) === null) {
this.raise(Errors.InvalidNumber, {
at: this.state.curPosition()
});
}
const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
if (hasLeadingZero) {
const integer = this.input.slice(start, this.state.pos);
this.recordStrictModeErrors(Errors.StrictOctalLiteral, {
at: startLoc
});
if (!this.state.strict) {
const underscorePos = integer.indexOf("_");
if (underscorePos > 0) {
this.raise(Errors.ZeroDigitNumericSeparator, {
at: createPositionWithColumnOffset(startLoc, underscorePos)
});
}
}
isOctal = hasLeadingZero && !/[89]/.test(integer);
}
let next = this.input.charCodeAt(this.state.pos);
if (next === 46 && !isOctal) {
++this.state.pos;
this.readInt(10);
isFloat = true;
next = this.input.charCodeAt(this.state.pos);
}
if ((next === 69 || next === 101) && !isOctal) {
next = this.input.charCodeAt(++this.state.pos);
if (next === 43 || next === 45) {
++this.state.pos;
}
if (this.readInt(10) === null) {
this.raise(Errors.InvalidOrMissingExponent, {
at: startLoc
});
}
isFloat = true;
hasExponent = true;
next = this.input.charCodeAt(this.state.pos);
}
if (next === 110) {
if (isFloat || hasLeadingZero) {
this.raise(Errors.InvalidBigIntLiteral, {
at: startLoc
});
}
++this.state.pos;
isBigInt = true;
}
if (next === 109) {
this.expectPlugin("decimal", this.state.curPosition());
if (hasExponent || hasLeadingZero) {
this.raise(Errors.InvalidDecimal, {
at: startLoc
});
}
++this.state.pos;
isDecimal = true;
}
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
throw this.raise(Errors.NumberIdentifier, {
at: this.state.curPosition()
});
}
const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
if (isBigInt) {
this.finishToken(135, str);
return;
}
if (isDecimal) {
this.finishToken(136, str);
return;
}
const val = isOctal ? parseInt(str, 8) : parseFloat(str);
this.finishToken(134, val);
}
readCodePoint(throwOnInvalid) {
const {
code,
pos
} = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
this.state.pos = pos;
return code;
}
readString(quote) {
const {
str,
pos,
curLine,
lineStart
} = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
this.state.pos = pos + 1;
this.state.lineStart = lineStart;
this.state.curLine = curLine;
this.finishToken(133, str);
}
readTemplateContinuation() {
if (!this.match(8)) {
this.unexpected(null, 8);
}
this.state.pos--;
this.readTemplateToken();
}
readTemplateToken() {
const opening = this.input[this.state.pos];
const {
str,
firstInvalidLoc,
pos,
curLine,
lineStart
} = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
this.state.pos = pos + 1;
this.state.lineStart = lineStart;
this.state.curLine = curLine;
if (firstInvalidLoc) {
this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);
}
if (this.input.codePointAt(pos) === 96) {
this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
} else {
this.state.pos++;
this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
}
}
recordStrictModeErrors(toParseError, {
at
}) {
const index = at.index;
if (this.state.strict && !this.state.strictErrors.has(index)) {
this.raise(toParseError, {
at
});
} else {
this.state.strictErrors.set(index, [toParseError, at]);
}
}
readWord1(firstCode) {
this.state.containsEsc = false;
let word = "";
const start = this.state.pos;
let chunkStart = this.state.pos;
if (firstCode !== undefined) {
this.state.pos += firstCode <= 0xffff ? 1 : 2;
}
while (this.state.pos < this.length) {
const ch = this.codePointAtPos(this.state.pos);
if (isIdentifierChar(ch)) {
this.state.pos += ch <= 0xffff ? 1 : 2;
} else if (ch === 92) {
this.state.containsEsc = true;
word += this.input.slice(chunkStart, this.state.pos);
const escStart = this.state.curPosition();
const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
if (this.input.charCodeAt(++this.state.pos) !== 117) {
this.raise(Errors.MissingUnicodeEscape, {
at: this.state.curPosition()
});
chunkStart = this.state.pos - 1;
continue;
}
++this.state.pos;
const esc = this.readCodePoint(true);
if (esc !== null) {
if (!identifierCheck(esc)) {
this.raise(Errors.EscapedCharNotAnIdentifier, {
at: escStart
});
}
word += String.fromCodePoint(esc);
}
chunkStart = this.state.pos;
} else {
break;
}
}
return word + this.input.slice(chunkStart, this.state.pos);
}
readWord(firstCode) {
const word = this.readWord1(firstCode);
const type = keywords$1.get(word);
if (type !== undefined) {
this.finishToken(type, tokenLabelName(type));
} else {
this.finishToken(132, word);
}
}
checkKeywordEscapes() {
const {
type
} = this.state;
if (tokenIsKeyword(type) && this.state.containsEsc) {
this.raise(Errors.InvalidEscapedReservedWord, {
at: this.state.startLoc,
reservedWord: tokenLabelName(type)
});
}
}
raise(toParseError, raiseProperties) {
const {
at
} = raiseProperties,
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
const loc = at instanceof Position ? at : at.loc.start;
const error = toParseError({
loc,
details
});
if (!this.options.errorRecovery) throw error;
if (!this.isLookahead) this.state.errors.push(error);
return error;
}
raiseOverwrite(toParseError, raiseProperties) {
const {
at
} = raiseProperties,
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
const loc = at instanceof Position ? at : at.loc.start;
const pos = loc.index;
const errors = this.state.errors;
for (let i = errors.length - 1; i >= 0; i--) {
const error = errors[i];
if (error.loc.index === pos) {
return errors[i] = toParseError({
loc,
details
});
}
if (error.loc.index < pos) break;
}
return this.raise(toParseError, raiseProperties);
}
updateContext(prevType) {}
unexpected(loc, type) {
throw this.raise(Errors.UnexpectedToken, {
expected: type ? tokenLabelName(type) : null,
at: loc != null ? loc : this.state.startLoc
});
}
expectPlugin(pluginName, loc) {
if (this.hasPlugin(pluginName)) {
return true;
}
throw this.raise(Errors.MissingPlugin, {
at: loc != null ? loc : this.state.startLoc,
missingPlugin: [pluginName]
});
}
expectOnePlugin(pluginNames) {
if (!pluginNames.some(name => this.hasPlugin(name))) {
throw this.raise(Errors.MissingOneOfPlugins, {
at: this.state.startLoc,
missingPlugin: pluginNames
});
}
}
errorBuilder(error) {
return (pos, lineStart, curLine) => {
this.raise(error, {
at: buildPosition(pos, lineStart, curLine)
});
};
}
}
class ClassScope {
constructor() {
this.privateNames = new Set();
this.loneAccessors = new Map();
this.undefinedPrivateNames = new Map();
}
}
class ClassScopeHandler {
constructor(parser) {
this.parser = void 0;
this.stack = [];
this.undefinedPrivateNames = new Map();
this.parser = parser;
}
current() {
return this.stack[this.stack.length - 1];
}
enter() {
this.stack.push(new ClassScope());
}
exit() {
const oldClassScope = this.stack.pop();
const current = this.current();
for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
if (current) {
if (!current.undefinedPrivateNames.has(name)) {
current.undefinedPrivateNames.set(name, loc);
}
} else {
this.parser.raise(Errors.InvalidPrivateFieldResolution, {
at: loc,
identifierName: name
});
}
}
}
declarePrivateName(name, elementType, loc) {
const {
privateNames,
loneAccessors,
undefinedPrivateNames
} = this.current();
let redefined = privateNames.has(name);
if (elementType & 3) {
const accessor = redefined && loneAccessors.get(name);
if (accessor) {
const oldStatic = accessor & 4;
const newStatic = elementType & 4;
const oldKind = accessor & 3;
const newKind = elementType & 3;
redefined = oldKind === newKind || oldStatic !== newStatic;
if (!redefined) loneAccessors.delete(name);
} else if (!redefined) {
loneAccessors.set(name, elementType);
}
}
if (redefined) {
this.parser.raise(Errors.PrivateNameRedeclaration, {
at: loc,
identifierName: name
});
}
privateNames.add(name);
undefinedPrivateNames.delete(name);
}
usePrivateName(name, loc) {
let classScope;
for (classScope of this.stack) {
if (classScope.privateNames.has(name)) return;
}
if (classScope) {
classScope.undefinedPrivateNames.set(name, loc);
} else {
this.parser.raise(Errors.InvalidPrivateFieldResolution, {
at: loc,
identifierName: name
});
}
}
}
class ExpressionScope {
constructor(type = 0) {
this.type = type;
}
canBeArrowParameterDeclaration() {
return this.type === 2 || this.type === 1;
}
isCertainlyParameterDeclaration() {
return this.type === 3;
}
}
class ArrowHeadParsingScope extends ExpressionScope {
constructor(type) {
super(type);
this.declarationErrors = new Map();
}
recordDeclarationError(ParsingErrorClass, {
at
}) {
const index = at.index;
this.declarationErrors.set(index, [ParsingErrorClass, at]);
}
clearDeclarationError(index) {
this.declarationErrors.delete(index);
}
iterateErrors(iterator) {
this.declarationErrors.forEach(iterator);
}
}
class ExpressionScopeHandler {
constructor(parser) {
this.parser = void 0;
this.stack = [new ExpressionScope()];
this.parser = parser;
}
enter(scope) {
this.stack.push(scope);
}
exit() {
this.stack.pop();
}
recordParameterInitializerError(toParseError, {
at: node
}) {
const origin = {
at: node.loc.start
};
const {
stack
} = this;
let i = stack.length - 1;
let scope = stack[i];
while (!scope.isCertainlyParameterDeclaration()) {
if (scope.canBeArrowParameterDeclaration()) {
scope.recordDeclarationError(toParseError, origin);
} else {
return;
}
scope = stack[--i];
}
this.parser.raise(toParseError, origin);
}
recordArrowParameterBindingError(error, {
at: node
}) {
const {
stack
} = this;
const scope = stack[stack.length - 1];
const origin = {
at: node.loc.start
};
if (scope.isCertainlyParameterDeclaration()) {
this.parser.raise(error, origin);
} else if (scope.canBeArrowParameterDeclaration()) {
scope.recordDeclarationError(error, origin);
} else {
return;
}
}
recordAsyncArrowParametersError({
at
}) {
const {
stack
} = this;
let i = stack.length - 1;
let scope = stack[i];
while (scope.canBeArrowParameterDeclaration()) {
if (scope.type === 2) {
scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
at
});
}
scope = stack[--i];
}
}
validateAsPattern() {
const {
stack
} = this;
const currentScope = stack[stack.length - 1];
if (!currentScope.canBeArrowParameterDeclaration()) return;
currentScope.iterateErrors(([toParseError, loc]) => {
this.parser.raise(toParseError, {
at: loc
});
let i = stack.length - 2;
let scope = stack[i];
while (scope.canBeArrowParameterDeclaration()) {
scope.clearDeclarationError(loc.index);
scope = stack[--i];
}
});
}
}
function newParameterDeclarationScope() {
return new ExpressionScope(3);
}
function newArrowHeadScope() {
return new ArrowHeadParsingScope(1);
}
function newAsyncArrowScope() {
return new ArrowHeadParsingScope(2);
}
function newExpressionScope() {
return new ExpressionScope();
}
const PARAM = 0b0000,
PARAM_YIELD = 0b0001,
PARAM_AWAIT = 0b0010,
PARAM_RETURN = 0b0100,
PARAM_IN = 0b1000;
class ProductionParameterHandler {
constructor() {
this.stacks = [];
}
enter(flags) {
this.stacks.push(flags);
}
exit() {
this.stacks.pop();
}
currentFlags() {
return this.stacks[this.stacks.length - 1];
}
get hasAwait() {
return (this.currentFlags() & PARAM_AWAIT) > 0;
}
get hasYield() {
return (this.currentFlags() & PARAM_YIELD) > 0;
}
get hasReturn() {
return (this.currentFlags() & PARAM_RETURN) > 0;
}
get hasIn() {
return (this.currentFlags() & PARAM_IN) > 0;
}
}
function functionFlags(isAsync, isGenerator) {
return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
}
class UtilParser extends Tokenizer {
addExtra(node, key, value, enumerable = true) {
if (!node) return;
const extra = node.extra = node.extra || {};
if (enumerable) {
extra[key] = value;
} else {
Object.defineProperty(extra, key, {
enumerable,
value
});
}
}
isContextual(token) {
return this.state.type === token && !this.state.containsEsc;
}
isUnparsedContextual(nameStart, name) {
const nameEnd = nameStart + name.length;
if (this.input.slice(nameStart, nameEnd) === name) {
const nextCh = this.input.charCodeAt(nameEnd);
return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);
}
return false;
}
isLookaheadContextual(name) {
const next = this.nextTokenStart();
return this.isUnparsedContextual(next, name);
}
eatContextual(token) {
if (this.isContextual(token)) {
this.next();
return true;
}
return false;
}
expectContextual(token, toParseError) {
if (!this.eatContextual(token)) {
if (toParseError != null) {
throw this.raise(toParseError, {
at: this.state.startLoc
});
}
this.unexpected(null, token);
}
}
canInsertSemicolon() {
return this.match(139) || this.match(8) || this.hasPrecedingLineBreak();
}
hasPrecedingLineBreak() {
return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start));
}
hasFollowingLineBreak() {
skipWhiteSpaceToLineBreak.lastIndex = this.state.end;
return skipWhiteSpaceToLineBreak.test(this.input);
}
isLineTerminator() {
return this.eat(13) || this.canInsertSemicolon();
}
semicolon(allowAsi = true) {
if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
this.raise(Errors.MissingSemicolon, {
at: this.state.lastTokEndLoc
});
}
expect(type, loc) {
this.eat(type) || this.unexpected(loc, type);
}
tryParse(fn, oldState = this.state.clone()) {
const abortSignal = {
node: null
};
try {
const node = fn((node = null) => {
abortSignal.node = node;
throw abortSignal;
});
if (this.state.errors.length > oldState.errors.length) {
const failState = this.state;
this.state = oldState;
this.state.tokensLength = failState.tokensLength;
return {
node,
error: failState.errors[oldState.errors.length],
thrown: false,
aborted: false,
failState
};
}
return {
node,
error: null,
thrown: false,
aborted: false,
failState: null
};
} catch (error) {
const failState = this.state;
this.state = oldState;
if (error instanceof SyntaxError) {
return {
node: null,
error,
thrown: true,
aborted: false,
failState
};
}
if (error === abortSignal) {
return {
node: abortSignal.node,
error: null,
thrown: false,
aborted: true,
failState
};
}
throw error;
}
}
checkExpressionErrors(refExpressionErrors, andThrow) {
if (!refExpressionErrors) return false;
const {
shorthandAssignLoc,
doubleProtoLoc,
privateKeyLoc,
optionalParametersLoc
} = refExpressionErrors;
const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;
if (!andThrow) {
return hasErrors;
}
if (shorthandAssignLoc != null) {
this.raise(Errors.InvalidCoverInitializedName, {
at: shorthandAssignLoc
});
}
if (doubleProtoLoc != null) {
this.raise(Errors.DuplicateProto, {
at: doubleProtoLoc
});
}
if (privateKeyLoc != null) {
this.raise(Errors.UnexpectedPrivateField, {
at: privateKeyLoc
});
}
if (optionalParametersLoc != null) {
this.unexpected(optionalParametersLoc);
}
}
isLiteralPropertyName() {
return tokenIsLiteralPropertyName(this.state.type);
}
isPrivateName(node) {
return node.type === "PrivateName";
}
getPrivateNameSV(node) {
return node.id.name;
}
hasPropertyAsPrivateName(node) {
return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property);
}
isObjectProperty(node) {
return node.type === "ObjectProperty";
}
isObjectMethod(node) {
return node.type === "ObjectMethod";
}
initializeScopes(inModule = this.options.sourceType === "module") {
const oldLabels = this.state.labels;
this.state.labels = [];
const oldExportedIdentifiers = this.exportedIdentifiers;
this.exportedIdentifiers = new Set();
const oldInModule = this.inModule;
this.inModule = inModule;
const oldScope = this.scope;
const ScopeHandler = this.getScopeHandler();
this.scope = new ScopeHandler(this, inModule);
const oldProdParam = this.prodParam;
this.prodParam = new ProductionParameterHandler();
const oldClassScope = this.classScope;
this.classScope = new ClassScopeHandler(this);
const oldExpressionScope = this.expressionScope;
this.expressionScope = new ExpressionScopeHandler(this);
return () => {
this.state.labels = oldLabels;
this.exportedIdentifiers = oldExportedIdentifiers;
this.inModule = oldInModule;
this.scope = oldScope;
this.prodParam = oldProdParam;
this.classScope = oldClassScope;
this.expressionScope = oldExpressionScope;
};
}
enterInitialScopes() {
let paramFlags = PARAM;
if (this.inModule) {
paramFlags |= PARAM_AWAIT;
}
this.scope.enter(1);
this.prodParam.enter(paramFlags);
}
checkDestructuringPrivate(refExpressionErrors) {
const {
privateKeyLoc
} = refExpressionErrors;
if (privateKeyLoc !== null) {
this.expectPlugin("destructuringPrivate", privateKeyLoc);
}
}
}
class ExpressionErrors {
constructor() {
this.shorthandAssignLoc = null;
this.doubleProtoLoc = null;
this.privateKeyLoc = null;
this.optionalParametersLoc = null;
}
}
class Node {
constructor(parser, pos, loc) {
this.type = "";
this.start = pos;
this.end = 0;
this.loc = new SourceLocation(loc);
if (parser != null && parser.options.ranges) this.range = [pos, 0];
if (parser != null && parser.filename) this.loc.filename = parser.filename;
}
}
const NodePrototype = Node.prototype;
{
NodePrototype.__clone = function () {
const newNode = new Node(undefined, this.start, this.loc.start);
const keys = Object.keys(this);
for (let i = 0, length = keys.length; i < length; i++) {
const key = keys[i];
if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") {
newNode[key] = this[key];
}
}
return newNode;
};
}
function clonePlaceholder(node) {
return cloneIdentifier(node);
}
function cloneIdentifier(node) {
const {
type,
start,
end,
loc,
range,
extra,
name
} = node;
const cloned = Object.create(NodePrototype);
cloned.type = type;
cloned.start = start;
cloned.end = end;
cloned.loc = loc;
cloned.range = range;
cloned.extra = extra;
cloned.name = name;
if (type === "Placeholder") {
cloned.expectedNode = node.expectedNode;
}
return cloned;
}
function cloneStringLiteral(node) {
const {
type,
start,
end,
loc,
range,
extra
} = node;
if (type === "Placeholder") {
return clonePlaceholder(node);
}
const cloned = Object.create(NodePrototype);
cloned.type = type;
cloned.start = start;
cloned.end = end;
cloned.loc = loc;
cloned.range = range;
if (node.raw !== undefined) {
cloned.raw = node.raw;
} else {
cloned.extra = extra;
}
cloned.value = node.value;
return cloned;
}
class NodeUtils extends UtilParser {
startNode() {
return new Node(this, this.state.start, this.state.startLoc);
}
startNodeAt(loc) {
return new Node(this, loc.index, loc);
}
startNodeAtNode(type) {
return this.startNodeAt(type.loc.start);
}
finishNode(node, type) {
return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
}
finishNodeAt(node, type, endLoc) {
node.type = type;
node.end = endLoc.index;
node.loc.end = endLoc;
if (this.options.ranges) node.range[1] = endLoc.index;
if (this.options.attachComment) this.processComment(node);
return node;
}
resetStartLocation(node, startLoc) {
node.start = startLoc.index;
node.loc.start = startLoc;
if (this.options.ranges) node.range[0] = startLoc.index;
}
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
node.end = endLoc.index;
node.loc.end = endLoc;
if (this.options.ranges) node.range[1] = endLoc.index;
}
resetStartLocationFromNode(node, locationNode) {
this.resetStartLocation(node, locationNode.loc.start);
}
}
const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
const FlowErrors = ParseErrorEnum`flow`({
AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
AmbiguousDeclareModuleKind: "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: ({
reservedType
}) => `Cannot overwrite reserved type ${reservedType}.`,
DeclareClassElement: "The `declare` modifier can only appear on class fields.",
DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
EnumBooleanMemberNotInitialized: ({
memberName,
enumName
}) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
EnumDuplicateMemberName: ({
memberName,
enumName
}) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
EnumInconsistentMemberValues: ({
enumName
}) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
EnumInvalidExplicitType: ({
invalidEnumType,
enumName
}) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
EnumInvalidExplicitTypeUnknownSupplied: ({
enumName
}) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
EnumInvalidMemberInitializerPrimaryType: ({
enumName,
memberName,
explicitType
}) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
EnumInvalidMemberInitializerSymbolType: ({
enumName,
memberName
}) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
EnumInvalidMemberInitializerUnknownType: ({
enumName,
memberName
}) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
EnumInvalidMemberName: ({
enumName,
memberName,
suggestion
}) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
EnumNumberMemberNotInitialized: ({
enumName,
memberName
}) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
EnumStringMemberInconsistentlyInitialized: ({
enumName
}) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
ImportTypeShorthandOnlyInPureImport: "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: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
InexactVariance: "Explicit inexact syntax cannot have variance.",
InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
PatternIsOptional: Object.assign({
message: "A binding pattern parameter cannot be optional in an implementation signature."
}, {
reasonCode: "OptionalBindingPattern"
}),
SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
SpreadVariance: "Spread properties cannot have variance.",
ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
ThisParamNoDefault: "The `this` parameter may not have a default value.",
TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
UnexpectedReservedType: ({
reservedType
}) => `Unexpected reserved type ${reservedType}.`,
UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
UnsupportedDeclareExportKind: ({
unsupportedExportKind,
suggestion
}) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
UnterminatedFlowComment: "Unterminated flow-comment."
});
function isEsModuleType(bodyElement) {
return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
}
function hasTypeImportKind(node) {
return node.importKind === "type" || node.importKind === "typeof";
}
const exportSuggestions = {
const: "declare export var",
let: "declare export var",
type: "export type",
interface: "export interface"
};
function partition(list, test) {
const list1 = [];
const list2 = [];
for (let i = 0; i < list.length; i++) {
(test(list[i], i, list) ? list1 : list2).push(list[i]);
}
return [list1, list2];
}
const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
var flow = superClass => class FlowParserMixin extends superClass {
constructor(...args) {
super(...args);
this.flowPragma = undefined;
}
getScopeHandler() {
return FlowScopeHandler;
}
shouldParseTypes() {
return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
}
shouldParseEnums() {
return !!this.getPluginOption("flow", "enums");
}
finishToken(type, val) {
if (type !== 133 && type !== 13 && type !== 28) {
if (this.flowPragma === undefined) {
this.flowPragma = null;
}
}
super.finishToken(type, val);
}
addComment(comment) {
if (this.flowPragma === undefined) {
const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
if (!matches) ;else if (matches[1] === "flow") {
this.flowPragma = "flow";
} else if (matches[1] === "noflow") {
this.flowPragma = "noflow";
} else {
throw new Error("Unexpected flow pragma");
}
}
super.addComment(comment);
}
flowParseTypeInitialiser(tok) {
const oldInType = this.state.inType;
this.state.inType = true;
this.expect(tok || 14);
const type = this.flowParseType();
this.state.inType = oldInType;
return type;
}
flowParsePredicate() {
const node = this.startNode();
const moduloLoc = this.state.startLoc;
this.next();
this.expectContextual(110);
if (this.state.lastTokStart > moduloLoc.index + 1) {
this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
at: moduloLoc
});
}
if (this.eat(10)) {
node.value = super.parseExpression();
this.expect(11);
return this.finishNode(node, "DeclaredPredicate");
} else {
return this.finishNode(node, "InferredPredicate");
}
}
flowParseTypeAndPredicateInitialiser() {
const oldInType = this.state.inType;
this.state.inType = true;
this.expect(14);
let type = null;
let predicate = null;
if (this.match(54)) {
this.state.inType = oldInType;
predicate = this.flowParsePredicate();
} else {
type = this.flowParseType();
this.state.inType = oldInType;
if (this.match(54)) {
predicate = this.flowParsePredicate();
}
}
return [type, predicate];
}
flowParseDeclareClass(node) {
this.next();
this.flowParseInterfaceish(node, true);
return this.finishNode(node, "DeclareClass");
}
flowParseDeclareFunction(node) {
this.next();
const id = node.id = this.parseIdentifier();
const typeNode = this.startNode();
const typeContainer = this.startNode();
if (this.match(47)) {
typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
} else {
typeNode.typeParameters = null;
}
this.expect(10);
const tmp = this.flowParseFunctionTypeParams();
typeNode.params = tmp.params;
typeNode.rest = tmp.rest;
typeNode.this = tmp._this;
this.expect(11);
[typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
this.resetEndLocation(id);
this.semicolon();
this.scope.declareName(node.id.name, 2048, node.id.loc.start);
return this.finishNode(node, "DeclareFunction");
}
flowParseDeclare(node, insideModule) {
if (this.match(80)) {
return this.flowParseDeclareClass(node);
} else if (this.match(68)) {
return this.flowParseDeclareFunction(node);
} else if (this.match(74)) {
return this.flowParseDeclareVariable(node);
} else if (this.eatContextual(127)) {
if (this.match(16)) {
return this.flowParseDeclareModuleExports(node);
} else {
if (insideModule) {
this.raise(FlowErrors.NestedDeclareModule, {
at: this.state.lastTokStartLoc
});
}
return this.flowParseDeclareModule(node);
}
} else if (this.isContextual(130)) {
return this.flowParseDeclareTypeAlias(node);
} else if (this.isContextual(131)) {
return this.flowParseDeclareOpaqueType(node);
} else if (this.isContextual(129)) {
return this.flowParseDeclareInterface(node);
} else if (this.match(82)) {
return this.flowParseDeclareExportDeclaration(node, insideModule);
} else {
this.unexpected();
}
}
flowParseDeclareVariable(node) {
this.next();
node.id = this.flowParseTypeAnnotatableIdentifier(true);
this.scope.declareName(node.id.name, 5, node.id.loc.start);
this.semicolon();
return this.finishNode(node, "DeclareVariable");
}
flowParseDeclareModule(node) {
this.scope.enter(0);
if (this.match(133)) {
node.id = super.parseExprAtom();
} else {
node.id = this.parseIdentifier();
}
const bodyNode = node.body = this.startNode();
const body = bodyNode.body = [];
this.expect(5);
while (!this.match(8)) {
let bodyNode = this.startNode();
if (this.match(83)) {
this.next();
if (!this.isContextual(130) && !this.match(87)) {
this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
at: this.state.lastTokStartLoc
});
}
super.parseImport(bodyNode);
} else {
this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);
bodyNode = this.flowParseDeclare(bodyNode, true);
}
body.push(bodyNode);
}
this.scope.exit();
this.expect(8);
this.finishNode(bodyNode, "BlockStatement");
let kind = null;
let hasModuleExport = false;
body.forEach(bodyElement => {
if (isEsModuleType(bodyElement)) {
if (kind === "CommonJS") {
this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
at: bodyElement
});
}
kind = "ES";
} else if (bodyElement.type === "DeclareModuleExports") {
if (hasModuleExport) {
this.raise(FlowErrors.DuplicateDeclareModuleExports, {
at: bodyElement
});
}
if (kind === "ES") {
this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
at: bodyElement
});
}
kind = "CommonJS";
hasModuleExport = true;
}
});
node.kind = kind || "CommonJS";
return this.finishNode(node, "DeclareModule");
}
flowParseDeclareExportDeclaration(node, insideModule) {
this.expect(82);
if (this.eat(65)) {
if (this.match(68) || this.match(80)) {
node.declaration = this.flowParseDeclare(this.startNode());
} else {
node.declaration = this.flowParseType();
this.semicolon();
}
node.default = true;
return this.finishNode(node, "DeclareExportDeclaration");
} else {
if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
const label = this.state.value;
throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
at: this.state.startLoc,
unsupportedExportKind: label,
suggestion: exportSuggestions[label]
});
}
if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {
node.declaration = this.flowParseDeclare(this.startNode());
node.default = false;
return this.finishNode(node, "DeclareExportDeclaration");
} else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {
node = this.parseExport(node, null);
if (node.type === "ExportNamedDeclaration") {
node.type = "ExportDeclaration";
node.default = false;
delete node.exportKind;
}
node.type = "Declare" + node.type;
return node;
}
}
this.unexpected();
}
flowParseDeclareModuleExports(node) {
this.next();
this.expectContextual(111);
node.typeAnnotation = this.flowParseTypeAnnotation();
this.semicolon();
return this.finishNode(node, "DeclareModuleExports");
}
flowParseDeclareTypeAlias(node) {
this.next();
const finished = this.flowParseTypeAlias(node);
finished.type = "DeclareTypeAlias";
return finished;
}
flowParseDeclareOpaqueType(node) {
this.next();
const finished = this.flowParseOpaqueType(node, true);
finished.type = "DeclareOpaqueType";
return finished;
}
flowParseDeclareInterface(node) {
this.next();
this.flowParseInterfaceish(node, false);
return this.finishNode(node, "DeclareInterface");
}
flowParseInterfaceish(node, isClass) {
node.id = this.flowParseRestrictedIdentifier(!isClass, true);
this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
} else {
node.typeParameters = null;
}
node.extends = [];
if (this.eat(81)) {
do {
node.extends.push(this.flowParseInterfaceExtends());
} while (!isClass && this.eat(12));
}
if (isClass) {
node.implements = [];
node.mixins = [];
if (this.eatContextual(117)) {
do {
node.mixins.push(this.flowParseInterfaceExtends());
} while (this.eat(12));
}
if (this.eatContextual(113)) {
do {
node.implements.push(this.flowParseInterfaceExtends());
} while (this.eat(12));
}
}
node.body = this.flowParseObjectType({
allowStatic: isClass,
allowExact: false,
allowSpread: false,
allowProto: isClass,
allowInexact: false
});
}
flowParseInterfaceExtends() {
const node = this.startNode();
node.id = this.flowParseQualifiedTypeIdentifier();
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterInstantiation();
} else {
node.typeParameters = null;
}
return this.finishNode(node, "InterfaceExtends");
}
flowParseInterface(node) {
this.flowParseInterfaceish(node, false);
return this.finishNode(node, "InterfaceDeclaration");
}
checkNotUnderscore(word) {
if (word === "_") {
this.raise(FlowErrors.UnexpectedReservedUnderscore, {
at: this.state.startLoc
});
}
}
checkReservedType(word, startLoc, declaration) {
if (!reservedTypes.has(word)) return;
this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
at: startLoc,
reservedType: word
});
}
flowParseRestrictedIdentifier(liberal, declaration) {
this.checkReservedType(this.state.value, this.state.startLoc, declaration);
return this.parseIdentifier(liberal);
}
flowParseTypeAlias(node) {
node.id = this.flowParseRestrictedIdentifier(false, true);
this.scope.declareName(node.id.name, 8201, node.id.loc.start);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
} else {
node.typeParameters = null;
}
node.right = this.flowParseTypeInitialiser(29);
this.semicolon();
return this.finishNode(node, "TypeAlias");
}
flowParseOpaqueType(node, declare) {
this.expectContextual(130);
node.id = this.flowParseRestrictedIdentifier(true, true);
this.scope.declareName(node.id.name, 8201, node.id.loc.start);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
} else {
node.typeParameters = null;
}
node.supertype = null;
if (this.match(14)) {
node.supertype = this.flowParseTypeInitialiser(14);
}
node.impltype = null;
if (!declare) {
node.impltype = this.flowParseTypeInitialiser(29);
}
this.semicolon();
return this.finishNode(node, "OpaqueType");
}
flowParseTypeParameter(requireDefault = false) {
const nodeStartLoc = this.state.startLoc;
const node = this.startNode();
const variance = this.flowParseVariance();
const ident = this.flowParseTypeAnnotatableIdentifier();
node.name = ident.name;
node.variance = variance;
node.bound = ident.typeAnnotation;
if (this.match(29)) {
this.eat(29);
node.default = this.flowParseType();
} else {
if (requireDefault) {
this.raise(FlowErrors.MissingTypeParamDefault, {
at: nodeStartLoc
});
}
}
return this.finishNode(node, "TypeParameter");
}
flowParseTypeParameterDeclaration() {
const oldInType = this.state.inType;
const node = this.startNode();
node.params = [];
this.state.inType = true;
if (this.match(47) || this.match(142)) {
this.next();
} else {
this.unexpected();
}
let defaultRequired = false;
do {
const typeParameter = this.flowParseTypeParameter(defaultRequired);
node.params.push(typeParameter);
if (typeParameter.default) {
defaultRequired = true;
}
if (!this.match(48)) {
this.expect(12);
}
} while (!this.match(48));
this.expect(48);
this.state.inType = oldInType;
return this.finishNode(node, "TypeParameterDeclaration");
}
flowParseTypeParameterInstantiation() {
const node = this.startNode();
const oldInType = this.state.inType;
node.params = [];
this.state.inType = true;
this.expect(47);
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
this.state.noAnonFunctionType = false;
while (!this.match(48)) {
node.params.push(this.flowParseType());
if (!this.match(48)) {
this.expect(12);
}
}
this.state.noAnonFunctionType = oldNoAnonFunctionType;
this.expect(48);
this.state.inType = oldInType;
return this.finishNode(node, "TypeParameterInstantiation");
}
flowParseTypeParameterInstantiationCallOrNew() {
const node = this.startNode();
const oldInType = this.state.inType;
node.params = [];
this.state.inType = true;
this.expect(47);
while (!this.match(48)) {
node.params.push(this.flowParseTypeOrImplicitInstantiation());
if (!this.match(48)) {
this.expect(12);
}
}
this.expect(48);
this.state.inType = oldInType;
return this.finishNode(node, "TypeParameterInstantiation");
}
flowParseInterfaceType() {
const node = this.startNode();
this.expectContextual(129);
node.extends = [];
if (this.eat(81)) {
do {
node.extends.push(this.flowParseInterfaceExtends());
} while (this.eat(12));
}
node.body = this.flowParseObjectType({
allowStatic: false,
allowExact: false,
allowSpread: false,
allowProto: false,
allowInexact: false
});
return this.finishNode(node, "InterfaceTypeAnnotation");
}
flowParseObjectPropertyKey() {
return this.match(134) || this.match(133) ? super.parseExprAtom() : this.parseIdentifier(true);
}
flowParseObjectTypeIndexer(node, isStatic, variance) {
node.static = isStatic;
if (this.lookahead().type === 14) {
node.id = this.flowParseObjectPropertyKey();
node.key = this.flowParseTypeInitialiser();
} else {
node.id = null;
node.key = this.flowParseType();
}
this.expect(3);
node.value = this.flowParseTypeInitialiser();
node.variance = variance;
return this.finishNode(node, "ObjectTypeIndexer");
}
flowParseObjectTypeInternalSlot(node, isStatic) {
node.static = isStatic;
node.id = this.flowParseObjectPropertyKey();
this.expect(3);
this.expect(3);
if (this.match(47) || this.match(10)) {
node.method = true;
node.optional = false;
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
} else {
node.method = false;
if (this.eat(17)) {
node.optional = true;
}
node.value = this.flowParseTypeInitialiser();
}
return this.finishNode(node, "ObjectTypeInternalSlot");
}
flowParseObjectTypeMethodish(node) {
node.params = [];
node.rest = null;
node.typeParameters = null;
node.this = null;
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
}
this.expect(10);
if (this.match(78)) {
node.this = this.flowParseFunctionTypeParam(true);
node.this.name = null;
if (!this.match(11)) {
this.expect(12);
}
}
while (!this.match(11) && !this.match(21)) {
node.params.push(this.flowParseFunctionTypeParam(false));
if (!this.match(11)) {
this.expect(12);
}
}
if (this.eat(21)) {
node.rest = this.flowParseFunctionTypeParam(false);
}
this.expect(11);
node.returnType = this.flowParseTypeInitialiser();
return this.finishNode(node, "FunctionTypeAnnotation");
}
flowParseObjectTypeCallProperty(node, isStatic) {
const valueNode = this.startNode();
node.static = isStatic;
node.value = this.flowParseObjectTypeMethodish(valueNode);
return this.finishNode(node, "ObjectTypeCallProperty");
}
flowParseObjectType({
allowStatic,
allowExact,
allowSpread,
allowProto,
allowInexact
}) {
const oldInType = this.state.inType;
this.state.inType = true;
const nodeStart = this.startNode();
nodeStart.callProperties = [];
nodeStart.properties = [];
nodeStart.indexers = [];
nodeStart.internalSlots = [];
let endDelim;
let exact;
let inexact = false;
if (allowExact && this.match(6)) {
this.expect(6);
endDelim = 9;
exact = true;
} else {
this.expect(5);
endDelim = 8;
exact = false;
}
nodeStart.exact = exact;
while (!this.match(endDelim)) {
let isStatic = false;
let protoStartLoc = null;
let inexactStartLoc = null;
const node = this.startNode();
if (allowProto && this.isContextual(118)) {
const lookahead = this.lookahead();
if (lookahead.type !== 14 && lookahead.type !== 17) {
this.next();
protoStartLoc = this.state.startLoc;
allowStatic = false;
}
}
if (allowStatic && this.isContextual(106)) {
const lookahead = this.lookahead();
if (lookahead.type !== 14 && lookahead.type !== 17) {
this.next();
isStatic = true;
}
}
const variance = this.flowParseVariance();
if (this.eat(0)) {
if (protoStartLoc != null) {
this.unexpected(protoStartLoc);
}
if (this.eat(0)) {
if (variance) {
this.unexpected(variance.loc.start);
}
nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
} else {
nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
}
} else if (this.match(10) || this.match(47)) {
if (protoStartLoc != null) {
this.unexpected(protoStartLoc);
}
if (variance) {
this.unexpected(variance.loc.start);
}
nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
} else {
let kind = "init";
if (this.isContextual(99) || this.isContextual(104)) {
const lookahead = this.lookahead();
if (tokenIsLiteralPropertyName(lookahead.type)) {
kind = this.state.value;
this.next();
}
}
const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
if (propOrInexact === null) {
inexact = true;
inexactStartLoc = this.state.lastTokStartLoc;
} else {
nodeStart.properties.push(propOrInexact);
}
}
this.flowObjectTypeSemicolon();
if (inexactStartLoc && !this.match(8) && !this.match(9)) {
this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
at: inexactStartLoc
});
}
}
this.expect(endDelim);
if (allowSpread) {
nodeStart.inexact = inexact;
}
const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
this.state.inType = oldInType;
return out;
}
flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
if (this.eat(21)) {
const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
if (isInexactToken) {
if (!allowSpread) {
this.raise(FlowErrors.InexactInsideNonObject, {
at: this.state.lastTokStartLoc
});
} else if (!allowInexact) {
this.raise(FlowErrors.InexactInsideExact, {
at: this.state.lastTokStartLoc
});
}
if (variance) {
this.raise(FlowErrors.InexactVariance, {
at: variance
});
}
return null;
}
if (!allowSpread) {
this.raise(FlowErrors.UnexpectedSpreadType, {
at: this.state.lastTokStartLoc
});
}
if (protoStartLoc != null) {
this.unexpected(protoStartLoc);
}
if (variance) {
this.raise(FlowErrors.SpreadVariance, {
at: variance
});
}
node.argument = this.flowParseType();
return this.finishNode(node, "ObjectTypeSpreadProperty");
} else {
node.key = this.flowParseObjectPropertyKey();
node.static = isStatic;
node.proto = protoStartLoc != null;
node.kind = kind;
let optional = false;
if (this.match(47) || this.match(10)) {
node.method = true;
if (protoStartLoc != null) {
this.unexpected(protoStartLoc);
}
if (variance) {
this.unexpected(variance.loc.start);
}
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
if (kind === "get" || kind === "set") {
this.flowCheckGetterSetterParams(node);
}
if (!allowSpread && node.key.name === "constructor" && node.value.this) {
this.raise(FlowErrors.ThisParamBannedInConstructor, {
at: node.value.this
});
}
} else {
if (kind !== "init") this.unexpected();
node.method = false;
if (this.eat(17)) {
optional = true;
}
node.value = this.flowParseTypeInitialiser();
node.variance = variance;
}
node.optional = optional;
return this.finishNode(node, "ObjectTypeProperty");
}
}
flowCheckGetterSetterParams(property) {
const paramCount = property.kind === "get" ? 0 : 1;
const length = property.value.params.length + (property.value.rest ? 1 : 0);
if (property.value.this) {
this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
at: property.value.this
});
}
if (length !== paramCount) {
this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
at: property
});
}
if (property.kind === "set" && property.value.rest) {
this.raise(Errors.BadSetterRestParameter, {
at: property
});
}
}
flowObjectTypeSemicolon() {
if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
this.unexpected();
}
}
flowParseQualifiedTypeIdentifier(startLoc, id) {
var _startLoc;
(_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
let node = id || this.flowParseRestrictedIdentifier(true);
while (this.eat(16)) {
const node2 = this.startNodeAt(startLoc);
node2.qualification = node;
node2.id = this.flowParseRestrictedIdentifier(true);
node = this.finishNode(node2, "QualifiedTypeIdentifier");
}
return node;
}
flowParseGenericType(startLoc, id) {
const node = this.startNodeAt(startLoc);
node.typeParameters = null;
node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterInstantiation();
}
return this.finishNode(node, "GenericTypeAnnotation");
}
flowParseTypeofType() {
const node = this.startNode();
this.expect(87);
node.argument = this.flowParsePrimaryType();
return this.finishNode(node, "TypeofTypeAnnotation");
}
flowParseTupleType() {
const node = this.startNode();
node.types = [];
this.expect(0);
while (this.state.pos < this.length && !this.match(3)) {
node.types.push(this.flowParseType());
if (this.match(3)) break;
this.expect(12);
}
this.expect(3);
return this.finishNode(node, "TupleTypeAnnotation");
}
flowParseFunctionTypeParam(first) {
let name = null;
let optional = false;
let typeAnnotation = null;
const node = this.startNode();
const lh = this.lookahead();
const isThis = this.state.type === 78;
if (lh.type === 14 || lh.type === 17) {
if (isThis && !first) {
this.raise(FlowErrors.ThisParamMustBeFirst, {
at: node
});
}
name = this.parseIdentifier(isThis);
if (this.eat(17)) {
optional = true;
if (isThis) {
this.raise(FlowErrors.ThisParamMayNotBeOptional, {
at: node
});
}
}
typeAnnotation = this.flowParseTypeInitialiser();
} else {
typeAnnotation = this.flowParseType();
}
node.name = name;
node.optional = optional;
node.typeAnnotation = typeAnnotation;
return this.finishNode(node, "FunctionTypeParam");
}
reinterpretTypeAsFunctionTypeParam(type) {
const node = this.startNodeAt(type.loc.start);
node.name = null;
node.optional = false;
node.typeAnnotation = type;
return this.finishNode(node, "FunctionTypeParam");
}
flowParseFunctionTypeParams(params = []) {
let rest = null;
let _this = null;
if (this.match(78)) {
_this = this.flowParseFunctionTypeParam(true);
_this.name = null;
if (!this.match(11)) {
this.expect(12);
}
}
while (!this.match(11) && !this.match(21)) {
params.push(this.flowParseFunctionTypeParam(false));
if (!this.match(11)) {
this.expect(12);
}
}
if (this.eat(21)) {
rest = this.flowParseFunctionTypeParam(false);
}
return {
params,
rest,
_this
};
}
flowIdentToTypeAnnotation(startLoc, node, id) {
switch (id.name) {
case "any":
return this.finishNode(node, "AnyTypeAnnotation");
case "bool":
case "boolean":
return this.finishNode(node, "BooleanTypeAnnotation");
case "mixed":
return this.finishNode(node, "MixedTypeAnnotation");
case "empty":
return this.finishNode(node, "EmptyTypeAnnotation");
case "number":
return this.finishNode(node, "NumberTypeAnnotation");
case "string":
return this.finishNode(node, "StringTypeAnnotation");
case "symbol":
return this.finishNode(node, "SymbolTypeAnnotation");
default:
this.checkNotUnderscore(id.name);
return this.flowParseGenericType(startLoc, id);
}
}
flowParsePrimaryType() {
const startLoc = this.state.startLoc;
const node = this.startNode();
let tmp;
let type;
let isGroupedType = false;
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
switch (this.state.type) {
case 5:
return this.flowParseObjectType({
allowStatic: false,
allowExact: false,
allowSpread: true,
allowProto: false,
allowInexact: true
});
case 6:
return this.flowParseObjectType({
allowStatic: false,
allowExact: true,
allowSpread: true,
allowProto: false,
allowInexact: false
});
case 0:
this.state.noAnonFunctionType = false;
type = this.flowParseTupleType();
this.state.noAnonFunctionType = oldNoAnonFunctionType;
return type;
case 47:
node.typeParameters = this.flowParseTypeParameterDeclaration();
this.expect(10);
tmp = this.flowParseFunctionTypeParams();
node.params = tmp.params;
node.rest = tmp.rest;
node.this = tmp._this;
this.expect(11);
this.expect(19);
node.returnType = this.flowParseType();
return this.finishNode(node, "FunctionTypeAnnotation");
case 10:
this.next();
if (!this.match(11) && !this.match(21)) {
if (tokenIsIdentifier(this.state.type) || this.match(78)) {
const token = this.lookahead().type;
isGroupedType = token !== 17 && token !== 14;
} else {
isGroupedType = true;
}
}
if (isGroupedType) {
this.state.noAnonFunctionType = false;
type = this.flowParseType();
this.state.noAnonFunctionType = oldNoAnonFunctionType;
if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
this.expect(11);
return type;
} else {
this.eat(12);
}
}
if (type) {
tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
} else {
tmp = this.flowParseFunctionTypeParams();
}
node.params = tmp.params;
node.rest = tmp.rest;
node.this = tmp._this;
this.expect(11);
this.expect(19);
node.returnType = this.flowParseType();
node.typeParameters = null;
return this.finishNode(node, "FunctionTypeAnnotation");
case 133:
return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
case 85:
case 86:
node.value = this.match(85);
this.next();
return this.finishNode(node, "BooleanLiteralTypeAnnotation");
case 53:
if (this.state.value === "-") {
this.next();
if (this.match(134)) {
return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
}
if (this.match(135)) {
return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
}
throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
at: this.state.startLoc
});
}
this.unexpected();
return;
case 134:
return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
case 135:
return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
case 88:
this.next();
return this.finishNode(node, "VoidTypeAnnotation");
case 84:
this.next();
return this.finishNode(node, "NullLiteralTypeAnnotation");
case 78:
this.next();
return this.finishNode(node, "ThisTypeAnnotation");
case 55:
this.next();
return this.finishNode(node, "ExistsTypeAnnotation");
case 87:
return this.flowParseTypeofType();
default:
if (tokenIsKeyword(this.state.type)) {
const label = tokenLabelName(this.state.type);
this.next();
return super.createIdentifier(node, label);
} else if (tokenIsIdentifier(this.state.type)) {
if (this.isContextual(129)) {
return this.flowParseInterfaceType();
}
return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
}
}
this.unexpected();
}
flowParsePostfixType() {
const startLoc = this.state.startLoc;
let type = this.flowParsePrimaryType();
let seenOptionalIndexedAccess = false;
while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
const node = this.startNodeAt(startLoc);
const optional = this.eat(18);
seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
this.expect(0);
if (!optional && this.match(3)) {
node.elementType = type;
this.next();
type = this.finishNode(node, "ArrayTypeAnnotation");
} else {
node.objectType = type;
node.indexType = this.flowParseType();
this.expect(3);
if (seenOptionalIndexedAccess) {
node.optional = optional;
type = this.finishNode(node, "OptionalIndexedAccessType");
} else {
type = this.finishNode(node, "IndexedAccessType");
}
}
}
return type;
}
flowParsePrefixType() {
const node = this.startNode();
if (this.eat(17)) {
node.typeAnnotation = this.flowParsePrefixType();
return this.finishNode(node, "NullableTypeAnnotation");
} else {
return this.flowParsePostfixType();
}
}
flowParseAnonFunctionWithoutParens() {
const param = this.flowParsePrefixType();
if (!this.state.noAnonFunctionType && this.eat(19)) {
const node = this.startNodeAt(param.loc.start);
node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
node.rest = null;
node.this = null;
node.returnType = this.flowParseType();
node.typeParameters = null;
return this.finishNode(node, "FunctionTypeAnnotation");
}
return param;
}
flowParseIntersectionType() {
const node = this.startNode();
this.eat(45);
const type = this.flowParseAnonFunctionWithoutParens();
node.types = [type];
while (this.eat(45)) {
node.types.push(this.flowParseAnonFunctionWithoutParens());
}
return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
}
flowParseUnionType() {
const node = this.startNode();
this.eat(43);
const type = this.flowParseIntersectionType();
node.types = [type];
while (this.eat(43)) {
node.types.push(this.flowParseIntersectionType());
}
return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
}
flowParseType() {
const oldInType = this.state.inType;
this.state.inType = true;
const type = this.flowParseUnionType();
this.state.inType = oldInType;
return type;
}
flowParseTypeOrImplicitInstantiation() {
if (this.state.type === 132 && this.state.value === "_") {
const startLoc = this.state.startLoc;
const node = this.parseIdentifier();
return this.flowParseGenericType(startLoc, node);
} else {
return this.flowParseType();
}
}
flowParseTypeAnnotation() {
const node = this.startNode();
node.typeAnnotation = this.flowParseTypeInitialiser();
return this.finishNode(node, "TypeAnnotation");
}
flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
if (this.match(14)) {
ident.typeAnnotation = this.flowParseTypeAnnotation();
this.resetEndLocation(ident);
}
return ident;
}
typeCastToParameter(node) {
node.expression.typeAnnotation = node.typeAnnotation;
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
return node.expression;
}
flowParseVariance() {
let variance = null;
if (this.match(53)) {
variance = this.startNode();
if (this.state.value === "+") {
variance.kind = "plus";
} else {
variance.kind = "minus";
}
this.next();
return this.finishNode(variance, "Variance");
}
return variance;
}
parseFunctionBody(node, allowExpressionBody, isMethod = false) {
if (allowExpressionBody) {
this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));
return;
}
super.parseFunctionBody(node, false, isMethod);
}
parseFunctionBodyAndFinish(node, type, isMethod = false) {
if (this.match(14)) {
const typeNode = this.startNode();
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
}
return super.parseFunctionBodyAndFinish(node, type, isMethod);
}
parseStatementLike(flags) {
if (this.state.strict && this.isContextual(129)) {
const lookahead = this.lookahead();
if (tokenIsKeywordOrIdentifier(lookahead.type)) {
const node = this.startNode();
this.next();
return this.flowParseInterface(node);
}
} else if (this.shouldParseEnums() && this.isContextual(126)) {
const node = this.startNode();
this.next();
return this.flowParseEnumDeclaration(node);
}
const stmt = super.parseStatementLike(flags);
if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
this.flowPragma = null;
}
return stmt;
}
parseExpressionStatement(node, expr, decorators) {
if (expr.type === "Identifier") {
if (expr.name === "declare") {
if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
return this.flowParseDeclare(node);
}
} else if (tokenIsIdentifier(this.state.type)) {
if (expr.name === "interface") {
return this.flowParseInterface(node);
} else if (expr.name === "type") {
return this.flowParseTypeAlias(node);
} else if (expr.name === "opaque") {
return this.flowParseOpaqueType(node, false);
}
}
}
return super.parseExpressionStatement(node, expr, decorators);
}
shouldParseExportDeclaration() {
const {
type
} = this.state;
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 126) {
return !this.state.containsEsc;
}
return super.shouldParseExportDeclaration();
}
isExportDefaultSpecifier() {
const {
type
} = this.state;
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 126) {
return this.state.containsEsc;
}
return super.isExportDefaultSpecifier();
}
parseExportDefaultExpression() {
if (this.shouldParseEnums() && this.isContextual(126)) {
const node = this.startNode();
this.next();
return this.flowParseEnumDeclaration(node);
}
return super.parseExportDefaultExpression();
}
parseConditional(expr, startLoc, refExpressionErrors) {
if (!this.match(17)) return expr;
if (this.state.maybeInArrowParameters) {
const nextCh = this.lookaheadCharCode();
if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
this.setOptionalParametersError(refExpressionErrors);
return expr;
}
}
this.expect(17);
const state = this.state.clone();
const originalNoArrowAt = this.state.noArrowAt;
const node = this.startNodeAt(startLoc);
let {
consequent,
failed
} = this.tryParseConditionalConsequent();
let [valid, invalid] = this.getArrowLikeExpressions(consequent);
if (failed || invalid.length > 0) {
const noArrowAt = [...originalNoArrowAt];
if (invalid.length > 0) {
this.state = state;
this.state.noArrowAt = noArrowAt;
for (let i = 0; i < invalid.length; i++) {
noArrowAt.push(invalid[i].start);
}
({
consequent,
failed
} = this.tryParseConditionalConsequent());
[valid, invalid] = this.getArrowLikeExpressions(consequent);
}
if (failed && valid.length > 1) {
this.raise(FlowErrors.AmbiguousConditionalArrow, {
at: state.startLoc
});
}
if (failed && valid.length === 1) {
this.state = state;
noArrowAt.push(valid[0].start);
this.state.noArrowAt = noArrowAt;
({
consequent,
failed
} = this.tryParseConditionalConsequent());
}
}
this.getArrowLikeExpressions(consequent, true);
this.state.noArrowAt = originalNoArrowAt;
this.expect(14);
node.test = expr;
node.consequent = consequent;
node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined));
return this.finishNode(node, "ConditionalExpression");
}
tryParseConditionalConsequent() {
this.state.noArrowParamsConversionAt.push(this.state.start);
const consequent = this.parseMaybeAssignAllowIn();
const failed = !this.match(14);
this.state.noArrowParamsConversionAt.pop();
return {
consequent,
failed
};
}
getArrowLikeExpressions(node, disallowInvalid) {
const stack = [node];
const arrows = [];
while (stack.length !== 0) {
const node = stack.pop();
if (node.type === "ArrowFunctionExpression") {
if (node.typeParameters || !node.returnType) {
this.finishArrowValidation(node);
} else {
arrows.push(node);
}
stack.push(node.body);
} else if (node.type === "ConditionalExpression") {
stack.push(node.consequent);
stack.push(node.alternate);
}
}
if (disallowInvalid) {
arrows.forEach(node => this.finishArrowValidation(node));
return [arrows, []];
}
return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));
}
finishArrowValidation(node) {
var _node$extra;
this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
this.scope.enter(2 | 4);
super.checkParams(node, false, true);
this.scope.exit();
}
forwardNoArrowParamsConversionAt(node, parse) {
let result;
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
this.state.noArrowParamsConversionAt.push(this.state.start);
result = parse();
this.state.noArrowParamsConversionAt.pop();
} else {
result = parse();
}
return result;
}
parseParenItem(node, startLoc) {
node = super.parseParenItem(node, startLoc);
if (this.eat(17)) {
node.optional = true;
this.resetEndLocation(node);
}
if (this.match(14)) {
const typeCastNode = this.startNodeAt(startLoc);
typeCastNode.expression = node;
typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
return this.finishNode(typeCastNode, "TypeCastExpression");
}
return node;
}
assertModuleNodeAllowed(node) {
if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
return;
}
super.assertModuleNodeAllowed(node);
}
parseExportDeclaration(node) {
if (this.isContextual(130)) {
node.exportKind = "type";
const declarationNode = this.startNode();
this.next();
if (this.match(5)) {
node.specifiers = this.parseExportSpecifiers(true);
super.parseExportFrom(node);
return null;
} else {
return this.flowParseTypeAlias(declarationNode);
}
} else if (this.isContextual(131)) {
node.exportKind = "type";
const declarationNode = this.startNode();
this.next();
return this.flowParseOpaqueType(declarationNode, false);
} else if (this.isContextual(129)) {
node.exportKind = "type";
const declarationNode = this.startNode();
this.next();
return this.flowParseInterface(declarationNode);
} else if (this.shouldParseEnums() && this.isContextual(126)) {
node.exportKind = "value";
const declarationNode = this.startNode();
this.next();
return this.flowParseEnumDeclaration(declarationNode);
} else {
return super.parseExportDeclaration(node);
}
}
eatExportStar(node) {
if (super.eatExportStar(node)) return true;
if (this.isContextual(130) && this.lookahead().type === 55) {
node.exportKind = "type";
this.next();
this.next();
return true;
}
return false;
}
maybeParseExportNamespaceSpecifier(node) {
const {
startLoc
} = this.state;
const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
if (hasNamespace && node.exportKind === "type") {
this.unexpected(startLoc);
}
return hasNamespace;
}
parseClassId(node, isStatement, optionalId) {
super.parseClassId(node, isStatement, optionalId);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
}
}
parseClassMember(classBody, member, state) {
const {
startLoc
} = this.state;
if (this.isContextual(125)) {
if (super.parseClassMemberFromModifier(classBody, member)) {
return;
}
member.declare = true;
}
super.parseClassMember(classBody, member, state);
if (member.declare) {
if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
this.raise(FlowErrors.DeclareClassElement, {
at: startLoc
});
} else if (member.value) {
this.raise(FlowErrors.DeclareClassFieldInitializer, {
at: member.value
});
}
}
}
isIterator(word) {
return word === "iterator" || word === "asyncIterator";
}
readIterator() {
const word = super.readWord1();
const fullWord = "@@" + word;
if (!this.isIterator(word) || !this.state.inType) {
this.raise(Errors.InvalidIdentifier, {
at: this.state.curPosition(),
identifierName: fullWord
});
}
this.finishToken(132, fullWord);
}
getTokenFromCode(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (code === 123 && next === 124) {
this.finishOp(6, 2);
} else if (this.state.inType && (code === 62 || code === 60)) {
this.finishOp(code === 62 ? 48 : 47, 1);
} else if (this.state.inType && code === 63) {
if (next === 46) {
this.finishOp(18, 2);
} else {
this.finishOp(17, 1);
}
} else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
this.state.pos += 2;
this.readIterator();
} else {
super.getTokenFromCode(code);
}
}
isAssignable(node, isBinding) {
if (node.type === "TypeCastExpression") {
return this.isAssignable(node.expression, isBinding);
} else {
return super.isAssignable(node, isBinding);
}
}
toAssignable(node, isLHS = false) {
if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
node.left = this.typeCastToParameter(node.left);
}
super.toAssignable(node, isLHS);
}
toAssignableList(exprList, trailingCommaLoc, isLHS) {
for (let i = 0; i < exprList.length; i++) {
const expr = exprList[i];
if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") {
exprList[i] = this.typeCastToParameter(expr);
}
}
super.toAssignableList(exprList, trailingCommaLoc, isLHS);
}
toReferencedList(exprList, isParenthesizedExpr) {
for (let i = 0; i < exprList.length; i++) {
var _expr$extra;
const expr = exprList[i];
if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
this.raise(FlowErrors.TypeCastInPattern, {
at: expr.typeAnnotation
});
}
}
return exprList;
}
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
if (canBePattern && !this.state.maybeInArrowParameters) {
this.toReferencedList(node.elements);
}
return node;
}
isValidLVal(type, isParenthesized, binding) {
return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding);
}
parseClassProperty(node) {
if (this.match(14)) {
node.typeAnnotation = this.flowParseTypeAnnotation();
}
return super.parseClassProperty(node);
}
parseClassPrivateProperty(node) {
if (this.match(14)) {
node.typeAnnotation = this.flowParseTypeAnnotation();
}
return super.parseClassPrivateProperty(node);
}
isClassMethod() {
return this.match(47) || super.isClassMethod();
}
isClassProperty() {
return this.match(14) || super.isClassProperty();
}
isNonstaticConstructor(method) {
return !this.match(14) && super.isNonstaticConstructor(method);
}
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
if (method.variance) {
this.unexpected(method.variance.loc.start);
}
delete method.variance;
if (this.match(47)) {
method.typeParameters = this.flowParseTypeParameterDeclaration();
}
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
if (method.params && isConstructor) {
const params = method.params;
if (params.length > 0 && this.isThisParam(params[0])) {
this.raise(FlowErrors.ThisParamBannedInConstructor, {
at: method
});
}
} else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
const params = method.value.params;
if (params.length > 0 && this.isThisParam(params[0])) {
this.raise(FlowErrors.ThisParamBannedInConstructor, {
at: method
});
}
}
}
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
if (method.variance) {
this.unexpected(method.variance.loc.start);
}
delete method.variance;
if (this.match(47)) {
method.typeParameters = this.flowParseTypeParameterDeclaration();
}
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
}
parseClassSuper(node) {
super.parseClassSuper(node);
if (node.superClass && this.match(47)) {
node.superTypeParameters = this.flowParseTypeParameterInstantiation();
}
if (this.isContextual(113)) {
this.next();
const implemented = node.implements = [];
do {
const node = this.startNode();
node.id = this.flowParseRestrictedIdentifier(true);
if (this.match(47)) {
node.typeParameters = this.flowParseTypeParameterInstantiation();
} else {
node.typeParameters = null;
}
implemented.push(this.finishNode(node, "ClassImplements"));
} while (this.eat(12));
}
}
checkGetterSetterParams(method) {
super.checkGetterSetterParams(method);
const params = this.getObjectOrClassMethodParams(method);
if (params.length > 0) {
const param = params[0];
if (this.isThisParam(param) && method.kind === "get") {
this.raise(FlowErrors.GetterMayNotHaveThisParam, {
at: param
});
} else if (this.isThisParam(param)) {
this.raise(FlowErrors.SetterMayNotHaveThisParam, {
at: param
});
}
}
}
parsePropertyNamePrefixOperator(node) {
node.variance = this.flowParseVariance();
}
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
if (prop.variance) {
this.unexpected(prop.variance.loc.start);
}
delete prop.variance;
let typeParameters;
if (this.match(47) && !isAccessor) {
typeParameters = this.flowParseTypeParameterDeclaration();
if (!this.match(10)) this.unexpected();
}
const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
if (typeParameters) {
(result.value || result).typeParameters = typeParameters;
}
return result;
}
parseAssignableListItemTypes(param) {
if (this.eat(17)) {
if (param.type !== "Identifier") {
this.raise(FlowErrors.PatternIsOptional, {
at: param
});
}
if (this.isThisParam(param)) {
this.raise(FlowErrors.ThisParamMayNotBeOptional, {
at: param
});
}
param.optional = true;
}
if (this.match(14)) {
param.typeAnnotation = this.flowParseTypeAnnotation();
} else if (this.isThisParam(param)) {
this.raise(FlowErrors.ThisParamAnnotationRequired, {
at: param
});
}
if (this.match(29) && this.isThisParam(param)) {
this.raise(FlowErrors.ThisParamNoDefault, {
at: param
});
}
this.resetEndLocation(param);
return param;
}
parseMaybeDefault(startLoc, left) {
const node = super.parseMaybeDefault(startLoc, left);
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
this.raise(FlowErrors.TypeBeforeInitializer, {
at: node.typeAnnotation
});
}
return node;
}
checkImportReflection(node) {
super.checkImportReflection(node);
if (node.module && node.importKind !== "value") {
this.raise(FlowErrors.ImportReflectionHasImportType, {
at: node.specifiers[0].loc.start
});
}
}
parseImportSpecifierLocal(node, specifier, type) {
specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
node.specifiers.push(this.finishImportSpecifier(specifier, type));
}
isPotentialImportPhase(isExport) {
if (super.isPotentialImportPhase(isExport)) return true;
if (this.isContextual(130)) {
if (!isExport) return true;
const ch = this.lookaheadCharCode();
return ch === 123 || ch === 42;
}
return !isExport && this.isContextual(87);
}
applyImportPhase(node, isExport, phase, loc) {
super.applyImportPhase(node, isExport, phase, loc);
if (isExport) {
if (!phase && this.match(65)) {
return;
}
node.exportKind = phase === "type" ? phase : "value";
} else {
if (phase === "type" && this.match(55)) this.unexpected();
node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
}
}
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
const firstIdent = specifier.imported;
let specifierTypeKind = null;
if (firstIdent.type === "Identifier") {
if (firstIdent.name === "type") {
specifierTypeKind = "type";
} else if (firstIdent.name === "typeof") {
specifierTypeKind = "typeof";
}
}
let isBinding = false;
if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
const as_ident = this.parseIdentifier(true);
if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
specifier.imported = as_ident;
specifier.importKind = specifierTypeKind;
specifier.local = cloneIdentifier(as_ident);
} else {
specifier.imported = firstIdent;
specifier.importKind = null;
specifier.local = this.parseIdentifier();
}
} else {
if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
specifier.imported = this.parseIdentifier(true);
specifier.importKind = specifierTypeKind;
} else {
if (importedIsString) {
throw this.raise(Errors.ImportBindingIsString, {
at: specifier,
importName: firstIdent.value
});
}
specifier.imported = firstIdent;
specifier.importKind = null;
}
if (this.eatContextual(93)) {
specifier.local = this.parseIdentifier();
} else {
isBinding = true;
specifier.local = cloneIdentifier(specifier.imported);
}
}
const specifierIsTypeImport = hasTypeImportKind(specifier);
if (isInTypeOnlyImport && specifierIsTypeImport) {
this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
at: specifier
});
}
if (isInTypeOnlyImport || specifierIsTypeImport) {
this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
}
if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
}
return this.finishImportSpecifier(specifier, "ImportSpecifier");
}
parseBindingAtom() {
switch (this.state.type) {
case 78:
return this.parseIdentifier(true);
default:
return super.parseBindingAtom();
}
}
parseFunctionParams(node, isConstructor) {
const kind = node.kind;
if (kind !== "get" && kind !== "set" && this.match(47)) {
node.typeParameters = this.flowParseTypeParameterDeclaration();
}
super.parseFunctionParams(node, isConstructor);
}
parseVarId(decl, kind) {
super.parseVarId(decl, kind);
if (this.match(14)) {
decl.id.typeAnnotation = this.flowParseTypeAnnotation();
this.resetEndLocation(decl.id);
}
}
parseAsyncArrowFromCallExpression(node, call) {
if (this.match(14)) {
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
this.state.noAnonFunctionType = true;
node.returnType = this.flowParseTypeAnnotation();
this.state.noAnonFunctionType = oldNoAnonFunctionType;
}
return super.parseAsyncArrowFromCallExpression(node, call);
}
shouldParseAsyncArrow() {
return this.match(14) || super.shouldParseAsyncArrow();
}
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
var _jsx;
let state = null;
let jsx;
if (this.hasPlugin("jsx") && (this.match(142) || this.match(47))) {
state = this.state.clone();
jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
if (!jsx.error) return jsx.node;
const {
context
} = this.state;
const currentContext = context[context.length - 1];
if (currentContext === types.j_oTag || currentContext === types.j_expr) {
context.pop();
}
}
if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {
var _jsx2, _jsx3;
state = state || this.state.clone();
let typeParameters;
const arrow = this.tryParse(abort => {
var _arrowExpression$extr;
typeParameters = this.flowParseTypeParameterDeclaration();
const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
this.resetStartLocationFromNode(result, typeParameters);
return result;
});
if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();
const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);
if (expr.type !== "ArrowFunctionExpression") abort();
expr.typeParameters = typeParameters;
this.resetStartLocationFromNode(expr, typeParameters);
return arrowExpression;
}, state);
let arrowExpression = null;
if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
if (!arrow.error && !arrow.aborted) {
if (arrow.node.async) {
this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
at: typeParameters
});
}
return arrow.node;
}
arrowExpression = arrow.node;
}
if ((_jsx2 = jsx) != null && _jsx2.node) {
this.state = jsx.failState;
return jsx.node;
}
if (arrowExpression) {
this.state = arrow.failState;
return arrowExpression;
}
if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
if (arrow.thrown) throw arrow.error;
throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
at: typeParameters
});
}
return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
}
parseArrow(node) {
if (this.match(14)) {
const result = this.tryParse(() => {
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
this.state.noAnonFunctionType = true;
const typeNode = this.startNode();
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
this.state.noAnonFunctionType = oldNoAnonFunctionType;
if (this.canInsertSemicolon()) this.unexpected();
if (!this.match(19)) this.unexpected();
return typeNode;
});
if (result.thrown) return null;
if (result.error) this.state = result.failState;
node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
}
return super.parseArrow(node);
}
shouldParseArrow(params) {
return this.match(14) || super.shouldParseArrow(params);
}
setArrowFunctionParameters(node, params) {
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
node.params = params;
} else {
super.setArrowFunctionParameters(node, params);
}
}
checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
return;
}
for (let i = 0; i < node.params.length; i++) {
if (this.isThisParam(node.params[i]) && i > 0) {
this.raise(FlowErrors.ThisParamMustBeFirst, {
at: node.params[i]
});
}
}
super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
}
parseParenAndDistinguishExpression(canBeArrow) {
return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
}
parseSubscripts(base, startLoc, noCalls) {
if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) {
this.next();
const node = this.startNodeAt(startLoc);
node.callee = base;
node.arguments = super.parseCallExpressionArguments(11, false);
base = this.finishNode(node, "CallExpression");
} else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
const state = this.state.clone();
const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
if (!arrow.error && !arrow.aborted) return arrow.node;
const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);
if (result.node && !result.error) return result.node;
if (arrow.node) {
this.state = arrow.failState;
return arrow.node;
}
if (result.node) {
this.state = result.failState;
return result.node;
}
throw arrow.error || result.error;
}
return super.parseSubscripts(base, startLoc, noCalls);
}
parseSubscript(base, startLoc, noCalls, subscriptState) {
if (this.match(18) && this.isLookaheadToken_lt()) {
subscriptState.optionalChainMember = true;
if (noCalls) {
subscriptState.stop = true;
return base;
}
this.next();
const node = this.startNodeAt(startLoc);
node.callee = base;
node.typeArguments = this.flowParseTypeParameterInstantiation();
this.expect(10);
node.arguments = this.parseCallExpressionArguments(11, false);
node.optional = true;
return this.finishCallExpression(node, true);
} else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
const node = this.startNodeAt(startLoc);
node.callee = base;
const result = this.tryParse(() => {
node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
this.expect(10);
node.arguments = super.parseCallExpressionArguments(11, false);
if (subscriptState.optionalChainMember) {
node.optional = false;
}
return this.finishCallExpression(node, subscriptState.optionalChainMember);
});
if (result.node) {
if (result.error) this.state = result.failState;
return result.node;
}
}
return super.parseSubscript(base, startLoc, noCalls, subscriptState);
}
parseNewCallee(node) {
super.parseNewCallee(node);
let targs = null;
if (this.shouldParseTypes() && this.match(47)) {
targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
}
node.typeArguments = targs;
}
parseAsyncArrowWithTypeParameters(startLoc) {
const node = this.startNodeAt(startLoc);
this.parseFunctionParams(node, false);
if (!this.parseArrow(node)) return;
return super.parseArrowExpression(node, undefined, true);
}
readToken_mult_modulo(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (code === 42 && next === 47 && this.state.hasFlowComment) {
this.state.hasFlowComment = false;
this.state.pos += 2;
this.nextToken();
return;
}
super.readToken_mult_modulo(code);
}
readToken_pipe_amp(code) {
const next = this.input.charCodeAt(this.state.pos + 1);
if (code === 124 && next === 125) {
this.finishOp(9, 2);
return;
}
super.readToken_pipe_amp(code);
}
parseTopLevel(file, program) {
const fileNode = super.parseTopLevel(file, program);
if (this.state.hasFlowComment) {
this.raise(FlowErrors.UnterminatedFlowComment, {
at: this.state.curPosition()
});
}
return fileNode;
}
skipBlockComment() {
if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
if (this.state.hasFlowComment) {
throw this.raise(FlowErrors.NestedFlowComment, {
at: this.state.startLoc
});
}
this.hasFlowCommentCompletion();
const commentSkip = this.skipFlowComment();
if (commentSkip) {
this.state.pos += commentSkip;
this.state.hasFlowComment = true;
}
return;
}
return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
}
skipFlowComment() {
const {
pos
} = this.state;
let shiftToFirstNonWhiteSpace = 2;
while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
shiftToFirstNonWhiteSpace++;
}
const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
if (ch2 === 58 && ch3 === 58) {
return shiftToFirstNonWhiteSpace + 2;
}
if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
return shiftToFirstNonWhiteSpace + 12;
}
if (ch2 === 58 && ch3 !== 58) {
return shiftToFirstNonWhiteSpace;
}
return false;
}
hasFlowCommentCompletion() {
const end = this.input.indexOf("*/", this.state.pos);
if (end === -1) {
throw this.raise(Errors.UnterminatedComment, {
at: this.state.curPosition()
});
}
}
flowEnumErrorBooleanMemberNotInitialized(loc, {
enumName,
memberName
}) {
this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
at: loc,
memberName,
enumName
});
}
flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
at: loc
}, enumContext));
}
flowEnumErrorNumberMemberNotInitialized(loc, {
enumName,
memberName
}) {
this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
at: loc,
enumName,
memberName
});
}
flowEnumErrorStringMemberInconsistentlyInitialized(node, {
enumName
}) {
this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, {
at: node,
enumName
});
}
flowEnumMemberInit() {
const startLoc = this.state.startLoc;
const endOfInit = () => this.match(12) || this.match(8);
switch (this.state.type) {
case 134:
{
const literal = this.parseNumericLiteral(this.state.value);
if (endOfInit()) {
return {
type: "number",
loc: literal.loc.start,
value: literal
};
}
return {
type: "invalid",
loc: startLoc
};
}
case 133:
{
const literal = this.parseStringLiteral(this.state.value);
if (endOfInit()) {
return {
type: "string",
loc: literal.loc.start,
value: literal
};
}
return {
type: "invalid",
loc: startLoc
};
}
case 85:
case 86:
{
const literal = this.parseBooleanLiteral(this.match(85));
if (endOfInit()) {
return {
type: "boolean",
loc: literal.loc.start,
value: literal
};
}
return {
type: "invalid",
loc: startLoc
};
}
default:
return {
type: "invalid",
loc: startLoc
};
}
}
flowEnumMemberRaw() {
const loc = this.state.startLoc;
const id = this.parseIdentifier(true);
const init = this.eat(29) ? this.flowEnumMemberInit() : {
type: "none",
loc
};
return {
id,
init
};
}
flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
const {
explicitType
} = context;
if (explicitType === null) {
return;
}
if (explicitType !== expectedType) {
this.flowEnumErrorInvalidMemberInitializer(loc, context);
}
}
flowEnumMembers({
enumName,
explicitType
}) {
const seenNames = new Set();
const members = {
booleanMembers: [],
numberMembers: [],
stringMembers: [],
defaultedMembers: []
};
let hasUnknownMembers = false;
while (!this.match(8)) {
if (this.eat(21)) {
hasUnknownMembers = true;
break;
}
const memberNode = this.startNode();
const {
id,
init
} = this.flowEnumMemberRaw();
const memberName = id.name;
if (memberName === "") {
continue;
}
if (/^[a-z]/.test(memberName)) {
this.raise(FlowErrors.EnumInvalidMemberName, {
at: id,
memberName,
suggestion: memberName[0].toUpperCase() + memberName.slice(1),
enumName
});
}
if (seenNames.has(memberName)) {
this.raise(FlowErrors.EnumDuplicateMemberName, {
at: id,
memberName,
enumName
});
}
seenNames.add(memberName);
const context = {
enumName,
explicitType,
memberName
};
memberNode.id = id;
switch (init.type) {
case "boolean":
{
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
memberNode.init = init.value;
members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
break;
}
case "number":
{
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
memberNode.init = init.value;
members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
break;
}
case "string":
{
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
memberNode.init = init.value;
members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
break;
}
case "invalid":
{
throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
}
case "none":
{
switch (explicitType) {
case "boolean":
this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
break;
case "number":
this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
break;
default:
members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
}
}
}
if (!this.match(8)) {
this.expect(12);
}
}
return {
members,
hasUnknownMembers
};
}
flowEnumStringMembers(initializedMembers, defaultedMembers, {
enumName
}) {
if (initializedMembers.length === 0) {
return defaultedMembers;
} else if (defaultedMembers.length === 0) {
return initializedMembers;
} else if (defaultedMembers.length > initializedMembers.length) {
for (const member of initializedMembers) {
this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
enumName
});
}
return defaultedMembers;
} else {
for (const member of defaultedMembers) {
this.flowEnumErrorStringMemberInconsistentlyInitialized(member, {
enumName
});
}
return initializedMembers;
}
}
flowEnumParseExplicitType({
enumName
}) {
if (!this.eatContextual(102)) return null;
if (!tokenIsIdentifier(this.state.type)) {
throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
at: this.state.startLoc,
enumName
});
}
const {
value
} = this.state;
this.next();
if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
this.raise(FlowErrors.EnumInvalidExplicitType, {
at: this.state.startLoc,
enumName,
invalidEnumType: value
});
}
return value;
}
flowEnumBody(node, id) {
const enumName = id.name;
const nameLoc = id.loc.start;
const explicitType = this.flowEnumParseExplicitType({
enumName
});
this.expect(5);
const {
members,
hasUnknownMembers
} = this.flowEnumMembers({
enumName,
explicitType
});
node.hasUnknownMembers = hasUnknownMembers;
switch (explicitType) {
case "boolean":
node.explicitType = true;
node.members = members.booleanMembers;
this.expect(8);
return this.finishNode(node, "EnumBooleanBody");
case "number":
node.explicitType = true;
node.members = members.numberMembers;
this.expect(8);
return this.finishNode(node, "EnumNumberBody");
case "string":
node.explicitType = true;
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
enumName
});
this.expect(8);
return this.finishNode(node, "EnumStringBody");
case "symbol":
node.members = members.defaultedMembers;
this.expect(8);
return this.finishNode(node, "EnumSymbolBody");
default:
{
const empty = () => {
node.members = [];
this.expect(8);
return this.finishNode(node, "EnumStringBody");
};
node.explicitType = false;
const boolsLen = members.booleanMembers.length;
const numsLen = members.numberMembers.length;
const strsLen = members.stringMembers.length;
const defaultedLen = members.defaultedMembers.length;
if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
return empty();
} else if (!boolsLen && !numsLen) {
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
enumName
});
this.expect(8);
return this.finishNode(node, "EnumStringBody");
} else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
for (const member of members.defaultedMembers) {
this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
enumName,
memberName: member.id.name
});
}
node.members = members.booleanMembers;
this.expect(8);
return this.finishNode(node, "EnumBooleanBody");
} else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
for (const member of members.defaultedMembers) {
this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
enumName,
memberName: member.id.name
});
}
node.members = members.numberMembers;
this.expect(8);
return this.finishNode(node, "EnumNumberBody");
} else {
this.raise(FlowErrors.EnumInconsistentMemberValues, {
at: nameLoc,
enumName
});
return empty();
}
}
}
}
flowParseEnumDeclaration(node) {
const id = this.parseIdentifier();
node.id = id;
node.body = this.flowEnumBody(this.startNode(), id);
return this.finishNode(node, "EnumDeclaration");
}
isLookaheadToken_lt() {
const next = this.nextTokenStart();
if (this.input.charCodeAt(next) === 60) {
const afterNext = this.input.charCodeAt(next + 1);
return afterNext !== 60 && afterNext !== 61;
}
return false;
}
maybeUnwrapTypeCastExpression(node) {
return node.type === "TypeCastExpression" ? node.expression : node;
}
};
const entities = {
__proto__: null,
quot: "\u0022",
amp: "&",
apos: "\u0027",
lt: "<",
gt: ">",
nbsp: "\u00A0",
iexcl: "\u00A1",
cent: "\u00A2",
pound: "\u00A3",
curren: "\u00A4",
yen: "\u00A5",
brvbar: "\u00A6",
sect: "\u00A7",
uml: "\u00A8",
copy: "\u00A9",
ordf: "\u00AA",
laquo: "\u00AB",
not: "\u00AC",
shy: "\u00AD",
reg: "\u00AE",
macr: "\u00AF",
deg: "\u00B0",
plusmn: "\u00B1",
sup2: "\u00B2",
sup3: "\u00B3",
acute: "\u00B4",
micro: "\u00B5",
para: "\u00B6",
middot: "\u00B7",
cedil: "\u00B8",
sup1: "\u00B9",
ordm: "\u00BA",
raquo: "\u00BB",
frac14: "\u00BC",
frac12: "\u00BD",
frac34: "\u00BE",
iquest: "\u00BF",
Agrave: "\u00C0",
Aacute: "\u00C1",
Acirc: "\u00C2",
Atilde: "\u00C3",
Auml: "\u00C4",
Aring: "\u00C5",
AElig: "\u00C6",
Ccedil: "\u00C7",
Egrave: "\u00C8",
Eacute: "\u00C9",
Ecirc: "\u00CA",
Euml: "\u00CB",
Igrave: "\u00CC",
Iacute: "\u00CD",
Icirc: "\u00CE",
Iuml: "\u00CF",
ETH: "\u00D0",
Ntilde: "\u00D1",
Ograve: "\u00D2",
Oacute: "\u00D3",
Ocirc: "\u00D4",
Otilde: "\u00D5",
Ouml: "\u00D6",
times: "\u00D7",
Oslash: "\u00D8",
Ugrave: "\u00D9",
Uacute: "\u00DA",
Ucirc: "\u00DB",
Uuml: "\u00DC",
Yacute: "\u00DD",
THORN: "\u00DE",
szlig: "\u00DF",
agrave: "\u00E0",
aacute: "\u00E1",
acirc: "\u00E2",
atilde: "\u00E3",
auml: "\u00E4",
aring: "\u00E5",
aelig: "\u00E6",
ccedil: "\u00E7",
egrave: "\u00E8",
eacute: "\u00E9",
ecirc: "\u00EA",
euml: "\u00EB",
igrave: "\u00EC",
iacute: "\u00ED",
icirc: "\u00EE",
iuml: "\u00EF",
eth: "\u00F0",
ntilde: "\u00F1",
ograve: "\u00F2",
oacute: "\u00F3",
ocirc: "\u00F4",
otilde: "\u00F5",
ouml: "\u00F6",
divide: "\u00F7",
oslash: "\u00F8",
ugrave: "\u00F9",
uacute: "\u00FA",
ucirc: "\u00FB",
uuml: "\u00FC",
yacute: "\u00FD",
thorn: "\u00FE",
yuml: "\u00FF",
OElig: "\u0152",
oelig: "\u0153",
Scaron: "\u0160",
scaron: "\u0161",
Yuml: "\u0178",
fnof: "\u0192",
circ: "\u02C6",
tilde: "\u02DC",
Alpha: "\u0391",
Beta: "\u0392",
Gamma: "\u0393",
Delta: "\u0394",
Epsilon: "\u0395",
Zeta: "\u0396",
Eta: "\u0397",
Theta: "\u0398",
Iota: "\u0399",
Kappa: "\u039A",
Lambda: "\u039B",
Mu: "\u039C",
Nu: "\u039D",
Xi: "\u039E",
Omicron: "\u039F",
Pi: "\u03A0",
Rho: "\u03A1",
Sigma: "\u03A3",
Tau: "\u03A4",
Upsilon: "\u03A5",
Phi: "\u03A6",
Chi: "\u03A7",
Psi: "\u03A8",
Omega: "\u03A9",
alpha: "\u03B1",
beta: "\u03B2",
gamma: "\u03B3",
delta: "\u03B4",
epsilon: "\u03B5",
zeta: "\u03B6",
eta: "\u03B7",
theta: "\u03B8",
iota: "\u03B9",
kappa: "\u03BA",
lambda: "\u03BB",
mu: "\u03BC",
nu: "\u03BD",
xi: "\u03BE",
omicron: "\u03BF",
pi: "\u03C0",
rho: "\u03C1",
sigmaf: "\u03C2",
sigma: "\u03C3",
tau: "\u03C4",
upsilon: "\u03C5",
phi: "\u03C6",
chi: "\u03C7",
psi: "\u03C8",
omega: "\u03C9",
thetasym: "\u03D1",
upsih: "\u03D2",
piv: "\u03D6",
ensp: "\u2002",
emsp: "\u2003",
thinsp: "\u2009",
zwnj: "\u200C",
zwj: "\u200D",
lrm: "\u200E",
rlm: "\u200F",
ndash: "\u2013",
mdash: "\u2014",
lsquo: "\u2018",
rsquo: "\u2019",
sbquo: "\u201A",
ldquo: "\u201C",
rdquo: "\u201D",
bdquo: "\u201E",
dagger: "\u2020",
Dagger: "\u2021",
bull: "\u2022",
hellip: "\u2026",
permil: "\u2030",
prime: "\u2032",
Prime: "\u2033",
lsaquo: "\u2039",
rsaquo: "\u203A",
oline: "\u203E",
frasl: "\u2044",
euro: "\u20AC",
image: "\u2111",
weierp: "\u2118",
real: "\u211C",
trade: "\u2122",
alefsym: "\u2135",
larr: "\u2190",
uarr: "\u2191",
rarr: "\u2192",
darr: "\u2193",
harr: "\u2194",
crarr: "\u21B5",
lArr: "\u21D0",
uArr: "\u21D1",
rArr: "\u21D2",
dArr: "\u21D3",
hArr: "\u21D4",
forall: "\u2200",
part: "\u2202",
exist: "\u2203",
empty: "\u2205",
nabla: "\u2207",
isin: "\u2208",
notin: "\u2209",
ni: "\u220B",
prod: "\u220F",
sum: "\u2211",
minus: "\u2212",
lowast: "\u2217",
radic: "\u221A",
prop: "\u221D",
infin: "\u221E",
ang: "\u2220",
and: "\u2227",
or: "\u2228",
cap: "\u2229",
cup: "\u222A",
int: "\u222B",
there4: "\u2234",
sim: "\u223C",
cong: "\u2245",
asymp: "\u2248",
ne: "\u2260",
equiv: "\u2261",
le: "\u2264",
ge: "\u2265",
sub: "\u2282",
sup: "\u2283",
nsub: "\u2284",
sube: "\u2286",
supe: "\u2287",
oplus: "\u2295",
otimes: "\u2297",
perp: "\u22A5",
sdot: "\u22C5",
lceil: "\u2308",
rceil: "\u2309",
lfloor: "\u230A",
rfloor: "\u230B",
lang: "\u2329",
rang: "\u232A",
loz: "\u25CA",
spades: "\u2660",
clubs: "\u2663",
hearts: "\u2665",
diams: "\u2666"
};
const JsxErrors = ParseErrorEnum`jsx`({
AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
MissingClosingTagElement: ({
openingTagName
}) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
UnexpectedToken: ({
unexpected,
HTMLEntity
}) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
UnterminatedJsxContent: "Unterminated JSX contents.",
UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
});
function isFragment(object) {
return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
}
function getQualifiedJSXName(object) {
if (object.type === "JSXIdentifier") {
return object.name;
}
if (object.type === "JSXNamespacedName") {
return object.namespace.name + ":" + object.name.name;
}
if (object.type === "JSXMemberExpression") {
return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
}
throw new Error("Node had unexpected type: " + object.type);
}
var jsx = superClass => class JSXParserMixin extends superClass {
jsxReadToken() {
let out = "";
let chunkStart = this.state.pos;
for (;;) {
if (this.state.pos >= this.length) {
throw this.raise(JsxErrors.UnterminatedJsxContent, {
at: this.state.startLoc
});
}
const ch = this.input.charCodeAt(this.state.pos);
switch (ch) {
case 60:
case 123:
if (this.state.pos === this.state.start) {
if (ch === 60 && this.state.canStartJSXElement) {
++this.state.pos;
this.finishToken(142);
} else {
super.getTokenFromCode(ch);
}
return;
}
out += this.input.slice(chunkStart, this.state.pos);
this.finishToken(141, out);
return;
case 38:
out += this.input.slice(chunkStart, this.state.pos);
out += this.jsxReadEntity();
chunkStart = this.state.pos;
break;
case 62:
case 125:
default:
if (isNewLine(ch)) {
out += this.input.slice(chunkStart, this.state.pos);
out += this.jsxReadNewLine(true);
chunkStart = this.state.pos;
} else {
++this.state.pos;
}
}
}
}
jsxReadNewLine(normalizeCRLF) {
const ch = this.input.charCodeAt(this.state.pos);
let out;
++this.state.pos;
if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
++this.state.pos;
out = normalizeCRLF ? "\n" : "\r\n";
} else {
out = String.fromCharCode(ch);
}
++this.state.curLine;
this.state.lineStart = this.state.pos;
return out;
}
jsxReadString(quote) {
let out = "";
let chunkStart = ++this.state.pos;
for (;;) {
if (this.state.pos >= this.length) {
throw this.raise(Errors.UnterminatedString, {
at: this.state.startLoc
});
}
const ch = this.input.charCodeAt(this.state.pos);
if (ch === quote) break;
if (ch === 38) {
out += this.input.slice(chunkStart, this.state.pos);
out += this.jsxReadEntity();
chunkStart = this.state.pos;
} else if (isNewLine(ch)) {
out += this.input.slice(chunkStart, this.state.pos);
out += this.jsxReadNewLine(false);
chunkStart = this.state.pos;
} else {
++this.state.pos;
}
}
out += this.input.slice(chunkStart, this.state.pos++);
this.finishToken(133, out);
}
jsxReadEntity() {
const startPos = ++this.state.pos;
if (this.codePointAtPos(this.state.pos) === 35) {
++this.state.pos;
let radix = 10;
if (this.codePointAtPos(this.state.pos) === 120) {
radix = 16;
++this.state.pos;
}
const codePoint = this.readInt(radix, undefined, false, "bail");
if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
++this.state.pos;
return String.fromCodePoint(codePoint);
}
} else {
let count = 0;
let semi = false;
while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
++this.state.pos;
}
if (semi) {
const desc = this.input.slice(startPos, this.state.pos);
const entity = entities[desc];
++this.state.pos;
if (entity) {
return entity;
}
}
}
this.state.pos = startPos;
return "&";
}
jsxReadWord() {
let ch;
const start = this.state.pos;
do {
ch = this.input.charCodeAt(++this.state.pos);
} while (isIdentifierChar(ch) || ch === 45);
this.finishToken(140, this.input.slice(start, this.state.pos));
}
jsxParseIdentifier() {
const node = this.startNode();
if (this.match(140)) {
node.name = this.state.value;
} else if (tokenIsKeyword(this.state.type)) {
node.name = tokenLabelName(this.state.type);
} else {
this.unexpected();
}
this.next();
return this.finishNode(node, "JSXIdentifier");
}
jsxParseNamespacedName() {
const startLoc = this.state.startLoc;
const name = this.jsxParseIdentifier();
if (!this.eat(14)) return name;
const node = this.startNodeAt(startLoc);
node.namespace = name;
node.name = this.jsxParseIdentifier();
return this.finishNode(node, "JSXNamespacedName");
}
jsxParseElementName() {
const startLoc = this.state.startLoc;
let node = this.jsxParseNamespacedName();
if (node.type === "JSXNamespacedName") {
return node;
}
while (this.eat(16)) {
const newNode = this.startNodeAt(startLoc);
newNode.object = node;
newNode.property = this.jsxParseIdentifier();
node = this.finishNode(newNode, "JSXMemberExpression");
}
return node;
}
jsxParseAttributeValue() {
let node;
switch (this.state.type) {
case 5:
node = this.startNode();
this.setContext(types.brace);
this.next();
node = this.jsxParseExpressionContainer(node, types.j_oTag);
if (node.expression.type === "JSXEmptyExpression") {
this.raise(JsxErrors.AttributeIsEmpty, {
at: node
});
}
return node;
case 142:
case 133:
return this.parseExprAtom();
default:
throw this.raise(JsxErrors.UnsupportedJsxValue, {
at: this.state.startLoc
});
}
}
jsxParseEmptyExpression() {
const node = this.startNodeAt(this.state.lastTokEndLoc);
return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
}
jsxParseSpreadChild(node) {
this.next();
node.expression = this.parseExpression();
this.setContext(types.j_expr);
this.state.canStartJSXElement = true;
this.expect(8);
return this.finishNode(node, "JSXSpreadChild");
}
jsxParseExpressionContainer(node, previousContext) {
if (this.match(8)) {
node.expression = this.jsxParseEmptyExpression();
} else {
const expression = this.parseExpression();
node.expression = expression;
}
this.setContext(previousContext);
this.state.canStartJSXElement = true;
this.expect(8);
return this.finishNode(node, "JSXExpressionContainer");
}
jsxParseAttribute() {
const node = this.startNode();
if (this.match(5)) {
this.setContext(types.brace);
this.next();
this.expect(21);
node.argument = this.parseMaybeAssignAllowIn();
this.setContext(types.j_oTag);
this.state.canStartJSXElement = true;
this.expect(8);
return this.finishNode(node, "JSXSpreadAttribute");
}
node.name = this.jsxParseNamespacedName();
node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
return this.finishNode(node, "JSXAttribute");
}
jsxParseOpeningElementAt(startLoc) {
const node = this.startNodeAt(startLoc);
if (this.eat(143)) {
return this.finishNode(node, "JSXOpeningFragment");
}
node.name = this.jsxParseElementName();
return this.jsxParseOpeningElementAfterName(node);
}
jsxParseOpeningElementAfterName(node) {
const attributes = [];
while (!this.match(56) && !this.match(143)) {
attributes.push(this.jsxParseAttribute());
}
node.attributes = attributes;
node.selfClosing = this.eat(56);
this.expect(143);
return this.finishNode(node, "JSXOpeningElement");
}
jsxParseClosingElementAt(startLoc) {
const node = this.startNodeAt(startLoc);
if (this.eat(143)) {
return this.finishNode(node, "JSXClosingFragment");
}
node.name = this.jsxParseElementName();
this.expect(143);
return this.finishNode(node, "JSXClosingElement");
}
jsxParseElementAt(startLoc) {
const node = this.startNodeAt(startLoc);
const children = [];
const openingElement = this.jsxParseOpeningElementAt(startLoc);
let closingElement = null;
if (!openingElement.selfClosing) {
contents: for (;;) {
switch (this.state.type) {
case 142:
startLoc = this.state.startLoc;
this.next();
if (this.eat(56)) {
closingElement = this.jsxParseClosingElementAt(startLoc);
break contents;
}
children.push(this.jsxParseElementAt(startLoc));
break;
case 141:
children.push(this.parseExprAtom());
break;
case 5:
{
const node = this.startNode();
this.setContext(types.brace);
this.next();
if (this.match(21)) {
children.push(this.jsxParseSpreadChild(node));
} else {
children.push(this.jsxParseExpressionContainer(node, types.j_expr));
}
break;
}
default:
this.unexpected();
}
}
if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
this.raise(JsxErrors.MissingClosingTagFragment, {
at: closingElement
});
} else if (!isFragment(openingElement) && isFragment(closingElement)) {
this.raise(JsxErrors.MissingClosingTagElement, {
at: closingElement,
openingTagName: getQualifiedJSXName(openingElement.name)
});
} else if (!isFragment(openingElement) && !isFragment(closingElement)) {
if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
this.raise(JsxErrors.MissingClosingTagElement, {
at: closingElement,
openingTagName: getQualifiedJSXName(openingElement.name)
});
}
}
}
if (isFragment(openingElement)) {
node.openingFragment = openingElement;
node.closingFragment = closingElement;
} else {
node.openingElement = openingElement;
node.closingElement = closingElement;
}
node.children = children;
if (this.match(47)) {
throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
at: this.state.startLoc
});
}
return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
}
jsxParseElement() {
const startLoc = this.state.startLoc;
this.next();
return this.jsxParseElementAt(startLoc);
}
setContext(newContext) {
const {
context
} = this.state;
context[context.length - 1] = newContext;
}
parseExprAtom(refExpressionErrors) {
if (this.match(141)) {
return this.parseLiteral(this.state.value, "JSXText");
} else if (this.match(142)) {
return this.jsxParseElement();
} else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
this.replaceToken(142);
return this.jsxParseElement();
} else {
return super.parseExprAtom(refExpressionErrors);
}
}
skipSpace() {
const curContext = this.curContext();
if (!curContext.preserveSpace) super.skipSpace();
}
getTokenFromCode(code) {
const context = this.curContext();
if (context === types.j_expr) {
this.jsxReadToken();
return;
}
if (context === types.j_oTag || context === types.j_cTag) {
if (isIdentifierStart(code)) {
this.jsxReadWord();
return;
}
if (code === 62) {
++this.state.pos;
this.finishToken(143);
return;
}
if ((code === 34 || code === 39) && context === types.j_oTag) {
this.jsxReadString(code);
return;
}
}
if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
++this.state.pos;
this.finishToken(142);
return;
}
super.getTokenFromCode(code);
}
updateContext(prevType) {
const {
context,
type
} = this.state;
if (type === 56 && prevType === 142) {
context.splice(-2, 2, types.j_cTag);
this.state.canStartJSXElement = false;
} else if (type === 142) {
context.push(types.j_oTag);
} else if (type === 143) {
const out = context[context.length - 1];
if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
context.pop();
this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
} else {
this.setContext(types.j_expr);
this.state.canStartJSXElement = true;
}
} else {
this.state.canStartJSXElement = tokenComesBeforeExpression(type);
}
}
};
class TypeScriptScope extends Scope {
constructor(...args) {
super(...args);
this.types = new Set();
this.enums = new Set();
this.constEnums = new Set();
this.classes = new Set();
this.exportOnlyBindings = new Set();
}
}
class TypeScriptScopeHandler extends ScopeHandler {
constructor(...args) {
super(...args);
this.importsStack = [];
}
createScope(flags) {
this.importsStack.push(new Set());
return new TypeScriptScope(flags);
}
enter(flags) {
if (flags == 256) {
this.importsStack.push(new Set());
}
super.enter(flags);
}
exit() {
const flags = super.exit();
if (flags == 256) {
this.importsStack.pop();
}
return flags;
}
hasImport(name, allowShadow) {
const len = this.importsStack.length;
if (this.importsStack[len - 1].has(name)) {
return true;
}
if (!allowShadow && len > 1) {
for (let i = 0; i < len - 1; i++) {
if (this.importsStack[i].has(name)) return true;
}
}
return false;
}
declareName(name, bindingType, loc) {
if (bindingType & 4096) {
if (this.hasImport(name, true)) {
this.parser.raise(Errors.VarRedeclaration, {
at: loc,
identifierName: name
});
}
this.importsStack[this.importsStack.length - 1].add(name);
return;
}
const scope = this.currentScope();
if (bindingType & 1024) {
this.maybeExportDefined(scope, name);
scope.exportOnlyBindings.add(name);
return;
}
super.declareName(name, bindingType, loc);
if (bindingType & 2) {
if (!(bindingType & 1)) {
this.checkRedeclarationInScope(scope, name, bindingType, loc);
this.maybeExportDefined(scope, name);
}
scope.types.add(name);
}
if (bindingType & 256) scope.enums.add(name);
if (bindingType & 512) {
scope.constEnums.add(name);
}
if (bindingType & 128) scope.classes.add(name);
}
isRedeclaredInScope(scope, name, bindingType) {
if (scope.enums.has(name)) {
if (bindingType & 256) {
const isConst = !!(bindingType & 512);
const wasConst = scope.constEnums.has(name);
return isConst !== wasConst;
}
return true;
}
if (bindingType & 128 && scope.classes.has(name)) {
if (scope.lexical.has(name)) {
return !!(bindingType & 1);
} else {
return false;
}
}
if (bindingType & 2 && scope.types.has(name)) {
return true;
}
return super.isRedeclaredInScope(scope, name, bindingType);
}
checkLocalExport(id) {
const {
name
} = id;
if (this.hasImport(name)) return;
const len = this.scopeStack.length;
for (let i = len - 1; i >= 0; i--) {
const scope = this.scopeStack[i];
if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;
}
super.checkLocalExport(id);
}
}
const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
const unwrapParenthesizedExpression = node => {
return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
};
class LValParser extends NodeUtils {
toAssignable(node, isLHS = false) {
var _node$extra, _node$extra3;
let parenthesized = undefined;
if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
parenthesized = unwrapParenthesizedExpression(node);
if (isLHS) {
if (parenthesized.type === "Identifier") {
this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
at: node
});
} else if (parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) {
this.raise(Errors.InvalidParenthesizedAssignment, {
at: node
});
}
} else {
this.raise(Errors.InvalidParenthesizedAssignment, {
at: node
});
}
}
switch (node.type) {
case "Identifier":
case "ObjectPattern":
case "ArrayPattern":
case "AssignmentPattern":
case "RestElement":
break;
case "ObjectExpression":
node.type = "ObjectPattern";
for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
var _node$extra2;
const prop = node.properties[i];
const isLast = i === last;
this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
this.raise(Errors.RestTrailingComma, {
at: node.extra.trailingCommaLoc
});
}
}
break;
case "ObjectProperty":
{
const {
key,
value
} = node;
if (this.isPrivateName(key)) {
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
}
this.toAssignable(value, isLHS);
break;
}
case "SpreadElement":
{
throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
}
case "ArrayExpression":
node.type = "ArrayPattern";
this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
break;
case "AssignmentExpression":
if (node.operator !== "=") {
this.raise(Errors.MissingEqInAssignment, {
at: node.left.loc.end
});
}
node.type = "AssignmentPattern";
delete node.operator;
this.toAssignable(node.left, isLHS);
break;
case "ParenthesizedExpression":
this.toAssignable(parenthesized, isLHS);
break;
}
}
toAssignableObjectExpressionProp(prop, isLast, isLHS) {
if (prop.type === "ObjectMethod") {
this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
at: prop.key
});
} else if (prop.type === "SpreadElement") {
prop.type = "RestElement";
const arg = prop.argument;
this.checkToRestConversion(arg, false);
this.toAssignable(arg, isLHS);
if (!isLast) {
this.raise(Errors.RestTrailingComma, {
at: prop
});
}
} else {
this.toAssignable(prop, isLHS);
}
}
toAssignableList(exprList, trailingCommaLoc, isLHS) {
const end = exprList.length - 1;
for (let i = 0; i <= end; i++) {
const elt = exprList[i];
if (!elt) continue;
if (elt.type === "SpreadElement") {
elt.type = "RestElement";
const arg = elt.argument;
this.checkToRestConversion(arg, true);
this.toAssignable(arg, isLHS);
} else {
this.toAssignable(elt, isLHS);
}
if (elt.type === "RestElement") {
if (i < end) {
this.raise(Errors.RestTrailingComma, {
at: elt
});
} else if (trailingCommaLoc) {
this.raise(Errors.RestTrailingComma, {
at: trailingCommaLoc
});
}
}
}
}
isAssignable(node, isBinding) {
switch (node.type) {
case "Identifier":
case "ObjectPattern":
case "ArrayPattern":
case "AssignmentPattern":
case "RestElement":
return true;
case "ObjectExpression":
{
const last = node.properties.length - 1;
return node.properties.every((prop, i) => {
return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop);
});
}
case "ObjectProperty":
return this.isAssignable(node.value);
case "SpreadElement":
return this.isAssignable(node.argument);
case "ArrayExpression":
return node.elements.every(element => element === null || this.isAssignable(element));
case "AssignmentExpression":
return node.operator === "=";
case "ParenthesizedExpression":
return this.isAssignable(node.expression);
case "MemberExpression":
case "OptionalMemberExpression":
return !isBinding;
default:
return false;
}
}
toReferencedList(exprList, isParenthesizedExpr) {
return exprList;
}
toReferencedListDeep(exprList, isParenthesizedExpr) {
this.toReferencedList(exprList, isParenthesizedExpr);
for (const expr of exprList) {
if ((expr == null ? void 0 : expr.type) === "ArrayExpression") {
this.toReferencedListDeep(expr.elements);
}
}
}
parseSpread(refExpressionErrors) {
const node = this.startNode();
this.next();
node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
return this.finishNode(node, "SpreadElement");
}
parseRestBinding() {
const node = this.startNode();
this.next();
node.argument = this.parseBindingAtom();
return this.finishNode(node, "RestElement");
}
parseBindingAtom() {
switch (this.state.type) {
case 0:
{
const node = this.startNode();
this.next();
node.elements = this.parseBindingList(3, 93, 1);
return this.finishNode(node, "ArrayPattern");
}
case 5:
return this.parseObjectLike(8, true);
}
return this.parseIdentifier();
}
parseBindingList(close, closeCharCode, flags) {
const allowEmpty = flags & 1;
const elts = [];
let first = true;
while (!this.eat(close)) {
if (first) {
first = false;
} else {
this.expect(12);
}
if (allowEmpty && this.match(12)) {
elts.push(null);
} else if (this.eat(close)) {
break;
} else if (this.match(21)) {
elts.push(this.parseAssignableListItemTypes(this.parseRestBinding(), flags));
if (!this.checkCommaAfterRest(closeCharCode)) {
this.expect(close);
break;
}
} else {
const decorators = [];
if (this.match(26) && this.hasPlugin("decorators")) {
this.raise(Errors.UnsupportedParameterDecorator, {
at: this.state.startLoc
});
}
while (this.match(26)) {
decorators.push(this.parseDecorator());
}
elts.push(this.parseAssignableListItem(flags, decorators));
}
}
return elts;
}
parseBindingRestProperty(prop) {
this.next();
prop.argument = this.parseIdentifier();
this.checkCommaAfterRest(125);
return this.finishNode(prop, "RestElement");
}
parseBindingProperty() {
const prop = this.startNode();
const {
type,
startLoc
} = this.state;
if (type === 21) {
return this.parseBindingRestProperty(prop);
} else if (type === 138) {
this.expectPlugin("destructuringPrivate", startLoc);
this.classScope.usePrivateName(this.state.value, startLoc);
prop.key = this.parsePrivateName();
} else {
this.parsePropertyName(prop);
}
prop.method = false;
return this.parseObjPropValue(prop, startLoc, false, false, true, false);
}
parseAssignableListItem(flags, decorators) {
const left = this.parseMaybeDefault();
this.parseAssignableListItemTypes(left, flags);
const elt = this.parseMaybeDefault(left.loc.start, left);
if (decorators.length) {
left.decorators = decorators;
}
return elt;
}
parseAssignableListItemTypes(param, flags) {
return param;
}
parseMaybeDefault(startLoc, left) {
var _startLoc, _left;
(_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
left = (_left = left) != null ? _left : this.parseBindingAtom();
if (!this.eat(29)) return left;
const node = this.startNodeAt(startLoc);
node.left = left;
node.right = this.parseMaybeAssignAllowIn();
return this.finishNode(node, "AssignmentPattern");
}
isValidLVal(type, isUnparenthesizedInAssign, binding) {
return getOwn$1({
AssignmentPattern: "left",
RestElement: "argument",
ObjectProperty: "value",
ParenthesizedExpression: "expression",
ArrayPattern: "elements",
ObjectPattern: "properties"
}, type);
}
isOptionalMemberExpression(expression) {
return expression.type === "OptionalMemberExpression";
}
checkLVal(expression, {
in: ancestor,
binding = 64,
checkClashes = false,
strictModeChanged = false,
hasParenthesizedAncestor = false
}) {
var _expression$extra;
const type = expression.type;
if (this.isObjectMethod(expression)) return;
const isOptionalMemberExpression = this.isOptionalMemberExpression(expression);
if (isOptionalMemberExpression || type === "MemberExpression") {
if (isOptionalMemberExpression) {
this.expectPlugin("optionalChainingAssign", expression.loc.start);
if (ancestor.type !== "AssignmentExpression") {
this.raise(Errors.InvalidLhsOptionalChaining, {
at: expression,
ancestor
});
}
}
if (binding !== 64) {
this.raise(Errors.InvalidPropertyBindingPattern, {
at: expression
});
}
return;
}
if (type === "Identifier") {
this.checkIdentifier(expression, binding, strictModeChanged);
const {
name
} = expression;
if (checkClashes) {
if (checkClashes.has(name)) {
this.raise(Errors.ParamDupe, {
at: expression
});
} else {
checkClashes.add(name);
}
}
return;
}
const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
if (validity === true) return;
if (validity === false) {
const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
this.raise(ParseErrorClass, {
at: expression,
ancestor
});
return;
}
const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" ? {
type
} : ancestor;
for (const child of [].concat(expression[key])) {
if (child) {
this.checkLVal(child, {
in: nextAncestor,
binding,
checkClashes,
strictModeChanged,
hasParenthesizedAncestor: isParenthesizedExpression
});
}
}
}
checkIdentifier(at, bindingType, strictModeChanged = false) {
if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
if (bindingType === 64) {
this.raise(Errors.StrictEvalArguments, {
at,
referenceName: at.name
});
} else {
this.raise(Errors.StrictEvalArgumentsBinding, {
at,
bindingName: at.name
});
}
}
if (bindingType & 8192 && at.name === "let") {
this.raise(Errors.LetInLexicalBinding, {
at
});
}
if (!(bindingType & 64)) {
this.declareNameFromIdentifier(at, bindingType);
}
}
declareNameFromIdentifier(identifier, binding) {
this.scope.declareName(identifier.name, binding, identifier.loc.start);
}
checkToRestConversion(node, allowPattern) {
switch (node.type) {
case "ParenthesizedExpression":
this.checkToRestConversion(node.expression, allowPattern);
break;
case "Identifier":
case "MemberExpression":
break;
case "ArrayExpression":
case "ObjectExpression":
if (allowPattern) break;
default:
this.raise(Errors.InvalidRestAssignmentPattern, {
at: node
});
}
}
checkCommaAfterRest(close) {
if (!this.match(12)) {
return false;
}
this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
at: this.state.startLoc
});
return true;
}
}
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
function nonNull(x) {
if (x == null) {
throw new Error(`Unexpected ${x} value.`);
}
return x;
}
function assert(x) {
if (!x) {
throw new Error("Assert fail");
}
}
const TSErrors = ParseErrorEnum`typescript`({
AbstractMethodHasImplementation: ({
methodName
}) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
AbstractPropertyHasInitializer: ({
propertyName
}) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
DeclareAccessor: ({
kind
}) => `'declare' is not allowed in ${kind}ters.`,
DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
DuplicateAccessibilityModifier: ({
modifier
}) => `Accessibility modifier already seen.`,
DuplicateModifier: ({
modifier
}) => `Duplicate modifier: '${modifier}'.`,
EmptyHeritageClauseType: ({
token
}) => `'${token}' list cannot be empty.`,
EmptyTypeArguments: "Type argument list cannot be empty.",
EmptyTypeParameters: "Type parameter list cannot be empty.",
ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
ImportAliasHasImportType: "An import alias can not use 'import type'.",
ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
IncompatibleModifiers: ({
modifiers
}) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
IndexSignatureHasAccessibility: ({
modifier
}) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
InvalidModifierOnTypeMember: ({
modifier
}) => `'${modifier}' modifier cannot appear on a type member.`,
InvalidModifierOnTypeParameter: ({
modifier
}) => `'${modifier}' modifier cannot appear on a type parameter.`,
InvalidModifierOnTypeParameterPositions: ({
modifier
}) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
InvalidModifiersOrder: ({
orderedModifiers
}) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
PrivateElementHasAccessibility: ({
modifier
}) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
SingleTypeParameterWithoutTrailingComma: ({
typeParameterName
}) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
UnsupportedSignatureParameterKind: ({
type
}) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
});
function keywordTypeFromName(value) {
switch (value) {
case "any":
return "TSAnyKeyword";
case "boolean":
return "TSBooleanKeyword";
case "bigint":
return "TSBigIntKeyword";
case "never":
return "TSNeverKeyword";
case "number":
return "TSNumberKeyword";
case "object":
return "TSObjectKeyword";
case "string":
return "TSStringKeyword";
case "symbol":
return "TSSymbolKeyword";
case "undefined":
return "TSUndefinedKeyword";
case "unknown":
return "TSUnknownKeyword";
default:
return undefined;
}
}
function tsIsAccessModifier(modifier) {
return modifier === "private" || modifier === "public" || modifier === "protected";
}
function tsIsVarianceAnnotations(modifier) {
return modifier === "in" || modifier === "out";
}
var typescript = superClass => class TypeScriptParserMixin extends superClass {
constructor(...args) {
super(...args);
this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
allowedModifiers: ["in", "out"],
disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
errorTemplate: TSErrors.InvalidModifierOnTypeParameter
});
this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
allowedModifiers: ["const"],
disallowedModifiers: ["in", "out"],
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
});
this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
allowedModifiers: ["in", "out", "const"],
disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
errorTemplate: TSErrors.InvalidModifierOnTypeParameter
});
}
getScopeHandler() {
return TypeScriptScopeHandler;
}
tsIsIdentifier() {
return tokenIsIdentifier(this.state.type);
}
tsTokenCanFollowModifier() {
return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(138) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
}
tsNextTokenCanFollowModifier() {
this.next();
return this.tsTokenCanFollowModifier();
}
tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
return undefined;
}
const modifier = this.state.value;
if (allowedModifiers.indexOf(modifier) !== -1) {
if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
return undefined;
}
if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
return modifier;
}
}
return undefined;
}
tsParseModifiers({
allowedModifiers,
disallowedModifiers,
stopOnStartOfClassStaticBlock,
errorTemplate = TSErrors.InvalidModifierOnTypeMember
}, modified) {
const enforceOrder = (loc, modifier, before, after) => {
if (modifier === before && modified[after]) {
this.raise(TSErrors.InvalidModifiersOrder, {
at: loc,
orderedModifiers: [before, after]
});
}
};
const incompatible = (loc, modifier, mod1, mod2) => {
if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
this.raise(TSErrors.IncompatibleModifiers, {
at: loc,
modifiers: [mod1, mod2]
});
}
};
for (;;) {
const {
startLoc
} = this.state;
const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
if (!modifier) break;
if (tsIsAccessModifier(modifier)) {
if (modified.accessibility) {
this.raise(TSErrors.DuplicateAccessibilityModifier, {
at: startLoc,
modifier
});
} else {
enforceOrder(startLoc, modifier, modifier, "override");
enforceOrder(startLoc, modifier, modifier, "static");
enforceOrder(startLoc, modifier, modifier, "readonly");
modified.accessibility = modifier;
}
} else if (tsIsVarianceAnnotations(modifier)) {
if (modified[modifier]) {
this.raise(TSErrors.DuplicateModifier, {
at: startLoc,
modifier
});
}
modified[modifier] = true;
enforceOrder(startLoc, modifier, "in", "out");
} else {
if (Object.hasOwnProperty.call(modified, modifier)) {
this.raise(TSErrors.DuplicateModifier, {
at: startLoc,
modifier
});
} else {
enforceOrder(startLoc, modifier, "static", "readonly");
enforceOrder(startLoc, modifier, "static", "override");
enforceOrder(startLoc, modifier, "override", "readonly");
enforceOrder(startLoc, modifier, "abstract", "override");
incompatible(startLoc, modifier, "declare", "override");
incompatible(startLoc, modifier, "static", "abstract");
}
modified[modifier] = true;
}
if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
this.raise(errorTemplate, {
at: startLoc,
modifier
});
}
}
}
tsIsListTerminator(kind) {
switch (kind) {
case "EnumMembers":
case "TypeMembers":
return this.match(8);
case "HeritageClauseElement":
return this.match(5);
case "TupleElementTypes":
return this.match(3);
case "TypeParametersOrArguments":
return this.match(48);
}
}
tsParseList(kind, parseElement) {
const result = [];
while (!this.tsIsListTerminator(kind)) {
result.push(parseElement());
}
return result;
}
tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
}
tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
const result = [];
let trailingCommaPos = -1;
for (;;) {
if (this.tsIsListTerminator(kind)) {
break;
}
trailingCommaPos = -1;
const element = parseElement();
if (element == null) {
return undefined;
}
result.push(element);
if (this.eat(12)) {
trailingCommaPos = this.state.lastTokStart;
continue;
}
if (this.tsIsListTerminator(kind)) {
break;
}
if (expectSuccess) {
this.expect(12);
}
return undefined;
}
if (refTrailingCommaPos) {
refTrailingCommaPos.value = trailingCommaPos;
}
return result;
}
tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
if (!skipFirstToken) {
if (bracket) {
this.expect(0);
} else {
this.expect(47);
}
}
const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
if (bracket) {
this.expect(3);
} else {
this.expect(48);
}
return result;
}
tsParseImportType() {
const node = this.startNode();
this.expect(83);
this.expect(10);
if (!this.match(133)) {
this.raise(TSErrors.UnsupportedImportTypeArgument, {
at: this.state.startLoc
});
}
node.argument = super.parseExprAtom();
this.expect(11);
if (this.eat(16)) {
node.qualifier = this.tsParseEntityName();
}
if (this.match(47)) {
node.typeParameters = this.tsParseTypeArguments();
}
return this.finishNode(node, "TSImportType");
}
tsParseEntityName(allowReservedWords = true) {
let entity = this.parseIdentifier(allowReservedWords);
while (this.eat(16)) {
const node = this.startNodeAtNode(entity);
node.left = entity;
node.right = this.parseIdentifier(allowReservedWords);
entity = this.finishNode(node, "TSQualifiedName");
}
return entity;
}
tsParseTypeReference() {
const node = this.startNode();
node.typeName = this.tsParseEntityName();
if (!this.hasPrecedingLineBreak() && this.match(47)) {
node.typeParameters = this.tsParseTypeArguments();
}
return this.finishNode(node, "TSTypeReference");
}
tsParseThisTypePredicate(lhs) {
this.next();
const node = this.startNodeAtNode(lhs);
node.parameterName = lhs;
node.typeAnnotation = this.tsParseTypeAnnotation(false);
node.asserts = false;
return this.finishNode(node, "TSTypePredicate");
}
tsParseThisTypeNode() {
const node = this.startNode();
this.next();
return this.finishNode(node, "TSThisType");
}
tsParseTypeQuery() {
const node = this.startNode();
this.expect(87);
if (this.match(83)) {
node.exprName = this.tsParseImportType();
} else {
node.exprName = this.tsParseEntityName();
}
if (!this.hasPrecedingLineBreak() && this.match(47)) {
node.typeParameters = this.tsParseTypeArguments();
}
return this.finishNode(node, "TSTypeQuery");
}
tsParseTypeParameter(parseModifiers) {
const node = this.startNode();
parseModifiers(node);
node.name = this.tsParseTypeParameterName();
node.constraint = this.tsEatThenParseType(81);
node.default = this.tsEatThenParseType(29);
return this.finishNode(node, "TSTypeParameter");
}
tsTryParseTypeParameters(parseModifiers) {
if (this.match(47)) {
return this.tsParseTypeParameters(parseModifiers);
}
}
tsParseTypeParameters(parseModifiers) {
const node = this.startNode();
if (this.match(47) || this.match(142)) {
this.next();
} else {
this.unexpected();
}
const refTrailingCommaPos = {
value: -1
};
node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
if (node.params.length === 0) {
this.raise(TSErrors.EmptyTypeParameters, {
at: node
});
}
if (refTrailingCommaPos.value !== -1) {
this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
}
return this.finishNode(node, "TSTypeParameterDeclaration");
}
tsFillSignature(returnToken, signature) {
const returnTokenRequired = returnToken === 19;
const paramsKey = "parameters";
const returnTypeKey = "typeAnnotation";
signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
this.expect(10);
signature[paramsKey] = this.tsParseBindingListForSignature();
if (returnTokenRequired) {
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
} else if (this.match(returnToken)) {
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
}
}
tsParseBindingListForSignature() {
const list = super.parseBindingList(11, 41, 2);
for (const pattern of list) {
const {
type
} = pattern;
if (type === "AssignmentPattern" || type === "TSParameterProperty") {
this.raise(TSErrors.UnsupportedSignatureParameterKind, {
at: pattern,
type
});
}
}
return list;
}
tsParseTypeMemberSemicolon() {
if (!this.eat(12) && !this.isLineTerminator()) {
this.expect(13);
}
}
tsParseSignatureMember(kind, node) {
this.tsFillSignature(14, node);
this.tsParseTypeMemberSemicolon();
return this.finishNode(node, kind);
}
tsIsUnambiguouslyIndexSignature() {
this.next();
if (tokenIsIdentifier(this.state.type)) {
this.next();
return this.match(14);
}
return false;
}
tsTryParseIndexSignature(node) {
if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
return;
}
this.expect(0);
const id = this.parseIdentifier();
id.typeAnnotation = this.tsParseTypeAnnotation();
this.resetEndLocation(id);
this.expect(3);
node.parameters = [id];
const type = this.tsTryParseTypeAnnotation();
if (type) node.typeAnnotation = type;
this.tsParseTypeMemberSemicolon();
return this.finishNode(node, "TSIndexSignature");
}
tsParsePropertyOrMethodSignature(node, readonly) {
if (this.eat(17)) node.optional = true;
const nodeAny = node;
if (this.match(10) || this.match(47)) {
if (readonly) {
this.raise(TSErrors.ReadonlyForMethodSignature, {
at: node
});
}
const method = nodeAny;
if (method.kind && this.match(47)) {
this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
at: this.state.curPosition()
});
}
this.tsFillSignature(14, method);
this.tsParseTypeMemberSemicolon();
const paramsKey = "parameters";
const returnTypeKey = "typeAnnotation";
if (method.kind === "get") {
if (method[paramsKey].length > 0) {
this.raise(Errors.BadGetterArity, {
at: this.state.curPosition()
});
if (this.isThisParam(method[paramsKey][0])) {
this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
at: this.state.curPosition()
});
}
}
} else if (method.kind === "set") {
if (method[paramsKey].length !== 1) {
this.raise(Errors.BadSetterArity, {
at: this.state.curPosition()
});
} else {
const firstParameter = method[paramsKey][0];
if (this.isThisParam(firstParameter)) {
this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
at: this.state.curPosition()
});
}
if (firstParameter.type === "Identifier" && firstParameter.optional) {
this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
at: this.state.curPosition()
});
}
if (firstParameter.type === "RestElement") {
this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
at: this.state.curPosition()
});
}
}
if (method[returnTypeKey]) {
this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
at: method[returnTypeKey]
});
}
} else {
method.kind = "method";
}
return this.finishNode(method, "TSMethodSignature");
} else {
const property = nodeAny;
if (readonly) property.readonly = true;
const type = this.tsTryParseTypeAnnotation();
if (type) property.typeAnnotation = type;
this.tsParseTypeMemberSemicolon();
return this.finishNode(property, "TSPropertySignature");
}
}
tsParseTypeMember() {
const node = this.startNode();
if (this.match(10) || this.match(47)) {
return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
}
if (this.match(77)) {
const id = this.startNode();
this.next();
if (this.match(10) || this.match(47)) {
return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
} else {
node.key = this.createIdentifier(id, "new");
return this.tsParsePropertyOrMethodSignature(node, false);
}
}
this.tsParseModifiers({
allowedModifiers: ["readonly"],
disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
}, node);
const idx = this.tsTryParseIndexSignature(node);
if (idx) {
return idx;
}
super.parsePropertyName(node);
if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
node.kind = node.key.name;
super.parsePropertyName(node);
}
return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
}
tsParseTypeLiteral() {
const node = this.startNode();
node.members = this.tsParseObjectTypeMembers();
return this.finishNode(node, "TSTypeLiteral");
}
tsParseObjectTypeMembers() {
this.expect(5);
const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
this.expect(8);
return members;
}
tsIsStartOfMappedType() {
this.next();
if (this.eat(53)) {
return this.isContextual(122);
}
if (this.isContextual(122)) {
this.next();
}
if (!this.match(0)) {
return false;
}
this.next();
if (!this.tsIsIdentifier()) {
return false;
}
this.next();
return this.match(58);
}
tsParseMappedTypeParameter() {
const node = this.startNode();
node.name = this.tsParseTypeParameterName();
node.constraint = this.tsExpectThenParseType(58);
return this.finishNode(node, "TSTypeParameter");
}
tsParseMappedType() {
const node = this.startNode();
this.expect(5);
if (this.match(53)) {
node.readonly = this.state.value;
this.next();
this.expectContextual(122);
} else if (this.eatContextual(122)) {
node.readonly = true;
}
this.expect(0);
node.typeParameter = this.tsParseMappedTypeParameter();
node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
this.expect(3);
if (this.match(53)) {
node.optional = this.state.value;
this.next();
this.expect(17);
} else if (this.eat(17)) {
node.optional = true;
}
node.typeAnnotation = this.tsTryParseType();
this.semicolon();
this.expect(8);
return this.finishNode(node, "TSMappedType");
}
tsParseTupleType() {
const node = this.startNode();
node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
let seenOptionalElement = false;
node.elementTypes.forEach(elementNode => {
const {
type
} = elementNode;
if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
this.raise(TSErrors.OptionalTypeBeforeRequired, {
at: elementNode
});
}
seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
});
return this.finishNode(node, "TSTupleType");
}
tsParseTupleElementType() {
const {
startLoc
} = this.state;
const rest = this.eat(21);
let labeled;
let label;
let optional;
let type;
const isWord = tokenIsKeywordOrIdentifier(this.state.type);
const chAfterWord = isWord ? this.lookaheadCharCode() : null;
if (chAfterWord === 58) {
labeled = true;
optional = false;
label = this.parseIdentifier(true);
this.expect(14);
type = this.tsParseType();
} else if (chAfterWord === 63) {
optional = true;
const startLoc = this.state.startLoc;
const wordName = this.state.value;
const typeOrLabel = this.tsParseNonArrayType();
if (this.lookaheadCharCode() === 58) {
labeled = true;
label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
this.expect(17);
this.expect(14);
type = this.tsParseType();
} else {
labeled = false;
type = typeOrLabel;
this.expect(17);
}
} else {
type = this.tsParseType();
optional = this.eat(17);
labeled = this.eat(14);
}
if (labeled) {
let labeledNode;
if (label) {
labeledNode = this.startNodeAtNode(label);
labeledNode.optional = optional;
labeledNode.label = label;
labeledNode.elementType = type;
if (this.eat(17)) {
labeledNode.optional = true;
this.raise(TSErrors.TupleOptionalAfterType, {
at: this.state.lastTokStartLoc
});
}
} else {
labeledNode = this.startNodeAtNode(type);
labeledNode.optional = optional;
this.raise(TSErrors.InvalidTupleMemberLabel, {
at: type
});
labeledNode.label = type;
labeledNode.elementType = this.tsParseType();
}
type = this.finishNode(labeledNode, "TSNamedTupleMember");
} else if (optional) {
const optionalTypeNode = this.startNodeAtNode(type);
optionalTypeNode.typeAnnotation = type;
type = this.finishNode(optionalTypeNode, "TSOptionalType");
}
if (rest) {
const restNode = this.startNodeAt(startLoc);
restNode.typeAnnotation = type;
type = this.finishNode(restNode, "TSRestType");
}
return type;
}
tsParseParenthesizedType() {
const node = this.startNode();
this.expect(10);
node.typeAnnotation = this.tsParseType();
this.expect(11);
return this.finishNode(node, "TSParenthesizedType");
}
tsParseFunctionOrConstructorType(type, abstract) {
const node = this.startNode();
if (type === "TSConstructorType") {
node.abstract = !!abstract;
if (abstract) this.next();
this.next();
}
this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
return this.finishNode(node, type);
}
tsParseLiteralTypeNode() {
const node = this.startNode();
switch (this.state.type) {
case 134:
case 135:
case 133:
case 85:
case 86:
node.literal = super.parseExprAtom();
break;
default:
this.unexpected();
}
return this.finishNode(node, "TSLiteralType");
}
tsParseTemplateLiteralType() {
const node = this.startNode();
node.literal = super.parseTemplate(false);
return this.finishNode(node, "TSLiteralType");
}
parseTemplateSubstitution() {
if (this.state.inType) return this.tsParseType();
return super.parseTemplateSubstitution();
}
tsParseThisTypeOrThisTypePredicate() {
const thisKeyword = this.tsParseThisTypeNode();
if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
return this.tsParseThisTypePredicate(thisKeyword);
} else {
return thisKeyword;
}
}
tsParseNonArrayType() {
switch (this.state.type) {
case 133:
case 134:
case 135:
case 85:
case 86:
return this.tsParseLiteralTypeNode();
case 53:
if (this.state.value === "-") {
const node = this.startNode();
const nextToken = this.lookahead();
if (nextToken.type !== 134 && nextToken.type !== 135) {
this.unexpected();
}
node.literal = this.parseMaybeUnary();
return this.finishNode(node, "TSLiteralType");
}
break;
case 78:
return this.tsParseThisTypeOrThisTypePredicate();
case 87:
return this.tsParseTypeQuery();
case 83:
return this.tsParseImportType();
case 5:
return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
case 0:
return this.tsParseTupleType();
case 10:
return this.tsParseParenthesizedType();
case 25:
case 24:
return this.tsParseTemplateLiteralType();
default:
{
const {
type
} = this.state;
if (tokenIsIdentifier(type) || type === 88 || type === 84) {
const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {
const node = this.startNode();
this.next();
return this.finishNode(node, nodeType);
}
return this.tsParseTypeReference();
}
}
}
this.unexpected();
}
tsParseArrayTypeOrHigher() {
let type = this.tsParseNonArrayType();
while (!this.hasPrecedingLineBreak() && this.eat(0)) {
if (this.match(3)) {
const node = this.startNodeAtNode(type);
node.elementType = type;
this.expect(3);
type = this.finishNode(node, "TSArrayType");
} else {
const node = this.startNodeAtNode(type);
node.objectType = type;
node.indexType = this.tsParseType();
this.expect(3);
type = this.finishNode(node, "TSIndexedAccessType");
}
}
return type;
}
tsParseTypeOperator() {
const node = this.startNode();
const operator = this.state.value;
this.next();
node.operator = operator;
node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
if (operator === "readonly") {
this.tsCheckTypeAnnotationForReadOnly(node);
}
return this.finishNode(node, "TSTypeOperator");
}
tsCheckTypeAnnotationForReadOnly(node) {
switch (node.typeAnnotation.type) {
case "TSTupleType":
case "TSArrayType":
return;
default:
this.raise(TSErrors.UnexpectedReadonly, {
at: node
});
}
}
tsParseInferType() {
const node = this.startNode();
this.expectContextual(115);
const typeParameter = this.startNode();
typeParameter.name = this.tsParseTypeParameterName();
typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
return this.finishNode(node, "TSInferType");
}
tsParseConstraintForInferType() {
if (this.eat(81)) {
const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
return constraint;
}
}
}
tsParseTypeOperatorOrHigher() {
const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
}
tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
const node = this.startNode();
const hasLeadingOperator = this.eat(operator);
const types = [];
do {
types.push(parseConstituentType());
} while (this.eat(operator));
if (types.length === 1 && !hasLeadingOperator) {
return types[0];
}
node.types = types;
return this.finishNode(node, kind);
}
tsParseIntersectionTypeOrHigher() {
return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
}
tsParseUnionTypeOrHigher() {
return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
}
tsIsStartOfFunctionType() {
if (this.match(47)) {
return true;
}
return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
}
tsSkipParameterStart() {
if (tokenIsIdentifier(this.state.type) || this.match(78)) {
this.next();
return true;
}
if (this.match(5)) {
const {
errors
} = this.state;
const previousErrorCount = errors.length;
try {
this.parseObjectLike(8, true);
return errors.length === previousErrorCount;
} catch (_unused) {
return false;
}
}
if (this.match(0)) {
this.next();
const {
errors
} = this.state;
const previousErrorCount = errors.length;
try {
super.parseBindingList(3, 93, 1);
return errors.length === previousErrorCount;
} catch (_unused2) {
return false;
}
}
return false;
}
tsIsUnambiguouslyStartOfFunctionType() {
this.next();
if (this.match(11) || this.match(21)) {
return true;
}
if (this.tsSkipParameterStart()) {
if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
return true;
}
if (this.match(11)) {
this.next();
if (this.match(19)) {
return true;
}
}
}
return false;
}
tsParseTypeOrTypePredicateAnnotation(returnToken) {
return this.tsInType(() => {
const t = this.startNode();
this.expect(returnToken);
const node = this.startNode();
const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
if (asserts && this.match(78)) {
let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
if (thisTypePredicate.type === "TSThisType") {
node.parameterName = thisTypePredicate;
node.asserts = true;
node.typeAnnotation = null;
thisTypePredicate = this.finishNode(node, "TSTypePredicate");
} else {
this.resetStartLocationFromNode(thisTypePredicate, node);
thisTypePredicate.asserts = true;
}
t.typeAnnotation = thisTypePredicate;
return this.finishNode(t, "TSTypeAnnotation");
}
const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
if (!typePredicateVariable) {
if (!asserts) {
return this.tsParseTypeAnnotation(false, t);
}
node.parameterName = this.parseIdentifier();
node.asserts = asserts;
node.typeAnnotation = null;
t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
return this.finishNode(t, "TSTypeAnnotation");
}
const type = this.tsParseTypeAnnotation(false);
node.parameterName = typePredicateVariable;
node.typeAnnotation = type;
node.asserts = asserts;
t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
return this.finishNode(t, "TSTypeAnnotation");
});
}
tsTryParseTypeOrTypePredicateAnnotation() {
if (this.match(14)) {
return this.tsParseTypeOrTypePredicateAnnotation(14);
}
}
tsTryParseTypeAnnotation() {
if (this.match(14)) {
return this.tsParseTypeAnnotation();
}
}
tsTryParseType() {
return this.tsEatThenParseType(14);
}
tsParseTypePredicatePrefix() {
const id = this.parseIdentifier();
if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
this.next();
return id;
}
}
tsParseTypePredicateAsserts() {
if (this.state.type !== 109) {
return false;
}
const containsEsc = this.state.containsEsc;
this.next();
if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
return false;
}
if (containsEsc) {
this.raise(Errors.InvalidEscapedReservedWord, {
at: this.state.lastTokStartLoc,
reservedWord: "asserts"
});
}
return true;
}
tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
this.tsInType(() => {
if (eatColon) this.expect(14);
t.typeAnnotation = this.tsParseType();
});
return this.finishNode(t, "TSTypeAnnotation");
}
tsParseType() {
assert(this.state.inType);
const type = this.tsParseNonConditionalType();
if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
return type;
}
const node = this.startNodeAtNode(type);
node.checkType = type;
node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
this.expect(17);
node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
this.expect(14);
node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
return this.finishNode(node, "TSConditionalType");
}
isAbstractConstructorSignature() {
return this.isContextual(124) && this.lookahead().type === 77;
}
tsParseNonConditionalType() {
if (this.tsIsStartOfFunctionType()) {
return this.tsParseFunctionOrConstructorType("TSFunctionType");
}
if (this.match(77)) {
return this.tsParseFunctionOrConstructorType("TSConstructorType");
} else if (this.isAbstractConstructorSignature()) {
return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
}
return this.tsParseUnionTypeOrHigher();
}
tsParseTypeAssertion() {
if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
this.raise(TSErrors.ReservedTypeAssertion, {
at: this.state.startLoc
});
}
const node = this.startNode();
node.typeAnnotation = this.tsInType(() => {
this.next();
return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
});
this.expect(48);
node.expression = this.parseMaybeUnary();
return this.finishNode(node, "TSTypeAssertion");
}
tsParseHeritageClause(token) {
const originalStartLoc = this.state.startLoc;
const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
const node = this.startNode();
node.expression = this.tsParseEntityName();
if (this.match(47)) {
node.typeParameters = this.tsParseTypeArguments();
}
return this.finishNode(node, "TSExpressionWithTypeArguments");
});
if (!delimitedList.length) {
this.raise(TSErrors.EmptyHeritageClauseType, {
at: originalStartLoc,
token
});
}
return delimitedList;
}
tsParseInterfaceDeclaration(node, properties = {}) {
if (this.hasFollowingLineBreak()) return null;
this.expectContextual(129);
if (properties.declare) node.declare = true;
if (tokenIsIdentifier(this.state.type)) {
node.id = this.parseIdentifier();
this.checkIdentifier(node.id, 130);
} else {
node.id = null;
this.raise(TSErrors.MissingInterfaceName, {
at: this.state.startLoc
});
}
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
if (this.eat(81)) {
node.extends = this.tsParseHeritageClause("extends");
}
const body = this.startNode();
body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
node.body = this.finishNode(body, "TSInterfaceBody");
return this.finishNode(node, "TSInterfaceDeclaration");
}
tsParseTypeAliasDeclaration(node) {
node.id = this.parseIdentifier();
this.checkIdentifier(node.id, 2);
node.typeAnnotation = this.tsInType(() => {
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
this.expect(29);
if (this.isContextual(114) && this.lookahead().type !== 16) {
const node = this.startNode();
this.next();
return this.finishNode(node, "TSIntrinsicKeyword");
}
return this.tsParseType();
});
this.semicolon();
return this.finishNode(node, "TSTypeAliasDeclaration");
}
tsInNoContext(cb) {
const oldContext = this.state.context;
this.state.context = [oldContext[0]];
try {
return cb();
} finally {
this.state.context = oldContext;
}
}
tsInType(cb) {
const oldInType = this.state.inType;
this.state.inType = true;
try {
return cb();
} finally {
this.state.inType = oldInType;
}
}
tsInDisallowConditionalTypesContext(cb) {
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
this.state.inDisallowConditionalTypesContext = true;
try {
return cb();
} finally {
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
}
}
tsInAllowConditionalTypesContext(cb) {
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
this.state.inDisallowConditionalTypesContext = false;
try {
return cb();
} finally {
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
}
}
tsEatThenParseType(token) {
if (this.match(token)) {
return this.tsNextThenParseType();
}
}
tsExpectThenParseType(token) {
return this.tsInType(() => {
this.expect(token);
return this.tsParseType();
});
}
tsNextThenParseType() {
return this.tsInType(() => {
this.next();
return this.tsParseType();
});
}
tsParseEnumMember() {
const node = this.startNode();
node.id = this.match(133) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
if (this.eat(29)) {
node.initializer = super.parseMaybeAssignAllowIn();
}
return this.finishNode(node, "TSEnumMember");
}
tsParseEnumDeclaration(node, properties = {}) {
if (properties.const) node.const = true;
if (properties.declare) node.declare = true;
this.expectContextual(126);
node.id = this.parseIdentifier();
this.checkIdentifier(node.id, node.const ? 8971 : 8459);
this.expect(5);
node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
this.expect(8);
return this.finishNode(node, "TSEnumDeclaration");
}
tsParseModuleBlock() {
const node = this.startNode();
this.scope.enter(0);
this.expect(5);
super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);
this.scope.exit();
return this.finishNode(node, "TSModuleBlock");
}
tsParseModuleOrNamespaceDeclaration(node, nested = false) {
node.id = this.parseIdentifier();
if (!nested) {
this.checkIdentifier(node.id, 1024);
}
if (this.eat(16)) {
const inner = this.startNode();
this.tsParseModuleOrNamespaceDeclaration(inner, true);
node.body = inner;
} else {
this.scope.enter(256);
this.prodParam.enter(PARAM);
node.body = this.tsParseModuleBlock();
this.prodParam.exit();
this.scope.exit();
}
return this.finishNode(node, "TSModuleDeclaration");
}
tsParseAmbientExternalModuleDeclaration(node) {
if (this.isContextual(112)) {
node.global = true;
node.id = this.parseIdentifier();
} else if (this.match(133)) {
node.id = super.parseStringLiteral(this.state.value);
} else {
this.unexpected();
}
if (this.match(5)) {
this.scope.enter(256);
this.prodParam.enter(PARAM);
node.body = this.tsParseModuleBlock();
this.prodParam.exit();
this.scope.exit();
} else {
this.semicolon();
}
return this.finishNode(node, "TSModuleDeclaration");
}
tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
node.isExport = isExport || false;
node.id = maybeDefaultIdentifier || this.parseIdentifier();
this.checkIdentifier(node.id, 4096);
this.expect(29);
const moduleReference = this.tsParseModuleReference();
if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
this.raise(TSErrors.ImportAliasHasImportType, {
at: moduleReference
});
}
node.moduleReference = moduleReference;
this.semicolon();
return this.finishNode(node, "TSImportEqualsDeclaration");
}
tsIsExternalModuleReference() {
return this.isContextual(119) && this.lookaheadCharCode() === 40;
}
tsParseModuleReference() {
return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
}
tsParseExternalModuleReference() {
const node = this.startNode();
this.expectContextual(119);
this.expect(10);
if (!this.match(133)) {
this.unexpected();
}
node.expression = super.parseExprAtom();
this.expect(11);
this.sawUnambiguousESM = true;
return this.finishNode(node, "TSExternalModuleReference");
}
tsLookAhead(f) {
const state = this.state.clone();
const res = f();
this.state = state;
return res;
}
tsTryParseAndCatch(f) {
const result = this.tryParse(abort => f() || abort());
if (result.aborted || !result.node) return;
if (result.error) this.state = result.failState;
return result.node;
}
tsTryParse(f) {
const state = this.state.clone();
const result = f();
if (result !== undefined && result !== false) {
return result;
}
this.state = state;
}
tsTryParseDeclare(nany) {
if (this.isLineTerminator()) {
return;
}
let startType = this.state.type;
let kind;
if (this.isContextual(100)) {
startType = 74;
kind = "let";
}
return this.tsInAmbientContext(() => {
switch (startType) {
case 68:
nany.declare = true;
return super.parseFunctionStatement(nany, false, false);
case 80:
nany.declare = true;
return this.parseClass(nany, true, false);
case 126:
return this.tsParseEnumDeclaration(nany, {
declare: true
});
case 112:
return this.tsParseAmbientExternalModuleDeclaration(nany);
case 75:
case 74:
if (!this.match(75) || !this.isLookaheadContextual("enum")) {
nany.declare = true;
return this.parseVarStatement(nany, kind || this.state.value, true);
}
this.expect(75);
return this.tsParseEnumDeclaration(nany, {
const: true,
declare: true
});
case 129:
{
const result = this.tsParseInterfaceDeclaration(nany, {
declare: true
});
if (result) return result;
}
default:
if (tokenIsIdentifier(startType)) {
return this.tsParseDeclaration(nany, this.state.value, true, null);
}
}
});
}
tsTryParseExportDeclaration() {
return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
}
tsParseExpressionStatement(node, expr, decorators) {
switch (expr.name) {
case "declare":
{
const declaration = this.tsTryParseDeclare(node);
if (declaration) {
declaration.declare = true;
}
return declaration;
}
case "global":
if (this.match(5)) {
this.scope.enter(256);
this.prodParam.enter(PARAM);
const mod = node;
mod.global = true;
mod.id = expr;
mod.body = this.tsParseModuleBlock();
this.scope.exit();
this.prodParam.exit();
return this.finishNode(mod, "TSModuleDeclaration");
}
break;
default:
return this.tsParseDeclaration(node, expr.name, false, decorators);
}
}
tsParseDeclaration(node, value, next, decorators) {
switch (value) {
case "abstract":
if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
return this.tsParseAbstractDeclaration(node, decorators);
}
break;
case "module":
if (this.tsCheckLineTerminator(next)) {
if (this.match(133)) {
return this.tsParseAmbientExternalModuleDeclaration(node);
} else if (tokenIsIdentifier(this.state.type)) {
return this.tsParseModuleOrNamespaceDeclaration(node);
}
}
break;
case "namespace":
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
return this.tsParseModuleOrNamespaceDeclaration(node);
}
break;
case "type":
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
return this.tsParseTypeAliasDeclaration(node);
}
break;
}
}
tsCheckLineTerminator(next) {
if (next) {
if (this.hasFollowingLineBreak()) return false;
this.next();
return true;
}
return !this.isLineTerminator();
}
tsTryParseGenericAsyncArrowFunction(startLoc) {
if (!this.match(47)) return;
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
this.state.maybeInArrowParameters = true;
const res = this.tsTryParseAndCatch(() => {
const node = this.startNodeAt(startLoc);
node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
super.parseFunctionParams(node);
node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
this.expect(19);
return node;
});
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
if (!res) return;
return super.parseArrowExpression(res, null, true);
}
tsParseTypeArgumentsInExpression() {
if (this.reScan_lt() !== 47) return;
return this.tsParseTypeArguments();
}
tsParseTypeArguments() {
const node = this.startNode();
node.params = this.tsInType(() => this.tsInNoContext(() => {
this.expect(47);
return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
}));
if (node.params.length === 0) {
this.raise(TSErrors.EmptyTypeArguments, {
at: node
});
} else if (!this.state.inType && this.curContext() === types.brace) {
this.reScan_lt_gt();
}
this.expect(48);
return this.finishNode(node, "TSTypeParameterInstantiation");
}
tsIsDeclarationStart() {
return tokenIsTSDeclarationStart(this.state.type);
}
isExportDefaultSpecifier() {
if (this.tsIsDeclarationStart()) return false;
return super.isExportDefaultSpecifier();
}
parseAssignableListItem(flags, decorators) {
const startLoc = this.state.startLoc;
const modified = {};
this.tsParseModifiers({
allowedModifiers: ["public", "private", "protected", "override", "readonly"]
}, modified);
const accessibility = modified.accessibility;
const override = modified.override;
const readonly = modified.readonly;
if (!(flags & 4) && (accessibility || readonly || override)) {
this.raise(TSErrors.UnexpectedParameterModifier, {
at: startLoc
});
}
const left = this.parseMaybeDefault();
this.parseAssignableListItemTypes(left, flags);
const elt = this.parseMaybeDefault(left.loc.start, left);
if (accessibility || readonly || override) {
const pp = this.startNodeAt(startLoc);
if (decorators.length) {
pp.decorators = decorators;
}
if (accessibility) pp.accessibility = accessibility;
if (readonly) pp.readonly = readonly;
if (override) pp.override = override;
if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
this.raise(TSErrors.UnsupportedParameterPropertyKind, {
at: pp
});
}
pp.parameter = elt;
return this.finishNode(pp, "TSParameterProperty");
}
if (decorators.length) {
left.decorators = decorators;
}
return elt;
}
isSimpleParameter(node) {
return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
}
tsDisallowOptionalPattern(node) {
for (const param of node.params) {
if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
this.raise(TSErrors.PatternIsOptional, {
at: param
});
}
}
}
setArrowFunctionParameters(node, params, trailingCommaLoc) {
super.setArrowFunctionParameters(node, params, trailingCommaLoc);
this.tsDisallowOptionalPattern(node);
}
parseFunctionBodyAndFinish(node, type, isMethod = false) {
if (this.match(14)) {
node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
}
const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined;
if (bodilessType && !this.match(5) && this.isLineTerminator()) {
return this.finishNode(node, bodilessType);
}
if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
this.raise(TSErrors.DeclareFunctionHasImplementation, {
at: node
});
if (node.declare) {
return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
}
}
this.tsDisallowOptionalPattern(node);
return super.parseFunctionBodyAndFinish(node, type, isMethod);
}
registerFunctionStatementId(node) {
if (!node.body && node.id) {
this.checkIdentifier(node.id, 1024);
} else {
super.registerFunctionStatementId(node);
}
}
tsCheckForInvalidTypeCasts(items) {
items.forEach(node => {
if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
this.raise(TSErrors.UnexpectedTypeAnnotation, {
at: node.typeAnnotation
});
}
});
}
toReferencedList(exprList, isInParens) {
this.tsCheckForInvalidTypeCasts(exprList);
return exprList;
}
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
if (node.type === "ArrayExpression") {
this.tsCheckForInvalidTypeCasts(node.elements);
}
return node;
}
parseSubscript(base, startLoc, noCalls, state) {
if (!this.hasPrecedingLineBreak() && this.match(35)) {
this.state.canStartJSXElement = false;
this.next();
const nonNullExpression = this.startNodeAt(startLoc);
nonNullExpression.expression = base;
return this.finishNode(nonNullExpression, "TSNonNullExpression");
}
let isOptionalCall = false;
if (this.match(18) && this.lookaheadCharCode() === 60) {
if (noCalls) {
state.stop = true;
return base;
}
state.optionalChainMember = isOptionalCall = true;
this.next();
}
if (this.match(47) || this.match(51)) {
let missingParenErrorLoc;
const result = this.tsTryParseAndCatch(() => {
if (!noCalls && this.atPossibleAsyncArrow(base)) {
const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
if (asyncArrowFn) {
return asyncArrowFn;
}
}
const typeArguments = this.tsParseTypeArgumentsInExpression();
if (!typeArguments) return;
if (isOptionalCall && !this.match(10)) {
missingParenErrorLoc = this.state.curPosition();
return;
}
if (tokenIsTemplate(this.state.type)) {
const result = super.parseTaggedTemplateExpression(base, startLoc, state);
result.typeParameters = typeArguments;
return result;
}
if (!noCalls && this.eat(10)) {
const node = this.startNodeAt(startLoc);
node.callee = base;
node.arguments = this.parseCallExpressionArguments(11, false);
this.tsCheckForInvalidTypeCasts(node.arguments);
node.typeParameters = typeArguments;
if (state.optionalChainMember) {
node.optional = isOptionalCall;
}
return this.finishCallExpression(node, state.optionalChainMember);
}
const tokenType = this.state.type;
if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
return;
}
const node = this.startNodeAt(startLoc);
node.expression = base;
node.typeParameters = typeArguments;
return this.finishNode(node, "TSInstantiationExpression");
});
if (missingParenErrorLoc) {
this.unexpected(missingParenErrorLoc, 10);
}
if (result) {
if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
at: this.state.startLoc
});
}
return result;
}
}
return super.parseSubscript(base, startLoc, noCalls, state);
}
parseNewCallee(node) {
var _callee$extra;
super.parseNewCallee(node);
const {
callee
} = node;
if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
node.typeParameters = callee.typeParameters;
node.callee = callee.expression;
}
}
parseExprOp(left, leftStartLoc, minPrec) {
let isSatisfies;
if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {
const node = this.startNodeAt(leftStartLoc);
node.expression = left;
node.typeAnnotation = this.tsInType(() => {
this.next();
if (this.match(75)) {
if (isSatisfies) {
this.raise(Errors.UnexpectedKeyword, {
at: this.state.startLoc,
keyword: "const"
});
}
return this.tsParseTypeReference();
}
return this.tsParseType();
});
this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
this.reScan_lt_gt();
return this.parseExprOp(node, leftStartLoc, minPrec);
}
return super.parseExprOp(left, leftStartLoc, minPrec);
}
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
if (!this.state.isAmbientContext) {
super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
}
}
checkImportReflection(node) {
super.checkImportReflection(node);
if (node.module && node.importKind !== "value") {
this.raise(TSErrors.ImportReflectionHasImportType, {
at: node.specifiers[0].loc.start
});
}
}
checkDuplicateExports() {}
isPotentialImportPhase(isExport) {
if (super.isPotentialImportPhase(isExport)) return true;
if (this.isContextual(130)) {
const ch = this.lookaheadCharCode();
return isExport ? ch === 123 || ch === 42 : ch !== 61;
}
return !isExport && this.isContextual(87);
}
applyImportPhase(node, isExport, phase, loc) {
super.applyImportPhase(node, isExport, phase, loc);
if (isExport) {
node.exportKind = phase === "type" ? "type" : "value";
} else {
node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
}
}
parseImport(node) {
if (this.match(133)) {
node.importKind = "value";
return super.parseImport(node);
}
let importNode;
if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
node.importKind = "value";
return this.tsParseImportEqualsDeclaration(node);
} else if (this.isContextual(130)) {
const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
if (this.lookaheadCharCode() === 61) {
return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
} else {
importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
}
} else {
importNode = super.parseImport(node);
}
if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
at: importNode
});
}
return importNode;
}
parseExport(node, decorators) {
if (this.match(83)) {
this.next();
let maybeDefaultIdentifier = null;
if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
} else {
node.importKind = "value";
}
return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, true);
} else if (this.eat(29)) {
const assign = node;
assign.expression = super.parseExpression();
this.semicolon();
this.sawUnambiguousESM = true;
return this.finishNode(assign, "TSExportAssignment");
} else if (this.eatContextual(93)) {
const decl = node;
this.expectContextual(128);
decl.id = this.parseIdentifier();
this.semicolon();
return this.finishNode(decl, "TSNamespaceExportDeclaration");
} else {
return super.parseExport(node, decorators);
}
}
isAbstractClass() {
return this.isContextual(124) && this.lookahead().type === 80;
}
parseExportDefaultExpression() {
if (this.isAbstractClass()) {
const cls = this.startNode();
this.next();
cls.abstract = true;
return this.parseClass(cls, true, true);
}
if (this.match(129)) {
const result = this.tsParseInterfaceDeclaration(this.startNode());
if (result) return result;
}
return super.parseExportDefaultExpression();
}
parseVarStatement(node, kind, allowMissingInitializer = false) {
const {
isAmbientContext
} = this.state;
const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
if (!isAmbientContext) return declaration;
for (const {
id,
init
} of declaration.declarations) {
if (!init) continue;
if (kind !== "const" || !!id.typeAnnotation) {
this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
at: init
});
} else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
at: init
});
}
}
return declaration;
}
parseStatementContent(flags, decorators) {
if (this.match(75) && this.isLookaheadContextual("enum")) {
const node = this.startNode();
this.expect(75);
return this.tsParseEnumDeclaration(node, {
const: true
});
}
if (this.isContextual(126)) {
return this.tsParseEnumDeclaration(this.startNode());
}
if (this.isContextual(129)) {
const result = this.tsParseInterfaceDeclaration(this.startNode());
if (result) return result;
}
return super.parseStatementContent(flags, decorators);
}
parseAccessModifier() {
return this.tsParseModifier(["public", "protected", "private"]);
}
tsHasSomeModifiers(member, modifiers) {
return modifiers.some(modifier => {
if (tsIsAccessModifier(modifier)) {
return member.accessibility === modifier;
}
return !!member[modifier];
});
}
tsIsStartOfStaticBlocks() {
return this.isContextual(106) && this.lookaheadCharCode() === 123;
}
parseClassMember(classBody, member, state) {
const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
this.tsParseModifiers({
allowedModifiers: modifiers,
disallowedModifiers: ["in", "out"],
stopOnStartOfClassStaticBlock: true,
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
}, member);
const callParseClassMemberWithIsStatic = () => {
if (this.tsIsStartOfStaticBlocks()) {
this.next();
this.next();
if (this.tsHasSomeModifiers(member, modifiers)) {
this.raise(TSErrors.StaticBlockCannotHaveModifier, {
at: this.state.curPosition()
});
}
super.parseClassStaticBlock(classBody, member);
} else {
this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
}
};
if (member.declare) {
this.tsInAmbientContext(callParseClassMemberWithIsStatic);
} else {
callParseClassMemberWithIsStatic();
}
}
parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
const idx = this.tsTryParseIndexSignature(member);
if (idx) {
classBody.body.push(idx);
if (member.abstract) {
this.raise(TSErrors.IndexSignatureHasAbstract, {
at: member
});
}
if (member.accessibility) {
this.raise(TSErrors.IndexSignatureHasAccessibility, {
at: member,
modifier: member.accessibility
});
}
if (member.declare) {
this.raise(TSErrors.IndexSignatureHasDeclare, {
at: member
});
}
if (member.override) {
this.raise(TSErrors.IndexSignatureHasOverride, {
at: member
});
}
return;
}
if (!this.state.inAbstractClass && member.abstract) {
this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
at: member
});
}
if (member.override) {
if (!state.hadSuperClass) {
this.raise(TSErrors.OverrideNotInSubClass, {
at: member
});
}
}
super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
}
parsePostMemberNameModifiers(methodOrProp) {
const optional = this.eat(17);
if (optional) methodOrProp.optional = true;
if (methodOrProp.readonly && this.match(10)) {
this.raise(TSErrors.ClassMethodHasReadonly, {
at: methodOrProp
});
}
if (methodOrProp.declare && this.match(10)) {
this.raise(TSErrors.ClassMethodHasDeclare, {
at: methodOrProp
});
}
}
parseExpressionStatement(node, expr, decorators) {
const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
return decl || super.parseExpressionStatement(node, expr, decorators);
}
shouldParseExportDeclaration() {
if (this.tsIsDeclarationStart()) return true;
return super.shouldParseExportDeclaration();
}
parseConditional(expr, startLoc, refExpressionErrors) {
if (!this.state.maybeInArrowParameters || !this.match(17)) {
return super.parseConditional(expr, startLoc, refExpressionErrors);
}
const result = this.tryParse(() => super.parseConditional(expr, startLoc));
if (!result.node) {
if (result.error) {
super.setOptionalParametersError(refExpressionErrors, result.error);
}
return expr;
}
if (result.error) this.state = result.failState;
return result.node;
}
parseParenItem(node, startLoc) {
node = super.parseParenItem(node, startLoc);
if (this.eat(17)) {
node.optional = true;
this.resetEndLocation(node);
}
if (this.match(14)) {
const typeCastNode = this.startNodeAt(startLoc);
typeCastNode.expression = node;
typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
return this.finishNode(typeCastNode, "TSTypeCastExpression");
}
return node;
}
parseExportDeclaration(node) {
if (!this.state.isAmbientContext && this.isContextual(125)) {
return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
}
const startLoc = this.state.startLoc;
const isDeclare = this.eatContextual(125);
if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) {
throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
at: this.state.startLoc
});
}
const isIdentifier = tokenIsIdentifier(this.state.type);
const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
if (!declaration) return null;
if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
node.exportKind = "type";
}
if (isDeclare) {
this.resetStartLocation(declaration, startLoc);
declaration.declare = true;
}
return declaration;
}
parseClassId(node, isStatement, optionalId, bindingType) {
if ((!isStatement || optionalId) && this.isContextual(113)) {
return;
}
super.parseClassId(node, isStatement, optionalId, node.declare ? 1024 : 8331);
const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
if (typeParameters) node.typeParameters = typeParameters;
}
parseClassPropertyAnnotation(node) {
if (!node.optional) {
if (this.eat(35)) {
node.definite = true;
} else if (this.eat(17)) {
node.optional = true;
}
}
const type = this.tsTryParseTypeAnnotation();
if (type) node.typeAnnotation = type;
}
parseClassProperty(node) {
this.parseClassPropertyAnnotation(node);
if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
this.raise(TSErrors.DeclareClassFieldHasInitializer, {
at: this.state.startLoc
});
}
if (node.abstract && this.match(29)) {
const {
key
} = node;
this.raise(TSErrors.AbstractPropertyHasInitializer, {
at: this.state.startLoc,
propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
});
}
return super.parseClassProperty(node);
}
parseClassPrivateProperty(node) {
if (node.abstract) {
this.raise(TSErrors.PrivateElementHasAbstract, {
at: node
});
}
if (node.accessibility) {
this.raise(TSErrors.PrivateElementHasAccessibility, {
at: node,
modifier: node.accessibility
});
}
this.parseClassPropertyAnnotation(node);
return super.parseClassPrivateProperty(node);
}
parseClassAccessorProperty(node) {
this.parseClassPropertyAnnotation(node);
if (node.optional) {
this.raise(TSErrors.AccessorCannotBeOptional, {
at: node
});
}
return super.parseClassAccessorProperty(node);
}
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
if (typeParameters && isConstructor) {
this.raise(TSErrors.ConstructorHasTypeParameters, {
at: typeParameters
});
}
const {
declare = false,
kind
} = method;
if (declare && (kind === "get" || kind === "set")) {
this.raise(TSErrors.DeclareAccessor, {
at: method,
kind
});
}
if (typeParameters) method.typeParameters = typeParameters;
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
}
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
if (typeParameters) method.typeParameters = typeParameters;
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
}
declareClassPrivateMethodInScope(node, kind) {
if (node.type === "TSDeclareMethod") return;
if (node.type === "MethodDefinition" && !node.value.body) return;
super.declareClassPrivateMethodInScope(node, kind);
}
parseClassSuper(node) {
super.parseClassSuper(node);
if (node.superClass && (this.match(47) || this.match(51))) {
node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
}
if (this.eatContextual(113)) {
node.implements = this.tsParseHeritageClause("implements");
}
}
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
if (typeParameters) prop.typeParameters = typeParameters;
return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
}
parseFunctionParams(node, isConstructor) {
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
if (typeParameters) node.typeParameters = typeParameters;
super.parseFunctionParams(node, isConstructor);
}
parseVarId(decl, kind) {
super.parseVarId(decl, kind);
if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
decl.definite = true;
}
const type = this.tsTryParseTypeAnnotation();
if (type) {
decl.id.typeAnnotation = type;
this.resetEndLocation(decl.id);
}
}
parseAsyncArrowFromCallExpression(node, call) {
if (this.match(14)) {
node.returnType = this.tsParseTypeAnnotation();
}
return super.parseAsyncArrowFromCallExpression(node, call);
}
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;
let state;
let jsx;
let typeCast;
if (this.hasPlugin("jsx") && (this.match(142) || this.match(47))) {
state = this.state.clone();
jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
if (!jsx.error) return jsx.node;
const {
context
} = this.state;
const currentContext = context[context.length - 1];
if (currentContext === types.j_oTag || currentContext === types.j_expr) {
context.pop();
}
}
if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
}
if (!state || state === this.state) state = this.state.clone();
let typeParameters;
const arrow = this.tryParse(abort => {
var _expr$extra, _typeParameters;
typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
abort();
}
if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
this.resetStartLocationFromNode(expr, typeParameters);
}
expr.typeParameters = typeParameters;
return expr;
}, state);
if (!arrow.error && !arrow.aborted) {
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
return arrow.node;
}
if (!jsx) {
assert(!this.hasPlugin("jsx"));
typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
if (!typeCast.error) return typeCast.node;
}
if ((_jsx2 = jsx) != null && _jsx2.node) {
this.state = jsx.failState;
return jsx.node;
}
if (arrow.node) {
this.state = arrow.failState;
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
return arrow.node;
}
if ((_typeCast = typeCast) != null && _typeCast.node) {
this.state = typeCast.failState;
return typeCast.node;
}
throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
}
reportReservedArrowTypeParam(node) {
var _node$extra;
if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
this.raise(TSErrors.ReservedArrowTypeParam, {
at: node
});
}
}
parseMaybeUnary(refExpressionErrors, sawUnary) {
if (!this.hasPlugin("jsx") && this.match(47)) {
return this.tsParseTypeAssertion();
}
return super.parseMaybeUnary(refExpressionErrors, sawUnary);
}
parseArrow(node) {
if (this.match(14)) {
const result = this.tryParse(abort => {
const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
if (this.canInsertSemicolon() || !this.match(19)) abort();
return returnType;
});
if (result.aborted) return;
if (!result.thrown) {
if (result.error) this.state = result.failState;
node.returnType = result.node;
}
}
return super.parseArrow(node);
}
parseAssignableListItemTypes(param, flags) {
if (!(flags & 2)) return param;
if (this.eat(17)) {
param.optional = true;
}
const type = this.tsTryParseTypeAnnotation();
if (type) param.typeAnnotation = type;
this.resetEndLocation(param);
return param;
}
isAssignable(node, isBinding) {
switch (node.type) {
case "TSTypeCastExpression":
return this.isAssignable(node.expression, isBinding);
case "TSParameterProperty":
return true;
default:
return super.isAssignable(node, isBinding);
}
}
toAssignable(node, isLHS = false) {
switch (node.type) {
case "ParenthesizedExpression":
this.toAssignableParenthesizedExpression(node, isLHS);
break;
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSNonNullExpression":
case "TSTypeAssertion":
if (isLHS) {
this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
at: node
});
} else {
this.raise(TSErrors.UnexpectedTypeCastInParameter, {
at: node
});
}
this.toAssignable(node.expression, isLHS);
break;
case "AssignmentExpression":
if (!isLHS && node.left.type === "TSTypeCastExpression") {
node.left = this.typeCastToParameter(node.left);
}
default:
super.toAssignable(node, isLHS);
}
}
toAssignableParenthesizedExpression(node, isLHS) {
switch (node.expression.type) {
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSNonNullExpression":
case "TSTypeAssertion":
case "ParenthesizedExpression":
this.toAssignable(node.expression, isLHS);
break;
default:
super.toAssignable(node, isLHS);
}
}
checkToRestConversion(node, allowPattern) {
switch (node.type) {
case "TSAsExpression":
case "TSSatisfiesExpression":
case "TSTypeAssertion":
case "TSNonNullExpression":
this.checkToRestConversion(node.expression, false);
break;
default:
super.checkToRestConversion(node, allowPattern);
}
}
isValidLVal(type, isUnparenthesizedInAssign, binding) {
return getOwn({
TSTypeCastExpression: true,
TSParameterProperty: "parameter",
TSNonNullExpression: "expression",
TSAsExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true],
TSSatisfiesExpression: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true],
TSTypeAssertion: (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true]
}, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
}
parseBindingAtom() {
if (this.state.type === 78) {
return this.parseIdentifier(true);
}
return super.parseBindingAtom();
}
parseMaybeDecoratorArguments(expr) {
if (this.match(47) || this.match(51)) {
const typeArguments = this.tsParseTypeArgumentsInExpression();
if (this.match(10)) {
const call = super.parseMaybeDecoratorArguments(expr);
call.typeParameters = typeArguments;
return call;
}
this.unexpected(null, 10);
}
return super.parseMaybeDecoratorArguments(expr);
}
checkCommaAfterRest(close) {
if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
this.next();
return false;
}
return super.checkCommaAfterRest(close);
}
isClassMethod() {
return this.match(47) || super.isClassMethod();
}
isClassProperty() {
return this.match(35) || this.match(14) || super.isClassProperty();
}
parseMaybeDefault(startLoc, left) {
const node = super.parseMaybeDefault(startLoc, left);
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
this.raise(TSErrors.TypeAnnotationAfterAssign, {
at: node.typeAnnotation
});
}
return node;
}
getTokenFromCode(code) {
if (this.state.inType) {
if (code === 62) {
this.finishOp(48, 1);
return;
}
if (code === 60) {
this.finishOp(47, 1);
return;
}
}
super.getTokenFromCode(code);
}
reScan_lt_gt() {
const {
type
} = this.state;
if (type === 47) {
this.state.pos -= 1;
this.readToken_lt();
} else if (type === 48) {
this.state.pos -= 1;
this.readToken_gt();
}
}
reScan_lt() {
const {
type
} = this.state;
if (type === 51) {
this.state.pos -= 2;
this.finishOp(47, 1);
return 47;
}
return type;
}
toAssignableList(exprList, trailingCommaLoc, isLHS) {
for (let i = 0; i < exprList.length; i++) {
const expr = exprList[i];
if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
exprList[i] = this.typeCastToParameter(expr);
}
}
super.toAssignableList(exprList, trailingCommaLoc, isLHS);
}
typeCastToParameter(node) {
node.expression.typeAnnotation = node.typeAnnotation;
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
return node.expression;
}
shouldParseArrow(params) {
if (this.match(14)) {
return params.every(expr => this.isAssignable(expr, true));
}
return super.shouldParseArrow(params);
}
shouldParseAsyncArrow() {
return this.match(14) || super.shouldParseAsyncArrow();
}
canHaveLeadingDecorator() {
return super.canHaveLeadingDecorator() || this.isAbstractClass();
}
jsxParseOpeningElementAfterName(node) {
if (this.match(47) || this.match(51)) {
const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
if (typeArguments) node.typeParameters = typeArguments;
}
return super.jsxParseOpeningElementAfterName(node);
}
getGetterSetterExpectedParamCount(method) {
const baseCount = super.getGetterSetterExpectedParamCount(method);
const params = this.getObjectOrClassMethodParams(method);
const firstParam = params[0];
const hasContextParam = firstParam && this.isThisParam(firstParam);
return hasContextParam ? baseCount + 1 : baseCount;
}
parseCatchClauseParam() {
const param = super.parseCatchClauseParam();
const type = this.tsTryParseTypeAnnotation();
if (type) {
param.typeAnnotation = type;
this.resetEndLocation(param);
}
return param;
}
tsInAmbientContext(cb) {
const oldIsAmbientContext = this.state.isAmbientContext;
this.state.isAmbientContext = true;
try {
return cb();
} finally {
this.state.isAmbientContext = oldIsAmbientContext;
}
}
parseClass(node, isStatement, optionalId) {
const oldInAbstractClass = this.state.inAbstractClass;
this.state.inAbstractClass = !!node.abstract;
try {
return super.parseClass(node, isStatement, optionalId);
} finally {
this.state.inAbstractClass = oldInAbstractClass;
}
}
tsParseAbstractDeclaration(node, decorators) {
if (this.match(80)) {
node.abstract = true;
return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
} else if (this.isContextual(129)) {
if (!this.hasFollowingLineBreak()) {
node.abstract = true;
this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
at: node
});
return this.tsParseInterfaceDeclaration(node);
}
} else {
this.unexpected(null, 80);
}
}
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
if (method.abstract) {
const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
if (hasBody) {
const {
key
} = method;
this.raise(TSErrors.AbstractMethodHasImplementation, {
at: method,
methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
});
}
}
return method;
}
tsParseTypeParameterName() {
const typeName = this.parseIdentifier();
return typeName.name;
}
shouldParseAsAmbientContext() {
return !!this.getPluginOption("typescript", "dts");
}
parse() {
if (this.shouldParseAsAmbientContext()) {
this.state.isAmbientContext = true;
}
return super.parse();
}
getExpression() {
if (this.shouldParseAsAmbientContext()) {
this.state.isAmbientContext = true;
}
return super.getExpression();
}
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
if (!isString && isMaybeTypeOnly) {
this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
return this.finishNode(node, "ExportSpecifier");
}
node.exportKind = "value";
return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
}
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
if (!importedIsString && isMaybeTypeOnly) {
this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
return this.finishNode(specifier, "ImportSpecifier");
}
specifier.importKind = "value";
return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);
}
parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
const leftOfAsKey = isImport ? "imported" : "local";
const rightOfAsKey = isImport ? "local" : "exported";
let leftOfAs = node[leftOfAsKey];
let rightOfAs;
let hasTypeSpecifier = false;
let canParseAsKeyword = true;
const loc = leftOfAs.loc.start;
if (this.isContextual(93)) {
const firstAs = this.parseIdentifier();
if (this.isContextual(93)) {
const secondAs = this.parseIdentifier();
if (tokenIsKeywordOrIdentifier(this.state.type)) {
hasTypeSpecifier = true;
leftOfAs = firstAs;
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
canParseAsKeyword = false;
} else {
rightOfAs = secondAs;
canParseAsKeyword = false;
}
} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
canParseAsKeyword = false;
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
} else {
hasTypeSpecifier = true;
leftOfAs = firstAs;
}
} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
hasTypeSpecifier = true;
if (isImport) {
leftOfAs = this.parseIdentifier(true);
if (!this.isContextual(93)) {
this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
}
} else {
leftOfAs = this.parseModuleExportName();
}
}
if (hasTypeSpecifier && isInTypeOnlyImportExport) {
this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
at: loc
});
}
node[leftOfAsKey] = leftOfAs;
node[rightOfAsKey] = rightOfAs;
const kindKey = isImport ? "importKind" : "exportKind";
node[kindKey] = hasTypeSpecifier ? "type" : "value";
if (canParseAsKeyword && this.eatContextual(93)) {
node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
}
if (!node[rightOfAsKey]) {
node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
}
if (isImport) {
this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096);
}
}
};
function isPossiblyLiteralEnum(expression) {
if (expression.type !== "MemberExpression") return false;
const {
computed,
property
} = expression;
if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
return false;
}
return isUncomputedMemberExpressionChain(expression.object);
}
function isValidAmbientConstInitializer(expression, estree) {
var _expression$extra;
const {
type
} = expression;
if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
return false;
}
if (estree) {
if (type === "Literal") {
const {
value
} = expression;
if (typeof value === "string" || typeof value === "boolean") {
return true;
}
}
} else {
if (type === "StringLiteral" || type === "BooleanLiteral") {
return true;
}
}
if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) {
return true;
}
if (type === "TemplateLiteral" && expression.expressions.length === 0) {
return true;
}
if (isPossiblyLiteralEnum(expression)) {
return true;
}
return false;
}
function isNumber(expression, estree) {
if (estree) {
return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
}
return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
}
function isNegativeNumber(expression, estree) {
if (expression.type === "UnaryExpression") {
const {
operator,
argument
} = expression;
if (operator === "-" && isNumber(argument, estree)) {
return true;
}
}
return false;
}
function isUncomputedMemberExpressionChain(expression) {
if (expression.type === "Identifier") return true;
if (expression.type !== "MemberExpression" || expression.computed) {
return false;
}
return isUncomputedMemberExpressionChain(expression.object);
}
const PlaceholderErrors = ParseErrorEnum`placeholders`({
ClassNameIsRequired: "A class name is required.",
UnexpectedSpace: "Unexpected space in placeholder."
});
var placeholders = superClass => class PlaceholdersParserMixin extends superClass {
parsePlaceholder(expectedNode) {
if (this.match(144)) {
const node = this.startNode();
this.next();
this.assertNoSpace();
node.name = super.parseIdentifier(true);
this.assertNoSpace();
this.expect(144);
return this.finishPlaceholder(node, expectedNode);
}
}
finishPlaceholder(node, expectedNode) {
const isFinished = !!(node.expectedNode && node.type === "Placeholder");
node.expectedNode = expectedNode;
return isFinished ? node : this.finishNode(node, "Placeholder");
}
getTokenFromCode(code) {
if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
this.finishOp(144, 2);
} else {
super.getTokenFromCode(code);
}
}
parseExprAtom(refExpressionErrors) {
return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
}
parseIdentifier(liberal) {
return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
}
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
if (word !== undefined) {
super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
}
}
parseBindingAtom() {
return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
}
isValidLVal(type, isParenthesized, binding) {
return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
}
toAssignable(node, isLHS) {
if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
node.expectedNode = "Pattern";
} else {
super.toAssignable(node, isLHS);
}
}
chStartsBindingIdentifier(ch, pos) {
if (super.chStartsBindingIdentifier(ch, pos)) {
return true;
}
const nextToken = this.lookahead();
if (nextToken.type === 144) {
return true;
}
return false;
}
verifyBreakContinue(node, isBreak) {
if (node.label && node.label.type === "Placeholder") return;
super.verifyBreakContinue(node, isBreak);
}
parseExpressionStatement(node, expr) {
var _expr$extra;
if (expr.type !== "Placeholder" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
return super.parseExpressionStatement(node, expr);
}
if (this.match(14)) {
const stmt = node;
stmt.label = this.finishPlaceholder(expr, "Identifier");
this.next();
stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
return this.finishNode(stmt, "LabeledStatement");
}
this.semicolon();
node.name = expr.name;
return this.finishPlaceholder(node, "Statement");
}
parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
}
parseFunctionId(requireId) {
return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
}
parseClass(node, isStatement, optionalId) {
const type = isStatement ? "ClassDeclaration" : "ClassExpression";
this.next();
const oldStrict = this.state.strict;
const placeholder = this.parsePlaceholder("Identifier");
if (placeholder) {
if (this.match(81) || this.match(144) || this.match(5)) {
node.id = placeholder;
} else if (optionalId || !isStatement) {
node.id = null;
node.body = this.finishPlaceholder(placeholder, "ClassBody");
return this.finishNode(node, type);
} else {
throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
at: this.state.startLoc
});
}
} else {
this.parseClassId(node, isStatement, optionalId);
}
super.parseClassSuper(node);
node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
return this.finishNode(node, type);
}
parseExport(node, decorators) {
const placeholder = this.parsePlaceholder("Identifier");
if (!placeholder) return super.parseExport(node, decorators);
if (!this.isContextual(98) && !this.match(12)) {
node.specifiers = [];
node.source = null;
node.declaration = this.finishPlaceholder(placeholder, "Declaration");
return this.finishNode(node, "ExportNamedDeclaration");
}
this.expectPlugin("exportDefaultFrom");
const specifier = this.startNode();
specifier.exported = placeholder;
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
return super.parseExport(node, decorators);
}
isExportDefaultSpecifier() {
if (this.match(65)) {
const next = this.nextTokenStart();
if (this.isUnparsedContextual(next, "from")) {
if (this.input.startsWith(tokenLabelName(144), this.nextTokenStartSince(next + 4))) {
return true;
}
}
}
return super.isExportDefaultSpecifier();
}
maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
var _specifiers;
if ((_specifiers = node.specifiers) != null && _specifiers.length) {
return true;
}
return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
}
checkExport(node) {
const {
specifiers
} = node;
if (specifiers != null && specifiers.length) {
node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
}
super.checkExport(node);
node.specifiers = specifiers;
}
parseImport(node) {
const placeholder = this.parsePlaceholder("Identifier");
if (!placeholder) return super.parseImport(node);
node.specifiers = [];
if (!this.isContextual(98) && !this.match(12)) {
node.source = this.finishPlaceholder(placeholder, "StringLiteral");
this.semicolon();
return this.finishNode(node, "ImportDeclaration");
}
const specifier = this.startNodeAtNode(placeholder);
specifier.local = placeholder;
node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
if (this.eat(12)) {
const hasStarImport = this.maybeParseStarImportSpecifier(node);
if (!hasStarImport) this.parseNamedImportSpecifiers(node);
}
this.expectContextual(98);
node.source = this.parseImportSource();
this.semicolon();
return this.finishNode(node, "ImportDeclaration");
}
parseImportSource() {
return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
}
assertNoSpace() {
if (this.state.start > this.state.lastTokEndLoc.index) {
this.raise(PlaceholderErrors.UnexpectedSpace, {
at: this.state.lastTokEndLoc
});
}
}
};
var v8intrinsic = superClass => class V8IntrinsicMixin extends superClass {
parseV8Intrinsic() {
if (this.match(54)) {
const v8IntrinsicStartLoc = this.state.startLoc;
const node = this.startNode();
this.next();
if (tokenIsIdentifier(this.state.type)) {
const name = this.parseIdentifierName();
const identifier = this.createIdentifier(node, name);
identifier.type = "V8IntrinsicIdentifier";
if (this.match(10)) {
return identifier;
}
}
this.unexpected(v8IntrinsicStartLoc);
}
}
parseExprAtom(refExpressionErrors) {
return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
}
};
function hasPlugin(plugins, expectedConfig) {
const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
const expectedKeys = Object.keys(expectedOptions);
const expectedOptionsIsEmpty = expectedKeys.length === 0;
return plugins.some(p => {
if (typeof p === "string") {
return expectedOptionsIsEmpty && p === expectedName;
} else {
const [pluginName, pluginOptions] = p;
if (pluginName !== expectedName) {
return false;
}
for (const key of expectedKeys) {
if (pluginOptions[key] !== expectedOptions[key]) {
return false;
}
}
return true;
}
});
}
function getPluginOption(plugins, name, option) {
const plugin = plugins.find(plugin => {
if (Array.isArray(plugin)) {
return plugin[0] === name;
} else {
return plugin === name;
}
});
if (plugin && Array.isArray(plugin) && plugin.length > 1) {
return plugin[1][option];
}
return null;
}
const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
function validatePlugins(plugins) {
if (hasPlugin(plugins, "decorators")) {
if (hasPlugin(plugins, "decorators-legacy")) {
throw new Error("Cannot use the decorators and decorators-legacy plugin together");
}
const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
}
const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
throw new Error("'allowCallParenthesized' must be a boolean.");
}
}
if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
throw new Error("Cannot combine flow and typescript plugins.");
}
if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
}
if (hasPlugin(plugins, "pipelineOperator")) {
const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
if (!PIPELINE_PROPOSALS.includes(proposal)) {
const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
}
const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
syntaxType: "hash"
}]);
if (proposal === "hack") {
if (hasPlugin(plugins, "placeholders")) {
throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
}
if (hasPlugin(plugins, "v8intrinsic")) {
throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
}
const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
if (!TOPIC_TOKENS.includes(topicToken)) {
const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", ");
throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
}
if (topicToken === "#" && tupleSyntaxIsHash) {
throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
}
} else if (proposal === "smart" && tupleSyntaxIsHash) {
throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
}
}
if (hasPlugin(plugins, "moduleAttributes")) {
{
if (hasPlugin(plugins, "importAssertions") || hasPlugin(plugins, "importAttributes")) {
throw new Error("Cannot combine importAssertions, importAttributes and moduleAttributes plugins.");
}
const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
if (moduleAttributesVersionPluginOption !== "may-2020") {
throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
}
}
}
if (hasPlugin(plugins, "importAssertions") && hasPlugin(plugins, "importAttributes")) {
throw new Error("Cannot combine importAssertions and importAttributes plugins.");
}
if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
}
if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
error.missingPlugins = "doExpressions";
throw error;
}
if (hasPlugin(plugins, "optionalChainingAssign") && getPluginOption(plugins, "optionalChainingAssign", "version") !== "2023-07") {
throw new Error("The 'optionalChainingAssign' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is '2023-07'.");
}
}
const mixinPlugins = {
estree,
jsx,
flow,
typescript,
v8intrinsic,
placeholders
};
const mixinPluginNames = Object.keys(mixinPlugins);
const defaultOptions = {
sourceType: "script",
sourceFilename: undefined,
startColumn: 0,
startLine: 1,
allowAwaitOutsideFunction: false,
allowReturnOutsideFunction: false,
allowNewTargetOutsideFunction: false,
allowImportExportEverywhere: false,
allowSuperOutsideMethod: false,
allowUndeclaredExports: false,
plugins: [],
strictMode: null,
ranges: false,
tokens: false,
createImportExpressions: false,
createParenthesizedExpressions: false,
errorRecovery: false,
attachComment: true,
annexB: true
};
function getOptions(opts) {
if (opts == null) {
return Object.assign({}, defaultOptions);
}
if (opts.annexB != null && opts.annexB !== false) {
throw new Error("The `annexB` option can only be set to `false`.");
}
const options = {};
for (const key of Object.keys(defaultOptions)) {
var _opts$key;
options[key] = (_opts$key = opts[key]) != null ? _opts$key : defaultOptions[key];
}
return options;
}
class ExpressionParser extends LValParser {
checkProto(prop, isRecord, protoRef, refExpressionErrors) {
if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
return;
}
const key = prop.key;
const name = key.type === "Identifier" ? key.name : key.value;
if (name === "__proto__") {
if (isRecord) {
this.raise(Errors.RecordNoProto, {
at: key
});
return;
}
if (protoRef.used) {
if (refExpressionErrors) {
if (refExpressionErrors.doubleProtoLoc === null) {
refExpressionErrors.doubleProtoLoc = key.loc.start;
}
} else {
this.raise(Errors.DuplicateProto, {
at: key
});
}
}
protoRef.used = true;
}
}
shouldExitDescending(expr, potentialArrowAt) {
return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt;
}
getExpression() {
this.enterInitialScopes();
this.nextToken();
const expr = this.parseExpression();
if (!this.match(139)) {
this.unexpected();
}
this.finalizeRemainingComments();
expr.comments = this.state.comments;
expr.errors = this.state.errors;
if (this.options.tokens) {
expr.tokens = this.tokens;
}
return expr;
}
parseExpression(disallowIn, refExpressionErrors) {
if (disallowIn) {
return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
}
return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
}
parseExpressionBase(refExpressionErrors) {
const startLoc = this.state.startLoc;
const expr = this.parseMaybeAssign(refExpressionErrors);
if (this.match(12)) {
const node = this.startNodeAt(startLoc);
node.expressions = [expr];
while (this.eat(12)) {
node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
}
this.toReferencedList(node.expressions);
return this.finishNode(node, "SequenceExpression");
}
return expr;
}
parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
}
parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
}
setOptionalParametersError(refExpressionErrors, resultError) {
var _resultError$loc;
refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
}
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
const startLoc = this.state.startLoc;
if (this.isContextual(108)) {
if (this.prodParam.hasYield) {
let left = this.parseYield();
if (afterLeftParse) {
left = afterLeftParse.call(this, left, startLoc);
}
return left;
}
}
let ownExpressionErrors;
if (refExpressionErrors) {
ownExpressionErrors = false;
} else {
refExpressionErrors = new ExpressionErrors();
ownExpressionErrors = true;
}
const {
type
} = this.state;
if (type === 10 || tokenIsIdentifier(type)) {
this.state.potentialArrowAt = this.state.start;
}
let left = this.parseMaybeConditional(refExpressionErrors);
if (afterLeftParse) {
left = afterLeftParse.call(this, left, startLoc);
}
if (tokenIsAssignment(this.state.type)) {
const node = this.startNodeAt(startLoc);
const operator = this.state.value;
node.operator = operator;
if (this.match(29)) {
this.toAssignable(left, true);
node.left = left;
const startIndex = startLoc.index;
if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {
refExpressionErrors.doubleProtoLoc = null;
}
if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {
refExpressionErrors.shorthandAssignLoc = null;
}
if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
this.checkDestructuringPrivate(refExpressionErrors);
refExpressionErrors.privateKeyLoc = null;
}
} else {
node.left = left;
}
this.next();
node.right = this.parseMaybeAssign();
this.checkLVal(left, {
in: this.finishNode(node, "AssignmentExpression")
});
return node;
} else if (ownExpressionErrors) {
this.checkExpressionErrors(refExpressionErrors, true);
}
return left;
}
parseMaybeConditional(refExpressionErrors) {
const startLoc = this.state.startLoc;
const potentialArrowAt = this.state.potentialArrowAt;
const expr = this.parseExprOps(refExpressionErrors);
if (this.shouldExitDescending(expr, potentialArrowAt)) {
return expr;
}
return this.parseConditional(expr, startLoc, refExpressionErrors);
}
parseConditional(expr, startLoc, refExpressionErrors) {
if (this.eat(17)) {
const node = this.startNodeAt(startLoc);
node.test = expr;
node.consequent = this.parseMaybeAssignAllowIn();
this.expect(14);
node.alternate = this.parseMaybeAssign();
return this.finishNode(node, "ConditionalExpression");
}
return expr;
}
parseMaybeUnaryOrPrivate(refExpressionErrors) {
return this.match(138) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
}
parseExprOps(refExpressionErrors) {
const startLoc = this.state.startLoc;
const potentialArrowAt = this.state.potentialArrowAt;
const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
if (this.shouldExitDescending(expr, potentialArrowAt)) {
return expr;
}
return this.parseExprOp(expr, startLoc, -1);
}
parseExprOp(left, leftStartLoc, minPrec) {
if (this.isPrivateName(left)) {
const value = this.getPrivateNameSV(left);
if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
this.raise(Errors.PrivateInExpectedIn, {
at: left,
identifierName: value
});
}
this.classScope.usePrivateName(value, left.loc.start);
}
const op = this.state.type;
if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
let prec = tokenOperatorPrecedence(op);
if (prec > minPrec) {
if (op === 39) {
this.expectPlugin("pipelineOperator");
if (this.state.inFSharpPipelineDirectBody) {
return left;
}
this.checkPipelineAtInfixOperator(left, leftStartLoc);
}
const node = this.startNodeAt(leftStartLoc);
node.left = left;
node.operator = this.state.value;
const logical = op === 41 || op === 42;
const coalesce = op === 40;
if (coalesce) {
prec = tokenOperatorPrecedence(42);
}
this.next();
if (op === 39 && this.hasPlugin(["pipelineOperator", {
proposal: "minimal"
}])) {
if (this.state.type === 96 && this.prodParam.hasAwait) {
throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {
at: this.state.startLoc
});
}
}
node.right = this.parseExprOpRightExpr(op, prec);
const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
const nextOp = this.state.type;
if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
throw this.raise(Errors.MixingCoalesceWithLogical, {
at: this.state.startLoc
});
}
return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
}
}
return left;
}
parseExprOpRightExpr(op, prec) {
const startLoc = this.state.startLoc;
switch (op) {
case 39:
switch (this.getPluginOption("pipelineOperator", "proposal")) {
case "hack":
return this.withTopicBindingContext(() => {
return this.parseHackPipeBody();
});
case "smart":
return this.withTopicBindingContext(() => {
if (this.prodParam.hasYield && this.isContextual(108)) {
throw this.raise(Errors.PipeBodyIsTighter, {
at: this.state.startLoc
});
}
return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
});
case "fsharp":
return this.withSoloAwaitPermittingContext(() => {
return this.parseFSharpPipelineBody(prec);
});
}
default:
return this.parseExprOpBaseRightExpr(op, prec);
}
}
parseExprOpBaseRightExpr(op, prec) {
const startLoc = this.state.startLoc;
return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
}
parseHackPipeBody() {
var _body$extra;
const {
startLoc
} = this.state;
const body = this.parseMaybeAssign();
const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);
if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
this.raise(Errors.PipeUnparenthesizedBody, {
at: startLoc,
type: body.type
});
}
if (!this.topicReferenceWasUsedInCurrentContext()) {
this.raise(Errors.PipeTopicUnused, {
at: startLoc
});
}
return body;
}
checkExponentialAfterUnary(node) {
if (this.match(57)) {
this.raise(Errors.UnexpectedTokenUnaryExponentiation, {
at: node.argument
});
}
}
parseMaybeUnary(refExpressionErrors, sawUnary) {
const startLoc = this.state.startLoc;
const isAwait = this.isContextual(96);
if (isAwait && this.isAwaitAllowed()) {
this.next();
const expr = this.parseAwait(startLoc);
if (!sawUnary) this.checkExponentialAfterUnary(expr);
return expr;
}
const update = this.match(34);
const node = this.startNode();
if (tokenIsPrefix(this.state.type)) {
node.operator = this.state.value;
node.prefix = true;
if (this.match(72)) {
this.expectPlugin("throwExpressions");
}
const isDelete = this.match(89);
this.next();
node.argument = this.parseMaybeUnary(null, true);
this.checkExpressionErrors(refExpressionErrors, true);
if (this.state.strict && isDelete) {
const arg = node.argument;
if (arg.type === "Identifier") {
this.raise(Errors.StrictDelete, {
at: node
});
} else if (this.hasPropertyAsPrivateName(arg)) {
this.raise(Errors.DeletePrivateField, {
at: node
});
}
}
if (!update) {
if (!sawUnary) {
this.checkExponentialAfterUnary(node);
}
return this.finishNode(node, "UnaryExpression");
}
}
const expr = this.parseUpdate(node, update, refExpressionErrors);
if (isAwait) {
const {
type
} = this.state;
const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
if (startsExpr && !this.isAmbiguousAwait()) {
this.raiseOverwrite(Errors.AwaitNotInAsyncContext, {
at: startLoc
});
return this.parseAwait(startLoc);
}
}
return expr;
}
parseUpdate(node, update, refExpressionErrors) {
if (update) {
const updateExpressionNode = node;
this.checkLVal(updateExpressionNode.argument, {
in: this.finishNode(updateExpressionNode, "UpdateExpression")
});
return node;
}
const startLoc = this.state.startLoc;
let expr = this.parseExprSubscripts(refExpressionErrors);
if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
const node = this.startNodeAt(startLoc);
node.operator = this.state.value;
node.prefix = false;
node.argument = expr;
this.next();
this.checkLVal(expr, {
in: expr = this.finishNode(node, "UpdateExpression")
});
}
return expr;
}
parseExprSubscripts(refExpressionErrors) {
const startLoc = this.state.startLoc;
const potentialArrowAt = this.state.potentialArrowAt;
const expr = this.parseExprAtom(refExpressionErrors);
if (this.shouldExitDescending(expr, potentialArrowAt)) {
return expr;
}
return this.parseSubscripts(expr, startLoc);
}
parseSubscripts(base, startLoc, noCalls) {
const state = {
optionalChainMember: false,
maybeAsyncArrow: this.atPossibleAsyncArrow(base),
stop: false
};
do {
base = this.parseSubscript(base, startLoc, noCalls, state);
state.maybeAsyncArrow = false;
} while (!state.stop);
return base;
}
parseSubscript(base, startLoc, noCalls, state) {
const {
type
} = this.state;
if (!noCalls && type === 15) {
return this.parseBind(base, startLoc, noCalls, state);
} else if (tokenIsTemplate(type)) {
return this.parseTaggedTemplateExpression(base, startLoc, state);
}
let optional = false;
if (type === 18) {
if (noCalls) {
this.raise(Errors.OptionalChainingNoNew, {
at: this.state.startLoc
});
if (this.lookaheadCharCode() === 40) {
state.stop = true;
return base;
}
}
state.optionalChainMember = optional = true;
this.next();
}
if (!noCalls && this.match(10)) {
return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
} else {
const computed = this.eat(0);
if (computed || optional || this.eat(16)) {
return this.parseMember(base, startLoc, state, computed, optional);
} else {
state.stop = true;
return base;
}
}
}
parseMember(base, startLoc, state, computed, optional) {
const node = this.startNodeAt(startLoc);
node.object = base;
node.computed = computed;
if (computed) {
node.property = this.parseExpression();
this.expect(3);
} else if (this.match(138)) {
if (base.type === "Super") {
this.raise(Errors.SuperPrivateField, {
at: startLoc
});
}
this.classScope.usePrivateName(this.state.value, this.state.startLoc);
node.property = this.parsePrivateName();
} else {
node.property = this.parseIdentifier(true);
}
if (state.optionalChainMember) {
node.optional = optional;
return this.finishNode(node, "OptionalMemberExpression");
} else {
return this.finishNode(node, "MemberExpression");
}
}
parseBind(base, startLoc, noCalls, state) {
const node = this.startNodeAt(startLoc);
node.object = base;
this.next();
node.callee = this.parseNoCallExpr();
state.stop = true;
return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls);
}
parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
let refExpressionErrors = null;
this.state.maybeInArrowParameters = true;
this.next();
const node = this.startNodeAt(startLoc);
node.callee = base;
const {
maybeAsyncArrow,
optionalChainMember
} = state;
if (maybeAsyncArrow) {
this.expressionScope.enter(newAsyncArrowScope());
refExpressionErrors = new ExpressionErrors();
}
if (optionalChainMember) {
node.optional = optional;
}
if (optional) {
node.arguments = this.parseCallExpressionArguments(11);
} else {
node.arguments = this.parseCallExpressionArguments(11, base.type === "Import", base.type !== "Super", node, refExpressionErrors);
}
let finishedNode = this.finishCallExpression(node, optionalChainMember);
if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
state.stop = true;
this.checkDestructuringPrivate(refExpressionErrors);
this.expressionScope.validateAsPattern();
this.expressionScope.exit();
finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
} else {
if (maybeAsyncArrow) {
this.checkExpressionErrors(refExpressionErrors, true);
this.expressionScope.exit();
}
this.toReferencedArguments(finishedNode);
}
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
return finishedNode;
}
toReferencedArguments(node, isParenthesizedExpr) {
this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
}
parseTaggedTemplateExpression(base, startLoc, state) {
const node = this.startNodeAt(startLoc);
node.tag = base;
node.quasi = this.parseTemplate(true);
if (state.optionalChainMember) {
this.raise(Errors.OptionalChainingNoTemplate, {
at: startLoc
});
}
return this.finishNode(node, "TaggedTemplateExpression");
}
atPossibleAsyncArrow(base) {
return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
}
expectImportAttributesPlugin() {
if (!this.hasPlugin("importAssertions")) {
this.expectPlugin("importAttributes");
}
}
finishCallExpression(node, optional) {
if (node.callee.type === "Import") {
if (node.arguments.length === 2) {
{
if (!this.hasPlugin("moduleAttributes")) {
this.expectImportAttributesPlugin();
}
}
}
if (node.arguments.length === 0 || node.arguments.length > 2) {
this.raise(Errors.ImportCallArity, {
at: node,
maxArgumentCount: this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
});
} else {
for (const arg of node.arguments) {
if (arg.type === "SpreadElement") {
this.raise(Errors.ImportCallSpreadArgument, {
at: arg
});
}
}
}
}
return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
}
parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) {
const elts = [];
let first = true;
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = false;
while (!this.eat(close)) {
if (first) {
first = false;
} else {
this.expect(12);
if (this.match(close)) {
if (dynamicImport && !this.hasPlugin("importAttributes") && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
this.raise(Errors.ImportCallArgumentTrailingComma, {
at: this.state.lastTokStartLoc
});
}
if (nodeForExtra) {
this.addTrailingCommaExtraToNode(nodeForExtra);
}
this.next();
break;
}
}
elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));
}
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
return elts;
}
shouldParseAsyncArrow() {
return this.match(19) && !this.canInsertSemicolon();
}
parseAsyncArrowFromCallExpression(node, call) {
var _call$extra;
this.resetPreviousNodeTrailingComments(call);
this.expect(19);
this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
if (call.innerComments) {
setInnerComments(node, call.innerComments);
}
if (call.callee.trailingComments) {
setInnerComments(node, call.callee.trailingComments);
}
return node;
}
parseNoCallExpr() {
const startLoc = this.state.startLoc;
return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
}
parseExprAtom(refExpressionErrors) {
let node;
let decorators = null;
const {
type
} = this.state;
switch (type) {
case 79:
return this.parseSuper();
case 83:
node = this.startNode();
this.next();
if (this.match(16)) {
return this.parseImportMetaProperty(node);
}
if (this.match(10)) {
if (this.options.createImportExpressions) {
return this.parseImportCall(node);
} else {
return this.finishNode(node, "Import");
}
} else {
this.raise(Errors.UnsupportedImport, {
at: this.state.lastTokStartLoc
});
return this.finishNode(node, "Import");
}
case 78:
node = this.startNode();
this.next();
return this.finishNode(node, "ThisExpression");
case 90:
{
return this.parseDo(this.startNode(), false);
}
case 56:
case 31:
{
this.readRegexp();
return this.parseRegExpLiteral(this.state.value);
}
case 134:
return this.parseNumericLiteral(this.state.value);
case 135:
return this.parseBigIntLiteral(this.state.value);
case 136:
return this.parseDecimalLiteral(this.state.value);
case 133:
return this.parseStringLiteral(this.state.value);
case 84:
return this.parseNullLiteral();
case 85:
return this.parseBooleanLiteral(true);
case 86:
return this.parseBooleanLiteral(false);
case 10:
{
const canBeArrow = this.state.potentialArrowAt === this.state.start;
return this.parseParenAndDistinguishExpression(canBeArrow);
}
case 2:
case 1:
{
return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true);
}
case 0:
{
return this.parseArrayLike(3, true, false, refExpressionErrors);
}
case 6:
case 7:
{
return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);
}
case 5:
{
return this.parseObjectLike(8, false, false, refExpressionErrors);
}
case 68:
return this.parseFunctionOrFunctionSent();
case 26:
decorators = this.parseDecorators();
case 80:
return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);
case 77:
return this.parseNewOrNewTarget();
case 25:
case 24:
return this.parseTemplate(false);
case 15:
{
node = this.startNode();
this.next();
node.object = null;
const callee = node.callee = this.parseNoCallExpr();
if (callee.type === "MemberExpression") {
return this.finishNode(node, "BindExpression");
} else {
throw this.raise(Errors.UnsupportedBind, {
at: callee
});
}
}
case 138:
{
this.raise(Errors.PrivateInExpectedIn, {
at: this.state.startLoc,
identifierName: this.state.value
});
return this.parsePrivateName();
}
case 33:
{
return this.parseTopicReferenceThenEqualsSign(54, "%");
}
case 32:
{
return this.parseTopicReferenceThenEqualsSign(44, "^");
}
case 37:
case 38:
{
return this.parseTopicReference("hack");
}
case 44:
case 54:
case 27:
{
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
if (pipeProposal) {
return this.parseTopicReference(pipeProposal);
}
this.unexpected();
break;
}
case 47:
{
const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {
this.expectOnePlugin(["jsx", "flow", "typescript"]);
} else {
this.unexpected();
}
break;
}
default:
if (tokenIsIdentifier(type)) {
if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) {
return this.parseModuleExpression();
}
const canBeArrow = this.state.potentialArrowAt === this.state.start;
const containsEsc = this.state.containsEsc;
const id = this.parseIdentifier();
if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
const {
type
} = this.state;
if (type === 68) {
this.resetPreviousNodeTrailingComments(id);
this.next();
return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
} else if (tokenIsIdentifier(type)) {
if (this.lookaheadCharCode() === 61) {
return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
} else {
return id;
}
} else if (type === 90) {
this.resetPreviousNodeTrailingComments(id);
return this.parseDo(this.startNodeAtNode(id), true);
}
}
if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
this.next();
return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
}
return id;
} else {
this.unexpected();
}
}
}
parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
if (pipeProposal) {
this.state.type = topicTokenType;
this.state.value = topicTokenValue;
this.state.pos--;
this.state.end--;
this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
return this.parseTopicReference(pipeProposal);
} else {
this.unexpected();
}
}
parseTopicReference(pipeProposal) {
const node = this.startNode();
const startLoc = this.state.startLoc;
const tokenType = this.state.type;
this.next();
return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);
}
finishTopicReference(node, startLoc, pipeProposal, tokenType) {
if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
if (!this.topicReferenceIsAllowedInCurrentContext()) {
this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, {
at: startLoc
});
}
this.registerTopicReference();
return this.finishNode(node, nodeType);
} else {
throw this.raise(Errors.PipeTopicUnconfiguredToken, {
at: startLoc,
token: tokenLabelName(tokenType)
});
}
}
testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
switch (pipeProposal) {
case "hack":
{
return this.hasPlugin(["pipelineOperator", {
topicToken: tokenLabelName(tokenType)
}]);
}
case "smart":
return tokenType === 27;
default:
throw this.raise(Errors.PipeTopicRequiresHackPipes, {
at: startLoc
});
}
}
parseAsyncArrowUnaryFunction(node) {
this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));
const params = [this.parseIdentifier()];
this.prodParam.exit();
if (this.hasPrecedingLineBreak()) {
this.raise(Errors.LineTerminatorBeforeArrow, {
at: this.state.curPosition()
});
}
this.expect(19);
return this.parseArrowExpression(node, params, true);
}
parseDo(node, isAsync) {
this.expectPlugin("doExpressions");
if (isAsync) {
this.expectPlugin("asyncDoExpressions");
}
node.async = isAsync;
this.next();
const oldLabels = this.state.labels;
this.state.labels = [];
if (isAsync) {
this.prodParam.enter(PARAM_AWAIT);
node.body = this.parseBlock();
this.prodParam.exit();
} else {
node.body = this.parseBlock();
}
this.state.labels = oldLabels;
return this.finishNode(node, "DoExpression");
}
parseSuper() {
const node = this.startNode();
this.next();
if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
this.raise(Errors.SuperNotAllowed, {
at: node
});
} else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
this.raise(Errors.UnexpectedSuper, {
at: node
});
}
if (!this.match(10) && !this.match(0) && !this.match(16)) {
this.raise(Errors.UnsupportedSuper, {
at: node
});
}
return this.finishNode(node, "Super");
}
parsePrivateName() {
const node = this.startNode();
const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));
const name = this.state.value;
this.next();
node.id = this.createIdentifier(id, name);
return this.finishNode(node, "PrivateName");
}
parseFunctionOrFunctionSent() {
const node = this.startNode();
this.next();
if (this.prodParam.hasYield && this.match(16)) {
const meta = this.createIdentifier(this.startNodeAtNode(node), "function");
this.next();
if (this.match(103)) {
this.expectPlugin("functionSent");
} else if (!this.hasPlugin("functionSent")) {
this.unexpected();
}
return this.parseMetaProperty(node, meta, "sent");
}
return this.parseFunction(node);
}
parseMetaProperty(node, meta, propertyName) {
node.meta = meta;
const containsEsc = this.state.containsEsc;
node.property = this.parseIdentifier(true);
if (node.property.name !== propertyName || containsEsc) {
this.raise(Errors.UnsupportedMetaProperty, {
at: node.property,
target: meta.name,
onlyValidPropertyName: propertyName
});
}
return this.finishNode(node, "MetaProperty");
}
parseImportMetaProperty(node) {
const id = this.createIdentifier(this.startNodeAtNode(node), "import");
this.next();
if (this.isContextual(101)) {
if (!this.inModule) {
this.raise(Errors.ImportMetaOutsideModule, {
at: id
});
}
this.sawUnambiguousESM = true;
} else if (this.isContextual(105) || this.isContextual(97)) {
const isSource = this.isContextual(105);
if (!isSource) this.unexpected();
this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
if (!this.options.createImportExpressions) {
throw this.raise(Errors.DynamicImportPhaseRequiresImportExpressions, {
at: this.state.startLoc,
phase: this.state.value
});
}
this.next();
node.phase = isSource ? "source" : "defer";
return this.parseImportCall(node);
}
return this.parseMetaProperty(node, id, "meta");
}
parseLiteralAtNode(value, type, node) {
this.addExtra(node, "rawValue", value);
this.addExtra(node, "raw", this.input.slice(node.start, this.state.end));
node.value = value;
this.next();
return this.finishNode(node, type);
}
parseLiteral(value, type) {
const node = this.startNode();
return this.parseLiteralAtNode(value, type, node);
}
parseStringLiteral(value) {
return this.parseLiteral(value, "StringLiteral");
}
parseNumericLiteral(value) {
return this.parseLiteral(value, "NumericLiteral");
}
parseBigIntLiteral(value) {
return this.parseLiteral(value, "BigIntLiteral");
}
parseDecimalLiteral(value) {
return this.parseLiteral(value, "DecimalLiteral");
}
parseRegExpLiteral(value) {
const node = this.parseLiteral(value.value, "RegExpLiteral");
node.pattern = value.pattern;
node.flags = value.flags;
return node;
}
parseBooleanLiteral(value) {
const node = this.startNode();
node.value = value;
this.next();
return this.finishNode(node, "BooleanLiteral");
}
parseNullLiteral() {
const node = this.startNode();
this.next();
return this.finishNode(node, "NullLiteral");
}
parseParenAndDistinguishExpression(canBeArrow) {
const startLoc = this.state.startLoc;
let val;
this.next();
this.expressionScope.enter(newArrowHeadScope());
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
this.state.maybeInArrowParameters = true;
this.state.inFSharpPipelineDirectBody = false;
const innerStartLoc = this.state.startLoc;
const exprList = [];
const refExpressionErrors = new ExpressionErrors();
let first = true;
let spreadStartLoc;
let optionalCommaStartLoc;
while (!this.match(11)) {
if (first) {
first = false;
} else {
this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
if (this.match(11)) {
optionalCommaStartLoc = this.state.startLoc;
break;
}
}
if (this.match(21)) {
const spreadNodeStartLoc = this.state.startLoc;
spreadStartLoc = this.state.startLoc;
exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));
if (!this.checkCommaAfterRest(41)) {
break;
}
} else {
exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
}
}
const innerEndLoc = this.state.lastTokEndLoc;
this.expect(11);
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
let arrowNode = this.startNodeAt(startLoc);
if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
this.checkDestructuringPrivate(refExpressionErrors);
this.expressionScope.validateAsPattern();
this.expressionScope.exit();
this.parseArrowExpression(arrowNode, exprList, false);
return arrowNode;
}
this.expressionScope.exit();
if (!exprList.length) {
this.unexpected(this.state.lastTokStartLoc);
}
if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);
if (spreadStartLoc) this.unexpected(spreadStartLoc);
this.checkExpressionErrors(refExpressionErrors, true);
this.toReferencedListDeep(exprList, true);
if (exprList.length > 1) {
val = this.startNodeAt(innerStartLoc);
val.expressions = exprList;
this.finishNode(val, "SequenceExpression");
this.resetEndLocation(val, innerEndLoc);
} else {
val = exprList[0];
}
return this.wrapParenthesis(startLoc, val);
}
wrapParenthesis(startLoc, expression) {
if (!this.options.createParenthesizedExpressions) {
this.addExtra(expression, "parenthesized", true);
this.addExtra(expression, "parenStart", startLoc.index);
this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
return expression;
}
const parenExpression = this.startNodeAt(startLoc);
parenExpression.expression = expression;
return this.finishNode(parenExpression, "ParenthesizedExpression");
}
shouldParseArrow(params) {
return !this.canInsertSemicolon();
}
parseArrow(node) {
if (this.eat(19)) {
return node;
}
}
parseParenItem(node, startLoc) {
return node;
}
parseNewOrNewTarget() {
const node = this.startNode();
this.next();
if (this.match(16)) {
const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
this.next();
const metaProp = this.parseMetaProperty(node, meta, "target");
if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
this.raise(Errors.UnexpectedNewTarget, {
at: metaProp
});
}
return metaProp;
}
return this.parseNew(node);
}
parseNew(node) {
this.parseNewCallee(node);
if (this.eat(10)) {
const args = this.parseExprList(11);
this.toReferencedList(args);
node.arguments = args;
} else {
node.arguments = [];
}
return this.finishNode(node, "NewExpression");
}
parseNewCallee(node) {
const isImport = this.match(83);
const callee = this.parseNoCallExpr();
node.callee = callee;
if (isImport && (callee.type === "Import" || callee.type === "ImportExpression")) {
this.raise(Errors.ImportCallNotNewExpression, {
at: callee
});
}
}
parseTemplateElement(isTagged) {
const {
start,
startLoc,
end,
value
} = this.state;
const elemStart = start + 1;
const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
if (value === null) {
if (!isTagged) {
this.raise(Errors.InvalidEscapeSequenceTemplate, {
at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)
});
}
}
const isTail = this.match(24);
const endOffset = isTail ? -1 : -2;
const elemEnd = end + endOffset;
elem.value = {
raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"),
cooked: value === null ? null : value.slice(1, endOffset)
};
elem.tail = isTail;
this.next();
const finishedNode = this.finishNode(elem, "TemplateElement");
this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
return finishedNode;
}
parseTemplate(isTagged) {
const node = this.startNode();
node.expressions = [];
let curElt = this.parseTemplateElement(isTagged);
node.quasis = [curElt];
while (!curElt.tail) {
node.expressions.push(this.parseTemplateSubstitution());
this.readTemplateContinuation();
node.quasis.push(curElt = this.parseTemplateElement(isTagged));
}
return this.finishNode(node, "TemplateLiteral");
}
parseTemplateSubstitution() {
return this.parseExpression();
}
parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
if (isRecord) {
this.expectPlugin("recordAndTuple");
}
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = false;
const propHash = Object.create(null);
let first = true;
const node = this.startNode();
node.properties = [];
this.next();
while (!this.match(close)) {
if (first) {
first = false;
} else {
this.expect(12);
if (this.match(close)) {
this.addTrailingCommaExtraToNode(node);
break;
}
}
let prop;
if (isPattern) {
prop = this.parseBindingProperty();
} else {
prop = this.parsePropertyDefinition(refExpressionErrors);
this.checkProto(prop, isRecord, propHash, refExpressionErrors);
}
if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
this.raise(Errors.InvalidRecordProperty, {
at: prop
});
}
if (prop.shorthand) {
this.addExtra(prop, "shorthand", true);
}
node.properties.push(prop);
}
this.next();
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
let type = "ObjectExpression";
if (isPattern) {
type = "ObjectPattern";
} else if (isRecord) {
type = "RecordExpression";
}
return this.finishNode(node, type);
}
addTrailingCommaExtraToNode(node) {
this.addExtra(node, "trailingComma", this.state.lastTokStart);
this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
}
maybeAsyncOrAccessorProp(prop) {
return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
}
parsePropertyDefinition(refExpressionErrors) {
let decorators = [];
if (this.match(26)) {
if (this.hasPlugin("decorators")) {
this.raise(Errors.UnsupportedPropertyDecorator, {
at: this.state.startLoc
});
}
while (this.match(26)) {
decorators.push(this.parseDecorator());
}
}
const prop = this.startNode();
let isAsync = false;
let isAccessor = false;
let startLoc;
if (this.match(21)) {
if (decorators.length) this.unexpected();
return this.parseSpread();
}
if (decorators.length) {
prop.decorators = decorators;
decorators = [];
}
prop.method = false;
if (refExpressionErrors) {
startLoc = this.state.startLoc;
}
let isGenerator = this.eat(55);
this.parsePropertyNamePrefixOperator(prop);
const containsEsc = this.state.containsEsc;
const key = this.parsePropertyName(prop, refExpressionErrors);
if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
const keyName = key.name;
if (keyName === "async" && !this.hasPrecedingLineBreak()) {
isAsync = true;
this.resetPreviousNodeTrailingComments(key);
isGenerator = this.eat(55);
this.parsePropertyName(prop);
}
if (keyName === "get" || keyName === "set") {
isAccessor = true;
this.resetPreviousNodeTrailingComments(key);
prop.kind = keyName;
if (this.match(55)) {
isGenerator = true;
this.raise(Errors.AccessorIsGenerator, {
at: this.state.curPosition(),
kind: keyName
});
this.next();
}
this.parsePropertyName(prop);
}
}
return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
}
getGetterSetterExpectedParamCount(method) {
return method.kind === "get" ? 0 : 1;
}
getObjectOrClassMethodParams(method) {
return method.params;
}
checkGetterSetterParams(method) {
var _params;
const paramCount = this.getGetterSetterExpectedParamCount(method);
const params = this.getObjectOrClassMethodParams(method);
if (params.length !== paramCount) {
this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
at: method
});
}
if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
this.raise(Errors.BadSetterRestParameter, {
at: method
});
}
}
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
if (isAccessor) {
const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
this.checkGetterSetterParams(finishedProp);
return finishedProp;
}
if (isAsync || isGenerator || this.match(10)) {
if (isPattern) this.unexpected();
prop.kind = "method";
prop.method = true;
return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
}
}
parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
prop.shorthand = false;
if (this.eat(14)) {
prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
return this.finishNode(prop, "ObjectProperty");
}
if (!prop.computed && prop.key.type === "Identifier") {
this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
if (isPattern) {
prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
} else if (this.match(29)) {
const shorthandAssignLoc = this.state.startLoc;
if (refExpressionErrors != null) {
if (refExpressionErrors.shorthandAssignLoc === null) {
refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
}
} else {
this.raise(Errors.InvalidCoverInitializedName, {
at: shorthandAssignLoc
});
}
prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
} else {
prop.value = cloneIdentifier(prop.key);
}
prop.shorthand = true;
return this.finishNode(prop, "ObjectProperty");
}
}
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
if (!node) this.unexpected();
return node;
}
parsePropertyName(prop, refExpressionErrors) {
if (this.eat(0)) {
prop.computed = true;
prop.key = this.parseMaybeAssignAllowIn();
this.expect(3);
} else {
const {
type,
value
} = this.state;
let key;
if (tokenIsKeywordOrIdentifier(type)) {
key = this.parseIdentifier(true);
} else {
switch (type) {
case 134:
key = this.parseNumericLiteral(value);
break;
case 133:
key = this.parseStringLiteral(value);
break;
case 135:
key = this.parseBigIntLiteral(value);
break;
case 136:
key = this.parseDecimalLiteral(value);
break;
case 138:
{
const privateKeyLoc = this.state.startLoc;
if (refExpressionErrors != null) {
if (refExpressionErrors.privateKeyLoc === null) {
refExpressionErrors.privateKeyLoc = privateKeyLoc;
}
} else {
this.raise(Errors.UnexpectedPrivateField, {
at: privateKeyLoc
});
}
key = this.parsePrivateName();
break;
}
default:
this.unexpected();
}
}
prop.key = key;
if (type !== 138) {
prop.computed = false;
}
}
return prop.key;
}
initFunction(node, isAsync) {
node.id = null;
node.generator = false;
node.async = isAsync;
}
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
this.initFunction(node, isAsync);
node.generator = isGenerator;
this.scope.enter(2 | 16 | (inClassScope ? 64 : 0) | (allowDirectSuper ? 32 : 0));
this.prodParam.enter(functionFlags(isAsync, node.generator));
this.parseFunctionParams(node, isConstructor);
const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
this.prodParam.exit();
this.scope.exit();
return finishedNode;
}
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
if (isTuple) {
this.expectPlugin("recordAndTuple");
}
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = false;
const node = this.startNode();
this.next();
node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
}
parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
this.scope.enter(2 | 4);
let flags = functionFlags(isAsync, false);
if (!this.match(5) && this.prodParam.hasIn) {
flags |= PARAM_IN;
}
this.prodParam.enter(flags);
this.initFunction(node, isAsync);
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
if (params) {
this.state.maybeInArrowParameters = true;
this.setArrowFunctionParameters(node, params, trailingCommaLoc);
}
this.state.maybeInArrowParameters = false;
this.parseFunctionBody(node, true);
this.prodParam.exit();
this.scope.exit();
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
return this.finishNode(node, "ArrowFunctionExpression");
}
setArrowFunctionParameters(node, params, trailingCommaLoc) {
this.toAssignableList(params, trailingCommaLoc, false);
node.params = params;
}
parseFunctionBodyAndFinish(node, type, isMethod = false) {
this.parseFunctionBody(node, false, isMethod);
return this.finishNode(node, type);
}
parseFunctionBody(node, allowExpression, isMethod = false) {
const isExpression = allowExpression && !this.match(5);
this.expressionScope.enter(newExpressionScope());
if (isExpression) {
node.body = this.parseMaybeAssign();
this.checkParams(node, false, allowExpression, false);
} else {
const oldStrict = this.state.strict;
const oldLabels = this.state.labels;
this.state.labels = [];
this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);
node.body = this.parseBlock(true, false, hasStrictModeDirective => {
const nonSimple = !this.isSimpleParamList(node.params);
if (hasStrictModeDirective && nonSimple) {
this.raise(Errors.IllegalLanguageModeDirective, {
at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node
});
}
const strictModeChanged = !oldStrict && this.state.strict;
this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
if (this.state.strict && node.id) {
this.checkIdentifier(node.id, 65, strictModeChanged);
}
});
this.prodParam.exit();
this.state.labels = oldLabels;
}
this.expressionScope.exit();
}
isSimpleParameter(node) {
return node.type === "Identifier";
}
isSimpleParamList(params) {
for (let i = 0, len = params.length; i < len; i++) {
if (!this.isSimpleParameter(params[i])) return false;
}
return true;
}
checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
const checkClashes = !allowDuplicates && new Set();
const formalParameters = {
type: "FormalParameters"
};
for (const param of node.params) {
this.checkLVal(param, {
in: formalParameters,
binding: 5,
checkClashes,
strictModeChanged
});
}
}
parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
const elts = [];
let first = true;
while (!this.eat(close)) {
if (first) {
first = false;
} else {
this.expect(12);
if (this.match(close)) {
if (nodeForExtra) {
this.addTrailingCommaExtraToNode(nodeForExtra);
}
this.next();
break;
}
}
elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
}
return elts;
}
parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {
let elt;
if (this.match(12)) {
if (!allowEmpty) {
this.raise(Errors.UnexpectedToken, {
at: this.state.curPosition(),
unexpected: ","
});
}
elt = null;
} else if (this.match(21)) {
const spreadNodeStartLoc = this.state.startLoc;
elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
} else if (this.match(17)) {
this.expectPlugin("partialApplication");
if (!allowPlaceholder) {
this.raise(Errors.UnexpectedArgumentPlaceholder, {
at: this.state.startLoc
});
}
const node = this.startNode();
this.next();
elt = this.finishNode(node, "ArgumentPlaceholder");
} else {
elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);
}
return elt;
}
parseIdentifier(liberal) {
const node = this.startNode();
const name = this.parseIdentifierName(liberal);
return this.createIdentifier(node, name);
}
createIdentifier(node, name) {
node.name = name;
node.loc.identifierName = name;
return this.finishNode(node, "Identifier");
}
parseIdentifierName(liberal) {
let name;
const {
startLoc,
type
} = this.state;
if (tokenIsKeywordOrIdentifier(type)) {
name = this.state.value;
} else {
this.unexpected();
}
const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
if (liberal) {
if (tokenIsKeyword) {
this.replaceToken(132);
}
} else {
this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
}
this.next();
return name;
}
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
if (word.length > 10) {
return;
}
if (!canBeReservedWord(word)) {
return;
}
if (checkKeywords && isKeyword(word)) {
this.raise(Errors.UnexpectedKeyword, {
at: startLoc,
keyword: word
});
return;
}
const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
if (reservedTest(word, this.inModule)) {
this.raise(Errors.UnexpectedReservedWord, {
at: startLoc,
reservedWord: word
});
return;
} else if (word === "yield") {
if (this.prodParam.hasYield) {
this.raise(Errors.YieldBindingIdentifier, {
at: startLoc
});
return;
}
} else if (word === "await") {
if (this.prodParam.hasAwait) {
this.raise(Errors.AwaitBindingIdentifier, {
at: startLoc
});
return;
}
if (this.scope.inStaticBlock) {
this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {
at: startLoc
});
return;
}
this.expressionScope.recordAsyncArrowParametersError({
at: startLoc
});
} else if (word === "arguments") {
if (this.scope.inClassAndNotInNonArrowFunction) {
this.raise(Errors.ArgumentsInClass, {
at: startLoc
});
return;
}
}
}
isAwaitAllowed() {
if (this.prodParam.hasAwait) return true;
if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
return true;
}
return false;
}
parseAwait(startLoc) {
const node = this.startNodeAt(startLoc);
this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, {
at: node
});
if (this.eat(55)) {
this.raise(Errors.ObsoleteAwaitStar, {
at: node
});
}
if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
if (this.isAmbiguousAwait()) {
this.ambiguousScriptDifferentAst = true;
} else {
this.sawUnambiguousESM = true;
}
}
if (!this.state.soloAwait) {
node.argument = this.parseMaybeUnary(null, true);
}
return this.finishNode(node, "AwaitExpression");
}
isAmbiguousAwait() {
if (this.hasPrecedingLineBreak()) return true;
const {
type
} = this.state;
return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 102 && !this.state.containsEsc || type === 137 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
}
parseYield() {
const node = this.startNode();
this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, {
at: node
});
this.next();
let delegating = false;
let argument = null;
if (!this.hasPrecedingLineBreak()) {
delegating = this.eat(55);
switch (this.state.type) {
case 13:
case 139:
case 8:
case 11:
case 3:
case 9:
case 14:
case 12:
if (!delegating) break;
default:
argument = this.parseMaybeAssign();
}
}
node.delegate = delegating;
node.argument = argument;
return this.finishNode(node, "YieldExpression");
}
parseImportCall(node) {
this.next();
node.source = this.parseMaybeAssignAllowIn();
if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
node.options = null;
}
if (this.eat(12)) {
this.expectImportAttributesPlugin();
if (!this.match(11)) {
node.options = this.parseMaybeAssignAllowIn();
this.eat(12);
}
}
this.expect(11);
return this.finishNode(node, "ImportExpression");
}
checkPipelineAtInfixOperator(left, leftStartLoc) {
if (this.hasPlugin(["pipelineOperator", {
proposal: "smart"
}])) {
if (left.type === "SequenceExpression") {
this.raise(Errors.PipelineHeadSequenceExpression, {
at: leftStartLoc
});
}
}
}
parseSmartPipelineBodyInStyle(childExpr, startLoc) {
if (this.isSimpleReference(childExpr)) {
const bodyNode = this.startNodeAt(startLoc);
bodyNode.callee = childExpr;
return this.finishNode(bodyNode, "PipelineBareFunction");
} else {
const bodyNode = this.startNodeAt(startLoc);
this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
bodyNode.expression = childExpr;
return this.finishNode(bodyNode, "PipelineTopicExpression");
}
}
isSimpleReference(expression) {
switch (expression.type) {
case "MemberExpression":
return !expression.computed && this.isSimpleReference(expression.object);
case "Identifier":
return true;
default:
return false;
}
}
checkSmartPipeTopicBodyEarlyErrors(startLoc) {
if (this.match(19)) {
throw this.raise(Errors.PipelineBodyNoArrow, {
at: this.state.startLoc
});
}
if (!this.topicReferenceWasUsedInCurrentContext()) {
this.raise(Errors.PipelineTopicUnused, {
at: startLoc
});
}
}
withTopicBindingContext(callback) {
const outerContextTopicState = this.state.topicContext;
this.state.topicContext = {
maxNumOfResolvableTopics: 1,
maxTopicIndex: null
};
try {
return callback();
} finally {
this.state.topicContext = outerContextTopicState;
}
}
withSmartMixTopicForbiddingContext(callback) {
if (this.hasPlugin(["pipelineOperator", {
proposal: "smart"
}])) {
const outerContextTopicState = this.state.topicContext;
this.state.topicContext = {
maxNumOfResolvableTopics: 0,
maxTopicIndex: null
};
try {
return callback();
} finally {
this.state.topicContext = outerContextTopicState;
}
} else {
return callback();
}
}
withSoloAwaitPermittingContext(callback) {
const outerContextSoloAwaitState = this.state.soloAwait;
this.state.soloAwait = true;
try {
return callback();
} finally {
this.state.soloAwait = outerContextSoloAwaitState;
}
}
allowInAnd(callback) {
const flags = this.prodParam.currentFlags();
const prodParamToSet = PARAM_IN & ~flags;
if (prodParamToSet) {
this.prodParam.enter(flags | PARAM_IN);
try {
return callback();
} finally {
this.prodParam.exit();
}
}
return callback();
}
disallowInAnd(callback) {
const flags = this.prodParam.currentFlags();
const prodParamToClear = PARAM_IN & flags;
if (prodParamToClear) {
this.prodParam.enter(flags & ~PARAM_IN);
try {
return callback();
} finally {
this.prodParam.exit();
}
}
return callback();
}
registerTopicReference() {
this.state.topicContext.maxTopicIndex = 0;
}
topicReferenceIsAllowedInCurrentContext() {
return this.state.topicContext.maxNumOfResolvableTopics >= 1;
}
topicReferenceWasUsedInCurrentContext() {
return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
}
parseFSharpPipelineBody(prec) {
const startLoc = this.state.startLoc;
this.state.potentialArrowAt = this.state.start;
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
this.state.inFSharpPipelineDirectBody = true;
const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
return ret;
}
parseModuleExpression() {
this.expectPlugin("moduleBlocks");
const node = this.startNode();
this.next();
if (!this.match(5)) {
this.unexpected(null, 5);
}
const program = this.startNodeAt(this.state.endLoc);
this.next();
const revertScopes = this.initializeScopes(true);
this.enterInitialScopes();
try {
node.body = this.parseProgram(program, 8, "module");
} finally {
revertScopes();
}
return this.finishNode(node, "ModuleExpression");
}
parsePropertyNamePrefixOperator(prop) {}
}
const loopLabel = {
kind: "loop"
},
switchLabel = {
kind: "switch"
};
const loneSurrogate = /[\uD800-\uDFFF]/u;
const keywordRelationalOperator = /in(?:stanceof)?/y;
function babel7CompatTokens(tokens, input) {
for (let i = 0; i < tokens.length; i++) {
const token = tokens[i];
const {
type
} = token;
if (typeof type === "number") {
{
if (type === 138) {
const {
loc,
start,
value,
end
} = token;
const hashEndPos = start + 1;
const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);
tokens.splice(i, 1, new Token({
type: getExportedToken(27),
value: "#",
start: start,
end: hashEndPos,
startLoc: loc.start,
endLoc: hashEndLoc
}), new Token({
type: getExportedToken(132),
value: value,
start: hashEndPos,
end: end,
startLoc: hashEndLoc,
endLoc: loc.end
}));
i++;
continue;
}
if (tokenIsTemplate(type)) {
const {
loc,
start,
value,
end
} = token;
const backquoteEnd = start + 1;
const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
let startToken;
if (input.charCodeAt(start) === 96) {
startToken = new Token({
type: getExportedToken(22),
value: "`",
start: start,
end: backquoteEnd,
startLoc: loc.start,
endLoc: backquoteEndLoc
});
} else {
startToken = new Token({
type: getExportedToken(8),
value: "}",
start: start,
end: backquoteEnd,
startLoc: loc.start,
endLoc: backquoteEndLoc
});
}
let templateValue, templateElementEnd, templateElementEndLoc, endToken;
if (type === 24) {
templateElementEnd = end - 1;
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);
templateValue = value === null ? null : value.slice(1, -1);
endToken = new Token({
type: getExportedToken(22),
value: "`",
start: templateElementEnd,
end: end,
startLoc: templateElementEndLoc,
endLoc: loc.end
});
} else {
templateElementEnd = end - 2;
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);
templateValue = value === null ? null : value.slice(1, -2);
endToken = new Token({
type: getExportedToken(23),
value: "${",
start: templateElementEnd,
end: end,
startLoc: templateElementEndLoc,
endLoc: loc.end
});
}
tokens.splice(i, 1, startToken, new Token({
type: getExportedToken(20),
value: templateValue,
start: backquoteEnd,
end: templateElementEnd,
startLoc: backquoteEndLoc,
endLoc: templateElementEndLoc
}), endToken);
i += 2;
continue;
}
}
token.type = getExportedToken(type);
}
}
return tokens;
}
class StatementParser extends ExpressionParser {
parseTopLevel(file, program) {
file.program = this.parseProgram(program);
file.comments = this.state.comments;
if (this.options.tokens) {
file.tokens = babel7CompatTokens(this.tokens, this.input);
}
return this.finishNode(file, "File");
}
parseProgram(program, end = 139, sourceType = this.options.sourceType) {
program.sourceType = sourceType;
program.interpreter = this.parseInterpreterDirective();
this.parseBlockBody(program, true, true, end);
if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
for (const [localName, at] of Array.from(this.scope.undefinedExports)) {
this.raise(Errors.ModuleExportUndefined, {
at,
localName
});
}
}
let finishedProgram;
if (end === 139) {
finishedProgram = this.finishNode(program, "Program");
} else {
finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
}
return finishedProgram;
}
stmtToDirective(stmt) {
const directive = stmt;
directive.type = "Directive";
directive.value = directive.expression;
delete directive.expression;
const directiveLiteral = directive.value;
const expressionValue = directiveLiteral.value;
const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);
const val = directiveLiteral.value = raw.slice(1, -1);
this.addExtra(directiveLiteral, "raw", raw);
this.addExtra(directiveLiteral, "rawValue", val);
this.addExtra(directiveLiteral, "expressionValue", expressionValue);
directiveLiteral.type = "DirectiveLiteral";
return directive;
}
parseInterpreterDirective() {
if (!this.match(28)) {
return null;
}
const node = this.startNode();
node.value = this.state.value;
this.next();
return this.finishNode(node, "InterpreterDirective");
}
isLet() {
if (!this.isContextual(100)) {
return false;
}
return this.hasFollowingBindingAtom();
}
chStartsBindingIdentifier(ch, pos) {
if (isIdentifierStart(ch)) {
keywordRelationalOperator.lastIndex = pos;
if (keywordRelationalOperator.test(this.input)) {
const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
if (!isIdentifierChar(endCh) && endCh !== 92) {
return false;
}
}
return true;
} else if (ch === 92) {
return true;
} else {
return false;
}
}
chStartsBindingPattern(ch) {
return ch === 91 || ch === 123;
}
hasFollowingBindingAtom() {
const next = this.nextTokenStart();
const nextCh = this.codePointAtPos(next);
return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
}
hasInLineFollowingBindingIdentifier() {
const next = this.nextTokenInLineStart();
const nextCh = this.codePointAtPos(next);
return this.chStartsBindingIdentifier(nextCh, next);
}
startsUsingForOf() {
const {
type,
containsEsc
} = this.lookahead();
if (type === 102 && !containsEsc) {
return false;
} else if (tokenIsIdentifier(type) && !this.hasFollowingLineBreak()) {
this.expectPlugin("explicitResourceManagement");
return true;
}
}
startsAwaitUsing() {
let next = this.nextTokenInLineStart();
if (this.isUnparsedContextual(next, "using")) {
next = this.nextTokenInLineStartSince(next + 5);
const nextCh = this.codePointAtPos(next);
if (this.chStartsBindingIdentifier(nextCh, next)) {
this.expectPlugin("explicitResourceManagement");
return true;
}
}
return false;
}
parseModuleItem() {
return this.parseStatementLike(1 | 2 | 4 | 8);
}
parseStatementListItem() {
return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));
}
parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
let flags = 0;
if (this.options.annexB && !this.state.strict) {
flags |= 4;
if (allowLabeledFunction) {
flags |= 8;
}
}
return this.parseStatementLike(flags);
}
parseStatement() {
return this.parseStatementLike(0);
}
parseStatementLike(flags) {
let decorators = null;
if (this.match(26)) {
decorators = this.parseDecorators(true);
}
return this.parseStatementContent(flags, decorators);
}
parseStatementContent(flags, decorators) {
const starttype = this.state.type;
const node = this.startNode();
const allowDeclaration = !!(flags & 2);
const allowFunctionDeclaration = !!(flags & 4);
const topLevel = flags & 1;
switch (starttype) {
case 60:
return this.parseBreakContinueStatement(node, true);
case 63:
return this.parseBreakContinueStatement(node, false);
case 64:
return this.parseDebuggerStatement(node);
case 90:
return this.parseDoWhileStatement(node);
case 91:
return this.parseForStatement(node);
case 68:
if (this.lookaheadCharCode() === 46) break;
if (!allowFunctionDeclaration) {
this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
at: this.state.startLoc
});
}
return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
case 80:
if (!allowDeclaration) this.unexpected();
return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
case 69:
return this.parseIfStatement(node);
case 70:
return this.parseReturnStatement(node);
case 71:
return this.parseSwitchStatement(node);
case 72:
return this.parseThrowStatement(node);
case 73:
return this.parseTryStatement(node);
case 96:
if (!this.state.containsEsc && this.startsAwaitUsing()) {
if (!this.isAwaitAllowed()) {
this.raise(Errors.AwaitUsingNotInAsyncContext, {
at: node
});
} else if (!allowDeclaration) {
this.raise(Errors.UnexpectedLexicalDeclaration, {
at: node
});
}
this.next();
return this.parseVarStatement(node, "await using");
}
break;
case 107:
if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifier()) {
break;
}
this.expectPlugin("explicitResourceManagement");
if (!this.scope.inModule && this.scope.inTopLevel) {
this.raise(Errors.UnexpectedUsingDeclaration, {
at: this.state.startLoc
});
} else if (!allowDeclaration) {
this.raise(Errors.UnexpectedLexicalDeclaration, {
at: this.state.startLoc
});
}
return this.parseVarStatement(node, "using");
case 100:
{
if (this.state.containsEsc) {
break;
}
const next = this.nextTokenStart();
const nextCh = this.codePointAtPos(next);
if (nextCh !== 91) {
if (!allowDeclaration && this.hasFollowingLineBreak()) break;
if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
break;
}
}
}
case 75:
{
if (!allowDeclaration) {
this.raise(Errors.UnexpectedLexicalDeclaration, {
at: this.state.startLoc
});
}
}
case 74:
{
const kind = this.state.value;
return this.parseVarStatement(node, kind);
}
case 92:
return this.parseWhileStatement(node);
case 76:
return this.parseWithStatement(node);
case 5:
return this.parseBlock();
case 13:
return this.parseEmptyStatement(node);
case 83:
{
const nextTokenCharCode = this.lookaheadCharCode();
if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
break;
}
}
case 82:
{
if (!this.options.allowImportExportEverywhere && !topLevel) {
this.raise(Errors.UnexpectedImportExport, {
at: this.state.startLoc
});
}
this.next();
let result;
if (starttype === 83) {
result = this.parseImport(node);
if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
this.sawUnambiguousESM = true;
}
} else {
result = this.parseExport(node, decorators);
if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
this.sawUnambiguousESM = true;
}
}
this.assertModuleNodeAllowed(result);
return result;
}
default:
{
if (this.isAsyncFunction()) {
if (!allowDeclaration) {
this.raise(Errors.AsyncFunctionInSingleStatementContext, {
at: this.state.startLoc
});
}
this.next();
return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
}
}
}
const maybeName = this.state.value;
const expr = this.parseExpression();
if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
return this.parseLabeledStatement(node, maybeName, expr, flags);
} else {
return this.parseExpressionStatement(node, expr, decorators);
}
}
assertModuleNodeAllowed(node) {
if (!this.options.allowImportExportEverywhere && !this.inModule) {
this.raise(Errors.ImportOutsideModule, {
at: node
});
}
}
decoratorsEnabledBeforeExport() {
if (this.hasPlugin("decorators-legacy")) return true;
return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
}
maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
if (maybeDecorators) {
if (classNode.decorators && classNode.decorators.length > 0) {
if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
this.raise(Errors.DecoratorsBeforeAfterExport, {
at: classNode.decorators[0]
});
}
classNode.decorators.unshift(...maybeDecorators);
} else {
classNode.decorators = maybeDecorators;
}
this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
}
return classNode;
}
canHaveLeadingDecorator() {
return this.match(80);
}
parseDecorators(allowExport) {
const decorators = [];
do {
decorators.push(this.parseDecorator());
} while (this.match(26));
if (this.match(82)) {
if (!allowExport) {
this.unexpected();
}
if (!this.decoratorsEnabledBeforeExport()) {
this.raise(Errors.DecoratorExportClass, {
at: this.state.startLoc
});
}
} else if (!this.canHaveLeadingDecorator()) {
throw this.raise(Errors.UnexpectedLeadingDecorator, {
at: this.state.startLoc
});
}
return decorators;
}
parseDecorator() {
this.expectOnePlugin(["decorators", "decorators-legacy"]);
const node = this.startNode();
this.next();
if (this.hasPlugin("decorators")) {
const startLoc = this.state.startLoc;
let expr;
if (this.match(10)) {
const startLoc = this.state.startLoc;
this.next();
expr = this.parseExpression();
this.expect(11);
expr = this.wrapParenthesis(startLoc, expr);
const paramsStartLoc = this.state.startLoc;
node.expression = this.parseMaybeDecoratorArguments(expr);
if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
this.raise(Errors.DecoratorArgumentsOutsideParentheses, {
at: paramsStartLoc
});
}
} else {
expr = this.parseIdentifier(false);
while (this.eat(16)) {
const node = this.startNodeAt(startLoc);
node.object = expr;
if (this.match(138)) {
this.classScope.usePrivateName(this.state.value, this.state.startLoc);
node.property = this.parsePrivateName();
} else {
node.property = this.parseIdentifier(true);
}
node.computed = false;
expr = this.finishNode(node, "MemberExpression");
}
node.expression = this.parseMaybeDecoratorArguments(expr);
}
} else {
node.expression = this.parseExprSubscripts();
}
return this.finishNode(node, "Decorator");
}
parseMaybeDecoratorArguments(expr) {
if (this.eat(10)) {
const node = this.startNodeAtNode(expr);
node.callee = expr;
node.arguments = this.parseCallExpressionArguments(11, false);
this.toReferencedList(node.arguments);
return this.finishNode(node, "CallExpression");
}
return expr;
}
parseBreakContinueStatement(node, isBreak) {
this.next();
if (this.isLineTerminator()) {
node.label = null;
} else {
node.label = this.parseIdentifier();
this.semicolon();
}
this.verifyBreakContinue(node, isBreak);
return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
}
verifyBreakContinue(node, isBreak) {
let i;
for (i = 0; i < this.state.labels.length; ++i) {
const lab = this.state.labels[i];
if (node.label == null || lab.name === node.label.name) {
if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
if (node.label && isBreak) break;
}
}
if (i === this.state.labels.length) {
const type = isBreak ? "BreakStatement" : "ContinueStatement";
this.raise(Errors.IllegalBreakContinue, {
at: node,
type
});
}
}
parseDebuggerStatement(node) {
this.next();
this.semicolon();
return this.finishNode(node, "DebuggerStatement");
}
parseHeaderExpression() {
this.expect(10);
const val = this.parseExpression();
this.expect(11);
return val;
}
parseDoWhileStatement(node) {
this.next();
this.state.labels.push(loopLabel);
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
this.state.labels.pop();
this.expect(92);
node.test = this.parseHeaderExpression();
this.eat(13);
return this.finishNode(node, "DoWhileStatement");
}
parseForStatement(node) {
this.next();
this.state.labels.push(loopLabel);
let awaitAt = null;
if (this.isAwaitAllowed() && this.eatContextual(96)) {
awaitAt = this.state.lastTokStartLoc;
}
this.scope.enter(0);
this.expect(10);
if (this.match(13)) {
if (awaitAt !== null) {
this.unexpected(awaitAt);
}
return this.parseFor(node, null);
}
const startsWithLet = this.isContextual(100);
{
const startsWithAwaitUsing = this.isContextual(96) && this.startsAwaitUsing();
const starsWithUsingDeclaration = startsWithAwaitUsing || this.isContextual(107) && this.startsUsingForOf();
const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
if (this.match(74) || this.match(75) || isLetOrUsing) {
const initNode = this.startNode();
let kind;
if (startsWithAwaitUsing) {
kind = "await using";
if (!this.isAwaitAllowed()) {
this.raise(Errors.AwaitUsingNotInAsyncContext, {
at: this.state.startLoc
});
}
this.next();
} else {
kind = this.state.value;
}
this.next();
this.parseVar(initNode, true, kind);
const init = this.finishNode(initNode, "VariableDeclaration");
const isForIn = this.match(58);
if (isForIn && starsWithUsingDeclaration) {
this.raise(Errors.ForInUsing, {
at: init
});
}
if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) {
return this.parseForIn(node, init, awaitAt);
}
if (awaitAt !== null) {
this.unexpected(awaitAt);
}
return this.parseFor(node, init);
}
}
const startsWithAsync = this.isContextual(95);
const refExpressionErrors = new ExpressionErrors();
const init = this.parseExpression(true, refExpressionErrors);
const isForOf = this.isContextual(102);
if (isForOf) {
if (startsWithLet) {
this.raise(Errors.ForOfLet, {
at: init
});
}
if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
this.raise(Errors.ForOfAsync, {
at: init
});
}
}
if (isForOf || this.match(58)) {
this.checkDestructuringPrivate(refExpressionErrors);
this.toAssignable(init, true);
const type = isForOf ? "ForOfStatement" : "ForInStatement";
this.checkLVal(init, {
in: {
type
}
});
return this.parseForIn(node, init, awaitAt);
} else {
this.checkExpressionErrors(refExpressionErrors, true);
}
if (awaitAt !== null) {
this.unexpected(awaitAt);
}
return this.parseFor(node, init);
}
parseFunctionStatement(node, isAsync, isHangingDeclaration) {
this.next();
return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));
}
parseIfStatement(node) {
this.next();
node.test = this.parseHeaderExpression();
node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
return this.finishNode(node, "IfStatement");
}
parseReturnStatement(node) {
if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
this.raise(Errors.IllegalReturn, {
at: this.state.startLoc
});
}
this.next();
if (this.isLineTerminator()) {
node.argument = null;
} else {
node.argument = this.parseExpression();
this.semicolon();
}
return this.finishNode(node, "ReturnStatement");
}
parseSwitchStatement(node) {
this.next();
node.discriminant = this.parseHeaderExpression();
const cases = node.cases = [];
this.expect(5);
this.state.labels.push(switchLabel);
this.scope.enter(0);
let cur;
for (let sawDefault; !this.match(8);) {
if (this.match(61) || this.match(65)) {
const isCase = this.match(61);
if (cur) this.finishNode(cur, "SwitchCase");
cases.push(cur = this.startNode());
cur.consequent = [];
this.next();
if (isCase) {
cur.test = this.parseExpression();
} else {
if (sawDefault) {
this.raise(Errors.MultipleDefaultsInSwitch, {
at: this.state.lastTokStartLoc
});
}
sawDefault = true;
cur.test = null;
}
this.expect(14);
} else {
if (cur) {
cur.consequent.push(this.parseStatementListItem());
} else {
this.unexpected();
}
}
}
this.scope.exit();
if (cur) this.finishNode(cur, "SwitchCase");
this.next();
this.state.labels.pop();
return this.finishNode(node, "SwitchStatement");
}
parseThrowStatement(node) {
this.next();
if (this.hasPrecedingLineBreak()) {
this.raise(Errors.NewlineAfterThrow, {
at: this.state.lastTokEndLoc
});
}
node.argument = this.parseExpression();
this.semicolon();
return this.finishNode(node, "ThrowStatement");
}
parseCatchClauseParam() {
const param = this.parseBindingAtom();
this.scope.enter(this.options.annexB && param.type === "Identifier" ? 8 : 0);
this.checkLVal(param, {
in: {
type: "CatchClause"
},
binding: 9
});
return param;
}
parseTryStatement(node) {
this.next();
node.block = this.parseBlock();
node.handler = null;
if (this.match(62)) {
const clause = this.startNode();
this.next();
if (this.match(10)) {
this.expect(10);
clause.param = this.parseCatchClauseParam();
this.expect(11);
} else {
clause.param = null;
this.scope.enter(0);
}
clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
this.scope.exit();
node.handler = this.finishNode(clause, "CatchClause");
}
node.finalizer = this.eat(67) ? this.parseBlock() : null;
if (!node.handler && !node.finalizer) {
this.raise(Errors.NoCatchOrFinally, {
at: node
});
}
return this.finishNode(node, "TryStatement");
}
parseVarStatement(node, kind, allowMissingInitializer = false) {
this.next();
this.parseVar(node, false, kind, allowMissingInitializer);
this.semicolon();
return this.finishNode(node, "VariableDeclaration");
}
parseWhileStatement(node) {
this.next();
node.test = this.parseHeaderExpression();
this.state.labels.push(loopLabel);
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
this.state.labels.pop();
return this.finishNode(node, "WhileStatement");
}
parseWithStatement(node) {
if (this.state.strict) {
this.raise(Errors.StrictWith, {
at: this.state.startLoc
});
}
this.next();
node.object = this.parseHeaderExpression();
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
return this.finishNode(node, "WithStatement");
}
parseEmptyStatement(node) {
this.next();
return this.finishNode(node, "EmptyStatement");
}
parseLabeledStatement(node, maybeName, expr, flags) {
for (const label of this.state.labels) {
if (label.name === maybeName) {
this.raise(Errors.LabelRedeclaration, {
at: expr,
labelName: maybeName
});
}
}
const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null;
for (let i = this.state.labels.length - 1; i >= 0; i--) {
const label = this.state.labels[i];
if (label.statementStart === node.start) {
label.statementStart = this.state.start;
label.kind = kind;
} else {
break;
}
}
this.state.labels.push({
name: maybeName,
kind: kind,
statementStart: this.state.start
});
node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
this.state.labels.pop();
node.label = expr;
return this.finishNode(node, "LabeledStatement");
}
parseExpressionStatement(node, expr, decorators) {
node.expression = expr;
this.semicolon();
return this.finishNode(node, "ExpressionStatement");
}
parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
const node = this.startNode();
if (allowDirectives) {
this.state.strictErrors.clear();
}
this.expect(5);
if (createNewLexicalScope) {
this.scope.enter(0);
}
this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);
if (createNewLexicalScope) {
this.scope.exit();
}
return this.finishNode(node, "BlockStatement");
}
isValidDirective(stmt) {
return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
}
parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
const body = node.body = [];
const directives = node.directives = [];
this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);
}
parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
const oldStrict = this.state.strict;
let hasStrictModeDirective = false;
let parsedNonDirective = false;
while (!this.match(end)) {
const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
if (directives && !parsedNonDirective) {
if (this.isValidDirective(stmt)) {
const directive = this.stmtToDirective(stmt);
directives.push(directive);
if (!hasStrictModeDirective && directive.value.value === "use strict") {
hasStrictModeDirective = true;
this.setStrict(true);
}
continue;
}
parsedNonDirective = true;
this.state.strictErrors.clear();
}
body.push(stmt);
}
afterBlockParse == null ? void 0 : afterBlockParse.call(this, hasStrictModeDirective);
if (!oldStrict) {
this.setStrict(false);
}
this.next();
}
parseFor(node, init) {
node.init = init;
this.semicolon(false);
node.test = this.match(13) ? null : this.parseExpression();
this.semicolon(false);
node.update = this.match(11) ? null : this.parseExpression();
this.expect(11);
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
this.scope.exit();
this.state.labels.pop();
return this.finishNode(node, "ForStatement");
}
parseForIn(node, init, awaitAt) {
const isForIn = this.match(58);
this.next();
if (isForIn) {
if (awaitAt !== null) this.unexpected(awaitAt);
} else {
node.await = awaitAt !== null;
}
if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
this.raise(Errors.ForInOfLoopInitializer, {
at: init,
type: isForIn ? "ForInStatement" : "ForOfStatement"
});
}
if (init.type === "AssignmentPattern") {
this.raise(Errors.InvalidLhs, {
at: init,
ancestor: {
type: "ForStatement"
}
});
}
node.left = init;
node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
this.expect(11);
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
this.scope.exit();
this.state.labels.pop();
return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
}
parseVar(node, isFor, kind, allowMissingInitializer = false) {
const declarations = node.declarations = [];
node.kind = kind;
for (;;) {
const decl = this.startNode();
this.parseVarId(decl, kind);
decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
if (decl.init === null && !allowMissingInitializer) {
if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(102)))) {
this.raise(Errors.DeclarationMissingInitializer, {
at: this.state.lastTokEndLoc,
kind: "destructuring"
});
} else if (kind === "const" && !(this.match(58) || this.isContextual(102))) {
this.raise(Errors.DeclarationMissingInitializer, {
at: this.state.lastTokEndLoc,
kind: "const"
});
}
}
declarations.push(this.finishNode(decl, "VariableDeclarator"));
if (!this.eat(12)) break;
}
return node;
}
parseVarId(decl, kind) {
const id = this.parseBindingAtom();
this.checkLVal(id, {
in: {
type: "VariableDeclarator"
},
binding: kind === "var" ? 5 : 8201
});
decl.id = id;
}
parseAsyncFunctionExpression(node) {
return this.parseFunction(node, 8);
}
parseFunction(node, flags = 0) {
const hangingDeclaration = flags & 2;
const isDeclaration = !!(flags & 1);
const requireId = isDeclaration && !(flags & 4);
const isAsync = !!(flags & 8);
this.initFunction(node, isAsync);
if (this.match(55)) {
if (hangingDeclaration) {
this.raise(Errors.GeneratorInSingleStatementContext, {
at: this.state.startLoc
});
}
this.next();
node.generator = true;
}
if (isDeclaration) {
node.id = this.parseFunctionId(requireId);
}
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
this.state.maybeInArrowParameters = false;
this.scope.enter(2);
this.prodParam.enter(functionFlags(isAsync, node.generator));
if (!isDeclaration) {
node.id = this.parseFunctionId();
}
this.parseFunctionParams(node, false);
this.withSmartMixTopicForbiddingContext(() => {
this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
});
this.prodParam.exit();
this.scope.exit();
if (isDeclaration && !hangingDeclaration) {
this.registerFunctionStatementId(node);
}
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
return node;
}
parseFunctionId(requireId) {
return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
}
parseFunctionParams(node, isConstructor) {
this.expect(10);
this.expressionScope.enter(newParameterDeclarationScope());
node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
this.expressionScope.exit();
}
registerFunctionStatementId(node) {
if (!node.id) return;
this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);
}
parseClass(node, isStatement, optionalId) {
this.next();
const oldStrict = this.state.strict;
this.state.strict = true;
this.parseClassId(node, isStatement, optionalId);
this.parseClassSuper(node);
node.body = this.parseClassBody(!!node.superClass, oldStrict);
return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
}
isClassProperty() {
return this.match(29) || this.match(13) || this.match(8);
}
isClassMethod() {
return this.match(10);
}
isNonstaticConstructor(method) {
return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
}
parseClassBody(hadSuperClass, oldStrict) {
this.classScope.enter();
const state = {
hadConstructor: false,
hadSuperClass
};
let decorators = [];
const classBody = this.startNode();
classBody.body = [];
this.expect(5);
this.withSmartMixTopicForbiddingContext(() => {
while (!this.match(8)) {
if (this.eat(13)) {
if (decorators.length > 0) {
throw this.raise(Errors.DecoratorSemicolon, {
at: this.state.lastTokEndLoc
});
}
continue;
}
if (this.match(26)) {
decorators.push(this.parseDecorator());
continue;
}
const member = this.startNode();
if (decorators.length) {
member.decorators = decorators;
this.resetStartLocationFromNode(member, decorators[0]);
decorators = [];
}
this.parseClassMember(classBody, member, state);
if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
this.raise(Errors.DecoratorConstructor, {
at: member
});
}
}
});
this.state.strict = oldStrict;
this.next();
if (decorators.length) {
throw this.raise(Errors.TrailingDecorator, {
at: this.state.startLoc
});
}
this.classScope.exit();
return this.finishNode(classBody, "ClassBody");
}
parseClassMemberFromModifier(classBody, member) {
const key = this.parseIdentifier(true);
if (this.isClassMethod()) {
const method = member;
method.kind = "method";
method.computed = false;
method.key = key;
method.static = false;
this.pushClassMethod(classBody, method, false, false, false, false);
return true;
} else if (this.isClassProperty()) {
const prop = member;
prop.computed = false;
prop.key = key;
prop.static = false;
classBody.body.push(this.parseClassProperty(prop));
return true;
}
this.resetPreviousNodeTrailingComments(key);
return false;
}
parseClassMember(classBody, member, state) {
const isStatic = this.isContextual(106);
if (isStatic) {
if (this.parseClassMemberFromModifier(classBody, member)) {
return;
}
if (this.eat(5)) {
this.parseClassStaticBlock(classBody, member);
return;
}
}
this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
}
parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
const publicMethod = member;
const privateMethod = member;
const publicProp = member;
const privateProp = member;
const accessorProp = member;
const method = publicMethod;
const publicMember = publicMethod;
member.static = isStatic;
this.parsePropertyNamePrefixOperator(member);
if (this.eat(55)) {
method.kind = "method";
const isPrivateName = this.match(138);
this.parseClassElementName(method);
if (isPrivateName) {
this.pushClassPrivateMethod(classBody, privateMethod, true, false);
return;
}
if (this.isNonstaticConstructor(publicMethod)) {
this.raise(Errors.ConstructorIsGenerator, {
at: publicMethod.key
});
}
this.pushClassMethod(classBody, publicMethod, true, false, false, false);
return;
}
const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
const isPrivate = this.match(138);
const key = this.parseClassElementName(member);
const maybeQuestionTokenStartLoc = this.state.startLoc;
this.parsePostMemberNameModifiers(publicMember);
if (this.isClassMethod()) {
method.kind = "method";
if (isPrivate) {
this.pushClassPrivateMethod(classBody, privateMethod, false, false);
return;
}
const isConstructor = this.isNonstaticConstructor(publicMethod);
let allowsDirectSuper = false;
if (isConstructor) {
publicMethod.kind = "constructor";
if (state.hadConstructor && !this.hasPlugin("typescript")) {
this.raise(Errors.DuplicateConstructor, {
at: key
});
}
if (isConstructor && this.hasPlugin("typescript") && member.override) {
this.raise(Errors.OverrideOnConstructor, {
at: key
});
}
state.hadConstructor = true;
allowsDirectSuper = state.hadSuperClass;
}
this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
} else if (this.isClassProperty()) {
if (isPrivate) {
this.pushClassPrivateProperty(classBody, privateProp);
} else {
this.pushClassProperty(classBody, publicProp);
}
} else if (isContextual && key.name === "async" && !this.isLineTerminator()) {
this.resetPreviousNodeTrailingComments(key);
const isGenerator = this.eat(55);
if (publicMember.optional) {
this.unexpected(maybeQuestionTokenStartLoc);
}
method.kind = "method";
const isPrivate = this.match(138);
this.parseClassElementName(method);
this.parsePostMemberNameModifiers(publicMember);
if (isPrivate) {
this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
} else {
if (this.isNonstaticConstructor(publicMethod)) {
this.raise(Errors.ConstructorIsAsync, {
at: publicMethod.key
});
}
this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
}
} else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) {
this.resetPreviousNodeTrailingComments(key);
method.kind = key.name;
const isPrivate = this.match(138);
this.parseClassElementName(publicMethod);
if (isPrivate) {
this.pushClassPrivateMethod(classBody, privateMethod, false, false);
} else {
if (this.isNonstaticConstructor(publicMethod)) {
this.raise(Errors.ConstructorIsAccessor, {
at: publicMethod.key
});
}
this.pushClassMethod(classBody, publicMethod, false, false, false, false);
}
this.checkGetterSetterParams(publicMethod);
} else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) {
this.expectPlugin("decoratorAutoAccessors");
this.resetPreviousNodeTrailingComments(key);
const isPrivate = this.match(138);
this.parseClassElementName(publicProp);
this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);
} else if (this.isLineTerminator()) {
if (isPrivate) {
this.pushClassPrivateProperty(classBody, privateProp);
} else {
this.pushClassProperty(classBody, publicProp);
}
} else {
this.unexpected();
}
}
parseClassElementName(member) {
const {
type,
value
} = this.state;
if ((type === 132 || type === 133) && member.static && value === "prototype") {
this.raise(Errors.StaticPrototype, {
at: this.state.startLoc
});
}
if (type === 138) {
if (value === "constructor") {
this.raise(Errors.ConstructorClassPrivateField, {
at: this.state.startLoc
});
}
const key = this.parsePrivateName();
member.key = key;
return key;
}
return this.parsePropertyName(member);
}
parseClassStaticBlock(classBody, member) {
var _member$decorators;
this.scope.enter(64 | 128 | 16);
const oldLabels = this.state.labels;
this.state.labels = [];
this.prodParam.enter(PARAM);
const body = member.body = [];
this.parseBlockOrModuleBlockBody(body, undefined, false, 8);
this.prodParam.exit();
this.scope.exit();
this.state.labels = oldLabels;
classBody.body.push(this.finishNode(member, "StaticBlock"));
if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
this.raise(Errors.DecoratorStaticBlock, {
at: member
});
}
}
pushClassProperty(classBody, prop) {
if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
this.raise(Errors.ConstructorClassField, {
at: prop.key
});
}
classBody.body.push(this.parseClassProperty(prop));
}
pushClassPrivateProperty(classBody, prop) {
const node = this.parseClassPrivateProperty(prop);
classBody.body.push(node);
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
}
pushClassAccessorProperty(classBody, prop, isPrivate) {
if (!isPrivate && !prop.computed) {
const key = prop.key;
if (key.name === "constructor" || key.value === "constructor") {
this.raise(Errors.ConstructorClassField, {
at: key
});
}
}
const node = this.parseClassAccessorProperty(prop);
classBody.body.push(node);
if (isPrivate) {
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
}
}
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
}
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
classBody.body.push(node);
const kind = node.kind === "get" ? node.static ? 6 : 2 : node.kind === "set" ? node.static ? 5 : 1 : 0;
this.declareClassPrivateMethodInScope(node, kind);
}
declareClassPrivateMethodInScope(node, kind) {
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
}
parsePostMemberNameModifiers(methodOrProp) {}
parseClassPrivateProperty(node) {
this.parseInitializer(node);
this.semicolon();
return this.finishNode(node, "ClassPrivateProperty");
}
parseClassProperty(node) {
this.parseInitializer(node);
this.semicolon();
return this.finishNode(node, "ClassProperty");
}
parseClassAccessorProperty(node) {
this.parseInitializer(node);
this.semicolon();
return this.finishNode(node, "ClassAccessorProperty");
}
parseInitializer(node) {
this.scope.enter(64 | 16);
this.expressionScope.enter(newExpressionScope());
this.prodParam.enter(PARAM);
node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
this.expressionScope.exit();
this.prodParam.exit();
this.scope.exit();
}
parseClassId(node, isStatement, optionalId, bindingType = 8331) {
if (tokenIsIdentifier(this.state.type)) {
node.id = this.parseIdentifier();
if (isStatement) {
this.declareNameFromIdentifier(node.id, bindingType);
}
} else {
if (optionalId || !isStatement) {
node.id = null;
} else {
throw this.raise(Errors.MissingClassName, {
at: this.state.startLoc
});
}
}
}
parseClassSuper(node) {
node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
}
parseExport(node, decorators) {
const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
const parseAfterDefault = !hasDefault || this.eat(12);
const hasStar = parseAfterDefault && this.eatExportStar(node);
const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
const isFromRequired = hasDefault || hasStar;
if (hasStar && !hasNamespace) {
if (hasDefault) this.unexpected();
if (decorators) {
throw this.raise(Errors.UnsupportedDecoratorExport, {
at: node
});
}
this.parseExportFrom(node, true);
return this.finishNode(node, "ExportAllDeclaration");
}
const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
this.unexpected(null, 5);
}
if (hasNamespace && parseAfterNamespace) {
this.unexpected(null, 98);
}
let hasDeclaration;
if (isFromRequired || hasSpecifiers) {
hasDeclaration = false;
if (decorators) {
throw this.raise(Errors.UnsupportedDecoratorExport, {
at: node
});
}
this.parseExportFrom(node, isFromRequired);
} else {
hasDeclaration = this.maybeParseExportDeclaration(node);
}
if (isFromRequired || hasSpecifiers || hasDeclaration) {
var _node2$declaration;
const node2 = node;
this.checkExport(node2, true, false, !!node2.source);
if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
this.maybeTakeDecorators(decorators, node2.declaration, node2);
} else if (decorators) {
throw this.raise(Errors.UnsupportedDecoratorExport, {
at: node
});
}
return this.finishNode(node2, "ExportNamedDeclaration");
}
if (this.eat(65)) {
const node2 = node;
const decl = this.parseExportDefaultExpression();
node2.declaration = decl;
if (decl.type === "ClassDeclaration") {
this.maybeTakeDecorators(decorators, decl, node2);
} else if (decorators) {
throw this.raise(Errors.UnsupportedDecoratorExport, {
at: node
});
}
this.checkExport(node2, true, true);
return this.finishNode(node2, "ExportDefaultDeclaration");
}
this.unexpected(null, 5);
}
eatExportStar(node) {
return this.eat(55);
}
maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
const id = maybeDefaultIdentifier || this.parseIdentifier(true);
const specifier = this.startNodeAtNode(id);
specifier.exported = id;
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
return true;
}
return false;
}
maybeParseExportNamespaceSpecifier(node) {
if (this.isContextual(93)) {
if (!node.specifiers) node.specifiers = [];
const specifier = this.startNodeAt(this.state.lastTokStartLoc);
this.next();
specifier.exported = this.parseModuleExportName();
node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
return true;
}
return false;
}
maybeParseExportNamedSpecifiers(node) {
if (this.match(5)) {
if (!node.specifiers) node.specifiers = [];
const isTypeExport = node.exportKind === "type";
node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
node.source = null;
node.declaration = null;
if (this.hasPlugin("importAssertions")) {
node.assertions = [];
}
return true;
}
return false;
}
maybeParseExportDeclaration(node) {
if (this.shouldParseExportDeclaration()) {
node.specifiers = [];
node.source = null;
if (this.hasPlugin("importAssertions")) {
node.assertions = [];
}
node.declaration = this.parseExportDeclaration(node);
return true;
}
return false;
}
isAsyncFunction() {
if (!this.isContextual(95)) return false;
const next = this.nextTokenInLineStart();
return this.isUnparsedContextual(next, "function");
}
parseExportDefaultExpression() {
const expr = this.startNode();
if (this.match(68)) {
this.next();
return this.parseFunction(expr, 1 | 4);
} else if (this.isAsyncFunction()) {
this.next();
this.next();
return this.parseFunction(expr, 1 | 4 | 8);
}
if (this.match(80)) {
return this.parseClass(expr, true, true);
}
if (this.match(26)) {
if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
this.raise(Errors.DecoratorBeforeExport, {
at: this.state.startLoc
});
}
return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
}
if (this.match(75) || this.match(74) || this.isLet()) {
throw this.raise(Errors.UnsupportedDefaultExport, {
at: this.state.startLoc
});
}
const res = this.parseMaybeAssignAllowIn();
this.semicolon();
return res;
}
parseExportDeclaration(node) {
if (this.match(80)) {
const node = this.parseClass(this.startNode(), true, false);
return node;
}
return this.parseStatementListItem();
}
isExportDefaultSpecifier() {
const {
type
} = this.state;
if (tokenIsIdentifier(type)) {
if (type === 95 && !this.state.containsEsc || type === 100) {
return false;
}
if ((type === 130 || type === 129) && !this.state.containsEsc) {
const {
type: nextType
} = this.lookahead();
if (tokenIsIdentifier(nextType) && nextType !== 98 || nextType === 5) {
this.expectOnePlugin(["flow", "typescript"]);
return false;
}
}
} else if (!this.match(65)) {
return false;
}
const next = this.nextTokenStart();
const hasFrom = this.isUnparsedContextual(next, "from");
if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {
return true;
}
if (this.match(65) && hasFrom) {
const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
return nextAfterFrom === 34 || nextAfterFrom === 39;
}
return false;
}
parseExportFrom(node, expect) {
if (this.eatContextual(98)) {
node.source = this.parseImportSource();
this.checkExport(node);
this.maybeParseImportAttributes(node);
this.checkJSONModuleImport(node);
} else if (expect) {
this.unexpected();
}
this.semicolon();
}
shouldParseExportDeclaration() {
const {
type
} = this.state;
if (type === 26) {
this.expectOnePlugin(["decorators", "decorators-legacy"]);
if (this.hasPlugin("decorators")) {
if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
this.raise(Errors.DecoratorBeforeExport, {
at: this.state.startLoc
});
}
return true;
}
}
return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
}
checkExport(node, checkNames, isDefault, isFrom) {
if (checkNames) {
var _node$specifiers;
if (isDefault) {
this.checkDuplicateExports(node, "default");
if (this.hasPlugin("exportDefaultFrom")) {
var _declaration$extra;
const declaration = node.declaration;
if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {
this.raise(Errors.ExportDefaultFromAsIdentifier, {
at: declaration
});
}
}
} else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) {
for (const specifier of node.specifiers) {
const {
exported
} = specifier;
const exportName = exported.type === "Identifier" ? exported.name : exported.value;
this.checkDuplicateExports(specifier, exportName);
if (!isFrom && specifier.local) {
const {
local
} = specifier;
if (local.type !== "Identifier") {
this.raise(Errors.ExportBindingIsString, {
at: specifier,
localName: local.value,
exportName
});
} else {
this.checkReservedWord(local.name, local.loc.start, true, false);
this.scope.checkLocalExport(local);
}
}
}
} else if (node.declaration) {
if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
const id = node.declaration.id;
if (!id) throw new Error("Assertion failure");
this.checkDuplicateExports(node, id.name);
} else if (node.declaration.type === "VariableDeclaration") {
for (const declaration of node.declaration.declarations) {
this.checkDeclaration(declaration.id);
}
}
}
}
}
checkDeclaration(node) {
if (node.type === "Identifier") {
this.checkDuplicateExports(node, node.name);
} else if (node.type === "ObjectPattern") {
for (const prop of node.properties) {
this.checkDeclaration(prop);
}
} else if (node.type === "ArrayPattern") {
for (const elem of node.elements) {
if (elem) {
this.checkDeclaration(elem);
}
}
} else if (node.type === "ObjectProperty") {
this.checkDeclaration(node.value);
} else if (node.type === "RestElement") {
this.checkDeclaration(node.argument);
} else if (node.type === "AssignmentPattern") {
this.checkDeclaration(node.left);
}
}
checkDuplicateExports(node, exportName) {
if (this.exportedIdentifiers.has(exportName)) {
if (exportName === "default") {
this.raise(Errors.DuplicateDefaultExport, {
at: node
});
} else {
this.raise(Errors.DuplicateExport, {
at: node,
exportName
});
}
}
this.exportedIdentifiers.add(exportName);
}
parseExportSpecifiers(isInTypeExport) {
const nodes = [];
let first = true;
this.expect(5);
while (!this.eat(8)) {
if (first) {
first = false;
} else {
this.expect(12);
if (this.eat(8)) break;
}
const isMaybeTypeOnly = this.isContextual(130);
const isString = this.match(133);
const node = this.startNode();
node.local = this.parseModuleExportName();
nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
}
return nodes;
}
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
if (this.eatContextual(93)) {
node.exported = this.parseModuleExportName();
} else if (isString) {
node.exported = cloneStringLiteral(node.local);
} else if (!node.exported) {
node.exported = cloneIdentifier(node.local);
}
return this.finishNode(node, "ExportSpecifier");
}
parseModuleExportName() {
if (this.match(133)) {
const result = this.parseStringLiteral(this.state.value);
const surrogate = result.value.match(loneSurrogate);
if (surrogate) {
this.raise(Errors.ModuleExportNameHasLoneSurrogate, {
at: result,
surrogateCharCode: surrogate[0].charCodeAt(0)
});
}
return result;
}
return this.parseIdentifier(true);
}
isJSONModuleImport(node) {
if (node.assertions != null) {
return node.assertions.some(({
key,
value
}) => {
return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
});
}
return false;
}
checkImportReflection(node) {
const {
specifiers
} = node;
const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
if (node.phase === "source") {
if (singleBindingType !== "ImportDefaultSpecifier") {
this.raise(Errors.SourcePhaseImportRequiresDefault, {
at: specifiers[0].loc.start
});
}
} else if (node.phase === "defer") {
if (singleBindingType !== "ImportNamespaceSpecifier") {
this.raise(Errors.DeferImportRequiresNamespace, {
at: specifiers[0].loc.start
});
}
} else if (node.module) {
var _node$assertions;
if (singleBindingType !== "ImportDefaultSpecifier") {
this.raise(Errors.ImportReflectionNotBinding, {
at: specifiers[0].loc.start
});
}
if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {
this.raise(Errors.ImportReflectionHasAssertion, {
at: node.specifiers[0].loc.start
});
}
}
}
checkJSONModuleImport(node) {
if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
const {
specifiers
} = node;
if (specifiers != null) {
const nonDefaultNamedSpecifier = specifiers.find(specifier => {
let imported;
if (specifier.type === "ExportSpecifier") {
imported = specifier.local;
} else if (specifier.type === "ImportSpecifier") {
imported = specifier.imported;
}
if (imported !== undefined) {
return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
}
});
if (nonDefaultNamedSpecifier !== undefined) {
this.raise(Errors.ImportJSONBindingNotDefault, {
at: nonDefaultNamedSpecifier.loc.start
});
}
}
}
}
isPotentialImportPhase(isExport) {
if (isExport) return false;
return this.isContextual(105) || this.isContextual(97) || this.isContextual(127);
}
applyImportPhase(node, isExport, phase, loc) {
if (isExport) {
return;
}
if (phase === "module") {
this.expectPlugin("importReflection", loc);
node.module = true;
} else if (this.hasPlugin("importReflection")) {
node.module = false;
}
if (phase === "source") {
this.expectPlugin("sourcePhaseImports", loc);
node.phase = "source";
} else if (phase === "defer") {
this.expectPlugin("deferredImportEvaluation", loc);
node.phase = "defer";
} else if (this.hasPlugin("sourcePhaseImports")) {
node.phase = null;
}
}
parseMaybeImportPhase(node, isExport) {
if (!this.isPotentialImportPhase(isExport)) {
this.applyImportPhase(node, isExport, null);
return null;
}
const phaseIdentifier = this.parseIdentifier(true);
const {
type
} = this.state;
const isImportPhase = tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
if (isImportPhase) {
this.resetPreviousIdentifierLeadingComments(phaseIdentifier);
this.applyImportPhase(node, isExport, phaseIdentifier.name, phaseIdentifier.loc.start);
return null;
} else {
this.applyImportPhase(node, isExport, null);
return phaseIdentifier;
}
}
isPrecedingIdImportPhase(phase) {
const {
type
} = this.state;
return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
}
parseImport(node) {
if (this.match(133)) {
return this.parseImportSourceAndAttributes(node);
}
return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
}
parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
node.specifiers = [];
const hasDefault = this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier);
const parseNext = !hasDefault || this.eat(12);
const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
this.expectContextual(98);
return this.parseImportSourceAndAttributes(node);
}
parseImportSourceAndAttributes(node) {
var _node$specifiers2;
(_node$specifiers2 = node.specifiers) != null ? _node$specifiers2 : node.specifiers = [];
node.source = this.parseImportSource();
this.maybeParseImportAttributes(node);
this.checkImportReflection(node);
this.checkJSONModuleImport(node);
this.semicolon();
return this.finishNode(node, "ImportDeclaration");
}
parseImportSource() {
if (!this.match(133)) this.unexpected();
return this.parseExprAtom();
}
parseImportSpecifierLocal(node, specifier, type) {
specifier.local = this.parseIdentifier();
node.specifiers.push(this.finishImportSpecifier(specifier, type));
}
finishImportSpecifier(specifier, type, bindingType = 8201) {
this.checkLVal(specifier.local, {
in: {
type
},
binding: bindingType
});
return this.finishNode(specifier, type);
}
parseImportAttributes() {
this.expect(5);
const attrs = [];
const attrNames = new Set();
do {
if (this.match(8)) {
break;
}
const node = this.startNode();
const keyName = this.state.value;
if (attrNames.has(keyName)) {
this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
at: this.state.startLoc,
key: keyName
});
}
attrNames.add(keyName);
if (this.match(133)) {
node.key = this.parseStringLiteral(keyName);
} else {
node.key = this.parseIdentifier(true);
}
this.expect(14);
if (!this.match(133)) {
throw this.raise(Errors.ModuleAttributeInvalidValue, {
at: this.state.startLoc
});
}
node.value = this.parseStringLiteral(this.state.value);
attrs.push(this.finishNode(node, "ImportAttribute"));
} while (this.eat(12));
this.expect(8);
return attrs;
}
parseModuleAttributes() {
const attrs = [];
const attributes = new Set();
do {
const node = this.startNode();
node.key = this.parseIdentifier(true);
if (node.key.name !== "type") {
this.raise(Errors.ModuleAttributeDifferentFromType, {
at: node.key
});
}
if (attributes.has(node.key.name)) {
this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
at: node.key,
key: node.key.name
});
}
attributes.add(node.key.name);
this.expect(14);
if (!this.match(133)) {
throw this.raise(Errors.ModuleAttributeInvalidValue, {
at: this.state.startLoc
});
}
node.value = this.parseStringLiteral(this.state.value);
attrs.push(this.finishNode(node, "ImportAttribute"));
} while (this.eat(12));
return attrs;
}
maybeParseImportAttributes(node) {
let attributes;
let useWith = false;
if (this.match(76)) {
if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) {
return;
}
this.next();
{
if (this.hasPlugin("moduleAttributes")) {
attributes = this.parseModuleAttributes();
} else {
this.expectImportAttributesPlugin();
attributes = this.parseImportAttributes();
}
}
useWith = true;
} else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
if (this.hasPlugin("importAttributes")) {
if (this.getPluginOption("importAttributes", "deprecatedAssertSyntax") !== true) {
this.raise(Errors.ImportAttributesUseAssert, {
at: this.state.startLoc
});
}
this.addExtra(node, "deprecatedAssertSyntax", true);
} else {
this.expectOnePlugin(["importAttributes", "importAssertions"]);
}
this.next();
attributes = this.parseImportAttributes();
} else if (this.hasPlugin("importAttributes") || this.hasPlugin("importAssertions")) {
attributes = [];
} else {
if (this.hasPlugin("moduleAttributes")) {
attributes = [];
} else return;
}
if (!useWith && this.hasPlugin("importAssertions")) {
node.assertions = attributes;
} else {
node.attributes = attributes;
}
}
maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
if (maybeDefaultIdentifier) {
const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
specifier.local = maybeDefaultIdentifier;
node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
return true;
} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
return true;
}
return false;
}
maybeParseStarImportSpecifier(node) {
if (this.match(55)) {
const specifier = this.startNode();
this.next();
this.expectContextual(93);
this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
return true;
}
return false;
}
parseNamedImportSpecifiers(node) {
let first = true;
this.expect(5);
while (!this.eat(8)) {
if (first) {
first = false;
} else {
if (this.eat(14)) {
throw this.raise(Errors.DestructureNamedImport, {
at: this.state.startLoc
});
}
this.expect(12);
if (this.eat(8)) break;
}
const specifier = this.startNode();
const importedIsString = this.match(133);
const isMaybeTypeOnly = this.isContextual(130);
specifier.imported = this.parseModuleExportName();
const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined);
node.specifiers.push(importSpecifier);
}
}
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
if (this.eatContextual(93)) {
specifier.local = this.parseIdentifier();
} else {
const {
imported
} = specifier;
if (importedIsString) {
throw this.raise(Errors.ImportBindingIsString, {
at: specifier,
importName: imported.value
});
}
this.checkReservedWord(imported.name, specifier.loc.start, true, true);
if (!specifier.local) {
specifier.local = cloneIdentifier(imported);
}
}
return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
}
isThisParam(param) {
return param.type === "Identifier" && param.name === "this";
}
}
class Parser extends StatementParser {
constructor(options, input) {
options = getOptions(options);
super(options, input);
this.options = options;
this.initializeScopes();
this.plugins = pluginsMap(this.options.plugins);
this.filename = options.sourceFilename;
}
getScopeHandler() {
return ScopeHandler;
}
parse() {
this.enterInitialScopes();
const file = this.startNode();
const program = this.startNode();
this.nextToken();
file.errors = null;
this.parseTopLevel(file, program);
file.errors = this.state.errors;
return file;
}
}
function pluginsMap(plugins) {
const pluginMap = new Map();
for (const plugin of plugins) {
const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
if (!pluginMap.has(name)) pluginMap.set(name, options || {});
}
return pluginMap;
}
function parse(input, options) {
var _options;
if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
options = Object.assign({}, options);
try {
options.sourceType = "module";
const parser = getParser(options, input);
const ast = parser.parse();
if (parser.sawUnambiguousESM) {
return ast;
}
if (parser.ambiguousScriptDifferentAst) {
try {
options.sourceType = "script";
return getParser(options, input).parse();
} catch (_unused) {}
} else {
ast.program.sourceType = "script";
}
return ast;
} catch (moduleError) {
try {
options.sourceType = "script";
return getParser(options, input).parse();
} catch (_unused2) {}
throw moduleError;
}
} else {
return getParser(options, input).parse();
}
}
function parseExpression(input, options) {
const parser = getParser(options, input);
if (parser.options.strictMode) {
parser.state.strict = true;
}
return parser.getExpression();
}
function generateExportedTokenTypes(internalTokenTypes) {
const tokenTypes = {};
for (const typeName of Object.keys(internalTokenTypes)) {
tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
}
return tokenTypes;
}
const tokTypes = generateExportedTokenTypes(tt);
function getParser(options, input) {
let cls = Parser;
if (options != null && options.plugins) {
validatePlugins(options.plugins);
cls = getParserClass(options.plugins);
}
return new cls(options, input);
}
const parserClassCache = {};
function getParserClass(pluginsFromOptions) {
const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name));
const key = pluginList.join("/");
let cls = parserClassCache[key];
if (!cls) {
cls = Parser;
for (const plugin of pluginList) {
cls = mixinPlugins[plugin](cls);
}
parserClassCache[key] = cls;
}
return cls;
}
lib$1.parse = parse;
lib$1.parseExpression = parseExpression;
lib$1.tokTypes = tokTypes;
return lib$1;
}
var libExports$1 = requireLib$1();
/**
*
* Copyright (c) by Ryan Duff
* Licensed under the MIT License.
*/
const alphanum = /[a-z0-9\-]/i;
function parseToken(str, start) {
let i = start;
while (i < str.length && alphanum.test(str.charAt(i++))) {
continue;
}
if (i !== start) {
return {
token: str.substring(start, i - 1),
index: i,
};
}
return null;
}
function parseAttributes(str, start) {
let i = start;
const attributes = {};
let attribute = null;
while (i < str.length) {
const c = str.charAt(i);
if (attribute === null && c == ">") {
break;
} else if (attribute === null && alphanum.test(c)) {
attribute = {
name: null,
value: true,
bool: true,
terminator: null,
};
const attributeNameNode = parseToken(str, i);
if (attributeNameNode) {
attribute.name = attributeNameNode.token;
i = attributeNameNode.index - 2;
}
} else if (attribute !== null) {
if (c === "=") {
// once we've started an attribute, look for = to indicate
// it's a non-boolean attribute
attribute.bool = false;
if (attribute.value === true) {
attribute.value = "";
}
} else if (
!attribute.bool &&
attribute.terminator === null &&
(c === '"' || c === "'")
) {
// once we've determined it's non-boolean, look for a
// value terminator (", ')
attribute.terminator = c;
} else if (attribute.terminator) {
if (c === attribute.terminator) {
// if we had a terminator and found another, we've
// reach the end of the attribute
attributes[attribute.name] = attribute.value;
attribute = null;
} else {
// otherwise, append the character to the attribute value
attribute.value += c;
// check for an escaped terminator and push it as well
// to avoid terminating prematurely
if (c === "\\") {
const next = str.charAt(i + 1);
if (next === attribute.terminator) {
attribute.value += next;
i += 1;
}
}
}
} else if (!/\s/.test(c)) {
// if we've hit a non-space character and aren't processing a value,
// we're starting a new attribute so push the attribute and clear the
// local variable
attributes[attribute.name] = attribute.value;
attribute = null;
// move the cursor back to re-find the start of the attribute
i -= 1;
}
}
i++;
}
if (i !== start) {
return {
attributes,
index: i,
};
}
return null;
}
function parseFragment(str, start = 0) {
let tag = null;
let open = false;
let attributes = {};
let i = start;
while (i < str.length) {
const c = str.charAt(i++);
if (!open && !tag && c === "<") {
// Open Start Tag
open = true;
const tagNode = parseToken(str, i);
if (!tagNode) {
return null;
}
i = tagNode.index - 1;
tag = tagNode.token;
} else if (open && c === ">") {
// Close Start Tag
break;
} else if (open) {
// Attributes
const attributeNode = parseAttributes(str, i - 1);
if (attributeNode) {
i = attributeNode.index;
attributes = attributeNode.attributes || attributes;
}
}
}
if (tag) {
return {
tag,
attributes,
};
}
return null;
}
const startScript = /<script[^>]*>/im;
const endScript = /<\/script\s*>/im;
const newLines = /\r\n|[\n\v\f\r\x85\u2028\u2029]/;
function getType(tag) {
const fragment = parseFragment(tag);
if (fragment) {
const type = fragment.attributes.type;
return type ? type.toLowerCase() : null;
}
return null;
}
function getCandidateScriptLocations(source, index) {
const i = index || 0;
const str = source.substring(i);
const startMatch = startScript.exec(str);
if (startMatch) {
const startsAt = startMatch.index + startMatch[0].length;
const afterStart = str.substring(startsAt);
const endMatch = endScript.exec(afterStart);
if (endMatch) {
const locLength = endMatch.index;
const locIndex = i + startsAt;
const endIndex = locIndex + locLength + endMatch[0].length;
// extract the complete tag (incl start and end tags and content). if the
// type is invalid (= not JS), skip this tag and continue
const tag = source.substring(i + startMatch.index, endIndex);
const type = getType(tag);
if (
type &&
type !== "javascript" &&
type !== "text/javascript" &&
type !== "module"
) {
return getCandidateScriptLocations(source, endIndex);
}
return [
adjustForLineAndColumn(source, {
index: locIndex,
length: locLength,
source: source.substring(locIndex, locIndex + locLength),
}),
...getCandidateScriptLocations(source, endIndex),
];
}
}
return [];
}
function parseScripts(locations, parser) {
return locations.map(parser);
}
function calcLineAndColumn(source, index) {
const lines = source.substring(0, index).split(newLines);
const line = lines.length;
const column = lines.pop().length + 1;
return {
column,
line,
};
}
function adjustForLineAndColumn(fullSource, location) {
const { column, line } = calcLineAndColumn(fullSource, location.index);
return Object.assign({}, location, {
line,
column,
// prepend whitespace for scripts that do not start on the first column
// NOTE: `column` is 1-based
source: " ".repeat(column - 1) + location.source,
});
}
function parseScriptTags$1(source, parser) {
const scripts = parseScripts(getCandidateScriptLocations(source), parser)
.filter(libExports$2.isFile)
.reduce(
(main, script) => {
return {
statements: main.statements.concat(script.program.body),
comments: main.comments.concat(script.comments),
tokens: main.tokens.concat(script.tokens),
};
},
{
statements: [],
comments: [],
tokens: [],
}
);
const program = libExports$2.program(scripts.statements);
const file = libExports$2.file(program, scripts.comments, scripts.tokens);
const end = calcLineAndColumn(source, source.length);
file.start = program.start = 0;
file.end = program.end = source.length;
file.loc = program.loc = {
start: {
line: 1,
column: 0,
},
end,
};
return file;
}
function parseScript$1({ source, line }) {
// remove empty or only whitespace scripts
if (source.length === 0 || /^\s+$/.test(source)) {
return null;
}
try {
return libExports$1.parse(source, {
sourceType: "script",
startLine: line,
});
} catch (e) {
return null;
}
}
function parseScriptTags(source, parser = parseScript$1) {
return parseScriptTags$1(source, parser);
}
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
const cachedSources = new Map();
function setSource(source) {
cachedSources.set(source.id, source);
}
function getSource(sourceId) {
const source = cachedSources.get(sourceId);
if (!source) {
throw new Error(`Parser: source ${sourceId} was not provided.`);
}
return source;
}
function clearSources(sourceIds) {
for (const sourceId of sourceIds) {
cachedSources.delete(sourceId);
}
}
const ASTs = new Map();
function _parse(code, opts) {
return libExports$1.parse(code, {
...opts,
tokens: true,
});
}
const sourceOptions = {
generated: {
sourceType: "unambiguous",
tokens: true,
plugins: [
"classStaticBlock",
"classPrivateProperties",
"classPrivateMethods",
"classProperties",
"objectRestSpread",
"optionalChaining",
"privateIn",
"nullishCoalescingOperator",
"regexpUnicodeSets",
],
},
original: {
sourceType: "unambiguous",
tokens: true,
plugins: [
"jsx",
"flow",
"doExpressions",
"optionalChaining",
"nullishCoalescingOperator",
"decorators-legacy",
"objectRestSpread",
"classStaticBlock",
"classPrivateProperties",
"classPrivateMethods",
"classProperties",
"exportDefaultFrom",
"exportNamespaceFrom",
"asyncGenerators",
"functionBind",
"functionSent",
"dynamicImport",
"react-jsx",
"regexpUnicodeSets",
],
},
};
function parse(text, opts) {
let ast = {};
if (!text) {
return ast;
}
try {
ast = _parse(text, opts);
} catch (error) {
console.error(error);
}
return ast;
}
// Custom parser for parse-script-tags that adapts its input structure to
// our parser's signature
function htmlParser({ source, line }) {
return parse(source, { startLine: line, ...sourceOptions.generated });
}
const VUE_COMPONENT_START = /^\s*</;
function vueParser({ source, line }) {
return parse(source, {
startLine: line,
...sourceOptions.original,
});
}
function parseVueScript(code) {
if (typeof code !== "string") {
return {};
}
let ast;
// .vue files go through several passes, so while there is a
// single-file-component Vue template, there are also generally .vue files
// that are still just JS as well.
if (code.match(VUE_COMPONENT_START)) {
ast = parseScriptTags(code, vueParser);
if (libExports$2.isFile(ast)) {
// parseScriptTags is currently hard-coded to return scripts, but Vue
// always expects ESM syntax, so we just hard-code it.
ast.program.sourceType = "module";
}
} else {
ast = parse(code, sourceOptions.original);
}
return ast;
}
function parseConsoleScript(text, opts) {
try {
return _parse(text, {
plugins: [
"classStaticBlock",
"classPrivateProperties",
"classPrivateMethods",
"objectRestSpread",
"dynamicImport",
"nullishCoalescingOperator",
"optionalChaining",
"regexpUnicodeSets",
],
...opts,
allowAwaitOutsideFunction: true,
});
} catch (e) {
return null;
}
}
function parseScript(text, opts) {
return _parse(text, opts);
}
function getAst(sourceId) {
if (ASTs.has(sourceId)) {
return ASTs.get(sourceId);
}
const source = getSource(sourceId);
if (source.isWasm) {
return null;
}
let ast = {};
const { contentType } = source;
if (contentType == "text/html") {
ast = parseScriptTags(source.text, htmlParser) || {};
} else if (contentType && contentType === "text/vue") {
ast = parseVueScript(source.text) || {};
} else if (
contentType &&
contentType.match(/(javascript|jsx)/) &&
!contentType.match(/typescript-jsx/)
) {
const type = source.id.includes("original") ? "original" : "generated";
const options = sourceOptions[type];
ast = parse(source.text, options);
} else if (contentType && contentType.match(/typescript/)) {
const options = {
...sourceOptions.original,
plugins: [
...sourceOptions.original.plugins.filter(
p =>
p !== "flow" &&
p !== "decorators" &&
p !== "decorators2" &&
(p !== "jsx" || contentType.match(/typescript-jsx/))
),
"decorators-legacy",
"typescript",
],
};
ast = parse(source.text, options);
}
ASTs.set(source.id, ast);
return ast;
}
function clearASTs(sourceIds) {
for (const sourceId of sourceIds) {
ASTs.delete(sourceId);
}
}
function traverseAst(sourceId, visitor, state) {
const ast = getAst(sourceId);
if (!ast || !Object.keys(ast).length) {
return null;
}
libExports$2.traverse(ast, visitor, state);
return ast;
}
function hasNode(rootNode, predicate) {
try {
libExports$2.traverse(rootNode, {
enter: (node, ancestors) => {
if (predicate(node, ancestors)) {
throw new Error("MATCH");
}
},
});
} catch (e) {
if (e.message === "MATCH") {
return true;
}
}
return false;
}
function replaceNode$1(ancestors, node) {
const parent = ancestors[ancestors.length - 1];
if (typeof parent.index === "number") {
if (Array.isArray(node)) {
parent.node[parent.key].splice(parent.index, 1, ...node);
} else {
parent.node[parent.key][parent.index] = node;
}
} else {
parent.node[parent.key] = node;
}
}
var lib = {};
var sourceMap = {};
var genMapping_umd = {exports: {}};
var setArray_umd = {exports: {}};
var hasRequiredSetArray_umd;
function requireSetArray_umd () {
if (hasRequiredSetArray_umd) return setArray_umd.exports;
hasRequiredSetArray_umd = 1;
(function (module, exports) {
(function (global, factory) {
factory(exports) ;
})(commonjsGlobal, (function (exports) {
/**
* Gets the index associated with `key` in the backing array, if it is already present.
*/
exports.get = void 0;
/**
* Puts `key` into the backing array, if it is not already present. Returns
* the index of the `key` in the backing array.
*/
exports.put = void 0;
/**
* Pops the last added item out of the SetArray.
*/
exports.pop = void 0;
/**
* SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
* index of the `key` in the backing array.
*
* This is designed to allow synchronizing a second array with the contents of the backing array,
* like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
* and there are never duplicates.
*/
class SetArray {
constructor() {
this._indexes = { __proto__: null };
this.array = [];
}
}
(() => {
exports.get = (strarr, key) => strarr._indexes[key];
exports.put = (strarr, key) => {
// The key may or may not be present. If it is present, it's a number.
const index = exports.get(strarr, key);
if (index !== undefined)
return index;
const { array, _indexes: indexes } = strarr;
return (indexes[key] = array.push(key) - 1);
};
exports.pop = (strarr) => {
const { array, _indexes: indexes } = strarr;
if (array.length === 0)
return;
const last = array.pop();
indexes[last] = undefined;
};
})();
exports.SetArray = SetArray;
Object.defineProperty(exports, '__esModule', { value: true });
}));
} (setArray_umd, setArray_umd.exports));
return setArray_umd.exports;
}
var lookup = [];
var revLookup = [];
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
var inited = false;
function init () {
inited = true;
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i];
revLookup[code.charCodeAt(i)] = i;
}
revLookup['-'.charCodeAt(0)] = 62;
revLookup['_'.charCodeAt(0)] = 63;
}
function toByteArray (b64) {
if (!inited) {
init();
}
var i, j, l, tmp, placeHolders, arr;
var len = b64.length;
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// the number of equal signs (place holders)
// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent 2 bytes
// this is just a cheap hack to not do indexOf twice
placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;
// base64 is 4/3 + up to two characters of the original data
arr = new Arr(len * 3 / 4 - placeHolders);
// if there are placeholders, only get up to the last complete 4 chars
l = placeHolders > 0 ? len - 4 : len;
var L = 0;
for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
arr[L++] = (tmp >> 16) & 0xFF;
arr[L++] = (tmp >> 8) & 0xFF;
arr[L++] = tmp & 0xFF;
}
if (placeHolders === 2) {
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
arr[L++] = tmp & 0xFF;
} else if (placeHolders === 1) {
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
arr[L++] = (tmp >> 8) & 0xFF;
arr[L++] = tmp & 0xFF;
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp;
var output = [];
for (var i = start; i < end; i += 3) {
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
output.push(tripletToBase64(tmp));
}
return output.join('')
}
function fromByteArray (uint8) {
if (!inited) {
init();
}
var tmp;
var len = uint8.length;
var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
var output = '';
var parts = [];
var maxChunkLength = 16383; // must be multiple of 3
// go through the array every three bytes, we'll deal with trailing stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
}
// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1];
output += lookup[tmp >> 2];
output += lookup[(tmp << 4) & 0x3F];
output += '==';
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
output += lookup[tmp >> 10];
output += lookup[(tmp >> 4) & 0x3F];
output += lookup[(tmp << 2) & 0x3F];
output += '=';
}
parts.push(output);
return parts.join('')
}
function read (buffer, offset, isLE, mLen, nBytes) {
var e, m;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i = isLE ? (nBytes - 1) : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & ((1 << (-nBits)) - 1);
s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1);
e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
function write (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
var i = isLE ? 0 : (nBytes - 1);
var d = isLE ? 1 : -1;
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128;
}
var toString = {}.toString;
var isArray = Array.isArray || function (arr) {
return toString.call(arr) == '[object Array]';
};
/*!
* The buffer module from node.js, for the browser.
*
* @license MIT
*/
var INSPECT_MAX_BYTES = 50;
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Due to various browser bugs, sometimes the Object implementation will be used even
* when the browser supports typed arrays.
*
* Note:
*
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
* incorrect length in some situations.
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
* get the Object implementation, which is slower but behaves correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
? global$1.TYPED_ARRAY_SUPPORT
: true;
/*
* Export kMaxLength after typed array support is determined.
*/
kMaxLength();
function kMaxLength () {
return Buffer.TYPED_ARRAY_SUPPORT
? 0x7fffffff
: 0x3fffffff
}
function createBuffer (that, length) {
if (kMaxLength() < length) {
throw new RangeError('Invalid typed array length')
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = new Uint8Array(length);
that.__proto__ = Buffer.prototype;
} else {
// Fallback: Return an object instance of the Buffer class
if (that === null) {
that = new Buffer(length);
}
that.length = length;
}
return that
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer (arg, encodingOrOffset, length) {
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
return new Buffer(arg, encodingOrOffset, length)
}
// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new Error(
'If encoding is specified then the first argument must be a string'
)
}
return allocUnsafe(this, arg)
}
return from(this, arg, encodingOrOffset, length)
}
Buffer.poolSize = 8192; // not used by this implementation
// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
arr.__proto__ = Buffer.prototype;
return arr
};
function from (that, value, encodingOrOffset, length) {
if (typeof value === 'number') {
throw new TypeError('"value" argument must not be a number')
}
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
return fromArrayBuffer(that, value, encodingOrOffset, length)
}
if (typeof value === 'string') {
return fromString(that, value, encodingOrOffset)
}
return fromObject(that, value)
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function (value, encodingOrOffset, length) {
return from(null, value, encodingOrOffset, length)
};
if (Buffer.TYPED_ARRAY_SUPPORT) {
Buffer.prototype.__proto__ = Uint8Array.prototype;
Buffer.__proto__ = Uint8Array;
}
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be a number')
} else if (size < 0) {
throw new RangeError('"size" argument must not be negative')
}
}
function alloc (that, size, fill, encoding) {
assertSize(size);
if (size <= 0) {
return createBuffer(that, size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(that, size).fill(fill, encoding)
: createBuffer(that, size).fill(fill)
}
return createBuffer(that, size)
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function (size, fill, encoding) {
return alloc(null, size, fill, encoding)
};
function allocUnsafe (that, size) {
assertSize(size);
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
if (!Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < size; ++i) {
that[i] = 0;
}
}
return that
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function (size) {
return allocUnsafe(null, size)
};
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(null, size)
};
function fromString (that, string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8';
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('"encoding" must be a valid string encoding')
}
var length = byteLength(string, encoding) | 0;
that = createBuffer(that, length);
var actual = that.write(string, encoding);
if (actual !== length) {
// Writing a hex string, for example, that contains invalid characters will
// cause everything after the first invalid character to be ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
that = that.slice(0, actual);
}
return that
}
function fromArrayLike (that, array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0;
that = createBuffer(that, length);
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255;
}
return that
}
function fromArrayBuffer (that, array, byteOffset, length) {
array.byteLength; // this throws if `array` is not a valid ArrayBuffer
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('\'offset\' is out of bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('\'length\' is out of bounds')
}
if (byteOffset === undefined && length === undefined) {
array = new Uint8Array(array);
} else if (length === undefined) {
array = new Uint8Array(array, byteOffset);
} else {
array = new Uint8Array(array, byteOffset, length);
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = array;
that.__proto__ = Buffer.prototype;
} else {
// Fallback: Return an object instance of the Buffer class
that = fromArrayLike(that, array);
}
return that
}
function fromObject (that, obj) {
if (internalIsBuffer(obj)) {
var len = checked(obj.length) | 0;
that = createBuffer(that, len);
if (that.length === 0) {
return that
}
obj.copy(that, 0, 0, len);
return that
}
if (obj) {
if ((typeof ArrayBuffer !== 'undefined' &&
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
if (typeof obj.length !== 'number' || isnan(obj.length)) {
return createBuffer(that, 0)
}
return fromArrayLike(that, obj)
}
if (obj.type === 'Buffer' && isArray(obj.data)) {
return fromArrayLike(that, obj.data)
}
}
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}
function checked (length) {
// Note: cannot use `length < kMaxLength()` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= kMaxLength()) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength().toString(16) + ' bytes')
}
return length | 0
}
Buffer.isBuffer = isBuffer;
function internalIsBuffer (b) {
return !!(b != null && b._isBuffer)
}
Buffer.compare = function compare (a, b) {
if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
throw new TypeError('Arguments must be Buffers')
}
if (a === b) return 0
var x = a.length;
var y = b.length;
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
};
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'latin1':
case 'binary':
case 'base64':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
};
Buffer.concat = function concat (list, length) {
if (!isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return Buffer.alloc(0)
}
var i;
if (length === undefined) {
length = 0;
for (i = 0; i < list.length; ++i) {
length += list[i].length;
}
}
var buffer = Buffer.allocUnsafe(length);
var pos = 0;
for (i = 0; i < list.length; ++i) {
var buf = list[i];
if (!internalIsBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos);
pos += buf.length;
}
return buffer
};
function byteLength (string, encoding) {
if (internalIsBuffer(string)) {
return string.length
}
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
string = '' + string;
}
var len = string.length;
if (len === 0) return 0
// Use a for loop to avoid recursion
var loweredCase = false;
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
case undefined:
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) return utf8ToBytes(string).length // assume utf8
encoding = ('' + encoding).toLowerCase();
loweredCase = true;
}
}
}
Buffer.byteLength = byteLength;
function slowToString (encoding, start, end) {
var loweredCase = false;
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
// property of a typed array.
// This behaves neither like String nor Uint8Array in that we set start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0;
}
// Return early if start > this.length. Done here to prevent potential uint32
// coercion fail below.
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length;
}
if (end <= 0) {
return ''
}
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
end >>>= 0;
start >>>= 0;
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8';
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'latin1':
case 'binary':
return latin1Slice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase();
loweredCase = true;
}
}
}
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = true;
function swap (b, n, m) {
var i = b[n];
b[n] = b[m];
b[m] = i;
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length;
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1);
}
return this
};
Buffer.prototype.swap32 = function swap32 () {
var len = this.length;
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this
};
Buffer.prototype.swap64 = function swap64 () {
var len = this.length;
if (len % 8 !== 0) {
throw new RangeError('Buffer size must be a multiple of 64-bits')
}
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this
};
Buffer.prototype.toString = function toString () {
var length = this.length | 0;
if (length === 0) return ''
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
};
Buffer.prototype.equals = function equals (b) {
if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
};
Buffer.prototype.inspect = function inspect () {
var str = '';
var max = INSPECT_MAX_BYTES;
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
if (this.length > max) str += ' ... ';
}
return '<Buffer ' + str + '>'
};
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
if (!internalIsBuffer(target)) {
throw new TypeError('Argument must be a Buffer')
}
if (start === undefined) {
start = 0;
}
if (end === undefined) {
end = target ? target.length : 0;
}
if (thisStart === undefined) {
thisStart = 0;
}
if (thisEnd === undefined) {
thisEnd = this.length;
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0;
end >>>= 0;
thisStart >>>= 0;
thisEnd >>>= 0;
if (this === target) return 0
var x = thisEnd - thisStart;
var y = end - start;
var len = Math.min(x, y);
var thisCopy = this.slice(thisStart, thisEnd);
var targetCopy = target.slice(start, end);
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i];
y = targetCopy[i];
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
};
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
// Empty buffer means no match
if (buffer.length === 0) return -1
// Normalize byteOffset
if (typeof byteOffset === 'string') {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff;
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000;
}
byteOffset = +byteOffset; // Coerce to Number.
if (isNaN(byteOffset)) {
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
byteOffset = dir ? 0 : (buffer.length - 1);
}
// Normalize byteOffset: negative offsets start from the end of the buffer
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
if (byteOffset >= buffer.length) {
if (dir) return -1
else byteOffset = buffer.length - 1;
} else if (byteOffset < 0) {
if (dir) byteOffset = 0;
else return -1
}
// Normalize val
if (typeof val === 'string') {
val = Buffer.from(val, encoding);
}
// Finally, search either indexOf (if dir is true) or lastIndexOf
if (internalIsBuffer(val)) {
// Special case: looking for empty string/buffer always fails
if (val.length === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF; // Search for a byte value [0-255]
if (Buffer.TYPED_ARRAY_SUPPORT &&
typeof Uint8Array.prototype.indexOf === 'function') {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
throw new TypeError('val must be string, number or Buffer')
}
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
var indexSize = 1;
var arrLength = arr.length;
var valLength = val.length;
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase();
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2;
arrLength /= 2;
valLength /= 2;
byteOffset /= 2;
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var i;
if (dir) {
var foundIndex = -1;
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i = byteOffset; i >= 0; i--) {
var found = true;
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false;
break
}
}
if (found) return i
}
}
return -1
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
};
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
};
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
};
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0;
var remaining = buf.length - offset;
if (!length) {
length = remaining;
} else {
length = Number(length);
if (length > remaining) {
length = remaining;
}
}
// must be an even number of digits
var strLen = string.length;
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
if (length > strLen / 2) {
length = strLen / 2;
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16);
if (isNaN(parsed)) return i
buf[offset + i] = parsed;
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function latin1Write (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
// Buffer#write(string)
if (offset === undefined) {
encoding = 'utf8';
length = this.length;
offset = 0;
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
encoding = offset;
length = this.length;
offset = 0;
// Buffer#write(string, offset[, length][, encoding])
} else if (isFinite(offset)) {
offset = offset | 0;
if (isFinite(length)) {
length = length | 0;
if (encoding === undefined) encoding = 'utf8';
} else {
encoding = length;
length = undefined;
}
// legacy write(string, encoding, offset, length) - remove in v0.13
} else {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
var remaining = this.length - offset;
if (length === undefined || length > remaining) length = remaining;
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8';
var loweredCase = false;
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)
case 'base64':
// Warning: maxLength not taken into account in base64Write
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase();
loweredCase = true;
}
}
};
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
};
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return fromByteArray(buf)
} else {
return fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
end = Math.min(buf.length, end);
var res = [];
var i = start;
while (i < end) {
var firstByte = buf[i];
var codePoint = null;
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1;
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte;
}
break
case 2:
secondByte = buf[i + 1];
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint;
}
}
break
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint;
}
}
break
case 4:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 3];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint;
}
}
}
}
if (codePoint === null) {
// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD;
bytesPerSequence = 1;
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000;
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
codePoint = 0xDC00 | codePoint & 0x3FF;
}
res.push(codePoint);
i += bytesPerSequence;
}
return decodeCodePointsArray(res)
}
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000;
function decodeCodePointsArray (codePoints) {
var len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
}
// Decode in chunks to avoid "call stack size exceeded".
var res = '';
var i = 0;
while (i < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
);
}
return res
}
function asciiSlice (buf, start, end) {
var ret = '';
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i] & 0x7F);
}
return ret
}
function latin1Slice (buf, start, end) {
var ret = '';
end = Math.min(buf.length, end);
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i]);
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
var out = '';
for (var i = start; i < end; ++i) {
out += toHex(buf[i]);
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end);
var res = '';
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length;
start = ~~start;
end = end === undefined ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0) start = 0;
} else if (start > len) {
start = len;
}
if (end < 0) {
end += len;
if (end < 0) end = 0;
} else if (end > len) {
end = len;
}
if (end < start) end = start;
var newBuf;
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = this.subarray(start, end);
newBuf.__proto__ = Buffer.prototype;
} else {
var sliceLen = end - start;
newBuf = new Buffer(sliceLen, undefined);
for (var i = 0; i < sliceLen; ++i) {
newBuf[i] = this[i + start];
}
}
return newBuf
};
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;
}
return val
};
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) {
checkOffset(offset, byteLength, this.length);
}
var val = this[offset + --byteLength];
var mul = 1;
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul;
}
return val
};
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset]
};
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | (this[offset + 1] << 8)
};
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length);
return (this[offset] << 8) | this[offset + 1]
};
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
};
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
};
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var val = this[offset];
var mul = 1;
var i = 0;
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;
}
mul *= 0x80;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val
};
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
var i = byteLength;
var mul = 1;
var val = this[offset + --i];
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul;
}
mul *= 0x80;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val
};
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length);
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
};
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset] | (this[offset + 1] << 8);
return (val & 0x8000) ? val | 0xFFFF0000 : val
};
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length);
var val = this[offset + 1] | (this[offset] << 8);
return (val & 0x8000) ? val | 0xFFFF0000 : val
};
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
};
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
};
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return read(this, offset, true, 23, 4)
};
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length);
return read(this, offset, false, 23, 4)
};
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length);
return read(this, offset, true, 52, 8)
};
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length);
return read(this, offset, false, 52, 8)
};
function checkInt (buf, value, offset, ext, max, min) {
if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
if (offset + ext > buf.length) throw new RangeError('Index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var mul = 1;
var i = 0;
this[offset] = value & 0xFF;
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset | 0;
byteLength = byteLength | 0;
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
var i = byteLength - 1;
var mul = 1;
this[offset + i] = value & 0xFF;
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
this[offset] = (value & 0xff);
return offset + 1
};
function objectWriteUInt16 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffff + value + 1;
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8;
}
}
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
} else {
objectWriteUInt16(this, value, offset, true);
}
return offset + 2
};
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8);
this[offset + 1] = (value & 0xff);
} else {
objectWriteUInt16(this, value, offset, false);
}
return offset + 2
};
function objectWriteUInt32 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffffffff + value + 1;
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
}
}
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24);
this[offset + 2] = (value >>> 16);
this[offset + 1] = (value >>> 8);
this[offset] = (value & 0xff);
} else {
objectWriteUInt32(this, value, offset, true);
}
return offset + 4
};
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24);
this[offset + 1] = (value >>> 16);
this[offset + 2] = (value >>> 8);
this[offset + 3] = (value & 0xff);
} else {
objectWriteUInt32(this, value, offset, false);
}
return offset + 4
};
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = 0;
var mul = 1;
var sub = 0;
this[offset] = value & 0xFF;
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1;
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
var i = byteLength - 1;
var mul = 1;
var sub = 0;
this[offset + i] = value & 0xFF;
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1;
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
}
return offset + byteLength
};
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
if (value < 0) value = 0xff + value + 1;
this[offset] = (value & 0xff);
return offset + 1
};
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
} else {
objectWriteUInt16(this, value, offset, true);
}
return offset + 2
};
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8);
this[offset + 1] = (value & 0xff);
} else {
objectWriteUInt16(this, value, offset, false);
}
return offset + 2
};
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff);
this[offset + 1] = (value >>> 8);
this[offset + 2] = (value >>> 16);
this[offset + 3] = (value >>> 24);
} else {
objectWriteUInt32(this, value, offset, true);
}
return offset + 4
};
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value;
offset = offset | 0;
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
if (value < 0) value = 0xffffffff + value + 1;
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24);
this[offset + 1] = (value >>> 16);
this[offset + 2] = (value >>> 8);
this[offset + 3] = (value & 0xff);
} else {
objectWriteUInt32(this, value, offset, false);
}
return offset + 4
};
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError('Index out of range')
if (offset < 0) throw new RangeError('Index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 4);
}
write(buf, value, offset, littleEndian, 23, 4);
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
};
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
};
function writeDouble (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 8);
}
write(buf, value, offset, littleEndian, 52, 8);
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
};
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
};
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!start) start = 0;
if (!end && end !== 0) end = this.length;
if (targetStart >= target.length) targetStart = target.length;
if (!targetStart) targetStart = 0;
if (end > 0 && end < start) end = start;
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length;
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start;
}
var len = end - start;
var i;
if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start];
}
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
// ascending copy from start
for (i = 0; i < len; ++i) {
target[i + targetStart] = this[i + start];
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, start + len),
targetStart
);
}
return len
};
// Usage:
// buffer.fill(number[, offset[, end]])
// buffer.fill(buffer[, offset[, end]])
// buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start;
start = 0;
end = this.length;
} else if (typeof end === 'string') {
encoding = end;
end = this.length;
}
if (val.length === 1) {
var code = val.charCodeAt(0);
if (code < 256) {
val = code;
}
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
} else if (typeof val === 'number') {
val = val & 255;
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0;
end = end === undefined ? this.length : end >>> 0;
if (!val) val = 0;
var i;
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val;
}
} else {
var bytes = internalIsBuffer(val)
? val
: utf8ToBytes(new Buffer(val, encoding).toString());
var len = bytes.length;
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len];
}
}
return this
};
// HELPER FUNCTIONS
// ================
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
function base64clean (str) {
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '');
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '=';
}
return str
}
function stringtrim (str) {
if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity;
var codePoint;
var length = string.length;
var leadSurrogate = null;
var bytes = [];
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i);
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
continue
}
// valid lead
leadSurrogate = codePoint;
continue
}
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
leadSurrogate = codePoint;
continue
}
// valid surrogate pair
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
}
leadSurrogate = null;
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint);
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
);
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
);
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
);
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = [];
for (var i = 0; i < str.length; ++i) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF);
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo;
var byteArray = [];
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray
}
function base64ToBytes (str) {
return toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i];
}
return i
}
function isnan (val) {
return val !== val // eslint-disable-line no-self-compare
}
// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence
// The _isBuffer check is for Safari 5-7 support, because it's missing
// Object.prototype.constructor. Remove this eventually
function isBuffer(obj) {
return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))
}
function isFastBuffer (obj) {
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
}
// For Node v0.10 support. Remove this eventually.
function isSlowBuffer (obj) {
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
}
var sourcemapCodec_umd = {exports: {}};
var hasRequiredSourcemapCodec_umd;
function requireSourcemapCodec_umd () {
if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd.exports;
hasRequiredSourcemapCodec_umd = 1;
(function (module, exports) {
(function (global, factory) {
factory(exports) ;
})(commonjsGlobal, (function (exports) {
const comma = ','.charCodeAt(0);
const semicolon = ';'.charCodeAt(0);
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
const intToChar = new Uint8Array(64); // 64 possible chars.
const charToInt = new Uint8Array(128); // z is 122 in ASCII
for (let i = 0; i < chars.length; i++) {
const c = chars.charCodeAt(i);
intToChar[i] = c;
charToInt[c] = i;
}
// Provide a fallback for older environments.
const td = typeof TextDecoder !== 'undefined'
? /* #__PURE__ */ new TextDecoder()
: typeof Buffer !== 'undefined'
? {
decode(buf) {
const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
return out.toString();
},
}
: {
decode(buf) {
let out = '';
for (let i = 0; i < buf.length; i++) {
out += String.fromCharCode(buf[i]);
}
return out;
},
};
function decode(mappings) {
const state = new Int32Array(5);
const decoded = [];
let index = 0;
do {
const semi = indexOf(mappings, index);
const line = [];
let sorted = true;
let lastCol = 0;
state[0] = 0;
for (let i = index; i < semi; i++) {
let seg;
i = decodeInteger(mappings, i, state, 0); // genColumn
const col = state[0];
if (col < lastCol)
sorted = false;
lastCol = col;
if (hasMoreVlq(mappings, i, semi)) {
i = decodeInteger(mappings, i, state, 1); // sourcesIndex
i = decodeInteger(mappings, i, state, 2); // sourceLine
i = decodeInteger(mappings, i, state, 3); // sourceColumn
if (hasMoreVlq(mappings, i, semi)) {
i = decodeInteger(mappings, i, state, 4); // namesIndex
seg = [col, state[1], state[2], state[3], state[4]];
}
else {
seg = [col, state[1], state[2], state[3]];
}
}
else {
seg = [col];
}
line.push(seg);
}
if (!sorted)
sort(line);
decoded.push(line);
index = semi + 1;
} while (index <= mappings.length);
return decoded;
}
function indexOf(mappings, index) {
const idx = mappings.indexOf(';', index);
return idx === -1 ? mappings.length : idx;
}
function decodeInteger(mappings, pos, state, j) {
let value = 0;
let shift = 0;
let integer = 0;
do {
const c = mappings.charCodeAt(pos++);
integer = charToInt[c];
value |= (integer & 31) << shift;
shift += 5;
} while (integer & 32);
const shouldNegate = value & 1;
value >>>= 1;
if (shouldNegate) {
value = -0x80000000 | -value;
}
state[j] += value;
return pos;
}
function hasMoreVlq(mappings, i, length) {
if (i >= length)
return false;
return mappings.charCodeAt(i) !== comma;
}
function sort(line) {
line.sort(sortComparator);
}
function sortComparator(a, b) {
return a[0] - b[0];
}
function encode(decoded) {
const state = new Int32Array(5);
const bufLength = 1024 * 16;
const subLength = bufLength - 36;
const buf = new Uint8Array(bufLength);
const sub = buf.subarray(0, subLength);
let pos = 0;
let out = '';
for (let i = 0; i < decoded.length; i++) {
const line = decoded[i];
if (i > 0) {
if (pos === bufLength) {
out += td.decode(buf);
pos = 0;
}
buf[pos++] = semicolon;
}
if (line.length === 0)
continue;
state[0] = 0;
for (let j = 0; j < line.length; j++) {
const segment = line[j];
// We can push up to 5 ints, each int can take at most 7 chars, and we
// may push a comma.
if (pos > subLength) {
out += td.decode(sub);
buf.copyWithin(0, subLength, pos);
pos -= subLength;
}
if (j > 0)
buf[pos++] = comma;
pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
if (segment.length === 1)
continue;
pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
if (segment.length === 4)
continue;
pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
}
}
return out + td.decode(buf.subarray(0, pos));
}
function encodeInteger(buf, pos, state, segment, j) {
const next = segment[j];
let num = next - state[j];
state[j] = next;
num = num < 0 ? (-num << 1) | 1 : num << 1;
do {
let clamped = num & 0b011111;
num >>>= 5;
if (num > 0)
clamped |= 0b100000;
buf[pos++] = intToChar[clamped];
} while (num > 0);
return pos;
}
exports.decode = decode;
exports.encode = encode;
Object.defineProperty(exports, '__esModule', { value: true });
}));
} (sourcemapCodec_umd, sourcemapCodec_umd.exports));
return sourcemapCodec_umd.exports;
}
var traceMapping_umd = {exports: {}};
var resolveUri_umd = {exports: {}};
var hasRequiredResolveUri_umd;
function requireResolveUri_umd () {
if (hasRequiredResolveUri_umd) return resolveUri_umd.exports;
hasRequiredResolveUri_umd = 1;
(function (module, exports) {
(function (global, factory) {
module.exports = factory() ;
})(commonjsGlobal, (function () {
// Matches the scheme of a URL, eg "http://"
const schemeRegex = /^[\w+.-]+:\/\//;
/**
* Matches the parts of a URL:
* 1. Scheme, including ":", guaranteed.
* 2. User/password, including "@", optional.
* 3. Host, guaranteed.
* 4. Port, including ":", optional.
* 5. Path, including "/", optional.
* 6. Query, including "?", optional.
* 7. Hash, including "#", optional.
*/
const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
/**
* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
*
* 1. Host, optional.
* 2. Path, which may include "/", guaranteed.
* 3. Query, including "?", optional.
* 4. Hash, including "#", optional.
*/
const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
var UrlType;
(function (UrlType) {
UrlType[UrlType["Empty"] = 1] = "Empty";
UrlType[UrlType["Hash"] = 2] = "Hash";
UrlType[UrlType["Query"] = 3] = "Query";
UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
UrlType[UrlType["Absolute"] = 7] = "Absolute";
})(UrlType || (UrlType = {}));
function isAbsoluteUrl(input) {
return schemeRegex.test(input);
}
function isSchemeRelativeUrl(input) {
return input.startsWith('//');
}
function isAbsolutePath(input) {
return input.startsWith('/');
}
function isFileUrl(input) {
return input.startsWith('file:');
}
function isRelative(input) {
return /^[.?#]/.test(input);
}
function parseAbsoluteUrl(input) {
const match = urlRegex.exec(input);
return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
}
function parseFileUrl(input) {
const match = fileRegex.exec(input);
const path = match[2];
return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
}
function makeUrl(scheme, user, host, port, path, query, hash) {
return {
scheme,
user,
host,
port,
path,
query,
hash,
type: UrlType.Absolute,
};
}
function parseUrl(input) {
if (isSchemeRelativeUrl(input)) {
const url = parseAbsoluteUrl('http:' + input);
url.scheme = '';
url.type = UrlType.SchemeRelative;
return url;
}
if (isAbsolutePath(input)) {
url.scheme = '';
url.host = '';
url.type = UrlType.AbsolutePath;
return url;
}
if (isFileUrl(input))
return parseFileUrl(input);
if (isAbsoluteUrl(input))
return parseAbsoluteUrl(input);
url.scheme = '';
url.host = '';
url.type = input
? input.startsWith('?')
? UrlType.Query
: input.startsWith('#')
? UrlType.Hash
: UrlType.RelativePath
: UrlType.Empty;
return url;
}
function stripPathFilename(path) {
// If a path ends with a parent directory "..", then it's a relative path with excess parent
// paths. It's not a file, so we can't strip it.
if (path.endsWith('/..'))
return path;
const index = path.lastIndexOf('/');
return path.slice(0, index + 1);
}
function mergePaths(url, base) {
normalizePath(base, base.type);
// If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
// path).
if (url.path === '/') {
url.path = base.path;
}
else {
// Resolution happens relative to the base path's directory, not the file.
url.path = stripPathFilename(base.path) + url.path;
}
}
/**
* The path can have empty directories "//", unneeded parents "foo/..", or current directory
* "foo/.". We need to normalize to a standard representation.
*/
function normalizePath(url, type) {
const rel = type <= UrlType.RelativePath;
const pieces = url.path.split('/');
// We need to preserve the first piece always, so that we output a leading slash. The item at
// pieces[0] is an empty string.
let pointer = 1;
// Positive is the number of real directories we've output, used for popping a parent directory.
// Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
let positive = 0;
// We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
// generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
// real directory, we won't need to append, unless the other conditions happen again.
let addTrailingSlash = false;
for (let i = 1; i < pieces.length; i++) {
const piece = pieces[i];
// An empty directory, could be a trailing slash, or just a double "//" in the path.
if (!piece) {
addTrailingSlash = true;
continue;
}
// If we encounter a real directory, then we don't need to append anymore.
addTrailingSlash = false;
// A current directory, which we can always drop.
if (piece === '.')
continue;
// A parent directory, we need to see if there are any real directories we can pop. Else, we
// have an excess of parents, and we'll need to keep the "..".
if (piece === '..') {
if (positive) {
addTrailingSlash = true;
positive--;
pointer--;
}
else if (rel) {
// If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
// URL, protocol relative URL, or an absolute path, we don't need to keep excess.
pieces[pointer++] = piece;
}
continue;
}
// We've encountered a real directory. Move it to the next insertion pointer, which accounts for
// any popped or dropped directories.
pieces[pointer++] = piece;
positive++;
}
let path = '';
for (let i = 1; i < pointer; i++) {
path += '/' + pieces[i];
}
if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
path += '/';
}
url.path = path;
}
/**
* Attempts to resolve `input` URL/path relative to `base`.
*/
function resolve(input, base) {
if (!input && !base)
return '';
const url = parseUrl(input);
let inputType = url.type;
if (base && inputType !== UrlType.Absolute) {
const baseUrl = parseUrl(base);
const baseType = baseUrl.type;
switch (inputType) {
case UrlType.Empty:
url.hash = baseUrl.hash;
// fall through
case UrlType.Hash:
url.query = baseUrl.query;
// fall through
case UrlType.Query:
case UrlType.RelativePath:
mergePaths(url, baseUrl);
// fall through
case UrlType.AbsolutePath:
// The host, user, and port are joined, you can't copy one without the others.
url.user = baseUrl.user;
url.host = baseUrl.host;
url.port = baseUrl.port;
// fall through
case UrlType.SchemeRelative:
// The input doesn't have a schema at least, so we need to copy at least that over.
url.scheme = baseUrl.scheme;
}
if (baseType > inputType)
inputType = baseType;
}
normalizePath(url, inputType);
const queryHash = url.query + url.hash;
switch (inputType) {
// This is impossible, because of the empty checks at the start of the function.
// case UrlType.Empty:
case UrlType.Hash:
case UrlType.Query:
return queryHash;
case UrlType.RelativePath: {
// The first char is always a "/", and we need it to be relative.
const path = url.path.slice(1);
if (!path)
return queryHash || '.';
if (isRelative(base || input) && !isRelative(path)) {
// If base started with a leading ".", or there is no base and input started with a ".",
// then we need to ensure that the relative path starts with a ".". We don't know if
// relative starts with a "..", though, so check before prepending.
return './' + path + queryHash;
}
return path + queryHash;
}
case UrlType.AbsolutePath:
return url.path + queryHash;
default:
return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
}
}
return resolve;
}));
} (resolveUri_umd));
return resolveUri_umd.exports;
}
var hasRequiredTraceMapping_umd;
function requireTraceMapping_umd () {
if (hasRequiredTraceMapping_umd) return traceMapping_umd.exports;
hasRequiredTraceMapping_umd = 1;
(function (module, exports) {
(function (global, factory) {
factory(exports, requireSourcemapCodec_umd(), requireResolveUri_umd()) ;
})(commonjsGlobal, (function (exports, sourcemapCodec, resolveUri) {
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var resolveUri__default = /*#__PURE__*/_interopDefaultLegacy(resolveUri);
function resolve(input, base) {
// The base is always treated as a directory, if it's not empty.
if (base && !base.endsWith('/'))
base += '/';
return resolveUri__default["default"](input, base);
}
/**
* Removes everything after the last "/", but leaves the slash.
*/
function stripFilename(path) {
if (!path)
return '';
const index = path.lastIndexOf('/');
return path.slice(0, index + 1);
}
const COLUMN = 0;
const SOURCES_INDEX = 1;
const SOURCE_LINE = 2;
const SOURCE_COLUMN = 3;
const NAMES_INDEX = 4;
const REV_GENERATED_LINE = 1;
const REV_GENERATED_COLUMN = 2;
function maybeSort(mappings, owned) {
const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
if (unsortedIndex === mappings.length)
return mappings;
// If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
// not, we do not want to modify the consumer's input array.
if (!owned)
mappings = mappings.slice();
for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
mappings[i] = sortSegments(mappings[i], owned);
}
return mappings;
}
function nextUnsortedSegmentLine(mappings, start) {
for (let i = start; i < mappings.length; i++) {
if (!isSorted(mappings[i]))
return i;
}
return mappings.length;
}
function isSorted(line) {
for (let j = 1; j < line.length; j++) {
if (line[j][COLUMN] < line[j - 1][COLUMN]) {
return false;
}
}
return true;
}
function sortSegments(line, owned) {
if (!owned)
line = line.slice();
return line.sort(sortComparator);
}
function sortComparator(a, b) {
return a[COLUMN] - b[COLUMN];
}
let found = false;
/**
* A binary search implementation that returns the index if a match is found.
* If no match is found, then the left-index (the index associated with the item that comes just
* before the desired index) is returned. To maintain proper sort order, a splice would happen at
* the next index:
*
* ```js
* const array = [1, 3];
* const needle = 2;
* const index = binarySearch(array, needle, (item, needle) => item - needle);
*
* assert.equal(index, 0);
* array.splice(index + 1, 0, needle);
* assert.deepEqual(array, [1, 2, 3]);
* ```
*/
function binarySearch(haystack, needle, low, high) {
while (low <= high) {
const mid = low + ((high - low) >> 1);
const cmp = haystack[mid][COLUMN] - needle;
if (cmp === 0) {
found = true;
return mid;
}
if (cmp < 0) {
low = mid + 1;
}
else {
high = mid - 1;
}
}
found = false;
return low - 1;
}
function upperBound(haystack, needle, index) {
for (let i = index + 1; i < haystack.length; index = i++) {
if (haystack[i][COLUMN] !== needle)
break;
}
return index;
}
function lowerBound(haystack, needle, index) {
for (let i = index - 1; i >= 0; index = i--) {
if (haystack[i][COLUMN] !== needle)
break;
}
return index;
}
function memoizedState() {
return {
lastKey: -1,
lastNeedle: -1,
lastIndex: -1,
};
}
/**
* This overly complicated beast is just to record the last tested line/column and the resulting
* index, allowing us to skip a few tests if mappings are monotonically increasing.
*/
function memoizedBinarySearch(haystack, needle, state, key) {
const { lastKey, lastNeedle, lastIndex } = state;
let low = 0;
let high = haystack.length - 1;
if (key === lastKey) {
if (needle === lastNeedle) {
found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
return lastIndex;
}
if (needle >= lastNeedle) {
// lastIndex may be -1 if the previous needle was not found.
low = lastIndex === -1 ? 0 : lastIndex;
}
else {
high = lastIndex;
}
}
state.lastKey = key;
state.lastNeedle = needle;
return (state.lastIndex = binarySearch(haystack, needle, low, high));
}
// Rebuilds the original source files, with mappings that are ordered by source line/column instead
// of generated line/column.
function buildBySources(decoded, memos) {
const sources = memos.map(buildNullArray);
for (let i = 0; i < decoded.length; i++) {
const line = decoded[i];
for (let j = 0; j < line.length; j++) {
const seg = line[j];
if (seg.length === 1)
continue;
const sourceIndex = seg[SOURCES_INDEX];
const sourceLine = seg[SOURCE_LINE];
const sourceColumn = seg[SOURCE_COLUMN];
const originalSource = sources[sourceIndex];
const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
const memo = memos[sourceIndex];
// The binary search either found a match, or it found the left-index just before where the
// segment should go. Either way, we want to insert after that. And there may be multiple
// generated segments associated with an original location, so there may need to move several
// indexes before we find where we need to insert.
const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
}
}
return sources;
}
function insert(array, index, value) {
for (let i = array.length; i > index; i--) {
array[i] = array[i - 1];
}
array[index] = value;
}
// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
// order when iterating with for-in.
function buildNullArray() {
return { __proto__: null };
}
const AnyMap = function (map, mapUrl) {
const parsed = typeof map === 'string' ? JSON.parse(map) : map;
if (!('sections' in parsed))
return new TraceMap(parsed, mapUrl);
const mappings = [];
const sources = [];
const sourcesContent = [];
const names = [];
recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
const joined = {
version: 3,
file: parsed.file,
names,
sources,
sourcesContent,
mappings,
};
return exports.presortedDecodedMap(joined);
};
function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
const { sections } = input;
for (let i = 0; i < sections.length; i++) {
const { map, offset } = sections[i];
let sl = stopLine;
let sc = stopColumn;
if (i + 1 < sections.length) {
const nextOffset = sections[i + 1].offset;
sl = Math.min(stopLine, lineOffset + nextOffset.line);
if (sl === stopLine) {
sc = Math.min(stopColumn, columnOffset + nextOffset.column);
}
else if (sl < stopLine) {
sc = columnOffset + nextOffset.column;
}
}
addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
}
}
function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
if ('sections' in input)
return recurse(...arguments);
const map = new TraceMap(input, mapUrl);
const sourcesOffset = sources.length;
const namesOffset = names.length;
const decoded = exports.decodedMappings(map);
const { resolvedSources, sourcesContent: contents } = map;
append(sources, resolvedSources);
append(names, map.names);
if (contents)
append(sourcesContent, contents);
else
for (let i = 0; i < resolvedSources.length; i++)
sourcesContent.push(null);
for (let i = 0; i < decoded.length; i++) {
const lineI = lineOffset + i;
// We can only add so many lines before we step into the range that the next section's map
// controls. When we get to the last line, then we'll start checking the segments to see if
// they've crossed into the column range. But it may not have any columns that overstep, so we
// still need to check that we don't overstep lines, too.
if (lineI > stopLine)
return;
// The out line may already exist in mappings (if we're continuing the line started by a
// previous section). Or, we may have jumped ahead several lines to start this section.
const out = getLine(mappings, lineI);
// On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
// map can be multiple lines), it doesn't.
const cOffset = i === 0 ? columnOffset : 0;
const line = decoded[i];
for (let j = 0; j < line.length; j++) {
const seg = line[j];
const column = cOffset + seg[COLUMN];
// If this segment steps into the column range that the next section's map controls, we need
// to stop early.
if (lineI === stopLine && column >= stopColumn)
return;
if (seg.length === 1) {
out.push([column]);
continue;
}
const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
const sourceLine = seg[SOURCE_LINE];
const sourceColumn = seg[SOURCE_COLUMN];
out.push(seg.length === 4
? [column, sourcesIndex, sourceLine, sourceColumn]
: [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
}
}
}
function append(arr, other) {
for (let i = 0; i < other.length; i++)
arr.push(other[i]);
}
function getLine(arr, index) {
for (let i = arr.length; i <= index; i++)
arr[i] = [];
return arr[index];
}
const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
const LEAST_UPPER_BOUND = -1;
const GREATEST_LOWER_BOUND = 1;
/**
* Returns the encoded (VLQ string) form of the SourceMap's mappings field.
*/
exports.encodedMappings = void 0;
/**
* Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
*/
exports.decodedMappings = void 0;
/**
* A low-level API to find the segment associated with a generated line/column (think, from a
* stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
*/
exports.traceSegment = void 0;
/**
* A higher-level API to find the source/line/column associated with a generated line/column
* (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
* `source-map` library.
*/
exports.originalPositionFor = void 0;
/**
* Finds the generated line/column position of the provided source/line/column source position.
*/
exports.generatedPositionFor = void 0;
/**
* Finds all generated line/column positions of the provided source/line/column source position.
*/
exports.allGeneratedPositionsFor = void 0;
/**
* Iterates each mapping in generated position order.
*/
exports.eachMapping = void 0;
/**
* Retrieves the source content for a particular source, if its found. Returns null if not.
*/
exports.sourceContentFor = void 0;
/**
* A helper that skips sorting of the input map's mappings array, which can be expensive for larger
* maps.
*/
exports.presortedDecodedMap = void 0;
/**
* Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
* a sourcemap, or to JSON.stringify.
*/
exports.decodedMap = void 0;
/**
* Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
* a sourcemap, or to JSON.stringify.
*/
exports.encodedMap = void 0;
class TraceMap {
constructor(map, mapUrl) {
const isString = typeof map === 'string';
if (!isString && map._decodedMemo)
return map;
const parsed = (isString ? JSON.parse(map) : map);
const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
this.version = version;
this.file = file;
this.names = names || [];
this.sourceRoot = sourceRoot;
this.sources = sources;
this.sourcesContent = sourcesContent;
const from = resolve(sourceRoot || '', stripFilename(mapUrl));
this.resolvedSources = sources.map((s) => resolve(s || '', from));
const { mappings } = parsed;
if (typeof mappings === 'string') {
this._encoded = mappings;
this._decoded = undefined;
}
else {
this._encoded = undefined;
this._decoded = maybeSort(mappings, isString);
}
this._decodedMemo = memoizedState();
this._bySources = undefined;
this._bySourceMemos = undefined;
}
}
(() => {
exports.encodedMappings = (map) => {
var _a;
return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = sourcemapCodec.encode(map._decoded)));
};
exports.decodedMappings = (map) => {
return (map._decoded || (map._decoded = sourcemapCodec.decode(map._encoded)));
};
exports.traceSegment = (map, line, column) => {
const decoded = exports.decodedMappings(map);
// It's common for parent source maps to have pointers to lines that have no
// mapping (like a "//# sourceMappingURL=") at the end of the child file.
if (line >= decoded.length)
return null;
const segments = decoded[line];
const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
return index === -1 ? null : segments[index];
};
exports.originalPositionFor = (map, { line, column, bias }) => {
line--;
if (line < 0)
throw new Error(LINE_GTR_ZERO);
if (column < 0)
throw new Error(COL_GTR_EQ_ZERO);
const decoded = exports.decodedMappings(map);
// It's common for parent source maps to have pointers to lines that have no
// mapping (like a "//# sourceMappingURL=") at the end of the child file.
if (line >= decoded.length)
return OMapping(null, null, null, null);
const segments = decoded[line];
const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
if (index === -1)
return OMapping(null, null, null, null);
const segment = segments[index];
if (segment.length === 1)
return OMapping(null, null, null, null);
const { names, resolvedSources } = map;
return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
};
exports.allGeneratedPositionsFor = (map, { source, line, column, bias }) => {
// SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
};
exports.generatedPositionFor = (map, { source, line, column, bias }) => {
return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
};
exports.eachMapping = (map, cb) => {
const decoded = exports.decodedMappings(map);
const { names, resolvedSources } = map;
for (let i = 0; i < decoded.length; i++) {
const line = decoded[i];
for (let j = 0; j < line.length; j++) {
const seg = line[j];
const generatedLine = i + 1;
const generatedColumn = seg[0];
let source = null;
let originalLine = null;
let originalColumn = null;
let name = null;
if (seg.length !== 1) {
source = resolvedSources[seg[1]];
originalLine = seg[2] + 1;
originalColumn = seg[3];
}
if (seg.length === 5)
name = names[seg[4]];
cb({
generatedLine,
generatedColumn,
source,
originalLine,
originalColumn,
name,
});
}
}
};
exports.sourceContentFor = (map, source) => {
const { sources, resolvedSources, sourcesContent } = map;
if (sourcesContent == null)
return null;
let index = sources.indexOf(source);
if (index === -1)
index = resolvedSources.indexOf(source);
return index === -1 ? null : sourcesContent[index];
};
exports.presortedDecodedMap = (map, mapUrl) => {
const tracer = new TraceMap(clone(map, []), mapUrl);
tracer._decoded = map.mappings;
return tracer;
};
exports.decodedMap = (map) => {
return clone(map, exports.decodedMappings(map));
};
exports.encodedMap = (map) => {
return clone(map, exports.encodedMappings(map));
};
function generatedPosition(map, source, line, column, bias, all) {
line--;
if (line < 0)
throw new Error(LINE_GTR_ZERO);
if (column < 0)
throw new Error(COL_GTR_EQ_ZERO);
const { sources, resolvedSources } = map;
let sourceIndex = sources.indexOf(source);
if (sourceIndex === -1)
sourceIndex = resolvedSources.indexOf(source);
if (sourceIndex === -1)
return all ? [] : GMapping(null, null);
const generated = (map._bySources || (map._bySources = buildBySources(exports.decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
const segments = generated[sourceIndex][line];
if (segments == null)
return all ? [] : GMapping(null, null);
const memo = map._bySourceMemos[sourceIndex];
if (all)
return sliceGeneratedPositions(segments, memo, line, column, bias);
const index = traceSegmentInternal(segments, memo, line, column, bias);
if (index === -1)
return GMapping(null, null);
const segment = segments[index];
return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
}
})();
function clone(map, mappings) {
return {
version: map.version,
file: map.file,
names: map.names,
sourceRoot: map.sourceRoot,
sources: map.sources,
sourcesContent: map.sourcesContent,
mappings,
};
}
function OMapping(source, line, column, name) {
return { source, line, column, name };
}
function GMapping(line, column) {
return { line, column };
}
function traceSegmentInternal(segments, memo, line, column, bias) {
let index = memoizedBinarySearch(segments, column, memo, line);
if (found) {
index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
}
else if (bias === LEAST_UPPER_BOUND)
index++;
if (index === -1 || index === segments.length)
return -1;
return index;
}
function sliceGeneratedPositions(segments, memo, line, column, bias) {
let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
// We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
// insertion order) segment that matched. Even if we did respect the bias when tracing, we would
// still need to call `lowerBound()` to find the first segment, which is slower than just looking
// for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
// binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
// match LEAST_UPPER_BOUND.
if (!found && bias === LEAST_UPPER_BOUND)
min++;
if (min === -1 || min === segments.length)
return [];
// We may have found the segment that started at an earlier column. If this is the case, then we
// need to slice all generated segments that match _that_ column, because all such segments span
// to our desired column.
const matchedColumn = found ? column : segments[min][COLUMN];
// The binary search is not guaranteed to find the lower bound when a match wasn't found.
if (!found)
min = lowerBound(segments, matchedColumn, min);
const max = upperBound(segments, matchedColumn, min);
const result = [];
for (; min <= max; min++) {
const segment = segments[min];
result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
}
return result;
}
exports.AnyMap = AnyMap;
exports.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
exports.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
exports.TraceMap = TraceMap;
Object.defineProperty(exports, '__esModule', { value: true });
}));
} (traceMapping_umd, traceMapping_umd.exports));
return traceMapping_umd.exports;
}
var hasRequiredGenMapping_umd;
function requireGenMapping_umd () {
if (hasRequiredGenMapping_umd) return genMapping_umd.exports;
hasRequiredGenMapping_umd = 1;
(function (module, exports) {
(function (global, factory) {
factory(exports, requireSetArray_umd(), requireSourcemapCodec_umd(), requireTraceMapping_umd()) ;
})(commonjsGlobal, (function (exports, setArray, sourcemapCodec, traceMapping) {
const COLUMN = 0;
const SOURCES_INDEX = 1;
const SOURCE_LINE = 2;
const SOURCE_COLUMN = 3;
const NAMES_INDEX = 4;
const NO_NAME = -1;
/**
* A low-level API to associate a generated position with an original source position. Line and
* column here are 0-based, unlike `addMapping`.
*/
exports.addSegment = void 0;
/**
* A high-level API to associate a generated position with an original source position. Line is
* 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
*/
exports.addMapping = void 0;
/**
* Same as `addSegment`, but will only add the segment if it generates useful information in the
* resulting map. This only works correctly if segments are added **in order**, meaning you should
* not add a segment with a lower generated line/column than one that came before.
*/
exports.maybeAddSegment = void 0;
/**
* Same as `addMapping`, but will only add the mapping if it generates useful information in the
* resulting map. This only works correctly if mappings are added **in order**, meaning you should
* not add a mapping with a lower generated line/column than one that came before.
*/
exports.maybeAddMapping = void 0;
/**
* Adds/removes the content of the source file to the source map.
*/
exports.setSourceContent = void 0;
/**
* Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
* a sourcemap, or to JSON.stringify.
*/
exports.toDecodedMap = void 0;
/**
* Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
* a sourcemap, or to JSON.stringify.
*/
exports.toEncodedMap = void 0;
/**
* Constructs a new GenMapping, using the already present mappings of the input.
*/
exports.fromMap = void 0;
/**
* Returns an array of high-level mapping objects for every recorded segment, which could then be
* passed to the `source-map` library.
*/
exports.allMappings = void 0;
// This split declaration is only so that terser can elminiate the static initialization block.
let addSegmentInternal;
/**
* Provides the state to generate a sourcemap.
*/
class GenMapping {
constructor({ file, sourceRoot } = {}) {
this._names = new setArray.SetArray();
this._sources = new setArray.SetArray();
this._sourcesContent = [];
this._mappings = [];
this.file = file;
this.sourceRoot = sourceRoot;
}
}
(() => {
exports.addSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
};
exports.maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
};
exports.addMapping = (map, mapping) => {
return addMappingInternal(false, map, mapping);
};
exports.maybeAddMapping = (map, mapping) => {
return addMappingInternal(true, map, mapping);
};
exports.setSourceContent = (map, source, content) => {
const { _sources: sources, _sourcesContent: sourcesContent } = map;
sourcesContent[setArray.put(sources, source)] = content;
};
exports.toDecodedMap = (map) => {
const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
removeEmptyFinalLines(mappings);
return {
version: 3,
file: file || undefined,
names: names.array,
sourceRoot: sourceRoot || undefined,
sources: sources.array,
sourcesContent,
mappings,
};
};
exports.toEncodedMap = (map) => {
const decoded = exports.toDecodedMap(map);
return Object.assign(Object.assign({}, decoded), { mappings: sourcemapCodec.encode(decoded.mappings) });
};
exports.allMappings = (map) => {
const out = [];
const { _mappings: mappings, _sources: sources, _names: names } = map;
for (let i = 0; i < mappings.length; i++) {
const line = mappings[i];
for (let j = 0; j < line.length; j++) {
const seg = line[j];
const generated = { line: i + 1, column: seg[COLUMN] };
let source = undefined;
let original = undefined;
let name = undefined;
if (seg.length !== 1) {
source = sources.array[seg[SOURCES_INDEX]];
original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
if (seg.length === 5)
name = names.array[seg[NAMES_INDEX]];
}
out.push({ generated, source, original, name });
}
}
return out;
};
exports.fromMap = (input) => {
const map = new traceMapping.TraceMap(input);
const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
putAll(gen._names, map.names);
putAll(gen._sources, map.sources);
gen._sourcesContent = map.sourcesContent || map.sources.map(() => null);
gen._mappings = traceMapping.decodedMappings(map);
return gen;
};
// Internal helpers
addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
const line = getLine(mappings, genLine);
const index = getColumnIndex(line, genColumn);
if (!source) {
if (skipable && skipSourceless(line, index))
return;
return insert(line, index, [genColumn]);
}
const sourcesIndex = setArray.put(sources, source);
const namesIndex = name ? setArray.put(names, name) : NO_NAME;
if (sourcesIndex === sourcesContent.length)
sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
return;
}
return insert(line, index, name
? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
: [genColumn, sourcesIndex, sourceLine, sourceColumn]);
};
})();
function getLine(mappings, index) {
for (let i = mappings.length; i <= index; i++) {
mappings[i] = [];
}
return mappings[index];
}
function getColumnIndex(line, genColumn) {
let index = line.length;
for (let i = index - 1; i >= 0; index = i--) {
const current = line[i];
if (genColumn >= current[COLUMN])
break;
}
return index;
}
function insert(array, index, value) {
for (let i = array.length; i > index; i--) {
array[i] = array[i - 1];
}
array[index] = value;
}
function removeEmptyFinalLines(mappings) {
const { length } = mappings;
let len = length;
for (let i = len - 1; i >= 0; len = i, i--) {
if (mappings[i].length > 0)
break;
}
if (len < length)
mappings.length = len;
}
function putAll(strarr, array) {
for (let i = 0; i < array.length; i++)
setArray.put(strarr, array[i]);
}
function skipSourceless(line, index) {
// The start of a line is already sourceless, so adding a sourceless segment to the beginning
// doesn't generate any useful information.
if (index === 0)
return true;
const prev = line[index - 1];
// If the previous segment is also sourceless, then adding another sourceless segment doesn't
// genrate any new information. Else, this segment will end the source/named segment and point to
// a sourceless position, which is useful.
return prev.length === 1;
}
function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
// A source/named segment at the start of a line gives position at that genColumn
if (index === 0)
return false;
const prev = line[index - 1];
// If the previous segment is sourceless, then we're transitioning to a source.
if (prev.length === 1)
return false;
// If the previous segment maps to the exact same source position, then this segment doesn't
// provide any new position information.
return (sourcesIndex === prev[SOURCES_INDEX] &&
sourceLine === prev[SOURCE_LINE] &&
sourceColumn === prev[SOURCE_COLUMN] &&
namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
}
function addMappingInternal(skipable, map, mapping) {
const { generated, source, original, name, content } = mapping;
if (!source) {
return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
}
const s = source;
return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name, content);
}
exports.GenMapping = GenMapping;
Object.defineProperty(exports, '__esModule', { value: true });
}));
} (genMapping_umd, genMapping_umd.exports));
return genMapping_umd.exports;
}
var hasRequiredSourceMap;
function requireSourceMap () {
if (hasRequiredSourceMap) return sourceMap;
hasRequiredSourceMap = 1;
Object.defineProperty(sourceMap, "__esModule", {
value: true
});
sourceMap.default = void 0;
var _genMapping = requireGenMapping_umd();
var _traceMapping = requireTraceMapping_umd();
class SourceMap {
constructor(opts, code) {
var _opts$sourceFileName;
this._map = void 0;
this._rawMappings = void 0;
this._sourceFileName = void 0;
this._lastGenLine = 0;
this._lastSourceLine = 0;
this._lastSourceColumn = 0;
this._inputMap = void 0;
const map = this._map = new _genMapping.GenMapping({
sourceRoot: opts.sourceRoot
});
this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/");
this._rawMappings = undefined;
if (opts.inputSourceMap) {
this._inputMap = new _traceMapping.TraceMap(opts.inputSourceMap);
const resolvedSources = this._inputMap.resolvedSources;
if (resolvedSources.length) {
for (let i = 0; i < resolvedSources.length; i++) {
var _this$_inputMap$sourc;
(0, _genMapping.setSourceContent)(map, resolvedSources[i], (_this$_inputMap$sourc = this._inputMap.sourcesContent) == null ? void 0 : _this$_inputMap$sourc[i]);
}
}
}
if (typeof code === "string" && !opts.inputSourceMap) {
(0, _genMapping.setSourceContent)(map, this._sourceFileName, code);
} else if (typeof code === "object") {
for (const sourceFileName of Object.keys(code)) {
(0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
}
}
}
get() {
return (0, _genMapping.toEncodedMap)(this._map);
}
getDecoded() {
return (0, _genMapping.toDecodedMap)(this._map);
}
getRawMappings() {
return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map));
}
mark(generated, line, column, identifierName, identifierNamePos, filename) {
var _originalMapping;
this._rawMappings = undefined;
let originalMapping;
if (line != null) {
if (this._inputMap) {
originalMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, {
line,
column
});
if (!originalMapping.name && identifierNamePos) {
const originalIdentifierMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, identifierNamePos);
if (originalIdentifierMapping.name) {
identifierName = originalIdentifierMapping.name;
}
}
} else {
originalMapping = {
source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
line: line,
column: column
};
}
}
(0, _genMapping.maybeAddMapping)(this._map, {
name: identifierName,
generated,
source: (_originalMapping = originalMapping) == null ? void 0 : _originalMapping.source,
original: originalMapping
});
}
}
sourceMap.default = SourceMap;
return sourceMap;
}
var printer = {};
var buffer = {};
var hasRequiredBuffer;
function requireBuffer () {
if (hasRequiredBuffer) return buffer;
hasRequiredBuffer = 1;
Object.defineProperty(buffer, "__esModule", {
value: true
});
buffer.default = void 0;
class Buffer {
constructor(map) {
this._map = null;
this._buf = "";
this._str = "";
this._appendCount = 0;
this._last = 0;
this._queue = [];
this._queueCursor = 0;
this._canMarkIdName = true;
this._position = {
line: 1,
column: 0
};
this._sourcePosition = {
identifierName: undefined,
identifierNamePos: undefined,
line: undefined,
column: undefined,
filename: undefined
};
this._map = map;
this._allocQueue();
}
_allocQueue() {
const queue = this._queue;
for (let i = 0; i < 16; i++) {
queue.push({
char: 0,
repeat: 1,
line: undefined,
column: undefined,
identifierName: undefined,
identifierNamePos: undefined,
filename: ""
});
}
}
_pushQueue(char, repeat, line, column, filename) {
const cursor = this._queueCursor;
if (cursor === this._queue.length) {
this._allocQueue();
}
const item = this._queue[cursor];
item.char = char;
item.repeat = repeat;
item.line = line;
item.column = column;
item.filename = filename;
this._queueCursor++;
}
_popQueue() {
if (this._queueCursor === 0) {
throw new Error("Cannot pop from empty queue");
}
return this._queue[--this._queueCursor];
}
get() {
this._flush();
const map = this._map;
const result = {
code: (this._buf + this._str).trimRight(),
decodedMap: map == null ? void 0 : map.getDecoded(),
get __mergedMap() {
return this.map;
},
get map() {
const resultMap = map ? map.get() : null;
result.map = resultMap;
return resultMap;
},
set map(value) {
Object.defineProperty(result, "map", {
value,
writable: true
});
},
get rawMappings() {
const mappings = map == null ? void 0 : map.getRawMappings();
result.rawMappings = mappings;
return mappings;
},
set rawMappings(value) {
Object.defineProperty(result, "rawMappings", {
value,
writable: true
});
}
};
return result;
}
append(str, maybeNewline) {
this._flush();
this._append(str, this._sourcePosition, maybeNewline);
}
appendChar(char) {
this._flush();
this._appendChar(char, 1, this._sourcePosition);
}
queue(char) {
if (char === 10) {
while (this._queueCursor !== 0) {
const char = this._queue[this._queueCursor - 1].char;
if (char !== 32 && char !== 9) {
break;
}
this._queueCursor--;
}
}
const sourcePosition = this._sourcePosition;
this._pushQueue(char, 1, sourcePosition.line, sourcePosition.column, sourcePosition.filename);
}
queueIndentation(char, repeat) {
this._pushQueue(char, repeat, undefined, undefined, undefined);
}
_flush() {
const queueCursor = this._queueCursor;
const queue = this._queue;
for (let i = 0; i < queueCursor; i++) {
const item = queue[i];
this._appendChar(item.char, item.repeat, item);
}
this._queueCursor = 0;
}
_appendChar(char, repeat, sourcePos) {
this._last = char;
this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
if (char !== 10) {
this._mark(sourcePos.line, sourcePos.column, sourcePos.identifierName, sourcePos.identifierNamePos, sourcePos.filename);
this._position.column += repeat;
} else {
this._position.line++;
this._position.column = 0;
}
if (this._canMarkIdName) {
sourcePos.identifierName = undefined;
sourcePos.identifierNamePos = undefined;
}
}
_append(str, sourcePos, maybeNewline) {
const len = str.length;
const position = this._position;
this._last = str.charCodeAt(len - 1);
if (++this._appendCount > 4096) {
+this._str;
this._buf += this._str;
this._str = str;
this._appendCount = 0;
} else {
this._str += str;
}
if (!maybeNewline && !this._map) {
position.column += len;
return;
}
const {
column,
identifierName,
identifierNamePos,
filename
} = sourcePos;
let line = sourcePos.line;
if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) {
sourcePos.identifierName = undefined;
sourcePos.identifierNamePos = undefined;
}
let i = str.indexOf("\n");
let last = 0;
if (i !== 0) {
this._mark(line, column, identifierName, identifierNamePos, filename);
}
while (i !== -1) {
position.line++;
position.column = 0;
last = i + 1;
if (last < len && line !== undefined) {
this._mark(++line, 0, null, null, filename);
}
i = str.indexOf("\n", last);
}
position.column += len - last;
}
_mark(line, column, identifierName, identifierNamePos, filename) {
var _this$_map;
(_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position, line, column, identifierName, identifierNamePos, filename);
}
removeTrailingNewline() {
const queueCursor = this._queueCursor;
if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 10) {
this._queueCursor--;
}
}
removeLastSemicolon() {
const queueCursor = this._queueCursor;
if (queueCursor !== 0 && this._queue[queueCursor - 1].char === 59) {
this._queueCursor--;
}
}
getLastChar() {
const queueCursor = this._queueCursor;
return queueCursor !== 0 ? this._queue[queueCursor - 1].char : this._last;
}
getNewlineCount() {
const queueCursor = this._queueCursor;
let count = 0;
if (queueCursor === 0) return this._last === 10 ? 1 : 0;
for (let i = queueCursor - 1; i >= 0; i--) {
if (this._queue[i].char !== 10) {
break;
}
count++;
}
return count === queueCursor && this._last === 10 ? count + 1 : count;
}
endsWithCharAndNewline() {
const queue = this._queue;
const queueCursor = this._queueCursor;
if (queueCursor !== 0) {
const lastCp = queue[queueCursor - 1].char;
if (lastCp !== 10) return;
if (queueCursor > 1) {
return queue[queueCursor - 2].char;
} else {
return this._last;
}
}
}
hasContent() {
return this._queueCursor !== 0 || !!this._last;
}
exactSource(loc, cb) {
if (!this._map) {
cb();
return;
}
this.source("start", loc);
const identifierName = loc.identifierName;
const sourcePos = this._sourcePosition;
if (identifierName) {
this._canMarkIdName = false;
sourcePos.identifierName = identifierName;
}
cb();
if (identifierName) {
this._canMarkIdName = true;
sourcePos.identifierName = undefined;
sourcePos.identifierNamePos = undefined;
}
this.source("end", loc);
}
source(prop, loc) {
if (!this._map) return;
this._normalizePosition(prop, loc, 0);
}
sourceWithOffset(prop, loc, columnOffset) {
if (!this._map) return;
this._normalizePosition(prop, loc, columnOffset);
}
withSource(prop, loc, cb) {
if (this._map) {
this.source(prop, loc);
}
cb();
}
_normalizePosition(prop, loc, columnOffset) {
const pos = loc[prop];
const target = this._sourcePosition;
if (pos) {
target.line = pos.line;
target.column = Math.max(pos.column + columnOffset, 0);
target.filename = loc.filename;
}
}
getCurrentColumn() {
const queue = this._queue;
const queueCursor = this._queueCursor;
let lastIndex = -1;
let len = 0;
for (let i = 0; i < queueCursor; i++) {
const item = queue[i];
if (item.char === 10) {
lastIndex = len;
}
len += item.repeat;
}
return lastIndex === -1 ? this._position.column + len : len - 1 - lastIndex;
}
getCurrentLine() {
let count = 0;
const queue = this._queue;
for (let i = 0; i < this._queueCursor; i++) {
if (queue[i].char === 10) {
count++;
}
}
return this._position.line + count;
}
}
buffer.default = Buffer;
return buffer;
}
var node = {};
var whitespace = {};
var hasRequiredWhitespace;
function requireWhitespace () {
if (hasRequiredWhitespace) return whitespace;
hasRequiredWhitespace = 1;
Object.defineProperty(whitespace, "__esModule", {
value: true
});
whitespace.nodes = void 0;
var _t = requireLib$2();
const {
FLIPPED_ALIAS_KEYS,
isArrayExpression,
isAssignmentExpression,
isBinary,
isBlockStatement,
isCallExpression,
isFunction,
isIdentifier,
isLiteral,
isMemberExpression,
isObjectExpression,
isOptionalCallExpression,
isOptionalMemberExpression,
isStringLiteral
} = _t;
function crawlInternal(node, state) {
if (!node) return state;
if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
crawlInternal(node.object, state);
if (node.computed) crawlInternal(node.property, state);
} else if (isBinary(node) || isAssignmentExpression(node)) {
crawlInternal(node.left, state);
crawlInternal(node.right, state);
} else if (isCallExpression(node) || isOptionalCallExpression(node)) {
state.hasCall = true;
crawlInternal(node.callee, state);
} else if (isFunction(node)) {
state.hasFunction = true;
} else if (isIdentifier(node)) {
state.hasHelper = state.hasHelper || node.callee && isHelper(node.callee);
}
return state;
}
function crawl(node) {
return crawlInternal(node, {
hasCall: false,
hasFunction: false,
hasHelper: false
});
}
function isHelper(node) {
if (!node) return false;
if (isMemberExpression(node)) {
return isHelper(node.object) || isHelper(node.property);
} else if (isIdentifier(node)) {
return node.name === "require" || node.name.charCodeAt(0) === 95;
} else if (isCallExpression(node)) {
return isHelper(node.callee);
} else if (isBinary(node) || isAssignmentExpression(node)) {
return isIdentifier(node.left) && isHelper(node.left) || isHelper(node.right);
} else {
return false;
}
}
function isType(node) {
return isLiteral(node) || isObjectExpression(node) || isArrayExpression(node) || isIdentifier(node) || isMemberExpression(node);
}
const nodes = {
AssignmentExpression(node) {
const state = crawl(node.right);
if (state.hasCall && state.hasHelper || state.hasFunction) {
return state.hasFunction ? 1 | 2 : 2;
}
},
SwitchCase(node, parent) {
return (!!node.consequent.length || parent.cases[0] === node ? 1 : 0) | (!node.consequent.length && parent.cases[parent.cases.length - 1] === node ? 2 : 0);
},
LogicalExpression(node) {
if (isFunction(node.left) || isFunction(node.right)) {
return 2;
}
},
Literal(node) {
if (isStringLiteral(node) && node.value === "use strict") {
return 2;
}
},
CallExpression(node) {
if (isFunction(node.callee) || isHelper(node)) {
return 1 | 2;
}
},
OptionalCallExpression(node) {
if (isFunction(node.callee)) {
return 1 | 2;
}
},
VariableDeclaration(node) {
for (let i = 0; i < node.declarations.length; i++) {
const declar = node.declarations[i];
let enabled = isHelper(declar.id) && !isType(declar.init);
if (!enabled && declar.init) {
const state = crawl(declar.init);
enabled = isHelper(declar.init) && state.hasCall || state.hasFunction;
}
if (enabled) {
return 1 | 2;
}
}
},
IfStatement(node) {
if (isBlockStatement(node.consequent)) {
return 1 | 2;
}
}
};
whitespace.nodes = nodes;
nodes.ObjectProperty = nodes.ObjectTypeProperty = nodes.ObjectMethod = function (node, parent) {
if (parent.properties[0] === node) {
return 1;
}
};
nodes.ObjectTypeCallProperty = function (node, parent) {
var _parent$properties;
if (parent.callProperties[0] === node && !((_parent$properties = parent.properties) != null && _parent$properties.length)) {
return 1;
}
};
nodes.ObjectTypeIndexer = function (node, parent) {
var _parent$properties2, _parent$callPropertie;
if (parent.indexers[0] === node && !((_parent$properties2 = parent.properties) != null && _parent$properties2.length) && !((_parent$callPropertie = parent.callProperties) != null && _parent$callPropertie.length)) {
return 1;
}
};
nodes.ObjectTypeInternalSlot = function (node, parent) {
var _parent$properties3, _parent$callPropertie2, _parent$indexers;
if (parent.internalSlots[0] === node && !((_parent$properties3 = parent.properties) != null && _parent$properties3.length) && !((_parent$callPropertie2 = parent.callProperties) != null && _parent$callPropertie2.length) && !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)) {
return 1;
}
};
[["Function", true], ["Class", true], ["Loop", true], ["LabeledStatement", true], ["SwitchStatement", true], ["TryStatement", true]].forEach(function ([type, amounts]) {
[type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
const ret = amounts ? 1 | 2 : 0;
nodes[type] = () => ret;
});
});
return whitespace;
}
var parentheses = {};
var hasRequiredParentheses;
function requireParentheses () {
if (hasRequiredParentheses) return parentheses;
hasRequiredParentheses = 1;
Object.defineProperty(parentheses, "__esModule", {
value: true
});
parentheses.ArrowFunctionExpression = ArrowFunctionExpression;
parentheses.AssignmentExpression = AssignmentExpression;
parentheses.Binary = Binary;
parentheses.BinaryExpression = BinaryExpression;
parentheses.ClassExpression = ClassExpression;
parentheses.ConditionalExpression = ConditionalExpression;
parentheses.DoExpression = DoExpression;
parentheses.FunctionExpression = FunctionExpression;
parentheses.FunctionTypeAnnotation = FunctionTypeAnnotation;
parentheses.Identifier = Identifier;
parentheses.LogicalExpression = LogicalExpression;
parentheses.NullableTypeAnnotation = NullableTypeAnnotation;
parentheses.ObjectExpression = ObjectExpression;
parentheses.OptionalIndexedAccessType = OptionalIndexedAccessType;
parentheses.OptionalCallExpression = parentheses.OptionalMemberExpression = OptionalMemberExpression;
parentheses.SequenceExpression = SequenceExpression;
parentheses.TSTypeAssertion = parentheses.TSSatisfiesExpression = parentheses.TSAsExpression = TSAsExpression;
parentheses.TSInferType = TSInferType;
parentheses.TSInstantiationExpression = TSInstantiationExpression;
parentheses.TSIntersectionType = parentheses.TSUnionType = TSUnionType;
parentheses.UnaryLike = UnaryLike;
parentheses.IntersectionTypeAnnotation = parentheses.UnionTypeAnnotation = UnionTypeAnnotation;
parentheses.UpdateExpression = UpdateExpression;
parentheses.AwaitExpression = parentheses.YieldExpression = YieldExpression;
var _t = requireLib$2();
const {
isArrayTypeAnnotation,
isArrowFunctionExpression,
isAssignmentExpression,
isAwaitExpression,
isBinary,
isBinaryExpression,
isUpdateExpression,
isCallExpression,
isClass,
isClassExpression,
isConditional,
isConditionalExpression,
isExportDeclaration,
isExportDefaultDeclaration,
isExpressionStatement,
isFor,
isForInStatement,
isForOfStatement,
isForStatement,
isFunctionExpression,
isIfStatement,
isIndexedAccessType,
isIntersectionTypeAnnotation,
isLogicalExpression,
isMemberExpression,
isNewExpression,
isNullableTypeAnnotation,
isObjectPattern,
isOptionalCallExpression,
isOptionalMemberExpression,
isReturnStatement,
isSequenceExpression,
isSwitchStatement,
isTSArrayType,
isTSAsExpression,
isTSInstantiationExpression,
isTSIntersectionType,
isTSNonNullExpression,
isTSOptionalType,
isTSRestType,
isTSTypeAssertion,
isTSUnionType,
isTaggedTemplateExpression,
isThrowStatement,
isTypeAnnotation,
isUnaryLike,
isUnionTypeAnnotation,
isVariableDeclarator,
isWhileStatement,
isYieldExpression,
isTSSatisfiesExpression
} = _t;
const PRECEDENCE = {
"||": 0,
"??": 0,
"|>": 0,
"&&": 1,
"|": 2,
"^": 3,
"&": 4,
"==": 5,
"===": 5,
"!=": 5,
"!==": 5,
"<": 6,
">": 6,
"<=": 6,
">=": 6,
in: 6,
instanceof: 6,
">>": 7,
"<<": 7,
">>>": 7,
"+": 8,
"-": 8,
"*": 9,
"/": 9,
"%": 9,
"**": 10
};
function isTSTypeExpression(node) {
return isTSAsExpression(node) || isTSSatisfiesExpression(node) || isTSTypeAssertion(node);
}
const isClassExtendsClause = (node, parent) => isClass(parent, {
superClass: node
});
const hasPostfixPart = (node, parent) => (isMemberExpression(parent) || isOptionalMemberExpression(parent)) && parent.object === node || (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent)) && parent.callee === node || isTaggedTemplateExpression(parent) && parent.tag === node || isTSNonNullExpression(parent);
function NullableTypeAnnotation(node, parent) {
return isArrayTypeAnnotation(parent);
}
function FunctionTypeAnnotation(node, parent, printStack) {
if (printStack.length < 3) return;
return isUnionTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isArrayTypeAnnotation(parent) || isTypeAnnotation(parent) && isArrowFunctionExpression(printStack[printStack.length - 3]);
}
function UpdateExpression(node, parent) {
return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
}
function ObjectExpression(node, parent, printStack) {
return isFirstInContext(printStack, 1 | 2);
}
function DoExpression(node, parent, printStack) {
return !node.async && isFirstInContext(printStack, 1);
}
function Binary(node, parent) {
if (node.operator === "**" && isBinaryExpression(parent, {
operator: "**"
})) {
return parent.left === node;
}
if (isClassExtendsClause(node, parent)) {
return true;
}
if (hasPostfixPart(node, parent) || isUnaryLike(parent) || isAwaitExpression(parent)) {
return true;
}
if (isBinary(parent)) {
const parentOp = parent.operator;
const parentPos = PRECEDENCE[parentOp];
const nodeOp = node.operator;
const nodePos = PRECEDENCE[nodeOp];
if (parentPos === nodePos && parent.right === node && !isLogicalExpression(parent) || parentPos > nodePos) {
return true;
}
}
}
function UnionTypeAnnotation(node, parent) {
return isArrayTypeAnnotation(parent) || isNullableTypeAnnotation(parent) || isIntersectionTypeAnnotation(parent) || isUnionTypeAnnotation(parent);
}
function OptionalIndexedAccessType(node, parent) {
return isIndexedAccessType(parent, {
objectType: node
});
}
function TSAsExpression() {
return true;
}
function TSUnionType(node, parent) {
return isTSArrayType(parent) || isTSOptionalType(parent) || isTSIntersectionType(parent) || isTSUnionType(parent) || isTSRestType(parent);
}
function TSInferType(node, parent) {
return isTSArrayType(parent) || isTSOptionalType(parent);
}
function TSInstantiationExpression(node, parent) {
return (isCallExpression(parent) || isOptionalCallExpression(parent) || isNewExpression(parent) || isTSInstantiationExpression(parent)) && !!parent.typeParameters;
}
function BinaryExpression(node, parent) {
return node.operator === "in" && (isVariableDeclarator(parent) || isFor(parent));
}
function SequenceExpression(node, parent) {
if (isForStatement(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement(parent) && parent.expression === node) {
return false;
}
return true;
}
function YieldExpression(node, parent) {
return isBinary(parent) || isUnaryLike(parent) || hasPostfixPart(node, parent) || isAwaitExpression(parent) && isYieldExpression(node) || isConditionalExpression(parent) && node === parent.test || isClassExtendsClause(node, parent);
}
function ClassExpression(node, parent, printStack) {
return isFirstInContext(printStack, 1 | 4);
}
function UnaryLike(node, parent) {
return hasPostfixPart(node, parent) || isBinaryExpression(parent, {
operator: "**",
left: node
}) || isClassExtendsClause(node, parent);
}
function FunctionExpression(node, parent, printStack) {
return isFirstInContext(printStack, 1 | 4);
}
function ArrowFunctionExpression(node, parent) {
return isExportDeclaration(parent) || ConditionalExpression(node, parent);
}
function ConditionalExpression(node, parent) {
if (isUnaryLike(parent) || isBinary(parent) || isConditionalExpression(parent, {
test: node
}) || isAwaitExpression(parent) || isTSTypeExpression(parent)) {
return true;
}
return UnaryLike(node, parent);
}
function OptionalMemberExpression(node, parent) {
return isCallExpression(parent, {
callee: node
}) || isMemberExpression(parent, {
object: node
});
}
function AssignmentExpression(node, parent) {
if (isObjectPattern(node.left)) {
return true;
} else {
return ConditionalExpression(node, parent);
}
}
function LogicalExpression(node, parent) {
if (isTSTypeExpression(parent)) return true;
switch (node.operator) {
case "||":
if (!isLogicalExpression(parent)) return false;
return parent.operator === "??" || parent.operator === "&&";
case "&&":
return isLogicalExpression(parent, {
operator: "??"
});
case "??":
return isLogicalExpression(parent) && parent.operator !== "??";
}
}
function Identifier(node, parent, printStack) {
var _node$extra;
if ((_node$extra = node.extra) != null && _node$extra.parenthesized && isAssignmentExpression(parent, {
left: node
}) && (isFunctionExpression(parent.right) || isClassExpression(parent.right)) && parent.right.id == null) {
return true;
}
if (node.name === "let") {
const isFollowedByBracket = isMemberExpression(parent, {
object: node,
computed: true
}) || isOptionalMemberExpression(parent, {
object: node,
computed: true,
optional: false
});
return isFirstInContext(printStack, isFollowedByBracket ? 1 | 8 | 16 | 32 : 32);
}
return node.name === "async" && isForOfStatement(parent) && node === parent.left;
}
function isFirstInContext(printStack, checkParam) {
const expressionStatement = checkParam & 1;
const arrowBody = checkParam & 2;
const exportDefault = checkParam & 4;
const forHead = checkParam & 8;
const forInHead = checkParam & 16;
const forOfHead = checkParam & 32;
let i = printStack.length - 1;
if (i <= 0) return;
let node = printStack[i];
i--;
let parent = printStack[i];
while (i >= 0) {
if (expressionStatement && isExpressionStatement(parent, {
expression: node
}) || exportDefault && isExportDefaultDeclaration(parent, {
declaration: node
}) || arrowBody && isArrowFunctionExpression(parent, {
body: node
}) || forHead && isForStatement(parent, {
init: node
}) || forInHead && isForInStatement(parent, {
left: node
}) || forOfHead && isForOfStatement(parent, {
left: node
})) {
return true;
}
if (i > 0 && (hasPostfixPart(node, parent) && !isNewExpression(parent) || isSequenceExpression(parent) && parent.expressions[0] === node || isUpdateExpression(parent) && !parent.prefix || isConditional(parent, {
test: node
}) || isBinary(parent, {
left: node
}) || isAssignmentExpression(parent, {
left: node
}))) {
node = parent;
i--;
parent = printStack[i];
} else {
return false;
}
}
return false;
}
return parentheses;
}
var hasRequiredNode;
function requireNode () {
if (hasRequiredNode) return node;
hasRequiredNode = 1;
Object.defineProperty(node, "__esModule", {
value: true
});
node.needsParens = needsParens;
node.needsWhitespace = needsWhitespace;
node.needsWhitespaceAfter = needsWhitespaceAfter;
node.needsWhitespaceBefore = needsWhitespaceBefore;
var whitespace = requireWhitespace();
var parens = requireParentheses();
var _t = requireLib$2();
const {
FLIPPED_ALIAS_KEYS,
isCallExpression,
isExpressionStatement,
isMemberExpression,
isNewExpression
} = _t;
function expandAliases(obj) {
const newObj = {};
function add(type, func) {
const fn = newObj[type];
newObj[type] = fn ? function (node, parent, stack) {
const result = fn(node, parent, stack);
return result == null ? func(node, parent, stack) : result;
} : func;
}
for (const type of Object.keys(obj)) {
const aliases = FLIPPED_ALIAS_KEYS[type];
if (aliases) {
for (const alias of aliases) {
add(alias, obj[type]);
}
} else {
add(type, obj[type]);
}
}
return newObj;
}
const expandedParens = expandAliases(parens);
const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
function find(obj, node, parent, printStack) {
const fn = obj[node.type];
return fn ? fn(node, parent, printStack) : null;
}
function isOrHasCallExpression(node) {
if (isCallExpression(node)) {
return true;
}
return isMemberExpression(node) && isOrHasCallExpression(node.object);
}
function needsWhitespace(node, parent, type) {
if (!node) return false;
if (isExpressionStatement(node)) {
node = node.expression;
}
const flag = find(expandedWhitespaceNodes, node, parent);
if (typeof flag === "number") {
return (flag & type) !== 0;
}
return false;
}
function needsWhitespaceBefore(node, parent) {
return needsWhitespace(node, parent, 1);
}
function needsWhitespaceAfter(node, parent) {
return needsWhitespace(node, parent, 2);
}
function needsParens(node, parent, printStack) {
if (!parent) return false;
if (isNewExpression(parent) && parent.callee === node) {
if (isOrHasCallExpression(node)) return true;
}
return find(expandedParens, node, parent, printStack);
}
return node;
}
var generators = {};
var templateLiterals = {};
var hasRequiredTemplateLiterals;
function requireTemplateLiterals () {
if (hasRequiredTemplateLiterals) return templateLiterals;
hasRequiredTemplateLiterals = 1;
Object.defineProperty(templateLiterals, "__esModule", {
value: true
});
templateLiterals.TaggedTemplateExpression = TaggedTemplateExpression;
templateLiterals.TemplateElement = TemplateElement;
templateLiterals.TemplateLiteral = TemplateLiteral;
function TaggedTemplateExpression(node) {
this.print(node.tag, node);
this.print(node.typeParameters, node);
this.print(node.quasi, node);
}
function TemplateElement(node, parent) {
const isFirst = parent.quasis[0] === node;
const isLast = parent.quasis[parent.quasis.length - 1] === node;
const value = (isFirst ? "`" : "}") + node.value.raw + (isLast ? "`" : "${");
this.token(value, true);
}
function TemplateLiteral(node) {
const quasis = node.quasis;
for (let i = 0; i < quasis.length; i++) {
this.print(quasis[i], node);
if (i + 1 < quasis.length) {
this.print(node.expressions[i], node);
}
}
}
return templateLiterals;
}
var expressions = {};
var hasRequiredExpressions;
function requireExpressions () {
if (hasRequiredExpressions) return expressions;
hasRequiredExpressions = 1;
Object.defineProperty(expressions, "__esModule", {
value: true
});
expressions.LogicalExpression = expressions.BinaryExpression = expressions.AssignmentExpression = AssignmentExpression;
expressions.AssignmentPattern = AssignmentPattern;
expressions.AwaitExpression = AwaitExpression;
expressions.BindExpression = BindExpression;
expressions.CallExpression = CallExpression;
expressions.ConditionalExpression = ConditionalExpression;
expressions.Decorator = Decorator;
expressions.DoExpression = DoExpression;
expressions.EmptyStatement = EmptyStatement;
expressions.ExpressionStatement = ExpressionStatement;
expressions.Import = Import;
expressions.MemberExpression = MemberExpression;
expressions.MetaProperty = MetaProperty;
expressions.ModuleExpression = ModuleExpression;
expressions.NewExpression = NewExpression;
expressions.OptionalCallExpression = OptionalCallExpression;
expressions.OptionalMemberExpression = OptionalMemberExpression;
expressions.ParenthesizedExpression = ParenthesizedExpression;
expressions.PrivateName = PrivateName;
expressions.SequenceExpression = SequenceExpression;
expressions.Super = Super;
expressions.ThisExpression = ThisExpression;
expressions.UnaryExpression = UnaryExpression;
expressions.UpdateExpression = UpdateExpression;
expressions.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
expressions.YieldExpression = YieldExpression;
expressions._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport;
var _t = requireLib$2();
var n = requireNode();
const {
isCallExpression,
isLiteral,
isMemberExpression,
isNewExpression
} = _t;
function UnaryExpression(node) {
const {
operator
} = node;
if (operator === "void" || operator === "delete" || operator === "typeof" || operator === "throw") {
this.word(operator);
this.space();
} else {
this.token(operator);
}
this.print(node.argument, node);
}
function DoExpression(node) {
if (node.async) {
this.word("async", true);
this.space();
}
this.word("do");
this.space();
this.print(node.body, node);
}
function ParenthesizedExpression(node) {
this.tokenChar(40);
this.print(node.expression, node);
this.rightParens(node);
}
function UpdateExpression(node) {
if (node.prefix) {
this.token(node.operator);
this.print(node.argument, node);
} else {
this.printTerminatorless(node.argument, node, true);
this.token(node.operator);
}
}
function ConditionalExpression(node) {
this.print(node.test, node);
this.space();
this.tokenChar(63);
this.space();
this.print(node.consequent, node);
this.space();
this.tokenChar(58);
this.space();
this.print(node.alternate, node);
}
function NewExpression(node, parent) {
this.word("new");
this.space();
this.print(node.callee, node);
if (this.format.minified && node.arguments.length === 0 && !node.optional && !isCallExpression(parent, {
callee: node
}) && !isMemberExpression(parent) && !isNewExpression(parent)) {
return;
}
this.print(node.typeArguments, node);
this.print(node.typeParameters, node);
if (node.optional) {
this.token("?.");
}
this.tokenChar(40);
this.printList(node.arguments, node);
this.rightParens(node);
}
function SequenceExpression(node) {
this.printList(node.expressions, node);
}
function ThisExpression() {
this.word("this");
}
function Super() {
this.word("super");
}
function isDecoratorMemberExpression(node) {
switch (node.type) {
case "Identifier":
return true;
case "MemberExpression":
return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
default:
return false;
}
}
function shouldParenthesizeDecoratorExpression(node) {
if (node.type === "ParenthesizedExpression") {
return false;
}
return !isDecoratorMemberExpression(node.type === "CallExpression" ? node.callee : node);
}
function _shouldPrintDecoratorsBeforeExport(node) {
if (typeof this.format.decoratorsBeforeExport === "boolean") {
return this.format.decoratorsBeforeExport;
}
return typeof node.start === "number" && node.start === node.declaration.start;
}
function Decorator(node) {
this.tokenChar(64);
const {
expression
} = node;
if (shouldParenthesizeDecoratorExpression(expression)) {
this.tokenChar(40);
this.print(expression, node);
this.tokenChar(41);
} else {
this.print(expression, node);
}
this.newline();
}
function OptionalMemberExpression(node) {
let {
computed
} = node;
const {
optional,
property
} = node;
this.print(node.object, node);
if (!computed && isMemberExpression(property)) {
throw new TypeError("Got a MemberExpression for MemberExpression property");
}
if (isLiteral(property) && typeof property.value === "number") {
computed = true;
}
if (optional) {
this.token("?.");
}
if (computed) {
this.tokenChar(91);
this.print(property, node);
this.tokenChar(93);
} else {
if (!optional) {
this.tokenChar(46);
}
this.print(property, node);
}
}
function OptionalCallExpression(node) {
this.print(node.callee, node);
this.print(node.typeParameters, node);
if (node.optional) {
this.token("?.");
}
this.print(node.typeArguments, node);
this.tokenChar(40);
this.printList(node.arguments, node);
this.rightParens(node);
}
function CallExpression(node) {
this.print(node.callee, node);
this.print(node.typeArguments, node);
this.print(node.typeParameters, node);
this.tokenChar(40);
this.printList(node.arguments, node);
this.rightParens(node);
}
function Import() {
this.word("import");
}
function AwaitExpression(node) {
this.word("await");
if (node.argument) {
this.space();
this.printTerminatorless(node.argument, node, false);
}
}
function YieldExpression(node) {
this.word("yield", true);
if (node.delegate) {
this.tokenChar(42);
if (node.argument) {
this.space();
this.print(node.argument, node);
}
} else {
if (node.argument) {
this.space();
this.printTerminatorless(node.argument, node, false);
}
}
}
function EmptyStatement() {
this.semicolon(true);
}
function ExpressionStatement(node) {
this.print(node.expression, node);
this.semicolon();
}
function AssignmentPattern(node) {
this.print(node.left, node);
if (node.left.optional) this.tokenChar(63);
this.print(node.left.typeAnnotation, node);
this.space();
this.tokenChar(61);
this.space();
this.print(node.right, node);
}
function AssignmentExpression(node, parent) {
const parens = this.inForStatementInitCounter && node.operator === "in" && !n.needsParens(node, parent);
if (parens) {
this.tokenChar(40);
}
this.print(node.left, node);
this.space();
if (node.operator === "in" || node.operator === "instanceof") {
this.word(node.operator);
} else {
this.token(node.operator);
}
this.space();
this.print(node.right, node);
if (parens) {
this.tokenChar(41);
}
}
function BindExpression(node) {
this.print(node.object, node);
this.token("::");
this.print(node.callee, node);
}
function MemberExpression(node) {
this.print(node.object, node);
if (!node.computed && isMemberExpression(node.property)) {
throw new TypeError("Got a MemberExpression for MemberExpression property");
}
let computed = node.computed;
if (isLiteral(node.property) && typeof node.property.value === "number") {
computed = true;
}
if (computed) {
this.tokenChar(91);
this.print(node.property, node);
this.tokenChar(93);
} else {
this.tokenChar(46);
this.print(node.property, node);
}
}
function MetaProperty(node) {
this.print(node.meta, node);
this.tokenChar(46);
this.print(node.property, node);
}
function PrivateName(node) {
this.tokenChar(35);
this.print(node.id, node);
}
function V8IntrinsicIdentifier(node) {
this.tokenChar(37);
this.word(node.name);
}
function ModuleExpression(node) {
this.word("module", true);
this.space();
this.tokenChar(123);
this.indent();
const {
body
} = node;
if (body.body.length || body.directives.length) {
this.newline();
}
this.print(body, node);
this.dedent();
this.rightBrace(node);
}
return expressions;
}
var statements = {};
var hasRequiredStatements;
function requireStatements () {
if (hasRequiredStatements) return statements;
hasRequiredStatements = 1;
Object.defineProperty(statements, "__esModule", {
value: true
});
statements.BreakStatement = BreakStatement;
statements.CatchClause = CatchClause;
statements.ContinueStatement = ContinueStatement;
statements.DebuggerStatement = DebuggerStatement;
statements.DoWhileStatement = DoWhileStatement;
statements.ForOfStatement = statements.ForInStatement = void 0;
statements.ForStatement = ForStatement;
statements.IfStatement = IfStatement;
statements.LabeledStatement = LabeledStatement;
statements.ReturnStatement = ReturnStatement;
statements.SwitchCase = SwitchCase;
statements.SwitchStatement = SwitchStatement;
statements.ThrowStatement = ThrowStatement;
statements.TryStatement = TryStatement;
statements.VariableDeclaration = VariableDeclaration;
statements.VariableDeclarator = VariableDeclarator;
statements.WhileStatement = WhileStatement;
statements.WithStatement = WithStatement;
var _t = requireLib$2();
const {
isFor,
isForStatement,
isIfStatement,
isStatement
} = _t;
function WithStatement(node) {
this.word("with");
this.space();
this.tokenChar(40);
this.print(node.object, node);
this.tokenChar(41);
this.printBlock(node);
}
function IfStatement(node) {
this.word("if");
this.space();
this.tokenChar(40);
this.print(node.test, node);
this.tokenChar(41);
this.space();
const needsBlock = node.alternate && isIfStatement(getLastStatement(node.consequent));
if (needsBlock) {
this.tokenChar(123);
this.newline();
this.indent();
}
this.printAndIndentOnComments(node.consequent, node);
if (needsBlock) {
this.dedent();
this.newline();
this.tokenChar(125);
}
if (node.alternate) {
if (this.endsWith(125)) this.space();
this.word("else");
this.space();
this.printAndIndentOnComments(node.alternate, node);
}
}
function getLastStatement(statement) {
const {
body
} = statement;
if (isStatement(body) === false) {
return statement;
}
return getLastStatement(body);
}
function ForStatement(node) {
this.word("for");
this.space();
this.tokenChar(40);
this.inForStatementInitCounter++;
this.print(node.init, node);
this.inForStatementInitCounter--;
this.tokenChar(59);
if (node.test) {
this.space();
this.print(node.test, node);
}
this.tokenChar(59);
if (node.update) {
this.space();
this.print(node.update, node);
}
this.tokenChar(41);
this.printBlock(node);
}
function WhileStatement(node) {
this.word("while");
this.space();
this.tokenChar(40);
this.print(node.test, node);
this.tokenChar(41);
this.printBlock(node);
}
function ForXStatement(node) {
this.word("for");
this.space();
const isForOf = node.type === "ForOfStatement";
if (isForOf && node.await) {
this.word("await");
this.space();
}
this.noIndentInnerCommentsHere();
this.tokenChar(40);
this.print(node.left, node);
this.space();
this.word(isForOf ? "of" : "in");
this.space();
this.print(node.right, node);
this.tokenChar(41);
this.printBlock(node);
}
const ForInStatement = ForXStatement;
statements.ForInStatement = ForInStatement;
const ForOfStatement = ForXStatement;
statements.ForOfStatement = ForOfStatement;
function DoWhileStatement(node) {
this.word("do");
this.space();
this.print(node.body, node);
this.space();
this.word("while");
this.space();
this.tokenChar(40);
this.print(node.test, node);
this.tokenChar(41);
this.semicolon();
}
function printStatementAfterKeyword(printer, node, parent, isLabel) {
if (node) {
printer.space();
printer.printTerminatorless(node, parent, isLabel);
}
printer.semicolon();
}
function BreakStatement(node) {
this.word("break");
printStatementAfterKeyword(this, node.label, node, true);
}
function ContinueStatement(node) {
this.word("continue");
printStatementAfterKeyword(this, node.label, node, true);
}
function ReturnStatement(node) {
this.word("return");
printStatementAfterKeyword(this, node.argument, node, false);
}
function ThrowStatement(node) {
this.word("throw");
printStatementAfterKeyword(this, node.argument, node, false);
}
function LabeledStatement(node) {
this.print(node.label, node);
this.tokenChar(58);
this.space();
this.print(node.body, node);
}
function TryStatement(node) {
this.word("try");
this.space();
this.print(node.block, node);
this.space();
if (node.handlers) {
this.print(node.handlers[0], node);
} else {
this.print(node.handler, node);
}
if (node.finalizer) {
this.space();
this.word("finally");
this.space();
this.print(node.finalizer, node);
}
}
function CatchClause(node) {
this.word("catch");
this.space();
if (node.param) {
this.tokenChar(40);
this.print(node.param, node);
this.print(node.param.typeAnnotation, node);
this.tokenChar(41);
this.space();
}
this.print(node.body, node);
}
function SwitchStatement(node) {
this.word("switch");
this.space();
this.tokenChar(40);
this.print(node.discriminant, node);
this.tokenChar(41);
this.space();
this.tokenChar(123);
this.printSequence(node.cases, node, {
indent: true,
addNewlines(leading, cas) {
if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
}
});
this.rightBrace(node);
}
function SwitchCase(node) {
if (node.test) {
this.word("case");
this.space();
this.print(node.test, node);
this.tokenChar(58);
} else {
this.word("default");
this.tokenChar(58);
}
if (node.consequent.length) {
this.newline();
this.printSequence(node.consequent, node, {
indent: true
});
}
}
function DebuggerStatement() {
this.word("debugger");
this.semicolon();
}
function VariableDeclaration(node, parent) {
if (node.declare) {
this.word("declare");
this.space();
}
const {
kind
} = node;
this.word(kind, kind === "using" || kind === "await using");
this.space();
let hasInits = false;
if (!isFor(parent)) {
for (const declar of node.declarations) {
if (declar.init) {
hasInits = true;
}
}
}
this.printList(node.declarations, node, {
separator: hasInits ? function () {
this.tokenChar(44);
this.newline();
} : undefined,
indent: node.declarations.length > 1 ? true : false
});
if (isFor(parent)) {
if (isForStatement(parent)) {
if (parent.init === node) return;
} else {
if (parent.left === node) return;
}
}
this.semicolon();
}
function VariableDeclarator(node) {
this.print(node.id, node);
if (node.definite) this.tokenChar(33);
this.print(node.id.typeAnnotation, node);
if (node.init) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.init, node);
}
}
return statements;
}
var classes = {};
var hasRequiredClasses;
function requireClasses () {
if (hasRequiredClasses) return classes;
hasRequiredClasses = 1;
Object.defineProperty(classes, "__esModule", {
value: true
});
classes.ClassAccessorProperty = ClassAccessorProperty;
classes.ClassBody = ClassBody;
classes.ClassExpression = classes.ClassDeclaration = ClassDeclaration;
classes.ClassMethod = ClassMethod;
classes.ClassPrivateMethod = ClassPrivateMethod;
classes.ClassPrivateProperty = ClassPrivateProperty;
classes.ClassProperty = ClassProperty;
classes.StaticBlock = StaticBlock;
classes._classMethodHead = _classMethodHead;
var _t = requireLib$2();
const {
isExportDefaultDeclaration,
isExportNamedDeclaration
} = _t;
function ClassDeclaration(node, parent) {
const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent);
if (!inExport || !this._shouldPrintDecoratorsBeforeExport(parent)) {
this.printJoin(node.decorators, node);
}
if (node.declare) {
this.word("declare");
this.space();
}
if (node.abstract) {
this.word("abstract");
this.space();
}
this.word("class");
if (node.id) {
this.space();
this.print(node.id, node);
}
this.print(node.typeParameters, node);
if (node.superClass) {
this.space();
this.word("extends");
this.space();
this.print(node.superClass, node);
this.print(node.superTypeParameters, node);
}
if (node.implements) {
this.space();
this.word("implements");
this.space();
this.printList(node.implements, node);
}
this.space();
this.print(node.body, node);
}
function ClassBody(node) {
this.tokenChar(123);
if (node.body.length === 0) {
this.tokenChar(125);
} else {
this.newline();
this.printSequence(node.body, node, {
indent: true
});
if (!this.endsWith(10)) this.newline();
this.rightBrace(node);
}
}
function ClassProperty(node) {
var _node$key$loc;
this.printJoin(node.decorators, node);
const endLine = (_node$key$loc = node.key.loc) == null || (_node$key$loc = _node$key$loc.end) == null ? void 0 : _node$key$loc.line;
if (endLine) this.catchUp(endLine);
this.tsPrintClassMemberModifiers(node);
if (node.computed) {
this.tokenChar(91);
this.print(node.key, node);
this.tokenChar(93);
} else {
this._variance(node);
this.print(node.key, node);
}
if (node.optional) {
this.tokenChar(63);
}
if (node.definite) {
this.tokenChar(33);
}
this.print(node.typeAnnotation, node);
if (node.value) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.value, node);
}
this.semicolon();
}
function ClassAccessorProperty(node) {
var _node$key$loc2;
this.printJoin(node.decorators, node);
const endLine = (_node$key$loc2 = node.key.loc) == null || (_node$key$loc2 = _node$key$loc2.end) == null ? void 0 : _node$key$loc2.line;
if (endLine) this.catchUp(endLine);
this.tsPrintClassMemberModifiers(node);
this.word("accessor", true);
this.space();
if (node.computed) {
this.tokenChar(91);
this.print(node.key, node);
this.tokenChar(93);
} else {
this._variance(node);
this.print(node.key, node);
}
if (node.optional) {
this.tokenChar(63);
}
if (node.definite) {
this.tokenChar(33);
}
this.print(node.typeAnnotation, node);
if (node.value) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.value, node);
}
this.semicolon();
}
function ClassPrivateProperty(node) {
this.printJoin(node.decorators, node);
if (node.static) {
this.word("static");
this.space();
}
this.print(node.key, node);
this.print(node.typeAnnotation, node);
if (node.value) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.value, node);
}
this.semicolon();
}
function ClassMethod(node) {
this._classMethodHead(node);
this.space();
this.print(node.body, node);
}
function ClassPrivateMethod(node) {
this._classMethodHead(node);
this.space();
this.print(node.body, node);
}
function _classMethodHead(node) {
var _node$key$loc3;
this.printJoin(node.decorators, node);
const endLine = (_node$key$loc3 = node.key.loc) == null || (_node$key$loc3 = _node$key$loc3.end) == null ? void 0 : _node$key$loc3.line;
if (endLine) this.catchUp(endLine);
this.tsPrintClassMemberModifiers(node);
this._methodHead(node);
}
function StaticBlock(node) {
this.word("static");
this.space();
this.tokenChar(123);
if (node.body.length === 0) {
this.tokenChar(125);
} else {
this.newline();
this.printSequence(node.body, node, {
indent: true
});
this.rightBrace(node);
}
}
return classes;
}
var methods = {};
var hasRequiredMethods;
function requireMethods () {
if (hasRequiredMethods) return methods;
hasRequiredMethods = 1;
Object.defineProperty(methods, "__esModule", {
value: true
});
methods.ArrowFunctionExpression = ArrowFunctionExpression;
methods.FunctionDeclaration = methods.FunctionExpression = FunctionExpression;
methods._functionHead = _functionHead;
methods._methodHead = _methodHead;
methods._param = _param;
methods._parameters = _parameters;
methods._params = _params;
methods._predicate = _predicate;
var _t = requireLib$2();
const {
isIdentifier
} = _t;
function _params(node, idNode, parentNode) {
this.print(node.typeParameters, node);
const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
if (nameInfo) {
this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
}
this.tokenChar(40);
this._parameters(node.params, node);
this.tokenChar(41);
const noLineTerminator = node.type === "ArrowFunctionExpression";
this.print(node.returnType, node, noLineTerminator);
this._noLineTerminator = noLineTerminator;
}
function _parameters(parameters, parent) {
const paramLength = parameters.length;
for (let i = 0; i < paramLength; i++) {
this._param(parameters[i], parent);
if (i < parameters.length - 1) {
this.tokenChar(44);
this.space();
}
}
}
function _param(parameter, parent) {
this.printJoin(parameter.decorators, parameter);
this.print(parameter, parent);
if (parameter.optional) {
this.tokenChar(63);
}
this.print(parameter.typeAnnotation, parameter);
}
function _methodHead(node) {
const kind = node.kind;
const key = node.key;
if (kind === "get" || kind === "set") {
this.word(kind);
this.space();
}
if (node.async) {
this.word("async", true);
this.space();
}
if (kind === "method" || kind === "init") {
if (node.generator) {
this.tokenChar(42);
}
}
if (node.computed) {
this.tokenChar(91);
this.print(key, node);
this.tokenChar(93);
} else {
this.print(key, node);
}
if (node.optional) {
this.tokenChar(63);
}
this._params(node, node.computed && node.key.type !== "StringLiteral" ? undefined : node.key, undefined);
}
function _predicate(node, noLineTerminatorAfter) {
if (node.predicate) {
if (!node.returnType) {
this.tokenChar(58);
}
this.space();
this.print(node.predicate, node, noLineTerminatorAfter);
}
}
function _functionHead(node, parent) {
if (node.async) {
this.word("async");
this._endsWithInnerRaw = false;
this.space();
}
this.word("function");
if (node.generator) {
this._endsWithInnerRaw = false;
this.tokenChar(42);
}
this.space();
if (node.id) {
this.print(node.id, node);
}
this._params(node, node.id, parent);
if (node.type !== "TSDeclareFunction") {
this._predicate(node);
}
}
function FunctionExpression(node, parent) {
this._functionHead(node, parent);
this.space();
this.print(node.body, node);
}
function ArrowFunctionExpression(node, parent) {
if (node.async) {
this.word("async", true);
this.space();
}
let firstParam;
if (!this.format.retainLines && node.params.length === 1 && isIdentifier(firstParam = node.params[0]) && !hasTypesOrComments(node, firstParam)) {
this.print(firstParam, node, true);
} else {
this._params(node, undefined, parent);
}
this._predicate(node, true);
this.space();
this.printInnerComments();
this.token("=>");
this.space();
this.print(node.body, node);
}
function hasTypesOrComments(node, param) {
var _param$leadingComment, _param$trailingCommen;
return !!(node.typeParameters || node.returnType || node.predicate || param.typeAnnotation || param.optional || (_param$leadingComment = param.leadingComments) != null && _param$leadingComment.length || (_param$trailingCommen = param.trailingComments) != null && _param$trailingCommen.length);
}
function _getFuncIdName(idNode, parent) {
let id = idNode;
if (!id && parent) {
const parentType = parent.type;
if (parentType === "VariableDeclarator") {
id = parent.id;
} else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") {
id = parent.left;
} else if (parentType === "ObjectProperty" || parentType === "ClassProperty") {
if (!parent.computed || parent.key.type === "StringLiteral") {
id = parent.key;
}
} else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") {
id = parent.key;
}
}
if (!id) return;
let nameInfo;
if (id.type === "Identifier") {
var _id$loc, _id$loc2;
nameInfo = {
pos: (_id$loc = id.loc) == null ? void 0 : _id$loc.start,
name: ((_id$loc2 = id.loc) == null ? void 0 : _id$loc2.identifierName) || id.name
};
} else if (id.type === "PrivateName") {
var _id$loc3;
nameInfo = {
pos: (_id$loc3 = id.loc) == null ? void 0 : _id$loc3.start,
name: "#" + id.id.name
};
} else if (id.type === "StringLiteral") {
var _id$loc4;
nameInfo = {
pos: (_id$loc4 = id.loc) == null ? void 0 : _id$loc4.start,
name: id.value
};
}
return nameInfo;
}
return methods;
}
var modules = {};
var hasRequiredModules;
function requireModules () {
if (hasRequiredModules) return modules;
hasRequiredModules = 1;
Object.defineProperty(modules, "__esModule", {
value: true
});
modules.ExportAllDeclaration = ExportAllDeclaration;
modules.ExportDefaultDeclaration = ExportDefaultDeclaration;
modules.ExportDefaultSpecifier = ExportDefaultSpecifier;
modules.ExportNamedDeclaration = ExportNamedDeclaration;
modules.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
modules.ExportSpecifier = ExportSpecifier;
modules.ImportAttribute = ImportAttribute;
modules.ImportDeclaration = ImportDeclaration;
modules.ImportDefaultSpecifier = ImportDefaultSpecifier;
modules.ImportExpression = ImportExpression;
modules.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
modules.ImportSpecifier = ImportSpecifier;
modules._printAttributes = _printAttributes;
var _t = requireLib$2();
const {
isClassDeclaration,
isExportDefaultSpecifier,
isExportNamespaceSpecifier,
isImportDefaultSpecifier,
isImportNamespaceSpecifier,
isStatement
} = _t;
function ImportSpecifier(node) {
if (node.importKind === "type" || node.importKind === "typeof") {
this.word(node.importKind);
this.space();
}
this.print(node.imported, node);
if (node.local && node.local.name !== node.imported.name) {
this.space();
this.word("as");
this.space();
this.print(node.local, node);
}
}
function ImportDefaultSpecifier(node) {
this.print(node.local, node);
}
function ExportDefaultSpecifier(node) {
this.print(node.exported, node);
}
function ExportSpecifier(node) {
if (node.exportKind === "type") {
this.word("type");
this.space();
}
this.print(node.local, node);
if (node.exported && node.local.name !== node.exported.name) {
this.space();
this.word("as");
this.space();
this.print(node.exported, node);
}
}
function ExportNamespaceSpecifier(node) {
this.tokenChar(42);
this.space();
this.word("as");
this.space();
this.print(node.exported, node);
}
let warningShown = false;
function _printAttributes(node) {
const {
importAttributesKeyword
} = this.format;
const {
attributes,
assertions
} = node;
if (attributes && !importAttributesKeyword && !warningShown) {
warningShown = true;
console.warn(`\
You are using import attributes, without specifying the desired output syntax.
Please specify the "importAttributesKeyword" generator option, whose value can be one of:
- "with" : \`import { a } from "b" with { type: "json" };\`
- "assert" : \`import { a } from "b" assert { type: "json" };\`
- "with-legacy" : \`import { a } from "b" with type: "json";\`
`);
}
const useAssertKeyword = importAttributesKeyword === "assert" || !importAttributesKeyword && assertions;
this.word(useAssertKeyword ? "assert" : "with");
this.space();
if (!useAssertKeyword && importAttributesKeyword !== "with") {
this.printList(attributes || assertions, node);
return;
}
this.tokenChar(123);
this.space();
this.printList(attributes || assertions, node);
this.space();
this.tokenChar(125);
}
function ExportAllDeclaration(node) {
var _node$attributes, _node$assertions;
this.word("export");
this.space();
if (node.exportKind === "type") {
this.word("type");
this.space();
}
this.tokenChar(42);
this.space();
this.word("from");
this.space();
if ((_node$attributes = node.attributes) != null && _node$attributes.length || (_node$assertions = node.assertions) != null && _node$assertions.length) {
this.print(node.source, node, true);
this.space();
this._printAttributes(node);
} else {
this.print(node.source, node);
}
this.semicolon();
}
function maybePrintDecoratorsBeforeExport(printer, node) {
if (isClassDeclaration(node.declaration) && printer._shouldPrintDecoratorsBeforeExport(node)) {
printer.printJoin(node.declaration.decorators, node);
}
}
function ExportNamedDeclaration(node) {
maybePrintDecoratorsBeforeExport(this, node);
this.word("export");
this.space();
if (node.declaration) {
const declar = node.declaration;
this.print(declar, node);
if (!isStatement(declar)) this.semicolon();
} else {
if (node.exportKind === "type") {
this.word("type");
this.space();
}
const specifiers = node.specifiers.slice(0);
let hasSpecial = false;
for (;;) {
const first = specifiers[0];
if (isExportDefaultSpecifier(first) || isExportNamespaceSpecifier(first)) {
hasSpecial = true;
this.print(specifiers.shift(), node);
if (specifiers.length) {
this.tokenChar(44);
this.space();
}
} else {
break;
}
}
if (specifiers.length || !specifiers.length && !hasSpecial) {
this.tokenChar(123);
if (specifiers.length) {
this.space();
this.printList(specifiers, node);
this.space();
}
this.tokenChar(125);
}
if (node.source) {
var _node$attributes2, _node$assertions2;
this.space();
this.word("from");
this.space();
if ((_node$attributes2 = node.attributes) != null && _node$attributes2.length || (_node$assertions2 = node.assertions) != null && _node$assertions2.length) {
this.print(node.source, node, true);
this.space();
this._printAttributes(node);
} else {
this.print(node.source, node);
}
}
this.semicolon();
}
}
function ExportDefaultDeclaration(node) {
maybePrintDecoratorsBeforeExport(this, node);
this.word("export");
this.noIndentInnerCommentsHere();
this.space();
this.word("default");
this.space();
const declar = node.declaration;
this.print(declar, node);
if (!isStatement(declar)) this.semicolon();
}
function ImportDeclaration(node) {
var _node$attributes3, _node$assertions3;
this.word("import");
this.space();
const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
if (isTypeKind) {
this.noIndentInnerCommentsHere();
this.word(node.importKind);
this.space();
} else if (node.module) {
this.noIndentInnerCommentsHere();
this.word("module");
this.space();
} else if (node.phase) {
this.noIndentInnerCommentsHere();
this.word(node.phase);
this.space();
}
const specifiers = node.specifiers.slice(0);
const hasSpecifiers = !!specifiers.length;
while (hasSpecifiers) {
const first = specifiers[0];
if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
this.print(specifiers.shift(), node);
if (specifiers.length) {
this.tokenChar(44);
this.space();
}
} else {
break;
}
}
if (specifiers.length) {
this.tokenChar(123);
this.space();
this.printList(specifiers, node);
this.space();
this.tokenChar(125);
} else if (isTypeKind && !hasSpecifiers) {
this.tokenChar(123);
this.tokenChar(125);
}
if (hasSpecifiers || isTypeKind) {
this.space();
this.word("from");
this.space();
}
if ((_node$attributes3 = node.attributes) != null && _node$attributes3.length || (_node$assertions3 = node.assertions) != null && _node$assertions3.length) {
this.print(node.source, node, true);
this.space();
this._printAttributes(node);
} else {
this.print(node.source, node);
}
this.semicolon();
}
function ImportAttribute(node) {
this.print(node.key);
this.tokenChar(58);
this.space();
this.print(node.value);
}
function ImportNamespaceSpecifier(node) {
this.tokenChar(42);
this.space();
this.word("as");
this.space();
this.print(node.local, node);
}
function ImportExpression(node) {
this.word("import");
if (node.phase) {
this.tokenChar(46);
this.word(node.phase);
}
this.tokenChar(40);
this.print(node.source, node);
if (node.options != null) {
this.tokenChar(44);
this.space();
this.print(node.options, node);
}
this.tokenChar(41);
}
return modules;
}
var types = {};
var jsesc_1;
var hasRequiredJsesc;
function requireJsesc () {
if (hasRequiredJsesc) return jsesc_1;
hasRequiredJsesc = 1;
const object = {};
const hasOwnProperty = object.hasOwnProperty;
const forOwn = (object, callback) => {
for (const key in object) {
if (hasOwnProperty.call(object, key)) {
callback(key, object[key]);
}
}
};
const extend = (destination, source) => {
if (!source) {
return destination;
}
forOwn(source, (key, value) => {
destination[key] = value;
});
return destination;
};
const forEach = (array, callback) => {
const length = array.length;
let index = -1;
while (++index < length) {
callback(array[index]);
}
};
const toString = object.toString;
const isArray = Array.isArray;
const isBuffer = Buffer.isBuffer;
const isObject = (value) => {
// This is a very simple check, but it’s good enough for what we need.
return toString.call(value) == '[object Object]';
};
const isString = (value) => {
return typeof value == 'string' ||
toString.call(value) == '[object String]';
};
const isNumber = (value) => {
return typeof value == 'number' ||
toString.call(value) == '[object Number]';
};
const isFunction = (value) => {
return typeof value == 'function';
};
const isMap = (value) => {
return toString.call(value) == '[object Map]';
};
const isSet = (value) => {
return toString.call(value) == '[object Set]';
};
/*--------------------------------------------------------------------------*/
const singleEscapes = {
'"': '\\"',
'\'': '\\\'',
'\\': '\\\\',
'\b': '\\b',
'\f': '\\f',
'\n': '\\n',
'\r': '\\r',
'\t': '\\t'
// `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'.
// '\v': '\\x0B'
};
const regexSingleEscape = /["'\\\b\f\n\r\t]/;
const regexDigit = /[0-9]/;
const regexWhitelist = /[ !#-&\(-\[\]-_a-~]/;
const jsesc = (argument, options) => {
const increaseIndentation = () => {
oldIndent = indent;
++options.indentLevel;
indent = options.indent.repeat(options.indentLevel);
};
// Handle options
const defaults = {
'escapeEverything': false,
'minimal': false,
'isScriptContext': false,
'quotes': 'single',
'wrap': false,
'es6': false,
'json': false,
'compact': true,
'lowercaseHex': false,
'numbers': 'decimal',
'indent': '\t',
'indentLevel': 0,
'__inline1__': false,
'__inline2__': false
};
const json = options && options.json;
if (json) {
defaults.quotes = 'double';
defaults.wrap = true;
}
options = extend(defaults, options);
if (
options.quotes != 'single' &&
options.quotes != 'double' &&
options.quotes != 'backtick'
) {
options.quotes = 'single';
}
const quote = options.quotes == 'double' ?
'"' :
(options.quotes == 'backtick' ?
'`' :
'\''
);
const compact = options.compact;
const lowercaseHex = options.lowercaseHex;
let indent = options.indent.repeat(options.indentLevel);
let oldIndent = '';
const inline1 = options.__inline1__;
const inline2 = options.__inline2__;
const newLine = compact ? '' : '\n';
let result;
let isEmpty = true;
const useBinNumbers = options.numbers == 'binary';
const useOctNumbers = options.numbers == 'octal';
const useDecNumbers = options.numbers == 'decimal';
const useHexNumbers = options.numbers == 'hexadecimal';
if (json && argument && isFunction(argument.toJSON)) {
argument = argument.toJSON();
}
if (!isString(argument)) {
if (isMap(argument)) {
if (argument.size == 0) {
return 'new Map()';
}
if (!compact) {
options.__inline1__ = true;
options.__inline2__ = false;
}
return 'new Map(' + jsesc(Array.from(argument), options) + ')';
}
if (isSet(argument)) {
if (argument.size == 0) {
return 'new Set()';
}
return 'new Set(' + jsesc(Array.from(argument), options) + ')';
}
if (isBuffer(argument)) {
if (argument.length == 0) {
return 'Buffer.from([])';
}
return 'Buffer.from(' + jsesc(Array.from(argument), options) + ')';
}
if (isArray(argument)) {
result = [];
options.wrap = true;
if (inline1) {
options.__inline1__ = false;
options.__inline2__ = true;
}
if (!inline2) {
increaseIndentation();
}
forEach(argument, (value) => {
isEmpty = false;
if (inline2) {
options.__inline2__ = false;
}
result.push(
(compact || inline2 ? '' : indent) +
jsesc(value, options)
);
});
if (isEmpty) {
return '[]';
}
if (inline2) {
return '[' + result.join(', ') + ']';
}
return '[' + newLine + result.join(',' + newLine) + newLine +
(compact ? '' : oldIndent) + ']';
} else if (isNumber(argument)) {
if (json) {
// Some number values (e.g. `Infinity`) cannot be represented in JSON.
return JSON.stringify(argument);
}
if (useDecNumbers) {
return String(argument);
}
if (useHexNumbers) {
let hexadecimal = argument.toString(16);
if (!lowercaseHex) {
hexadecimal = hexadecimal.toUpperCase();
}
return '0x' + hexadecimal;
}
if (useBinNumbers) {
return '0b' + argument.toString(2);
}
if (useOctNumbers) {
return '0o' + argument.toString(8);
}
} else if (!isObject(argument)) {
if (json) {
// For some values (e.g. `undefined`, `function` objects),
// `JSON.stringify(value)` returns `undefined` (which isn’t valid
// JSON) instead of `'null'`.
return JSON.stringify(argument) || 'null';
}
return String(argument);
} else { // it’s an object
result = [];
options.wrap = true;
increaseIndentation();
forOwn(argument, (key, value) => {
isEmpty = false;
result.push(
(compact ? '' : indent) +
jsesc(key, options) + ':' +
(compact ? '' : ' ') +
jsesc(value, options)
);
});
if (isEmpty) {
return '{}';
}
return '{' + newLine + result.join(',' + newLine) + newLine +
(compact ? '' : oldIndent) + '}';
}
}
const string = argument;
// Loop over each code unit in the string and escape it
let index = -1;
const length = string.length;
result = '';
while (++index < length) {
const character = string.charAt(index);
if (options.es6) {
const first = string.charCodeAt(index);
if ( // check if it’s the start of a surrogate pair
first >= 0xD800 && first <= 0xDBFF && // high surrogate
length > index + 1 // there is a next code unit
) {
const second = string.charCodeAt(index + 1);
if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
const codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
let hexadecimal = codePoint.toString(16);
if (!lowercaseHex) {
hexadecimal = hexadecimal.toUpperCase();
}
result += '\\u{' + hexadecimal + '}';
++index;
continue;
}
}
}
if (!options.escapeEverything) {
if (regexWhitelist.test(character)) {
// It’s a printable ASCII character that is not `"`, `'` or `\`,
// so don’t escape it.
result += character;
continue;
}
if (character == '"') {
result += quote == character ? '\\"' : character;
continue;
}
if (character == '`') {
result += quote == character ? '\\`' : character;
continue;
}
if (character == '\'') {
result += quote == character ? '\\\'' : character;
continue;
}
}
if (
character == '\0' &&
!json &&
!regexDigit.test(string.charAt(index + 1))
) {
result += '\\0';
continue;
}
if (regexSingleEscape.test(character)) {
// no need for a `hasOwnProperty` check here
result += singleEscapes[character];
continue;
}
const charCode = character.charCodeAt(0);
if (options.minimal && charCode != 0x2028 && charCode != 0x2029) {
result += character;
continue;
}
let hexadecimal = charCode.toString(16);
if (!lowercaseHex) {
hexadecimal = hexadecimal.toUpperCase();
}
const longhand = hexadecimal.length > 2 || json;
const escaped = '\\' + (longhand ? 'u' : 'x') +
('0000' + hexadecimal).slice(longhand ? -4 : -2);
result += escaped;
continue;
}
if (options.wrap) {
result = quote + result + quote;
}
if (quote == '`') {
result = result.replace(/\$\{/g, '\\\$\{');
}
if (options.isScriptContext) {
return result
.replace(/<\/(script|style)/gi, '<\\/$1')
.replace(/<!--/g, json ? '\\u003C!--' : '\\x3C!--');
}
return result;
};
jsesc.version = '2.5.2';
jsesc_1 = jsesc;
return jsesc_1;
}
var hasRequiredTypes;
function requireTypes () {
if (hasRequiredTypes) return types;
hasRequiredTypes = 1;
Object.defineProperty(types, "__esModule", {
value: true
});
types.ArgumentPlaceholder = ArgumentPlaceholder;
types.ArrayPattern = types.ArrayExpression = ArrayExpression;
types.BigIntLiteral = BigIntLiteral;
types.BooleanLiteral = BooleanLiteral;
types.DecimalLiteral = DecimalLiteral;
types.Identifier = Identifier;
types.NullLiteral = NullLiteral;
types.NumericLiteral = NumericLiteral;
types.ObjectPattern = types.ObjectExpression = ObjectExpression;
types.ObjectMethod = ObjectMethod;
types.ObjectProperty = ObjectProperty;
types.PipelineBareFunction = PipelineBareFunction;
types.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
types.PipelineTopicExpression = PipelineTopicExpression;
types.RecordExpression = RecordExpression;
types.RegExpLiteral = RegExpLiteral;
types.SpreadElement = types.RestElement = RestElement;
types.StringLiteral = StringLiteral;
types.TopicReference = TopicReference;
types.TupleExpression = TupleExpression;
var _t = requireLib$2();
var _jsesc = requireJsesc();
const {
isAssignmentPattern,
isIdentifier
} = _t;
function Identifier(node) {
var _node$loc;
this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
this.word(node.name);
}
function ArgumentPlaceholder() {
this.tokenChar(63);
}
function RestElement(node) {
this.token("...");
this.print(node.argument, node);
}
function ObjectExpression(node) {
const props = node.properties;
this.tokenChar(123);
if (props.length) {
this.space();
this.printList(props, node, {
indent: true,
statement: true
});
this.space();
}
this.sourceWithOffset("end", node.loc, -1);
this.tokenChar(125);
}
function ObjectMethod(node) {
this.printJoin(node.decorators, node);
this._methodHead(node);
this.space();
this.print(node.body, node);
}
function ObjectProperty(node) {
this.printJoin(node.decorators, node);
if (node.computed) {
this.tokenChar(91);
this.print(node.key, node);
this.tokenChar(93);
} else {
if (isAssignmentPattern(node.value) && isIdentifier(node.key) && node.key.name === node.value.left.name) {
this.print(node.value, node);
return;
}
this.print(node.key, node);
if (node.shorthand && isIdentifier(node.key) && isIdentifier(node.value) && node.key.name === node.value.name) {
return;
}
}
this.tokenChar(58);
this.space();
this.print(node.value, node);
}
function ArrayExpression(node) {
const elems = node.elements;
const len = elems.length;
this.tokenChar(91);
for (let i = 0; i < elems.length; i++) {
const elem = elems[i];
if (elem) {
if (i > 0) this.space();
this.print(elem, node);
if (i < len - 1) this.tokenChar(44);
} else {
this.tokenChar(44);
}
}
this.tokenChar(93);
}
function RecordExpression(node) {
const props = node.properties;
let startToken;
let endToken;
if (this.format.recordAndTupleSyntaxType === "bar") {
startToken = "{|";
endToken = "|}";
} else if (this.format.recordAndTupleSyntaxType !== "hash" && this.format.recordAndTupleSyntaxType != null) {
throw new Error(`The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`);
} else {
startToken = "#{";
endToken = "}";
}
this.token(startToken);
if (props.length) {
this.space();
this.printList(props, node, {
indent: true,
statement: true
});
this.space();
}
this.token(endToken);
}
function TupleExpression(node) {
const elems = node.elements;
const len = elems.length;
let startToken;
let endToken;
if (this.format.recordAndTupleSyntaxType === "bar") {
startToken = "[|";
endToken = "|]";
} else if (this.format.recordAndTupleSyntaxType === "hash") {
startToken = "#[";
endToken = "]";
} else {
throw new Error(`${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`);
}
this.token(startToken);
for (let i = 0; i < elems.length; i++) {
const elem = elems[i];
if (elem) {
if (i > 0) this.space();
this.print(elem, node);
if (i < len - 1) this.tokenChar(44);
}
}
this.token(endToken);
}
function RegExpLiteral(node) {
this.word(`/${node.pattern}/${node.flags}`);
}
function BooleanLiteral(node) {
this.word(node.value ? "true" : "false");
}
function NullLiteral() {
this.word("null");
}
function NumericLiteral(node) {
const raw = this.getPossibleRaw(node);
const opts = this.format.jsescOption;
const value = node.value + "";
if (opts.numbers) {
this.number(_jsesc(node.value, opts));
} else if (raw == null) {
this.number(value);
} else if (this.format.minified) {
this.number(raw.length < value.length ? raw : value);
} else {
this.number(raw);
}
}
function StringLiteral(node) {
const raw = this.getPossibleRaw(node);
if (!this.format.minified && raw !== undefined) {
this.token(raw);
return;
}
const val = _jsesc(node.value, this.format.jsescOption);
this.token(val);
}
function BigIntLiteral(node) {
const raw = this.getPossibleRaw(node);
if (!this.format.minified && raw !== undefined) {
this.word(raw);
return;
}
this.word(node.value + "n");
}
function DecimalLiteral(node) {
const raw = this.getPossibleRaw(node);
if (!this.format.minified && raw !== undefined) {
this.word(raw);
return;
}
this.word(node.value + "m");
}
const validTopicTokenSet = new Set(["^^", "@@", "^", "%", "#"]);
function TopicReference() {
const {
topicToken
} = this.format;
if (validTopicTokenSet.has(topicToken)) {
this.token(topicToken);
} else {
const givenTopicTokenJSON = JSON.stringify(topicToken);
const validTopics = Array.from(validTopicTokenSet, v => JSON.stringify(v));
throw new Error(`The "topicToken" generator option must be one of ` + `${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
}
}
function PipelineTopicExpression(node) {
this.print(node.expression, node);
}
function PipelineBareFunction(node) {
this.print(node.callee, node);
}
function PipelinePrimaryTopicReference() {
this.tokenChar(35);
}
return types;
}
var flow = {};
var hasRequiredFlow;
function requireFlow () {
if (hasRequiredFlow) return flow;
hasRequiredFlow = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AnyTypeAnnotation = AnyTypeAnnotation;
exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
exports.DeclareClass = DeclareClass;
exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
exports.DeclareExportDeclaration = DeclareExportDeclaration;
exports.DeclareFunction = DeclareFunction;
exports.DeclareInterface = DeclareInterface;
exports.DeclareModule = DeclareModule;
exports.DeclareModuleExports = DeclareModuleExports;
exports.DeclareOpaqueType = DeclareOpaqueType;
exports.DeclareTypeAlias = DeclareTypeAlias;
exports.DeclareVariable = DeclareVariable;
exports.DeclaredPredicate = DeclaredPredicate;
exports.EmptyTypeAnnotation = EmptyTypeAnnotation;
exports.EnumBooleanBody = EnumBooleanBody;
exports.EnumBooleanMember = EnumBooleanMember;
exports.EnumDeclaration = EnumDeclaration;
exports.EnumDefaultedMember = EnumDefaultedMember;
exports.EnumNumberBody = EnumNumberBody;
exports.EnumNumberMember = EnumNumberMember;
exports.EnumStringBody = EnumStringBody;
exports.EnumStringMember = EnumStringMember;
exports.EnumSymbolBody = EnumSymbolBody;
exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
exports.FunctionTypeParam = FunctionTypeParam;
exports.IndexedAccessType = IndexedAccessType;
exports.InferredPredicate = InferredPredicate;
exports.InterfaceDeclaration = InterfaceDeclaration;
exports.GenericTypeAnnotation = exports.ClassImplements = exports.InterfaceExtends = InterfaceExtends;
exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
exports.MixedTypeAnnotation = MixedTypeAnnotation;
exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
exports.NullableTypeAnnotation = NullableTypeAnnotation;
Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _types2.NumericLiteral;
}
});
exports.NumberTypeAnnotation = NumberTypeAnnotation;
exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
exports.ObjectTypeIndexer = ObjectTypeIndexer;
exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
exports.ObjectTypeProperty = ObjectTypeProperty;
exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
exports.OpaqueType = OpaqueType;
exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
enumerable: true,
get: function () {
return _types2.StringLiteral;
}
});
exports.StringTypeAnnotation = StringTypeAnnotation;
exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
exports.ThisTypeAnnotation = ThisTypeAnnotation;
exports.TupleTypeAnnotation = TupleTypeAnnotation;
exports.TypeAlias = TypeAlias;
exports.TypeAnnotation = TypeAnnotation;
exports.TypeCastExpression = TypeCastExpression;
exports.TypeParameter = TypeParameter;
exports.TypeParameterDeclaration = exports.TypeParameterInstantiation = TypeParameterInstantiation;
exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
exports.UnionTypeAnnotation = UnionTypeAnnotation;
exports.Variance = Variance;
exports.VoidTypeAnnotation = VoidTypeAnnotation;
exports._interfaceish = _interfaceish;
exports._variance = _variance;
var _t = requireLib$2();
var _modules = requireModules();
var _types2 = requireTypes();
const {
isDeclareExportDeclaration,
isStatement
} = _t;
function AnyTypeAnnotation() {
this.word("any");
}
function ArrayTypeAnnotation(node) {
this.print(node.elementType, node, true);
this.tokenChar(91);
this.tokenChar(93);
}
function BooleanTypeAnnotation() {
this.word("boolean");
}
function BooleanLiteralTypeAnnotation(node) {
this.word(node.value ? "true" : "false");
}
function NullLiteralTypeAnnotation() {
this.word("null");
}
function DeclareClass(node, parent) {
if (!isDeclareExportDeclaration(parent)) {
this.word("declare");
this.space();
}
this.word("class");
this.space();
this._interfaceish(node);
}
function DeclareFunction(node, parent) {
if (!isDeclareExportDeclaration(parent)) {
this.word("declare");
this.space();
}
this.word("function");
this.space();
this.print(node.id, node);
this.print(node.id.typeAnnotation.typeAnnotation, node);
if (node.predicate) {
this.space();
this.print(node.predicate, node);
}
this.semicolon();
}
function InferredPredicate() {
this.tokenChar(37);
this.word("checks");
}
function DeclaredPredicate(node) {
this.tokenChar(37);
this.word("checks");
this.tokenChar(40);
this.print(node.value, node);
this.tokenChar(41);
}
function DeclareInterface(node) {
this.word("declare");
this.space();
this.InterfaceDeclaration(node);
}
function DeclareModule(node) {
this.word("declare");
this.space();
this.word("module");
this.space();
this.print(node.id, node);
this.space();
this.print(node.body, node);
}
function DeclareModuleExports(node) {
this.word("declare");
this.space();
this.word("module");
this.tokenChar(46);
this.word("exports");
this.print(node.typeAnnotation, node);
}
function DeclareTypeAlias(node) {
this.word("declare");
this.space();
this.TypeAlias(node);
}
function DeclareOpaqueType(node, parent) {
if (!isDeclareExportDeclaration(parent)) {
this.word("declare");
this.space();
}
this.OpaqueType(node);
}
function DeclareVariable(node, parent) {
if (!isDeclareExportDeclaration(parent)) {
this.word("declare");
this.space();
}
this.word("var");
this.space();
this.print(node.id, node);
this.print(node.id.typeAnnotation, node);
this.semicolon();
}
function DeclareExportDeclaration(node) {
this.word("declare");
this.space();
this.word("export");
this.space();
if (node.default) {
this.word("default");
this.space();
}
FlowExportDeclaration.call(this, node);
}
function DeclareExportAllDeclaration(node) {
this.word("declare");
this.space();
_modules.ExportAllDeclaration.call(this, node);
}
function EnumDeclaration(node) {
const {
id,
body
} = node;
this.word("enum");
this.space();
this.print(id, node);
this.print(body, node);
}
function enumExplicitType(context, name, hasExplicitType) {
if (hasExplicitType) {
context.space();
context.word("of");
context.space();
context.word(name);
}
context.space();
}
function enumBody(context, node) {
const {
members
} = node;
context.token("{");
context.indent();
context.newline();
for (const member of members) {
context.print(member, node);
context.newline();
}
if (node.hasUnknownMembers) {
context.token("...");
context.newline();
}
context.dedent();
context.token("}");
}
function EnumBooleanBody(node) {
const {
explicitType
} = node;
enumExplicitType(this, "boolean", explicitType);
enumBody(this, node);
}
function EnumNumberBody(node) {
const {
explicitType
} = node;
enumExplicitType(this, "number", explicitType);
enumBody(this, node);
}
function EnumStringBody(node) {
const {
explicitType
} = node;
enumExplicitType(this, "string", explicitType);
enumBody(this, node);
}
function EnumSymbolBody(node) {
enumExplicitType(this, "symbol", true);
enumBody(this, node);
}
function EnumDefaultedMember(node) {
const {
id
} = node;
this.print(id, node);
this.tokenChar(44);
}
function enumInitializedMember(context, node) {
const {
id,
init
} = node;
context.print(id, node);
context.space();
context.token("=");
context.space();
context.print(init, node);
context.token(",");
}
function EnumBooleanMember(node) {
enumInitializedMember(this, node);
}
function EnumNumberMember(node) {
enumInitializedMember(this, node);
}
function EnumStringMember(node) {
enumInitializedMember(this, node);
}
function FlowExportDeclaration(node) {
if (node.declaration) {
const declar = node.declaration;
this.print(declar, node);
if (!isStatement(declar)) this.semicolon();
} else {
this.tokenChar(123);
if (node.specifiers.length) {
this.space();
this.printList(node.specifiers, node);
this.space();
}
this.tokenChar(125);
if (node.source) {
this.space();
this.word("from");
this.space();
this.print(node.source, node);
}
this.semicolon();
}
}
function ExistsTypeAnnotation() {
this.tokenChar(42);
}
function FunctionTypeAnnotation(node, parent) {
this.print(node.typeParameters, node);
this.tokenChar(40);
if (node.this) {
this.word("this");
this.tokenChar(58);
this.space();
this.print(node.this.typeAnnotation, node);
if (node.params.length || node.rest) {
this.tokenChar(44);
this.space();
}
}
this.printList(node.params, node);
if (node.rest) {
if (node.params.length) {
this.tokenChar(44);
this.space();
}
this.token("...");
this.print(node.rest, node);
}
this.tokenChar(41);
const type = parent == null ? void 0 : parent.type;
if (type != null && (type === "ObjectTypeCallProperty" || type === "ObjectTypeInternalSlot" || type === "DeclareFunction" || type === "ObjectTypeProperty" && parent.method)) {
this.tokenChar(58);
} else {
this.space();
this.token("=>");
}
this.space();
this.print(node.returnType, node);
}
function FunctionTypeParam(node) {
this.print(node.name, node);
if (node.optional) this.tokenChar(63);
if (node.name) {
this.tokenChar(58);
this.space();
}
this.print(node.typeAnnotation, node);
}
function InterfaceExtends(node) {
this.print(node.id, node);
this.print(node.typeParameters, node, true);
}
function _interfaceish(node) {
var _node$extends;
this.print(node.id, node);
this.print(node.typeParameters, node);
if ((_node$extends = node.extends) != null && _node$extends.length) {
this.space();
this.word("extends");
this.space();
this.printList(node.extends, node);
}
if (node.type === "DeclareClass") {
var _node$mixins, _node$implements;
if ((_node$mixins = node.mixins) != null && _node$mixins.length) {
this.space();
this.word("mixins");
this.space();
this.printList(node.mixins, node);
}
if ((_node$implements = node.implements) != null && _node$implements.length) {
this.space();
this.word("implements");
this.space();
this.printList(node.implements, node);
}
}
this.space();
this.print(node.body, node);
}
function _variance(node) {
var _node$variance;
const kind = (_node$variance = node.variance) == null ? void 0 : _node$variance.kind;
if (kind != null) {
if (kind === "plus") {
this.tokenChar(43);
} else if (kind === "minus") {
this.tokenChar(45);
}
}
}
function InterfaceDeclaration(node) {
this.word("interface");
this.space();
this._interfaceish(node);
}
function andSeparator() {
this.space();
this.tokenChar(38);
this.space();
}
function InterfaceTypeAnnotation(node) {
var _node$extends2;
this.word("interface");
if ((_node$extends2 = node.extends) != null && _node$extends2.length) {
this.space();
this.word("extends");
this.space();
this.printList(node.extends, node);
}
this.space();
this.print(node.body, node);
}
function IntersectionTypeAnnotation(node) {
this.printJoin(node.types, node, {
separator: andSeparator
});
}
function MixedTypeAnnotation() {
this.word("mixed");
}
function EmptyTypeAnnotation() {
this.word("empty");
}
function NullableTypeAnnotation(node) {
this.tokenChar(63);
this.print(node.typeAnnotation, node);
}
function NumberTypeAnnotation() {
this.word("number");
}
function StringTypeAnnotation() {
this.word("string");
}
function ThisTypeAnnotation() {
this.word("this");
}
function TupleTypeAnnotation(node) {
this.tokenChar(91);
this.printList(node.types, node);
this.tokenChar(93);
}
function TypeofTypeAnnotation(node) {
this.word("typeof");
this.space();
this.print(node.argument, node);
}
function TypeAlias(node) {
this.word("type");
this.space();
this.print(node.id, node);
this.print(node.typeParameters, node);
this.space();
this.tokenChar(61);
this.space();
this.print(node.right, node);
this.semicolon();
}
function TypeAnnotation(node) {
this.tokenChar(58);
this.space();
if (node.optional) this.tokenChar(63);
this.print(node.typeAnnotation, node);
}
function TypeParameterInstantiation(node) {
this.tokenChar(60);
this.printList(node.params, node, {});
this.tokenChar(62);
}
function TypeParameter(node) {
this._variance(node);
this.word(node.name);
if (node.bound) {
this.print(node.bound, node);
}
if (node.default) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.default, node);
}
}
function OpaqueType(node) {
this.word("opaque");
this.space();
this.word("type");
this.space();
this.print(node.id, node);
this.print(node.typeParameters, node);
if (node.supertype) {
this.tokenChar(58);
this.space();
this.print(node.supertype, node);
}
if (node.impltype) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.impltype, node);
}
this.semicolon();
}
function ObjectTypeAnnotation(node) {
if (node.exact) {
this.token("{|");
} else {
this.tokenChar(123);
}
const props = [...node.properties, ...(node.callProperties || []), ...(node.indexers || []), ...(node.internalSlots || [])];
if (props.length) {
this.newline();
this.space();
this.printJoin(props, node, {
addNewlines(leading) {
if (leading && !props[0]) return 1;
},
indent: true,
statement: true,
iterator: () => {
if (props.length !== 1 || node.inexact) {
this.tokenChar(44);
this.space();
}
}
});
this.space();
}
if (node.inexact) {
this.indent();
this.token("...");
if (props.length) {
this.newline();
}
this.dedent();
}
if (node.exact) {
this.token("|}");
} else {
this.tokenChar(125);
}
}
function ObjectTypeInternalSlot(node) {
if (node.static) {
this.word("static");
this.space();
}
this.tokenChar(91);
this.tokenChar(91);
this.print(node.id, node);
this.tokenChar(93);
this.tokenChar(93);
if (node.optional) this.tokenChar(63);
if (!node.method) {
this.tokenChar(58);
this.space();
}
this.print(node.value, node);
}
function ObjectTypeCallProperty(node) {
if (node.static) {
this.word("static");
this.space();
}
this.print(node.value, node);
}
function ObjectTypeIndexer(node) {
if (node.static) {
this.word("static");
this.space();
}
this._variance(node);
this.tokenChar(91);
if (node.id) {
this.print(node.id, node);
this.tokenChar(58);
this.space();
}
this.print(node.key, node);
this.tokenChar(93);
this.tokenChar(58);
this.space();
this.print(node.value, node);
}
function ObjectTypeProperty(node) {
if (node.proto) {
this.word("proto");
this.space();
}
if (node.static) {
this.word("static");
this.space();
}
if (node.kind === "get" || node.kind === "set") {
this.word(node.kind);
this.space();
}
this._variance(node);
this.print(node.key, node);
if (node.optional) this.tokenChar(63);
if (!node.method) {
this.tokenChar(58);
this.space();
}
this.print(node.value, node);
}
function ObjectTypeSpreadProperty(node) {
this.token("...");
this.print(node.argument, node);
}
function QualifiedTypeIdentifier(node) {
this.print(node.qualification, node);
this.tokenChar(46);
this.print(node.id, node);
}
function SymbolTypeAnnotation() {
this.word("symbol");
}
function orSeparator() {
this.space();
this.tokenChar(124);
this.space();
}
function UnionTypeAnnotation(node) {
this.printJoin(node.types, node, {
separator: orSeparator
});
}
function TypeCastExpression(node) {
this.tokenChar(40);
this.print(node.expression, node);
this.print(node.typeAnnotation, node);
this.tokenChar(41);
}
function Variance(node) {
if (node.kind === "plus") {
this.tokenChar(43);
} else {
this.tokenChar(45);
}
}
function VoidTypeAnnotation() {
this.word("void");
}
function IndexedAccessType(node) {
this.print(node.objectType, node, true);
this.tokenChar(91);
this.print(node.indexType, node);
this.tokenChar(93);
}
function OptionalIndexedAccessType(node) {
this.print(node.objectType, node);
if (node.optional) {
this.token("?.");
}
this.tokenChar(91);
this.print(node.indexType, node);
this.tokenChar(93);
}
} (flow));
return flow;
}
var base = {};
var hasRequiredBase;
function requireBase () {
if (hasRequiredBase) return base;
hasRequiredBase = 1;
Object.defineProperty(base, "__esModule", {
value: true
});
base.BlockStatement = BlockStatement;
base.Directive = Directive;
base.DirectiveLiteral = DirectiveLiteral;
base.File = File;
base.InterpreterDirective = InterpreterDirective;
base.Placeholder = Placeholder;
base.Program = Program;
function File(node) {
if (node.program) {
this.print(node.program.interpreter, node);
}
this.print(node.program, node);
}
function Program(node) {
var _node$directives;
this.noIndentInnerCommentsHere();
this.printInnerComments();
const directivesLen = (_node$directives = node.directives) == null ? void 0 : _node$directives.length;
if (directivesLen) {
var _node$directives$trai;
const newline = node.body.length ? 2 : 1;
this.printSequence(node.directives, node, {
trailingCommentsLineOffset: newline
});
if (!((_node$directives$trai = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai.length)) {
this.newline(newline);
}
}
this.printSequence(node.body, node);
}
function BlockStatement(node) {
var _node$directives2;
this.tokenChar(123);
const directivesLen = (_node$directives2 = node.directives) == null ? void 0 : _node$directives2.length;
if (directivesLen) {
var _node$directives$trai2;
const newline = node.body.length ? 2 : 1;
this.printSequence(node.directives, node, {
indent: true,
trailingCommentsLineOffset: newline
});
if (!((_node$directives$trai2 = node.directives[directivesLen - 1].trailingComments) != null && _node$directives$trai2.length)) {
this.newline(newline);
}
}
this.printSequence(node.body, node, {
indent: true
});
this.rightBrace(node);
}
function Directive(node) {
this.print(node.value, node);
this.semicolon();
}
const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
function DirectiveLiteral(node) {
const raw = this.getPossibleRaw(node);
if (!this.format.minified && raw !== undefined) {
this.token(raw);
return;
}
const {
value
} = node;
if (!unescapedDoubleQuoteRE.test(value)) {
this.token(`"${value}"`);
} else if (!unescapedSingleQuoteRE.test(value)) {
this.token(`'${value}'`);
} else {
throw new Error("Malformed AST: it is not possible to print a directive containing" + " both unescaped single and double quotes.");
}
}
function InterpreterDirective(node) {
this.token(`#!${node.value}`);
this.newline(1, true);
}
function Placeholder(node) {
this.token("%%");
this.print(node.name);
this.token("%%");
if (node.expectedNode === "Statement") {
this.semicolon();
}
}
return base;
}
var jsx = {};
var hasRequiredJsx;
function requireJsx () {
if (hasRequiredJsx) return jsx;
hasRequiredJsx = 1;
Object.defineProperty(jsx, "__esModule", {
value: true
});
jsx.JSXAttribute = JSXAttribute;
jsx.JSXClosingElement = JSXClosingElement;
jsx.JSXClosingFragment = JSXClosingFragment;
jsx.JSXElement = JSXElement;
jsx.JSXEmptyExpression = JSXEmptyExpression;
jsx.JSXExpressionContainer = JSXExpressionContainer;
jsx.JSXFragment = JSXFragment;
jsx.JSXIdentifier = JSXIdentifier;
jsx.JSXMemberExpression = JSXMemberExpression;
jsx.JSXNamespacedName = JSXNamespacedName;
jsx.JSXOpeningElement = JSXOpeningElement;
jsx.JSXOpeningFragment = JSXOpeningFragment;
jsx.JSXSpreadAttribute = JSXSpreadAttribute;
jsx.JSXSpreadChild = JSXSpreadChild;
jsx.JSXText = JSXText;
function JSXAttribute(node) {
this.print(node.name, node);
if (node.value) {
this.tokenChar(61);
this.print(node.value, node);
}
}
function JSXIdentifier(node) {
this.word(node.name);
}
function JSXNamespacedName(node) {
this.print(node.namespace, node);
this.tokenChar(58);
this.print(node.name, node);
}
function JSXMemberExpression(node) {
this.print(node.object, node);
this.tokenChar(46);
this.print(node.property, node);
}
function JSXSpreadAttribute(node) {
this.tokenChar(123);
this.token("...");
this.print(node.argument, node);
this.tokenChar(125);
}
function JSXExpressionContainer(node) {
this.tokenChar(123);
this.print(node.expression, node);
this.tokenChar(125);
}
function JSXSpreadChild(node) {
this.tokenChar(123);
this.token("...");
this.print(node.expression, node);
this.tokenChar(125);
}
function JSXText(node) {
const raw = this.getPossibleRaw(node);
if (raw !== undefined) {
this.token(raw, true);
} else {
this.token(node.value, true);
}
}
function JSXElement(node) {
const open = node.openingElement;
this.print(open, node);
if (open.selfClosing) return;
this.indent();
for (const child of node.children) {
this.print(child, node);
}
this.dedent();
this.print(node.closingElement, node);
}
function spaceSeparator() {
this.space();
}
function JSXOpeningElement(node) {
this.tokenChar(60);
this.print(node.name, node);
this.print(node.typeParameters, node);
if (node.attributes.length > 0) {
this.space();
this.printJoin(node.attributes, node, {
separator: spaceSeparator
});
}
if (node.selfClosing) {
this.space();
this.token("/>");
} else {
this.tokenChar(62);
}
}
function JSXClosingElement(node) {
this.token("</");
this.print(node.name, node);
this.tokenChar(62);
}
function JSXEmptyExpression() {
this.printInnerComments();
}
function JSXFragment(node) {
this.print(node.openingFragment, node);
this.indent();
for (const child of node.children) {
this.print(child, node);
}
this.dedent();
this.print(node.closingFragment, node);
}
function JSXOpeningFragment() {
this.tokenChar(60);
this.tokenChar(62);
}
function JSXClosingFragment() {
this.token("</");
this.tokenChar(62);
}
return jsx;
}
var typescript = {};
var hasRequiredTypescript;
function requireTypescript () {
if (hasRequiredTypescript) return typescript;
hasRequiredTypescript = 1;
Object.defineProperty(typescript, "__esModule", {
value: true
});
typescript.TSAnyKeyword = TSAnyKeyword;
typescript.TSArrayType = TSArrayType;
typescript.TSSatisfiesExpression = typescript.TSAsExpression = TSTypeExpression;
typescript.TSBigIntKeyword = TSBigIntKeyword;
typescript.TSBooleanKeyword = TSBooleanKeyword;
typescript.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
typescript.TSConditionalType = TSConditionalType;
typescript.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
typescript.TSConstructorType = TSConstructorType;
typescript.TSDeclareFunction = TSDeclareFunction;
typescript.TSDeclareMethod = TSDeclareMethod;
typescript.TSEnumDeclaration = TSEnumDeclaration;
typescript.TSEnumMember = TSEnumMember;
typescript.TSExportAssignment = TSExportAssignment;
typescript.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
typescript.TSExternalModuleReference = TSExternalModuleReference;
typescript.TSFunctionType = TSFunctionType;
typescript.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
typescript.TSImportType = TSImportType;
typescript.TSIndexSignature = TSIndexSignature;
typescript.TSIndexedAccessType = TSIndexedAccessType;
typescript.TSInferType = TSInferType;
typescript.TSInstantiationExpression = TSInstantiationExpression;
typescript.TSInterfaceBody = TSInterfaceBody;
typescript.TSInterfaceDeclaration = TSInterfaceDeclaration;
typescript.TSIntersectionType = TSIntersectionType;
typescript.TSIntrinsicKeyword = TSIntrinsicKeyword;
typescript.TSLiteralType = TSLiteralType;
typescript.TSMappedType = TSMappedType;
typescript.TSMethodSignature = TSMethodSignature;
typescript.TSModuleBlock = TSModuleBlock;
typescript.TSModuleDeclaration = TSModuleDeclaration;
typescript.TSNamedTupleMember = TSNamedTupleMember;
typescript.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
typescript.TSNeverKeyword = TSNeverKeyword;
typescript.TSNonNullExpression = TSNonNullExpression;
typescript.TSNullKeyword = TSNullKeyword;
typescript.TSNumberKeyword = TSNumberKeyword;
typescript.TSObjectKeyword = TSObjectKeyword;
typescript.TSOptionalType = TSOptionalType;
typescript.TSParameterProperty = TSParameterProperty;
typescript.TSParenthesizedType = TSParenthesizedType;
typescript.TSPropertySignature = TSPropertySignature;
typescript.TSQualifiedName = TSQualifiedName;
typescript.TSRestType = TSRestType;
typescript.TSStringKeyword = TSStringKeyword;
typescript.TSSymbolKeyword = TSSymbolKeyword;
typescript.TSThisType = TSThisType;
typescript.TSTupleType = TSTupleType;
typescript.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
typescript.TSTypeAnnotation = TSTypeAnnotation;
typescript.TSTypeAssertion = TSTypeAssertion;
typescript.TSTypeLiteral = TSTypeLiteral;
typescript.TSTypeOperator = TSTypeOperator;
typescript.TSTypeParameter = TSTypeParameter;
typescript.TSTypeParameterDeclaration = typescript.TSTypeParameterInstantiation = TSTypeParameterInstantiation;
typescript.TSTypePredicate = TSTypePredicate;
typescript.TSTypeQuery = TSTypeQuery;
typescript.TSTypeReference = TSTypeReference;
typescript.TSUndefinedKeyword = TSUndefinedKeyword;
typescript.TSUnionType = TSUnionType;
typescript.TSUnknownKeyword = TSUnknownKeyword;
typescript.TSVoidKeyword = TSVoidKeyword;
typescript.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
typescript.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
typescript.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
typescript.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
typescript.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
function TSTypeAnnotation(node) {
this.tokenChar(58);
this.space();
if (node.optional) this.tokenChar(63);
this.print(node.typeAnnotation, node);
}
function TSTypeParameterInstantiation(node, parent) {
this.tokenChar(60);
this.printList(node.params, node, {});
if (parent.type === "ArrowFunctionExpression" && node.params.length === 1) {
this.tokenChar(44);
}
this.tokenChar(62);
}
function TSTypeParameter(node) {
if (node.in) {
this.word("in");
this.space();
}
if (node.out) {
this.word("out");
this.space();
}
this.word(node.name);
if (node.constraint) {
this.space();
this.word("extends");
this.space();
this.print(node.constraint, node);
}
if (node.default) {
this.space();
this.tokenChar(61);
this.space();
this.print(node.default, node);
}
}
function TSParameterProperty(node) {
if (node.accessibility) {
this.word(node.accessibility);
this.space();
}
if (node.readonly) {
this.word("readonly");
this.space();
}
this._param(node.parameter);
}
function TSDeclareFunction(node, parent) {
if (node.declare) {
this.word("declare");
this.space();
}
this._functionHead(node, parent);
this.tokenChar(59);
}
function TSDeclareMethod(node) {
this._classMethodHead(node);
this.tokenChar(59);
}
function TSQualifiedName(node) {
this.print(node.left, node);
this.tokenChar(46);
this.print(node.right, node);
}
function TSCallSignatureDeclaration(node) {
this.tsPrintSignatureDeclarationBase(node);
this.tokenChar(59);
}
function TSConstructSignatureDeclaration(node) {
this.word("new");
this.space();
this.tsPrintSignatureDeclarationBase(node);
this.tokenChar(59);
}
function TSPropertySignature(node) {
const {
readonly,
initializer
} = node;
if (readonly) {
this.word("readonly");
this.space();
}
this.tsPrintPropertyOrMethodName(node);
this.print(node.typeAnnotation, node);
if (initializer) {
this.space();
this.tokenChar(61);
this.space();
this.print(initializer, node);
}
this.tokenChar(59);
}
function tsPrintPropertyOrMethodName(node) {
if (node.computed) {
this.tokenChar(91);
}
this.print(node.key, node);
if (node.computed) {
this.tokenChar(93);
}
if (node.optional) {
this.tokenChar(63);
}
}
function TSMethodSignature(node) {
const {
kind
} = node;
if (kind === "set" || kind === "get") {
this.word(kind);
this.space();
}
this.tsPrintPropertyOrMethodName(node);
this.tsPrintSignatureDeclarationBase(node);
this.tokenChar(59);
}
function TSIndexSignature(node) {
const {
readonly,
static: isStatic
} = node;
if (isStatic) {
this.word("static");
this.space();
}
if (readonly) {
this.word("readonly");
this.space();
}
this.tokenChar(91);
this._parameters(node.parameters, node);
this.tokenChar(93);
this.print(node.typeAnnotation, node);
this.tokenChar(59);
}
function TSAnyKeyword() {
this.word("any");
}
function TSBigIntKeyword() {
this.word("bigint");
}
function TSUnknownKeyword() {
this.word("unknown");
}
function TSNumberKeyword() {
this.word("number");
}
function TSObjectKeyword() {
this.word("object");
}
function TSBooleanKeyword() {
this.word("boolean");
}
function TSStringKeyword() {
this.word("string");
}
function TSSymbolKeyword() {
this.word("symbol");
}
function TSVoidKeyword() {
this.word("void");
}
function TSUndefinedKeyword() {
this.word("undefined");
}
function TSNullKeyword() {
this.word("null");
}
function TSNeverKeyword() {
this.word("never");
}
function TSIntrinsicKeyword() {
this.word("intrinsic");
}
function TSThisType() {
this.word("this");
}
function TSFunctionType(node) {
this.tsPrintFunctionOrConstructorType(node);
}
function TSConstructorType(node) {
if (node.abstract) {
this.word("abstract");
this.space();
}
this.word("new");
this.space();
this.tsPrintFunctionOrConstructorType(node);
}
function tsPrintFunctionOrConstructorType(node) {
const {
typeParameters
} = node;
const parameters = node.parameters;
this.print(typeParameters, node);
this.tokenChar(40);
this._parameters(parameters, node);
this.tokenChar(41);
this.space();
this.token("=>");
this.space();
const returnType = node.typeAnnotation;
this.print(returnType.typeAnnotation, node);
}
function TSTypeReference(node) {
this.print(node.typeName, node, true);
this.print(node.typeParameters, node, true);
}
function TSTypePredicate(node) {
if (node.asserts) {
this.word("asserts");
this.space();
}
this.print(node.parameterName);
if (node.typeAnnotation) {
this.space();
this.word("is");
this.space();
this.print(node.typeAnnotation.typeAnnotation);
}
}
function TSTypeQuery(node) {
this.word("typeof");
this.space();
this.print(node.exprName);
if (node.typeParameters) {
this.print(node.typeParameters, node);
}
}
function TSTypeLiteral(node) {
this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
}
function tsPrintTypeLiteralOrInterfaceBody(members, node) {
tsPrintBraced(this, members, node);
}
function tsPrintBraced(printer, members, node) {
printer.token("{");
if (members.length) {
printer.indent();
printer.newline();
for (const member of members) {
printer.print(member, node);
printer.newline();
}
printer.dedent();
}
printer.rightBrace(node);
}
function TSArrayType(node) {
this.print(node.elementType, node, true);
this.token("[]");
}
function TSTupleType(node) {
this.tokenChar(91);
this.printList(node.elementTypes, node);
this.tokenChar(93);
}
function TSOptionalType(node) {
this.print(node.typeAnnotation, node);
this.tokenChar(63);
}
function TSRestType(node) {
this.token("...");
this.print(node.typeAnnotation, node);
}
function TSNamedTupleMember(node) {
this.print(node.label, node);
if (node.optional) this.tokenChar(63);
this.tokenChar(58);
this.space();
this.print(node.elementType, node);
}
function TSUnionType(node) {
tsPrintUnionOrIntersectionType(this, node, "|");
}
function TSIntersectionType(node) {
tsPrintUnionOrIntersectionType(this, node, "&");
}
function tsPrintUnionOrIntersectionType(printer, node, sep) {
printer.printJoin(node.types, node, {
separator() {
this.space();
this.token(sep);
this.space();
}
});
}
function TSConditionalType(node) {
this.print(node.checkType);
this.space();
this.word("extends");
this.space();
this.print(node.extendsType);
this.space();
this.tokenChar(63);
this.space();
this.print(node.trueType);
this.space();
this.tokenChar(58);
this.space();
this.print(node.falseType);
}
function TSInferType(node) {
this.token("infer");
this.space();
this.print(node.typeParameter);
}
function TSParenthesizedType(node) {
this.tokenChar(40);
this.print(node.typeAnnotation, node);
this.tokenChar(41);
}
function TSTypeOperator(node) {
this.word(node.operator);
this.space();
this.print(node.typeAnnotation, node);
}
function TSIndexedAccessType(node) {
this.print(node.objectType, node, true);
this.tokenChar(91);
this.print(node.indexType, node);
this.tokenChar(93);
}
function TSMappedType(node) {
const {
nameType,
optional,
readonly,
typeParameter
} = node;
this.tokenChar(123);
this.space();
if (readonly) {
tokenIfPlusMinus(this, readonly);
this.word("readonly");
this.space();
}
this.tokenChar(91);
this.word(typeParameter.name);
this.space();
this.word("in");
this.space();
this.print(typeParameter.constraint, typeParameter);
if (nameType) {
this.space();
this.word("as");
this.space();
this.print(nameType, node);
}
this.tokenChar(93);
if (optional) {
tokenIfPlusMinus(this, optional);
this.tokenChar(63);
}
this.tokenChar(58);
this.space();
this.print(node.typeAnnotation, node);
this.space();
this.tokenChar(125);
}
function tokenIfPlusMinus(self, tok) {
if (tok !== true) {
self.token(tok);
}
}
function TSLiteralType(node) {
this.print(node.literal, node);
}
function TSExpressionWithTypeArguments(node) {
this.print(node.expression, node);
this.print(node.typeParameters, node);
}
function TSInterfaceDeclaration(node) {
const {
declare,
id,
typeParameters,
extends: extendz,
body
} = node;
if (declare) {
this.word("declare");
this.space();
}
this.word("interface");
this.space();
this.print(id, node);
this.print(typeParameters, node);
if (extendz != null && extendz.length) {
this.space();
this.word("extends");
this.space();
this.printList(extendz, node);
}
this.space();
this.print(body, node);
}
function TSInterfaceBody(node) {
this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
}
function TSTypeAliasDeclaration(node) {
const {
declare,
id,
typeParameters,
typeAnnotation
} = node;
if (declare) {
this.word("declare");
this.space();
}
this.word("type");
this.space();
this.print(id, node);
this.print(typeParameters, node);
this.space();
this.tokenChar(61);
this.space();
this.print(typeAnnotation, node);
this.tokenChar(59);
}
function TSTypeExpression(node) {
var _expression$trailingC;
const {
type,
expression,
typeAnnotation
} = node;
const forceParens = !!((_expression$trailingC = expression.trailingComments) != null && _expression$trailingC.length);
this.print(expression, node, true, undefined, forceParens);
this.space();
this.word(type === "TSAsExpression" ? "as" : "satisfies");
this.space();
this.print(typeAnnotation, node);
}
function TSTypeAssertion(node) {
const {
typeAnnotation,
expression
} = node;
this.tokenChar(60);
this.print(typeAnnotation, node);
this.tokenChar(62);
this.space();
this.print(expression, node);
}
function TSInstantiationExpression(node) {
this.print(node.expression, node);
this.print(node.typeParameters, node);
}
function TSEnumDeclaration(node) {
const {
declare,
const: isConst,
id,
members
} = node;
if (declare) {
this.word("declare");
this.space();
}
if (isConst) {
this.word("const");
this.space();
}
this.word("enum");
this.space();
this.print(id, node);
this.space();
tsPrintBraced(this, members, node);
}
function TSEnumMember(node) {
const {
id,
initializer
} = node;
this.print(id, node);
if (initializer) {
this.space();
this.tokenChar(61);
this.space();
this.print(initializer, node);
}
this.tokenChar(44);
}
function TSModuleDeclaration(node) {
const {
declare,
id
} = node;
if (declare) {
this.word("declare");
this.space();
}
if (!node.global) {
this.word(id.type === "Identifier" ? "namespace" : "module");
this.space();
}
this.print(id, node);
if (!node.body) {
this.tokenChar(59);
return;
}
let body = node.body;
while (body.type === "TSModuleDeclaration") {
this.tokenChar(46);
this.print(body.id, body);
body = body.body;
}
this.space();
this.print(body, node);
}
function TSModuleBlock(node) {
tsPrintBraced(this, node.body, node);
}
function TSImportType(node) {
const {
argument,
qualifier,
typeParameters
} = node;
this.word("import");
this.tokenChar(40);
this.print(argument, node);
this.tokenChar(41);
if (qualifier) {
this.tokenChar(46);
this.print(qualifier, node);
}
if (typeParameters) {
this.print(typeParameters, node);
}
}
function TSImportEqualsDeclaration(node) {
const {
isExport,
id,
moduleReference
} = node;
if (isExport) {
this.word("export");
this.space();
}
this.word("import");
this.space();
this.print(id, node);
this.space();
this.tokenChar(61);
this.space();
this.print(moduleReference, node);
this.tokenChar(59);
}
function TSExternalModuleReference(node) {
this.token("require(");
this.print(node.expression, node);
this.tokenChar(41);
}
function TSNonNullExpression(node) {
this.print(node.expression, node);
this.tokenChar(33);
}
function TSExportAssignment(node) {
this.word("export");
this.space();
this.tokenChar(61);
this.space();
this.print(node.expression, node);
this.tokenChar(59);
}
function TSNamespaceExportDeclaration(node) {
this.word("export");
this.space();
this.word("as");
this.space();
this.word("namespace");
this.space();
this.print(node.id, node);
}
function tsPrintSignatureDeclarationBase(node) {
const {
typeParameters
} = node;
const parameters = node.parameters;
this.print(typeParameters, node);
this.tokenChar(40);
this._parameters(parameters, node);
this.tokenChar(41);
const returnType = node.typeAnnotation;
this.print(returnType, node);
}
function tsPrintClassMemberModifiers(node) {
const isField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
if (isField && node.declare) {
this.word("declare");
this.space();
}
if (node.accessibility) {
this.word(node.accessibility);
this.space();
}
if (node.static) {
this.word("static");
this.space();
}
if (node.override) {
this.word("override");
this.space();
}
if (node.abstract) {
this.word("abstract");
this.space();
}
if (isField && node.readonly) {
this.word("readonly");
this.space();
}
}
return typescript;
}
var hasRequiredGenerators;
function requireGenerators () {
if (hasRequiredGenerators) return generators;
hasRequiredGenerators = 1;
(function (exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _templateLiterals = requireTemplateLiterals();
Object.keys(_templateLiterals).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _templateLiterals[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _templateLiterals[key];
}
});
});
var _expressions = requireExpressions();
Object.keys(_expressions).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _expressions[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _expressions[key];
}
});
});
var _statements = requireStatements();
Object.keys(_statements).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _statements[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _statements[key];
}
});
});
var _classes = requireClasses();
Object.keys(_classes).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _classes[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _classes[key];
}
});
});
var _methods = requireMethods();
Object.keys(_methods).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _methods[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _methods[key];
}
});
});
var _modules = requireModules();
Object.keys(_modules).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _modules[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _modules[key];
}
});
});
var _types = requireTypes();
Object.keys(_types).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _types[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _types[key];
}
});
});
var _flow = requireFlow();
Object.keys(_flow).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _flow[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _flow[key];
}
});
});
var _base = requireBase();
Object.keys(_base).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _base[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _base[key];
}
});
});
var _jsx = requireJsx();
Object.keys(_jsx).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _jsx[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _jsx[key];
}
});
});
var _typescript = requireTypescript();
Object.keys(_typescript).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _typescript[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function () {
return _typescript[key];
}
});
});
} (generators));
return generators;
}
var hasRequiredPrinter;
function requirePrinter () {
if (hasRequiredPrinter) return printer;
hasRequiredPrinter = 1;
Object.defineProperty(printer, "__esModule", {
value: true
});
printer.default = void 0;
var _buffer = requireBuffer();
var n = requireNode();
var _t = requireLib$2();
var generatorFunctions = requireGenerators();
const {
isFunction,
isStatement,
isClassBody,
isTSInterfaceBody,
isTSEnumDeclaration
} = _t;
const SCIENTIFIC_NOTATION = /e/i;
const ZERO_DECIMAL_INTEGER = /\.0+$/;
const NON_DECIMAL_LITERAL = /^0[box]/;
const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
const HAS_NEWLINE = /[\n\r\u2028\u2029]/;
const HAS_BlOCK_COMMENT_END = /\*\//;
const {
needsParens
} = n;
class Printer {
constructor(format, map) {
this.inForStatementInitCounter = 0;
this._printStack = [];
this._indent = 0;
this._indentChar = 0;
this._indentRepeat = 0;
this._insideAux = false;
this._parenPushNewlineState = null;
this._noLineTerminator = false;
this._printAuxAfterOnNextUserNode = false;
this._printedComments = new Set();
this._endsWithInteger = false;
this._endsWithWord = false;
this._lastCommentLine = 0;
this._endsWithInnerRaw = false;
this._indentInnerComments = true;
this.format = format;
this._buf = new _buffer.default(map);
this._indentChar = format.indent.style.charCodeAt(0);
this._indentRepeat = format.indent.style.length;
this._inputMap = map == null ? void 0 : map._inputMap;
}
generate(ast) {
this.print(ast);
this._maybeAddAuxComment();
return this._buf.get();
}
indent() {
if (this.format.compact || this.format.concise) return;
this._indent++;
}
dedent() {
if (this.format.compact || this.format.concise) return;
this._indent--;
}
semicolon(force = false) {
this._maybeAddAuxComment();
if (force) {
this._appendChar(59);
} else {
this._queue(59);
}
this._noLineTerminator = false;
}
rightBrace(node) {
if (this.format.minified) {
this._buf.removeLastSemicolon();
}
this.sourceWithOffset("end", node.loc, -1);
this.tokenChar(125);
}
rightParens(node) {
this.sourceWithOffset("end", node.loc, -1);
this.tokenChar(41);
}
space(force = false) {
if (this.format.compact) return;
if (force) {
this._space();
} else if (this._buf.hasContent()) {
const lastCp = this.getLastChar();
if (lastCp !== 32 && lastCp !== 10) {
this._space();
}
}
}
word(str, noLineTerminatorAfter = false) {
this._maybePrintInnerComments();
if (this._endsWithWord || str.charCodeAt(0) === 47 && this.endsWith(47)) {
this._space();
}
this._maybeAddAuxComment();
this._append(str, false);
this._endsWithWord = true;
this._noLineTerminator = noLineTerminatorAfter;
}
number(str) {
this.word(str);
this._endsWithInteger = Number.isInteger(+str) && !NON_DECIMAL_LITERAL.test(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46;
}
token(str, maybeNewline = false) {
this._maybePrintInnerComments();
const lastChar = this.getLastChar();
const strFirst = str.charCodeAt(0);
if (lastChar === 33 && (str === "--" || strFirst === 61) || strFirst === 43 && lastChar === 43 || strFirst === 45 && lastChar === 45 || strFirst === 46 && this._endsWithInteger) {
this._space();
}
this._maybeAddAuxComment();
this._append(str, maybeNewline);
this._noLineTerminator = false;
}
tokenChar(char) {
this._maybePrintInnerComments();
const lastChar = this.getLastChar();
if (char === 43 && lastChar === 43 || char === 45 && lastChar === 45 || char === 46 && this._endsWithInteger) {
this._space();
}
this._maybeAddAuxComment();
this._appendChar(char);
this._noLineTerminator = false;
}
newline(i = 1, force) {
if (i <= 0) return;
if (!force) {
if (this.format.retainLines || this.format.compact) return;
if (this.format.concise) {
this.space();
return;
}
}
if (i > 2) i = 2;
i -= this._buf.getNewlineCount();
for (let j = 0; j < i; j++) {
this._newline();
}
return;
}
endsWith(char) {
return this.getLastChar() === char;
}
getLastChar() {
return this._buf.getLastChar();
}
endsWithCharAndNewline() {
return this._buf.endsWithCharAndNewline();
}
removeTrailingNewline() {
this._buf.removeTrailingNewline();
}
exactSource(loc, cb) {
if (!loc) {
cb();
return;
}
this._catchUp("start", loc);
this._buf.exactSource(loc, cb);
}
source(prop, loc) {
if (!loc) return;
this._catchUp(prop, loc);
this._buf.source(prop, loc);
}
sourceWithOffset(prop, loc, columnOffset) {
if (!loc) return;
this._catchUp(prop, loc);
this._buf.sourceWithOffset(prop, loc, columnOffset);
}
withSource(prop, loc, cb) {
if (!loc) {
cb();
return;
}
this._catchUp(prop, loc);
this._buf.withSource(prop, loc, cb);
}
sourceIdentifierName(identifierName, pos) {
if (!this._buf._canMarkIdName) return;
const sourcePosition = this._buf._sourcePosition;
sourcePosition.identifierNamePos = pos;
sourcePosition.identifierName = identifierName;
}
_space() {
this._queue(32);
}
_newline() {
this._queue(10);
}
_append(str, maybeNewline) {
this._maybeAddParen(str);
this._maybeIndent(str.charCodeAt(0));
this._buf.append(str, maybeNewline);
this._endsWithWord = false;
this._endsWithInteger = false;
}
_appendChar(char) {
this._maybeAddParenChar(char);
this._maybeIndent(char);
this._buf.appendChar(char);
this._endsWithWord = false;
this._endsWithInteger = false;
}
_queue(char) {
this._maybeAddParenChar(char);
this._maybeIndent(char);
this._buf.queue(char);
this._endsWithWord = false;
this._endsWithInteger = false;
}
_maybeIndent(firstChar) {
if (this._indent && firstChar !== 10 && this.endsWith(10)) {
this._buf.queueIndentation(this._indentChar, this._getIndent());
}
}
_shouldIndent(firstChar) {
if (this._indent && firstChar !== 10 && this.endsWith(10)) {
return true;
}
}
_maybeAddParenChar(char) {
const parenPushNewlineState = this._parenPushNewlineState;
if (!parenPushNewlineState) return;
if (char === 32) {
return;
}
if (char !== 10) {
this._parenPushNewlineState = null;
return;
}
this.tokenChar(40);
this.indent();
parenPushNewlineState.printed = true;
}
_maybeAddParen(str) {
const parenPushNewlineState = this._parenPushNewlineState;
if (!parenPushNewlineState) return;
const len = str.length;
let i;
for (i = 0; i < len && str.charCodeAt(i) === 32; i++) continue;
if (i === len) {
return;
}
const cha = str.charCodeAt(i);
if (cha !== 10) {
if (cha !== 47 || i + 1 === len) {
this._parenPushNewlineState = null;
return;
}
const chaPost = str.charCodeAt(i + 1);
if (chaPost === 42) {
if (PURE_ANNOTATION_RE.test(str.slice(i + 2, len - 2))) {
return;
}
} else if (chaPost !== 47) {
this._parenPushNewlineState = null;
return;
}
}
this.tokenChar(40);
this.indent();
parenPushNewlineState.printed = true;
}
catchUp(line) {
if (!this.format.retainLines) return;
const count = line - this._buf.getCurrentLine();
for (let i = 0; i < count; i++) {
this._newline();
}
}
_catchUp(prop, loc) {
var _loc$prop;
if (!this.format.retainLines) return;
const line = loc == null || (_loc$prop = loc[prop]) == null ? void 0 : _loc$prop.line;
if (line != null) {
const count = line - this._buf.getCurrentLine();
for (let i = 0; i < count; i++) {
this._newline();
}
}
}
_getIndent() {
return this._indentRepeat * this._indent;
}
printTerminatorless(node, parent, isLabel) {
if (isLabel) {
this._noLineTerminator = true;
this.print(node, parent);
} else {
const terminatorState = {
printed: false
};
this._parenPushNewlineState = terminatorState;
this.print(node, parent);
if (terminatorState.printed) {
this.dedent();
this.newline();
this.tokenChar(41);
}
}
}
print(node, parent, noLineTerminatorAfter, trailingCommentsLineOffset, forceParens) {
var _node$extra;
if (!node) return;
this._endsWithInnerRaw = false;
const nodeType = node.type;
const format = this.format;
const oldConcise = format.concise;
if (node._compact) {
format.concise = true;
}
const printMethod = this[nodeType];
if (printMethod === undefined) {
throw new ReferenceError(`unknown node of type ${JSON.stringify(nodeType)} with constructor ${JSON.stringify(node.constructor.name)}`);
}
this._printStack.push(node);
const oldInAux = this._insideAux;
this._insideAux = node.loc == undefined;
this._maybeAddAuxComment(this._insideAux && !oldInAux);
const shouldPrintParens = forceParens || format.retainFunctionParens && nodeType === "FunctionExpression" && ((_node$extra = node.extra) == null ? void 0 : _node$extra.parenthesized) || needsParens(node, parent, this._printStack);
if (shouldPrintParens) {
this.tokenChar(40);
this._endsWithInnerRaw = false;
}
this._lastCommentLine = 0;
this._printLeadingComments(node, parent);
const loc = nodeType === "Program" || nodeType === "File" ? null : node.loc;
this.exactSource(loc, printMethod.bind(this, node, parent));
if (shouldPrintParens) {
this._printTrailingComments(node, parent);
this.tokenChar(41);
this._noLineTerminator = noLineTerminatorAfter;
} else if (noLineTerminatorAfter && !this._noLineTerminator) {
this._noLineTerminator = true;
this._printTrailingComments(node, parent);
} else {
this._printTrailingComments(node, parent, trailingCommentsLineOffset);
}
this._printStack.pop();
format.concise = oldConcise;
this._insideAux = oldInAux;
this._endsWithInnerRaw = false;
}
_maybeAddAuxComment(enteredPositionlessNode) {
if (enteredPositionlessNode) this._printAuxBeforeComment();
if (!this._insideAux) this._printAuxAfterComment();
}
_printAuxBeforeComment() {
if (this._printAuxAfterOnNextUserNode) return;
this._printAuxAfterOnNextUserNode = true;
const comment = this.format.auxiliaryCommentBefore;
if (comment) {
this._printComment({
type: "CommentBlock",
value: comment
}, 0);
}
}
_printAuxAfterComment() {
if (!this._printAuxAfterOnNextUserNode) return;
this._printAuxAfterOnNextUserNode = false;
const comment = this.format.auxiliaryCommentAfter;
if (comment) {
this._printComment({
type: "CommentBlock",
value: comment
}, 0);
}
}
getPossibleRaw(node) {
const extra = node.extra;
if ((extra == null ? void 0 : extra.raw) != null && extra.rawValue != null && node.value === extra.rawValue) {
return extra.raw;
}
}
printJoin(nodes, parent, opts = {}) {
if (!(nodes != null && nodes.length)) return;
let {
indent
} = opts;
if (indent == null && this.format.retainLines) {
var _nodes$0$loc;
const startLine = (_nodes$0$loc = nodes[0].loc) == null ? void 0 : _nodes$0$loc.start.line;
if (startLine != null && startLine !== this._buf.getCurrentLine()) {
indent = true;
}
}
if (indent) this.indent();
const newlineOpts = {
addNewlines: opts.addNewlines,
nextNodeStartLine: 0
};
const separator = opts.separator ? opts.separator.bind(this) : null;
const len = nodes.length;
for (let i = 0; i < len; i++) {
const node = nodes[i];
if (!node) continue;
if (opts.statement) this._printNewline(i === 0, newlineOpts);
this.print(node, parent, undefined, opts.trailingCommentsLineOffset || 0);
opts.iterator == null ? void 0 : opts.iterator(node, i);
if (i < len - 1) separator == null ? void 0 : separator();
if (opts.statement) {
if (i + 1 === len) {
this.newline(1);
} else {
var _nextNode$loc;
const nextNode = nodes[i + 1];
newlineOpts.nextNodeStartLine = ((_nextNode$loc = nextNode.loc) == null ? void 0 : _nextNode$loc.start.line) || 0;
this._printNewline(true, newlineOpts);
}
}
}
if (indent) this.dedent();
}
printAndIndentOnComments(node, parent) {
const indent = node.leadingComments && node.leadingComments.length > 0;
if (indent) this.indent();
this.print(node, parent);
if (indent) this.dedent();
}
printBlock(parent) {
const node = parent.body;
if (node.type !== "EmptyStatement") {
this.space();
}
this.print(node, parent);
}
_printTrailingComments(node, parent, lineOffset) {
const {
innerComments,
trailingComments
} = node;
if (innerComments != null && innerComments.length) {
this._printComments(2, innerComments, node, parent, lineOffset);
}
if (trailingComments != null && trailingComments.length) {
this._printComments(2, trailingComments, node, parent, lineOffset);
}
}
_printLeadingComments(node, parent) {
const comments = node.leadingComments;
if (!(comments != null && comments.length)) return;
this._printComments(0, comments, node, parent);
}
_maybePrintInnerComments() {
if (this._endsWithInnerRaw) this.printInnerComments();
this._endsWithInnerRaw = true;
this._indentInnerComments = true;
}
printInnerComments() {
const node = this._printStack[this._printStack.length - 1];
const comments = node.innerComments;
if (!(comments != null && comments.length)) return;
const hasSpace = this.endsWith(32);
const indent = this._indentInnerComments;
const printedCommentsCount = this._printedComments.size;
if (indent) this.indent();
this._printComments(1, comments, node);
if (hasSpace && printedCommentsCount !== this._printedComments.size) {
this.space();
}
if (indent) this.dedent();
}
noIndentInnerCommentsHere() {
this._indentInnerComments = false;
}
printSequence(nodes, parent, opts = {}) {
var _opts$indent;
opts.statement = true;
(_opts$indent = opts.indent) != null ? _opts$indent : opts.indent = false;
this.printJoin(nodes, parent, opts);
}
printList(items, parent, opts = {}) {
if (opts.separator == null) {
opts.separator = commaSeparator;
}
this.printJoin(items, parent, opts);
}
_printNewline(newLine, opts) {
const format = this.format;
if (format.retainLines || format.compact) return;
if (format.concise) {
this.space();
return;
}
if (!newLine) {
return;
}
const startLine = opts.nextNodeStartLine;
const lastCommentLine = this._lastCommentLine;
if (startLine > 0 && lastCommentLine > 0) {
const offset = startLine - lastCommentLine;
if (offset >= 0) {
this.newline(offset || 1);
return;
}
}
if (this._buf.hasContent()) {
this.newline(1);
}
}
_shouldPrintComment(comment) {
if (comment.ignore) return 0;
if (this._printedComments.has(comment)) return 0;
if (this._noLineTerminator && (HAS_NEWLINE.test(comment.value) || HAS_BlOCK_COMMENT_END.test(comment.value))) {
return 2;
}
this._printedComments.add(comment);
if (!this.format.shouldPrintComment(comment.value)) {
return 0;
}
return 1;
}
_printComment(comment, skipNewLines) {
const noLineTerminator = this._noLineTerminator;
const isBlockComment = comment.type === "CommentBlock";
const printNewLines = isBlockComment && skipNewLines !== 1 && !this._noLineTerminator;
if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
this.newline(1);
}
const lastCharCode = this.getLastChar();
if (lastCharCode !== 91 && lastCharCode !== 123) {
this.space();
}
let val;
if (isBlockComment) {
val = `/*${comment.value}*/`;
if (this.format.indent.adjustMultilineComment) {
var _comment$loc;
const offset = (_comment$loc = comment.loc) == null ? void 0 : _comment$loc.start.column;
if (offset) {
const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
val = val.replace(newlineRegex, "\n");
}
let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
if (this._shouldIndent(47) || this.format.retainLines) {
indentSize += this._getIndent();
}
val = val.replace(/\n(?!$)/g, `\n${" ".repeat(indentSize)}`);
}
} else if (!noLineTerminator) {
val = `//${comment.value}`;
} else {
val = `/*${comment.value}*/`;
}
if (this.endsWith(47)) this._space();
this.source("start", comment.loc);
this._append(val, isBlockComment);
if (!isBlockComment && !noLineTerminator) {
this.newline(1, true);
}
if (printNewLines && skipNewLines !== 3) {
this.newline(1);
}
}
_printComments(type, comments, node, parent, lineOffset = 0) {
const nodeLoc = node.loc;
const len = comments.length;
let hasLoc = !!nodeLoc;
const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
let lastLine = 0;
let leadingCommentNewline = 0;
const maybeNewline = this._noLineTerminator ? function () {} : this.newline.bind(this);
for (let i = 0; i < len; i++) {
const comment = comments[i];
const shouldPrint = this._shouldPrintComment(comment);
if (shouldPrint === 2) {
hasLoc = false;
break;
}
if (hasLoc && comment.loc && shouldPrint === 1) {
const commentStartLine = comment.loc.start.line;
const commentEndLine = comment.loc.end.line;
if (type === 0) {
let offset = 0;
if (i === 0) {
if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine != commentEndLine)) {
offset = leadingCommentNewline = 1;
}
} else {
offset = commentStartLine - lastLine;
}
lastLine = commentEndLine;
maybeNewline(offset);
this._printComment(comment, 1);
if (i + 1 === len) {
maybeNewline(Math.max(nodeStartLine - lastLine, leadingCommentNewline));
lastLine = nodeStartLine;
}
} else if (type === 1) {
const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
lastLine = commentEndLine;
maybeNewline(offset);
this._printComment(comment, 1);
if (i + 1 === len) {
maybeNewline(Math.min(1, nodeEndLine - lastLine));
lastLine = nodeEndLine;
}
} else {
const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
lastLine = commentEndLine;
maybeNewline(offset);
this._printComment(comment, 1);
}
} else {
hasLoc = false;
if (shouldPrint !== 1) {
continue;
}
if (len === 1) {
const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
const shouldSkipNewline = singleLine && !isStatement(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumDeclaration(parent);
if (type === 0) {
this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction(parent, {
body: node
}) ? 1 : 0);
} else if (shouldSkipNewline && type === 2) {
this._printComment(comment, 1);
} else {
this._printComment(comment, 0);
}
} else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody" && node.type !== "TSInterfaceBody") {
this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0);
} else {
this._printComment(comment, 0);
}
}
}
if (type === 2 && hasLoc && lastLine) {
this._lastCommentLine = lastLine;
}
}
}
Object.assign(Printer.prototype, generatorFunctions);
{
Printer.prototype.Noop = function Noop() {};
}
var _default = Printer;
printer.default = _default;
function commaSeparator() {
this.tokenChar(44);
this.space();
}
return printer;
}
var hasRequiredLib;
function requireLib () {
if (hasRequiredLib) return lib;
hasRequiredLib = 1;
Object.defineProperty(lib, "__esModule", {
value: true
});
lib.CodeGenerator = void 0;
lib.default = generate;
var _sourceMap = requireSourceMap();
var _printer = requirePrinter();
class Generator extends _printer.default {
constructor(ast, opts = {}, code) {
const format = normalizeOptions(code, opts);
const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
super(format, map);
this.ast = void 0;
this.ast = ast;
}
generate() {
return super.generate(this.ast);
}
}
function normalizeOptions(code, opts) {
var _opts$recordAndTupleS;
const format = {
auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
shouldPrintComment: opts.shouldPrintComment,
retainLines: opts.retainLines,
retainFunctionParens: opts.retainFunctionParens,
comments: opts.comments == null || opts.comments,
compact: opts.compact,
minified: opts.minified,
concise: opts.concise,
indent: {
adjustMultilineComment: true,
style: " "
},
jsescOption: Object.assign({
quotes: "double",
wrap: true,
minimal: false
}, opts.jsescOption),
recordAndTupleSyntaxType: (_opts$recordAndTupleS = opts.recordAndTupleSyntaxType) != null ? _opts$recordAndTupleS : "hash",
topicToken: opts.topicToken,
importAttributesKeyword: opts.importAttributesKeyword
};
{
format.decoratorsBeforeExport = opts.decoratorsBeforeExport;
format.jsescOption.json = opts.jsonCompatibleStrings;
}
if (format.minified) {
format.compact = true;
format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
} else {
format.shouldPrintComment = format.shouldPrintComment || (value => format.comments || value.includes("@license") || value.includes("@preserve"));
}
if (format.compact === "auto") {
format.compact = typeof code === "string" && code.length > 500000;
if (format.compact) {
console.error("[BABEL] Note: The code generator has deoptimised the styling of " + `${opts.filename} as it exceeds the max of ${"500KB"}.`);
}
}
if (format.compact) {
format.indent.adjustMultilineComment = false;
}
const {
auxiliaryCommentBefore,
auxiliaryCommentAfter,
shouldPrintComment
} = format;
if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) {
format.auxiliaryCommentBefore = undefined;
}
if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) {
format.auxiliaryCommentAfter = undefined;
}
return format;
}
class CodeGenerator {
constructor(ast, opts, code) {
this._generator = void 0;
this._generator = new Generator(ast, opts, code);
}
generate() {
return this._generator.generate();
}
}
lib.CodeGenerator = CodeGenerator;
function generate(ast, opts, code) {
const gen = new Generator(ast, opts, code);
return gen.generate();
}
return lib;
}
var libExports = requireLib();
var generate = /*@__PURE__*/getDefaultExportFromCjs(libExports);
function isFunction(node) {
return (
libExports$2.isFunction(node) ||
libExports$2.isArrowFunctionExpression(node) ||
libExports$2.isObjectMethod(node) ||
libExports$2.isClassMethod(node)
);
}
function isObjectShorthand(parent) {
if (!libExports$2.isObjectProperty(parent)) {
return false;
}
if (parent.value && parent.value.left) {
return (
parent.value.type === "AssignmentPattern" &&
parent.value.left.type === "Identifier"
);
}
return (
parent.value &&
parent.key.start == parent.value.start &&
parent.key.loc.identifierName === parent.value.loc.identifierName
);
}
function getObjectExpressionValue(node) {
const { value } = node;
if (libExports$2.isIdentifier(value)) {
return value.name;
}
if (libExports$2.isCallExpression(value) || libExports$2.isFunctionExpression(value)) {
return "";
}
const code = generate(value).code;
const shouldWrap = libExports$2.isObjectExpression(value);
return shouldWrap ? `(${code})` : code;
}
function getCode(node) {
return generate(node).code;
}
function getComments(ast) {
if (!ast || !ast.comments) {
return [];
}
return ast.comments.map(comment => ({
name: comment.location,
location: comment.loc,
}));
}
function isComputedExpression(expression) {
return /^\[/m.test(expression);
}
/**
* Add the identifiers for a given object pattern.
*
* @param {Array.<Object>} identifiers
* the current list of identifiers where to push the new identifiers
* related to this path.
* @param {Set<String>} identifiersKeys
* List of currently registered identifier location key.
* @param {Object} pattern
*/
function addPatternIdentifiers(identifiers, identifiersKeys, pattern) {
let items;
if (libExports$2.isObjectPattern(pattern)) {
items = pattern.properties.map(({ value }) => value);
}
if (libExports$2.isArrayPattern(pattern)) {
items = pattern.elements;
}
if (items) {
addIdentifiers(identifiers, identifiersKeys, items);
}
}
function addIdentifiers(identifiers, identifiersKeys, items) {
for (const item of items) {
if (libExports$2.isObjectPattern(item) || libExports$2.isArrayPattern(item)) {
addPatternIdentifiers(identifiers, identifiersKeys, item);
} else if (libExports$2.isIdentifier(item)) {
if (!identifiersKeys.has(nodeLocationKey(item.loc))) {
identifiers.push({
name: item.name,
expression: item.name,
location: item.loc,
});
}
}
}
}
// Top Level checks the number of "body" nodes in the ancestor chain
// if the node is top-level, then it shoul only have one body.
function isTopLevel(ancestors) {
return ancestors.filter(ancestor => ancestor.key == "body").length == 1;
}
function nodeLocationKey({ start, end }) {
return `${start.line}:${start.column}:${end.line}:${end.column}`;
}
function getFunctionParameterNames(path) {
if (path.node.params != null) {
return path.node.params.map(param => {
if (param.type !== "AssignmentPattern") {
return param.name;
}
// Parameter with default value
if (
param.left.type === "Identifier" &&
param.right.type === "Identifier"
) {
return `${param.left.name} = ${param.right.name}`;
} else if (
param.left.type === "Identifier" &&
param.right.type === "StringLiteral"
) {
return `${param.left.name} = ${param.right.value}`;
} else if (
param.left.type === "Identifier" &&
param.right.type === "ObjectExpression"
) {
return `${param.left.name} = {}`;
} else if (
param.left.type === "Identifier" &&
param.right.type === "ArrayExpression"
) {
return `${param.left.name} = []`;
} else if (
param.left.type === "Identifier" &&
param.right.type === "NullLiteral"
) {
return `${param.left.name} = null`;
}
return null;
});
}
return [];
}
// the function class is inferred from a call like
// createClass or extend
function fromCallExpression(callExpression) {
const allowlist = ["extend", "createClass"];
const { callee } = callExpression.node;
if (!callee) {
return null;
}
const name = libExports$2.isMemberExpression(callee)
? callee.property.name
: callee.name;
if (!allowlist.includes(name)) {
return null;
}
const variable = callExpression.findParent(p =>
libExports$2.isVariableDeclarator(p.node)
);
if (variable) {
return variable.node.id.name;
}
const assignment = callExpression.findParent(p =>
libExports$2.isAssignmentExpression(p.node)
);
if (!assignment) {
return null;
}
const { left } = assignment.node;
if (left.name) {
return name;
}
if (libExports$2.isMemberExpression(left)) {
return left.property.name;
}
return null;
}
// the function class is inferred from a prototype assignment
// e.g. TodoClass.prototype.render = function() {}
function fromPrototype(assignment) {
const { left } = assignment.node;
if (!left) {
return null;
}
if (
libExports$2.isMemberExpression(left) &&
left.object &&
libExports$2.isMemberExpression(left.object) &&
left.object.property.identifier === "prototype"
) {
return left.object.object.name;
}
return null;
}
// infer class finds an appropriate class for functions
// that are defined inside of a class like thing.
// e.g. `class Foo`, `TodoClass.prototype.foo`,
// `Todo = createClass({ foo: () => {}})`
function inferClassName(path) {
const classDeclaration = path.findParent(p => libExports$2.isClassDeclaration(p.node));
if (classDeclaration) {
return classDeclaration.node.id.name;
}
const callExpression = path.findParent(p => libExports$2.isCallExpression(p.node));
if (callExpression) {
return fromCallExpression(callExpression);
}
const assignment = path.findParent(p => libExports$2.isAssignmentExpression(p.node));
if (assignment) {
return fromPrototype(assignment);
}
return null;
}
// Perform ES6's anonymous function name inference for all
// locations where static analysis is possible.
// eslint-disable-next-line complexity
function getFunctionName(node, parent) {
if (libExports$2.isIdentifier(node.id)) {
return node.id.name;
}
if (
libExports$2.isObjectMethod(node, { computed: false }) ||
libExports$2.isClassMethod(node, { computed: false }) ||
libExports$2.isClassPrivateMethod(node)
) {
const { key } = node;
if (libExports$2.isIdentifier(key)) {
return key.name;
}
if (libExports$2.isStringLiteral(key)) {
return key.value;
}
if (libExports$2.isNumericLiteral(key)) {
return `${key.value}`;
}
if (libExports$2.isPrivateName(key)) {
return `#${key.id.name}`;
}
}
if (
libExports$2.isObjectProperty(parent, { computed: false, value: node }) ||
// TODO: Babylon 6 doesn't support computed class props. It is included
// here so that it is most flexible. Once Babylon 7 is used, this
// can change to use computed: false like ObjectProperty.
(libExports$2.isClassProperty(parent, { value: node }) && !parent.computed) ||
(libExports$2.isClassPrivateProperty(parent, { value: node }) && !parent.computed)
) {
const { key } = parent;
if (libExports$2.isIdentifier(key)) {
return key.name;
}
if (libExports$2.isStringLiteral(key)) {
return key.value;
}
if (libExports$2.isNumericLiteral(key)) {
return `${key.value}`;
}
if (libExports$2.isPrivateName(key)) {
return `#${key.id.name}`;
}
}
if (libExports$2.isAssignmentExpression(parent, { operator: "=", right: node })) {
if (libExports$2.isIdentifier(parent.left)) {
return parent.left.name;
}
// This case is not supported in standard ES6 name inference, but it
// is included here since it is still a helpful case during debugging.
if (libExports$2.isMemberExpression(parent.left, { computed: false })) {
return parent.left.property.name;
}
}
if (
libExports$2.isAssignmentPattern(parent, { right: node }) &&
libExports$2.isIdentifier(parent.left)
) {
return parent.left.name;
}
if (
libExports$2.isVariableDeclarator(parent, { init: node }) &&
libExports$2.isIdentifier(parent.id)
) {
return parent.id.name;
}
if (
libExports$2.isExportDefaultDeclaration(parent, { declaration: node }) &&
libExports$2.isFunctionDeclaration(node)
) {
return "default";
}
return "anonymous";
}
function getFramework(symbols) {
if (isReactComponent(symbols)) {
return "React";
}
if (isAngularComponent(symbols)) {
return "Angular";
}
if (isVueComponent(symbols)) {
return "Vue";
}
return null;
}
function isReactComponent({ importsReact, classes, identifiers }) {
return (
importsReact ||
extendsReactComponent(classes) ||
isReact(identifiers) ||
isRedux(identifiers)
);
}
function extendsReactComponent(classes) {
return classes.some(
classObj =>
libExports$2.isIdentifier(classObj.parent, { name: "Component" }) ||
libExports$2.isIdentifier(classObj.parent, { name: "PureComponent" }) ||
(libExports$2.isMemberExpression(classObj.parent, { computed: false }) &&
libExports$2.isIdentifier(classObj.parent, { name: "Component" }))
);
}
function isAngularComponent({ memberExpressions }) {
return memberExpressions.some(
item =>
item.expression == "angular.controller" ||
item.expression == "angular.module"
);
}
function isVueComponent({ identifiers }) {
return identifiers.some(identifier => identifier.name == "Vue");
}
/* This identifies the react lib file */
function isReact(identifiers) {
return identifiers.some(identifier => identifier.name == "isReactComponent");
}
/* This identifies the redux lib file */
function isRedux(identifiers) {
return identifiers.some(identifier => identifier.name == "Redux");
}
const symbolDeclarations = new Map();
function extractFunctionSymbol(path, state, symbols) {
const name = getFunctionName(path.node, path.parent);
if (!state.fnCounts[name]) {
state.fnCounts[name] = 0;
}
const index = state.fnCounts[name]++;
symbols.functions.push({
name,
klass: inferClassName(path),
location: path.node.loc,
parameterNames: getFunctionParameterNames(path),
identifier: path.node.id,
// indicates the occurence of the function in a file
// e.g { name: foo, ... index: 4 } is the 4th foo function
// in the file
index,
});
}
function extractSymbol(path, symbols, state) {
if (isFunction(path)) {
extractFunctionSymbol(path, state, symbols);
}
if (libExports$2.isJSXElement(path)) {
symbols.hasJsx = true;
}
if (libExports$2.isGenericTypeAnnotation(path)) {
symbols.hasTypes = true;
}
if (libExports$2.isClassDeclaration(path)) {
symbols.classes.push(getClassDeclarationSymbol(path.node));
}
if (!symbols.importsReact) {
if (libExports$2.isImportDeclaration(path)) {
symbols.importsReact = isReactImport(path.node);
} else if (libExports$2.isCallExpression(path)) {
symbols.importsReact = isReactRequire(path.node);
}
}
if (libExports$2.isMemberExpression(path) || libExports$2.isOptionalMemberExpression(path)) {
symbols.memberExpressions.push(getMemberExpressionSymbol(path));
}
if (
(libExports$2.isStringLiteral(path) || libExports$2.isNumericLiteral(path)) &&
libExports$2.isMemberExpression(path.parentPath)
) {
// We only need literals that are part of computed memeber expressions
const { start, end } = path.node.loc;
symbols.literals.push({
location: { start, end },
get expression() {
delete this.expression;
this.expression = getSnippet(path.parentPath);
return this.expression;
},
});
}
getIdentifierSymbols(symbols.identifiers, symbols.identifiersKeys, path);
}
function extractSymbols(sourceId) {
const symbols = {
functions: [],
memberExpressions: [],
comments: [],
identifiers: [],
// This holds a set of unique identifier location key (string)
// It helps registering only the first identifier when there is duplicated ones for the same location.
identifiersKeys: new Set(),
classes: [],
literals: [],
hasJsx: false,
hasTypes: false,
framework: undefined,
importsReact: false,
};
const state = {
fnCounts: Object.create(null),
};
const ast = traverseAst(sourceId, {
enter(node, ancestors) {
try {
const path = createSimplePath(ancestors);
if (path) {
extractSymbol(path, symbols, state);
}
} catch (e) {
console.error(e);
}
},
});
// comments are extracted separately from the AST
symbols.comments = getComments(ast);
symbols.framework = getFramework(symbols);
return symbols;
}
function extendSnippet(name, expression, path, prevPath) {
const computed = path?.node.computed;
const optional = path?.node.optional;
const prevComputed = prevPath?.node.computed;
const prevArray = libExports$2.isArrayExpression(prevPath);
const array = libExports$2.isArrayExpression(path);
const value = path?.node.property?.extra?.raw || "";
if (expression === "") {
if (computed) {
return name === undefined ? `[${value}]` : `[${name}]`;
}
return name;
}
if (computed || array) {
if (prevComputed || prevArray) {
return `[${name}]${expression}`;
}
return `[${name === undefined ? value : name}].${expression}`;
}
if (prevComputed || prevArray) {
return `${name}${expression}`;
}
if (isComputedExpression(expression) && name !== undefined) {
return `${name}${expression}`;
}
if (optional) {
return `${name}?.${expression}`;
}
return `${name}.${expression}`;
}
function getMemberSnippet(node, expression = "", optional = false) {
if (libExports$2.isMemberExpression(node) || libExports$2.isOptionalMemberExpression(node)) {
const name = libExports$2.isPrivateName(node.property)
? `#${node.property.id.name}`
: node.property.name;
const snippet = getMemberSnippet(
node.object,
extendSnippet(name, expression, { node }),
node.optional
);
return snippet;
}
if (libExports$2.isCallExpression(node)) {
return "";
}
if (libExports$2.isThisExpression(node)) {
return `this.${expression}`;
}
if (libExports$2.isIdentifier(node)) {
if (isComputedExpression(expression)) {
return `${node.name}${expression}`;
}
if (optional) {
return `${node.name}?.${expression}`;
}
return `${node.name}.${expression}`;
}
return expression;
}
function getObjectSnippet(path, prevPath, expression = "") {
if (!path) {
return expression;
}
const { name } = path.node.key;
const extendedExpression = extendSnippet(name, expression, path, prevPath);
const nextPrevPath = path;
const nextPath = path.parentPath && path.parentPath.parentPath;
return getSnippet(nextPath, nextPrevPath, extendedExpression);
}
function getArraySnippet(path, prevPath, expression) {
if (!prevPath.parentPath) {
throw new Error("Assertion failure - path should exist");
}
const index = `${prevPath.parentPath.containerIndex}`;
const extendedExpression = extendSnippet(index, expression, path, prevPath);
const nextPrevPath = path;
const nextPath = path.parentPath && path.parentPath.parentPath;
return getSnippet(nextPath, nextPrevPath, extendedExpression);
}
function getSnippet(path, prevPath, expression = "") {
if (!path) {
return expression;
}
if (libExports$2.isVariableDeclaration(path)) {
const node = path.node.declarations[0];
const { name } = node.id;
return extendSnippet(name, expression, path, prevPath);
}
if (libExports$2.isVariableDeclarator(path)) {
const node = path.node.id;
if (libExports$2.isObjectPattern(node)) {
return expression;
}
const prop = extendSnippet(node.name, expression, path, prevPath);
return prop;
}
if (libExports$2.isAssignmentExpression(path)) {
const node = path.node.left;
const name = libExports$2.isMemberExpression(node)
? getMemberSnippet(node)
: node.name;
const prop = extendSnippet(name, expression, path, prevPath);
return prop;
}
if (isFunction(path)) {
return expression;
}
if (libExports$2.isIdentifier(path)) {
return `${path.node.name}.${expression}`;
}
if (libExports$2.isObjectProperty(path)) {
return getObjectSnippet(path, prevPath, expression);
}
if (libExports$2.isObjectExpression(path)) {
const parentPath = prevPath?.parentPath;
return getObjectSnippet(parentPath, prevPath, expression);
}
if (libExports$2.isMemberExpression(path) || libExports$2.isOptionalMemberExpression(path)) {
return getMemberSnippet(path.node, expression);
}
if (libExports$2.isArrayExpression(path)) {
if (!prevPath) {
throw new Error("Assertion failure - path should exist");
}
return getArraySnippet(path, prevPath, expression);
}
return "";
}
function clearSymbols(sourceIds) {
for (const sourceId of sourceIds) {
symbolDeclarations.delete(sourceId);
}
}
function getInternalSymbols(sourceId) {
if (symbolDeclarations.has(sourceId)) {
const symbols = symbolDeclarations.get(sourceId);
if (symbols) {
return symbols;
}
}
const symbols = extractSymbols(sourceId);
symbolDeclarations.set(sourceId, symbols);
return symbols;
}
function getFunctionSymbols(sourceId, maxResults) {
const symbols = getInternalSymbols(sourceId);
if (!symbols) {
return [];
}
let { functions } = symbols;
// Avoid transferring more symbols than necessary
if (maxResults && functions.length > maxResults) {
functions = functions.slice(0, maxResults);
}
// The Outline & the Quick open panels do not need anonymous functions
return functions.filter(fn => fn.name !== "anonymous");
}
function getClassSymbols(sourceId) {
const symbols = getInternalSymbols(sourceId);
if (!symbols) {
return [];
}
return symbols.classes;
}
function containsPosition$1(a, b) {
const bColumn = b.column || 0;
const startsBefore =
a.start.line < b.line ||
(a.start.line === b.line && a.start.column <= bColumn);
const endsAfter =
a.end.line > b.line || (a.end.line === b.line && a.end.column >= bColumn);
return startsBefore && endsAfter;
}
function getClosestFunctionName(location) {
const symbols = getInternalSymbols(location.source.id);
if (!symbols || !symbols.functions) {
return "";
}
const closestFunction = symbols.functions.reduce((found, currNode) => {
if (
currNode.name === "anonymous" ||
!containsPosition$1(currNode.location, {
line: location.line,
column: location.column || 0,
})
) {
return found;
}
if (!found) {
return currNode;
}
if (found.location.start.line > currNode.location.start.line) {
return found;
}
if (
found.location.start.line === currNode.location.start.line &&
found.location.start.column > currNode.location.start.column
) {
return found;
}
return currNode;
}, null);
if (!closestFunction) {
return "";
}
return closestFunction.name;
}
// This is only called from the main thread and we return a subset of attributes
function getSymbols(sourceId) {
const symbols = getInternalSymbols(sourceId);
return {
// This is used in the main thread by:
// * The `getFunctionSymbols` function which is used by the Outline, QuickOpen panels.
// * The `getClosestFunctionName` function used in the mapping of frame function names.
// * The `findOutOfScopeLocations` function use to determine in scope lines.
// functions: symbols.functions,
// The three following attributes are only used by `findBestMatchExpression` within the worker thread
// `memberExpressions`, `literals`
// This one is also used within the worker for framework computation
// `identifiers`
//
// These three memberExpressions, literals and identifiers attributes are arrays containing objects whose attributes are:
// * name: string
// * location: object {start: number, end: number}
// * expression: string
// * computed: boolean (only for memberExpressions)
//
// `findBestMatchExpression` uses `location`, `computed` and `expression` (not name).
// `expression` isn't used from the worker thread implementation of `findBestMatchExpression`.
// The main thread only uses `expression` and `location`.
// framework computation uses only:
// * `name` for identifiers
// * `expression` for memberExpression
// This is used within the worker for framework computation,
// and in the `getClassSymbols` function
// `classes`
// The two following are only used by the main thread for computing CodeMirror "mode"
hasJsx: symbols.hasJsx,
hasTypes: symbols.hasTypes,
// This is used in the main thread only to compute the source icon
framework: symbols.framework,
// This is only used by `findOutOfScopeLocations`:
// `comments`
};
}
function getMemberExpressionSymbol(path) {
const { start, end } = path.node.property.loc;
return {
location: { start, end },
get expression() {
delete this.expression;
this.expression = getSnippet(path);
return this.expression;
},
computed: path.node.computed,
};
}
function isReactImport(node) {
return (
node.source.value == "react" &&
node.specifiers?.some(specifier => specifier.local?.name == "React")
);
}
function isReactRequire(node) {
const { callee } = node;
const name = libExports$2.isMemberExpression(callee)
? callee.property.name
: callee.loc.identifierName;
return name == "require" && node.arguments.some(arg => arg.value == "react");
}
function getClassParentName(superClass) {
return libExports$2.isMemberExpression(superClass)
? getCode(superClass)
: superClass.name;
}
function getClassParentSymbol(superClass) {
if (!superClass) {
return null;
}
return {
name: getClassParentName(superClass),
location: superClass.loc,
};
}
function getClassDeclarationSymbol(node) {
const { loc, superClass } = node;
return {
name: node.id.name,
parent: getClassParentSymbol(superClass),
location: loc,
};
}
/**
* Get a list of identifiers that are part of the given path.
*
* @param {Array.<Object>} identifiers
* the current list of identifiers where to push the new identifiers
* related to this path.
* @param {Set<String>} identifiersKeys
* List of currently registered identifier location key.
* @param {Object} path
*/
function getIdentifierSymbols(identifiers, identifiersKeys, path) {
if (libExports$2.isStringLiteral(path) && libExports$2.isProperty(path.parentPath)) {
if (!identifiersKeys.has(nodeLocationKey(path.node.loc))) {
identifiers.push({
name: path.node.value,
get expression() {
delete this.expression;
this.expression = getObjectExpressionValue(path.parent);
return this.expression;
},
location: path.node.loc,
});
}
return;
}
if (libExports$2.isIdentifier(path) && !libExports$2.isGenericTypeAnnotation(path.parent)) {
// We want to include function params, but exclude the function name
if (libExports$2.isClassMethod(path.parent) && !path.inList) {
return;
}
if (libExports$2.isProperty(path.parentPath) && !isObjectShorthand(path.parent)) {
if (!identifiersKeys.has(nodeLocationKey(path.node.loc))) {
identifiers.push({
name: path.node.name,
get expression() {
delete this.expression;
this.expression = getObjectExpressionValue(path.parent);
return this.expression;
},
location: path.node.loc,
});
}
return;
}
let { start, end } = path.node.loc;
if (path.node.typeAnnotation) {
const { column } = path.node.typeAnnotation.loc.start;
end = { ...end, column };
}
if (!identifiersKeys.has(nodeLocationKey({ start, end }))) {
identifiers.push({
name: path.node.name,
expression: path.node.name,
location: { start, end },
});
}
}
if (libExports$2.isThisExpression(path.node)) {
if (!identifiersKeys.has(nodeLocationKey(path.node.loc))) {
identifiers.push({
name: "this",
location: path.node.loc,
expression: "this",
});
}
}
if (libExports$2.isVariableDeclarator(path)) {
const nodeId = path.node.id;
addPatternIdentifiers(identifiers, identifiersKeys, nodeId);
}
}
/**
* "implicit"
* Variables added automaticly like "this" and "arguments"
*
* "var"
* Variables declared with "var" or non-block function declarations
*
* "let"
* Variables declared with "let".
*
* "const"
* Variables declared with "const", or added as const
* bindings like inner function expressions and inner class names.
*
* "import"
* Imported binding names exposed from other modules.
*
* "global"
* Variables that reference undeclared global values.
*/
// Location information about the expression immediartely surrounding a
// given binding reference.
function isGeneratedId(id) {
return !/\/originalSource/.test(id);
}
function parseSourceScopes(sourceId) {
const ast = getAst(sourceId);
if (!ast || !Object.keys(ast).length) {
return null;
}
return buildScopeList(ast, sourceId);
}
function buildScopeList(ast, sourceId) {
const { global, lexical } = createGlobalScope(ast, sourceId);
const state = {
// The id for the source that scope list is generated for
sourceId,
// A map of any free variables(variables which are used within the current scope but not
// declared within the scope). This changes when a new scope is created.
freeVariables: new Map(),
// A stack of all the free variables created across all the scopes that have
// been created.
freeVariableStack: [],
inType: null,
// The current scope, a new scope is potentially created on a visit to each node
// depending in the criteria. Initially set to the lexical global scope which is the
// child to the global scope.
scope: lexical,
// A stack of all the existing scopes, this is mainly used retrieve the parent scope
// (which is the last scope push onto the stack) on exiting a visited node.
scopeStack: [],
declarationBindingIds: new Set(),
};
libExports$2.traverse(ast, scopeCollectionVisitor, state);
for (const [key, freeVariables] of state.freeVariables) {
let binding = global.bindings[key];
if (!binding) {
binding = {
type: "global",
refs: [],
};
global.bindings[key] = binding;
}
binding.refs = freeVariables.concat(binding.refs);
}
// TODO: This should probably check for ".mjs" extension on the
// original file, and should also be skipped if the the generated
// code is an ES6 module rather than a script.
if (
isGeneratedId(sourceId) ||
(ast.program.sourceType === "script" && !looksLikeCommonJS(global))
) {
stripModuleScope(global);
}
return toParsedScopes([global]) || [];
}
function toParsedScopes(children, sourceId) {
if (!children || children.length === 0) {
return undefined;
}
return children.map(scope => ({
// Removing unneed information from TempScope such as parent reference.
// We also need to convert BabelLocation to the Location type.
start: scope.loc.start,
end: scope.loc.end,
type:
scope.type === "module" || scope.type === "function-body"
? "block"
: scope.type,
scopeKind: "",
displayName: scope.displayName,
bindings: scope.bindings,
children: toParsedScopes(scope.children),
}));
}
/**
* Create a new scope object and link the scope to it parent.
*
* @param {String} type - scope type
* @param {String} displayName - The scope display name
* @param {Object} parent - The parent object scope
* @param {Object} loc - The start and end postions (line/columns) of the scope
* @returns {Object} The newly created scope
*/
function createTempScope(type, displayName, parent, loc) {
const scope = {
type,
displayName,
parent,
// A list of all the child scopes
children: [],
loc,
// All the bindings defined in this scope
// bindings = [binding, ...]
// binding = { type: "", refs: []}
bindings: Object.create(null),
};
if (parent) {
parent.children.push(scope);
}
return scope;
}
// Sets a new current scope and creates a new map to store the free variables
// that may exist in this scope.
function pushTempScope(state, type, displayName, loc) {
const scope = createTempScope(type, displayName, state.scope, loc);
state.scope = scope;
state.freeVariableStack.push(state.freeVariables);
state.freeVariables = new Map();
return scope;
}
function isNode(node, type) {
return node ? node.type === type : false;
}
// Walks up the scope tree to the top most variable scope
function getVarScope(scope) {
let s = scope;
while (s.type !== "function" && s.type !== "module") {
if (!s.parent) {
return s;
}
s = s.parent;
}
return s;
}
function fromBabelLocation(location, sourceId) {
return {
sourceId,
line: location.line,
column: location.column,
};
}
function parseDeclarator(
declaratorId,
targetScope,
type,
locationType,
declaration,
state
) {
if (isNode(declaratorId, "Identifier")) {
let existing = targetScope.bindings[declaratorId.name];
if (!existing) {
existing = {
type,
refs: [],
};
targetScope.bindings[declaratorId.name] = existing;
}
state.declarationBindingIds.add(declaratorId);
existing.refs.push({
type: locationType,
start: fromBabelLocation(declaratorId.loc.start, state.sourceId),
end: fromBabelLocation(declaratorId.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(declaration.loc.start, state.sourceId),
end: fromBabelLocation(declaration.loc.end, state.sourceId),
},
});
} else if (isNode(declaratorId, "ObjectPattern")) {
declaratorId.properties.forEach(prop => {
parseDeclarator(
prop.value,
targetScope,
type,
locationType,
declaration,
state
);
});
} else if (isNode(declaratorId, "ArrayPattern")) {
declaratorId.elements.forEach(item => {
parseDeclarator(
item,
targetScope,
type,
locationType,
declaration,
state
);
});
} else if (isNode(declaratorId, "AssignmentPattern")) {
parseDeclarator(
declaratorId.left,
targetScope,
type,
locationType,
declaration,
state
);
} else if (isNode(declaratorId, "RestElement")) {
parseDeclarator(
declaratorId.argument,
targetScope,
type,
locationType,
declaration,
state
);
} else if (libExports$2.isTSParameterProperty(declaratorId)) {
parseDeclarator(
declaratorId.parameter,
targetScope,
type,
locationType,
declaration,
state
);
}
}
function isLetOrConst(node) {
return node.kind === "let" || node.kind === "const";
}
function hasLexicalDeclaration(node, parent) {
const nodes = [];
if (libExports$2.isSwitchStatement(node)) {
for (const caseNode of node.cases) {
nodes.push(...caseNode.consequent);
}
} else {
nodes.push(...node.body);
}
const isFunctionBody = libExports$2.isFunction(parent, { body: node });
return nodes.some(
child =>
isLexicalVariable(child) ||
libExports$2.isClassDeclaration(child) ||
(!isFunctionBody && libExports$2.isFunctionDeclaration(child))
);
}
function isLexicalVariable(node) {
return isNode(node, "VariableDeclaration") && isLetOrConst(node);
}
// Creates the global scopes for this source, the overall global scope
// and a lexical global scope.
function createGlobalScope(ast, sourceId) {
const global = createTempScope("object", "Global", null, {
start: fromBabelLocation(ast.loc.start, sourceId),
end: fromBabelLocation(ast.loc.end, sourceId),
});
const lexical = createTempScope("block", "Lexical Global", global, {
start: fromBabelLocation(ast.loc.start, sourceId),
end: fromBabelLocation(ast.loc.end, sourceId),
});
return { global, lexical };
}
const scopeCollectionVisitor = {
// eslint-disable-next-line complexity
enter(node, ancestors, state) {
state.scopeStack.push(state.scope);
const parentNode =
ancestors.length === 0 ? null : ancestors[ancestors.length - 1].node;
if (state.inType) {
return;
}
if (libExports$2.isProgram(node)) {
const scope = pushTempScope(state, "module", "Module", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
scope.bindings.this = {
type: "implicit",
refs: [],
};
} else if (libExports$2.isFunction(node)) {
let { scope } = state;
if (libExports$2.isFunctionExpression(node) && isNode(node.id, "Identifier")) {
scope = pushTempScope(state, "block", "Function Expression", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
state.declarationBindingIds.add(node.id);
scope.bindings[node.id.name] = {
type: "const",
refs: [
{
type: "fn-expr",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
],
};
}
if (libExports$2.isFunctionDeclaration(node) && isNode(node.id, "Identifier")) {
// This ignores Annex B function declaration hoisting, which
// is probably a fine assumption.
state.declarationBindingIds.add(node.id);
const refs = [
{
type: "fn-decl",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
];
if (scope.type === "block") {
scope.bindings[node.id.name] = {
type: "let",
refs,
};
} else {
// Add the binding to the ancestor scope
getVarScope(scope).bindings[node.id.name] = {
type: "var",
refs,
};
}
}
scope = pushTempScope(
state,
"function",
getFunctionName(node, parentNode),
{
// Being at the start of a function doesn't count as
// being inside of it.
start: fromBabelLocation(
node.params[0] ? node.params[0].loc.start : node.loc.start,
state.sourceId
),
end: fromBabelLocation(node.loc.end, state.sourceId),
}
);
node.params.forEach(param =>
parseDeclarator(param, scope, "var", "fn-param", node, state)
);
if (!libExports$2.isArrowFunctionExpression(node)) {
scope.bindings.this = {
type: "implicit",
refs: [],
};
scope.bindings.arguments = {
type: "implicit",
refs: [],
};
}
if (
libExports$2.isBlockStatement(node.body) &&
hasLexicalDeclaration(node.body, node)
) {
scope = pushTempScope(state, "function-body", "Function Body", {
start: fromBabelLocation(node.body.loc.start, state.sourceId),
end: fromBabelLocation(node.body.loc.end, state.sourceId),
});
}
} else if (libExports$2.isClass(node)) {
if (libExports$2.isIdentifier(node.id)) {
// For decorated classes, the AST considers the first the decorator
// to be the start of the class. For the purposes of mapping class
// declarations however, we really want to look for the "class Foo"
// piece. To achieve that, we estimate the location of the declaration
// instead.
let declStart = node.loc.start;
if (node.decorators && node.decorators.length) {
// Estimate the location of the "class" keyword since it
// is unlikely to be a different line than the class name.
declStart = {
line: node.id.loc.start.line,
column: node.id.loc.start.column - "class ".length,
};
}
const declaration = {
start: fromBabelLocation(declStart, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
};
if (libExports$2.isClassDeclaration(node)) {
state.declarationBindingIds.add(node.id);
state.scope.bindings[node.id.name] = {
type: "let",
refs: [
{
type: "class-decl",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration,
},
],
};
}
const scope = pushTempScope(state, "block", "Class", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
state.declarationBindingIds.add(node.id);
scope.bindings[node.id.name] = {
type: "const",
refs: [
{
type: "class-inner",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration,
},
],
};
}
} else if (libExports$2.isForXStatement(node) || libExports$2.isForStatement(node)) {
const init = node.init || node.left;
if (isNode(init, "VariableDeclaration") && isLetOrConst(init)) {
// Debugger will create new lexical environment for the for.
pushTempScope(state, "block", "For", {
// Being at the start of a for loop doesn't count as
// being inside it.
start: fromBabelLocation(init.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
}
} else if (libExports$2.isCatchClause(node)) {
const scope = pushTempScope(state, "block", "Catch", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
parseDeclarator(node.param, scope, "var", "catch", node, state);
} else if (
libExports$2.isBlockStatement(node) &&
// Function body's are handled in the function logic above.
!libExports$2.isFunction(parentNode) &&
hasLexicalDeclaration(node, parentNode)
) {
// Debugger will create new lexical environment for the block.
pushTempScope(state, "block", "Block", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
} else if (
libExports$2.isVariableDeclaration(node) &&
(node.kind === "var" ||
// Lexical declarations in for statements are handled above.
!libExports$2.isForStatement(parentNode, { init: node }) ||
!libExports$2.isForXStatement(parentNode, { left: node }))
) {
// Finds right lexical environment
const hoistAt = !isLetOrConst(node)
? getVarScope(state.scope)
: state.scope;
node.declarations.forEach(declarator => {
parseDeclarator(
declarator.id,
hoistAt,
node.kind,
node.kind,
node,
state
);
});
} else if (
libExports$2.isImportDeclaration(node) &&
(!node.importKind || node.importKind === "value")
) {
node.specifiers.forEach(spec => {
if (spec.importKind && spec.importKind !== "value") {
return;
}
if (libExports$2.isImportNamespaceSpecifier(spec)) {
state.declarationBindingIds.add(spec.local);
state.scope.bindings[spec.local.name] = {
// Imported namespaces aren't live import bindings, they are
// just normal const bindings.
type: "const",
refs: [
{
type: "import-ns-decl",
start: fromBabelLocation(spec.local.loc.start, state.sourceId),
end: fromBabelLocation(spec.local.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
],
};
} else {
state.declarationBindingIds.add(spec.local);
state.scope.bindings[spec.local.name] = {
type: "import",
refs: [
{
type: "import-decl",
start: fromBabelLocation(spec.local.loc.start, state.sourceId),
end: fromBabelLocation(spec.local.loc.end, state.sourceId),
importName: libExports$2.isImportDefaultSpecifier(spec)
? "default"
: spec.imported.name,
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
],
};
}
});
} else if (libExports$2.isTSEnumDeclaration(node)) {
state.declarationBindingIds.add(node.id);
state.scope.bindings[node.id.name] = {
type: "const",
refs: [
{
type: "ts-enum-decl",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
],
};
} else if (libExports$2.isTSModuleDeclaration(node)) {
state.declarationBindingIds.add(node.id);
state.scope.bindings[node.id.name] = {
type: "const",
refs: [
{
type: "ts-namespace-decl",
start: fromBabelLocation(node.id.loc.start, state.sourceId),
end: fromBabelLocation(node.id.loc.end, state.sourceId),
declaration: {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
},
},
],
};
} else if (libExports$2.isTSModuleBlock(node)) {
pushTempScope(state, "block", "TypeScript Namespace", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
} else if (
libExports$2.isIdentifier(node) &&
libExports$2.isReferenced(node, parentNode) &&
// Babel doesn't cover this in 'isReferenced' yet, but it should
// eventually.
!libExports$2.isTSEnumMember(parentNode, { id: node }) &&
!libExports$2.isTSModuleDeclaration(parentNode, { id: node }) &&
// isReferenced above fails to see `var { foo } = ...` as a non-reference
// because the direct parent is not enough to know that the pattern is
// used within a variable declaration.
!state.declarationBindingIds.has(node)
) {
let freeVariables = state.freeVariables.get(node.name);
if (!freeVariables) {
freeVariables = [];
state.freeVariables.set(node.name, freeVariables);
}
freeVariables.push({
type: "ref",
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
meta: buildMetaBindings(state.sourceId, node, ancestors),
});
} else if (isOpeningJSXIdentifier(node, ancestors)) {
let freeVariables = state.freeVariables.get(node.name);
if (!freeVariables) {
freeVariables = [];
state.freeVariables.set(node.name, freeVariables);
}
freeVariables.push({
type: "ref",
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
meta: buildMetaBindings(state.sourceId, node, ancestors),
});
} else if (libExports$2.isThisExpression(node)) {
let freeVariables = state.freeVariables.get("this");
if (!freeVariables) {
freeVariables = [];
state.freeVariables.set("this", freeVariables);
}
freeVariables.push({
type: "ref",
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
meta: buildMetaBindings(state.sourceId, node, ancestors),
});
} else if (libExports$2.isClassProperty(parentNode, { value: node })) {
const scope = pushTempScope(state, "function", "Class Field", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
scope.bindings.this = {
type: "implicit",
refs: [],
};
scope.bindings.arguments = {
type: "implicit",
refs: [],
};
} else if (
libExports$2.isSwitchStatement(node) &&
hasLexicalDeclaration(node, parentNode)
) {
pushTempScope(state, "block", "Switch", {
start: fromBabelLocation(node.loc.start, state.sourceId),
end: fromBabelLocation(node.loc.end, state.sourceId),
});
}
if (
// In general Flow expressions are deleted, so they can't contain
// runtime bindings, but typecasts are the one exception there.
(libExports$2.isFlow(node) && !libExports$2.isTypeCastExpression(node)) ||
// In general TS items are deleted, but TS has a few wrapper node
// types that can contain general JS expressions.
(node.type.startsWith("TS") &&
!libExports$2.isTSTypeAssertion(node) &&
!libExports$2.isTSAsExpression(node) &&
!libExports$2.isTSNonNullExpression(node) &&
!libExports$2.isTSModuleDeclaration(node) &&
!libExports$2.isTSModuleBlock(node) &&
!libExports$2.isTSParameterProperty(node) &&
!libExports$2.isTSExportAssignment(node))
) {
// Flag this node as a root "type" node. All items inside of this
// will be skipped entirely.
state.inType = node;
}
},
exit(node, ancestors, state) {
const currentScope = state.scope;
const parentScope = state.scopeStack.pop();
if (!parentScope) {
throw new Error("Assertion failure - unsynchronized pop");
}
state.scope = parentScope;
// It is possible, as in the case of function expressions, that a single
// node has added multiple scopes, so we need to traverse upward here
// rather than jumping stright to 'parentScope'.
for (
let scope = currentScope;
scope && scope !== parentScope;
scope = scope.parent
) {
const { freeVariables } = state;
state.freeVariables = state.freeVariableStack.pop();
const parentFreeVariables = state.freeVariables;
// Match up any free variables that match this scope's bindings and
// merge then into the refs.
for (const key of Object.keys(scope.bindings)) {
const binding = scope.bindings[key];
const freeVars = freeVariables.get(key);
if (freeVars) {
binding.refs.push(...freeVars);
freeVariables.delete(key);
}
}
// Move any undeclared references in this scope into the parent for
// processing in higher scopes.
for (const [key, value] of freeVariables) {
let refs = parentFreeVariables.get(key);
if (!refs) {
refs = [];
parentFreeVariables.set(key, refs);
}
refs.push(...value);
}
}
if (state.inType === node) {
state.inType = null;
}
},
};
function isOpeningJSXIdentifier(node, ancestors) {
if (!libExports$2.isJSXIdentifier(node)) {
return false;
}
for (let i = ancestors.length - 1; i >= 0; i--) {
const { node: parent, key } = ancestors[i];
if (libExports$2.isJSXOpeningElement(parent) && key === "name") {
return true;
} else if (!libExports$2.isJSXMemberExpression(parent) || key !== "object") {
break;
}
}
return false;
}
function buildMetaBindings(
sourceId,
node,
ancestors,
parentIndex = ancestors.length - 1
) {
if (parentIndex <= 1) {
return null;
}
const parent = ancestors[parentIndex].node;
const grandparent = ancestors[parentIndex - 1].node;
// Consider "0, foo" to be equivalent to "foo".
if (
libExports$2.isSequenceExpression(parent) &&
parent.expressions.length === 2 &&
libExports$2.isNumericLiteral(parent.expressions[0]) &&
parent.expressions[1] === node
) {
let { start, end } = parent.loc;
if (libExports$2.isCallExpression(grandparent, { callee: parent })) {
// Attempt to expand the range around parentheses, e.g.
// (0, foo.bar)()
start = grandparent.loc.start;
end = Object.assign({}, end);
end.column += 1;
}
return {
type: "inherit",
start: fromBabelLocation(start, sourceId),
end: fromBabelLocation(end, sourceId),
parent: buildMetaBindings(sourceId, parent, ancestors, parentIndex - 1),
};
}
// Consider "Object(foo)", and "__webpack_require__.i(foo)" to be
// equivalent to "foo" since they are essentially identity functions.
if (
libExports$2.isCallExpression(parent) &&
(libExports$2.isIdentifier(parent.callee, { name: "Object" }) ||
(libExports$2.isMemberExpression(parent.callee, { computed: false }) &&
libExports$2.isIdentifier(parent.callee.object, { name: "__webpack_require__" }) &&
libExports$2.isIdentifier(parent.callee.property, { name: "i" }))) &&
parent.arguments.length === 1 &&
parent.arguments[0] === node
) {
return {
type: "inherit",
start: fromBabelLocation(parent.loc.start, sourceId),
end: fromBabelLocation(parent.loc.end, sourceId),
parent: buildMetaBindings(sourceId, parent, ancestors, parentIndex - 1),
};
}
if (libExports$2.isMemberExpression(parent, { object: node })) {
if (parent.computed) {
if (libExports$2.isStringLiteral(parent.property)) {
return {
type: "member",
start: fromBabelLocation(parent.loc.start, sourceId),
end: fromBabelLocation(parent.loc.end, sourceId),
property: parent.property.value,
parent: buildMetaBindings(
sourceId,
parent,
ancestors,
parentIndex - 1
),
};
}
} else {
return {
type: "member",
start: fromBabelLocation(parent.loc.start, sourceId),
end: fromBabelLocation(parent.loc.end, sourceId),
property: parent.property.name,
parent: buildMetaBindings(sourceId, parent, ancestors, parentIndex - 1),
};
}
}
if (
libExports$2.isCallExpression(parent, { callee: node }) &&
!parent.arguments.length
) {
return {
type: "call",
start: fromBabelLocation(parent.loc.start, sourceId),
end: fromBabelLocation(parent.loc.end, sourceId),
parent: buildMetaBindings(sourceId, parent, ancestors, parentIndex - 1),
};
}
return null;
}
function looksLikeCommonJS(rootScope) {
const hasRefs = name =>
rootScope.bindings[name] && !!rootScope.bindings[name].refs.length;
return (
hasRefs("__dirname") ||
hasRefs("__filename") ||
hasRefs("require") ||
hasRefs("exports") ||
hasRefs("module")
);
}
function stripModuleScope(rootScope) {
const rootLexicalScope = rootScope.children[0];
const moduleScope = rootLexicalScope.children[0];
if (moduleScope.type !== "module") {
throw new Error("Assertion failure - should be module");
}
Object.keys(moduleScope.bindings).forEach(name => {
const binding = moduleScope.bindings[name];
if (binding.type === "let" || binding.type === "const") {
rootLexicalScope.bindings[name] = binding;
} else {
rootScope.bindings[name] = binding;
}
});
rootLexicalScope.children = moduleScope.children;
rootLexicalScope.children.forEach(child => {
child.parent = rootLexicalScope;
});
}
const parsedScopesCache = new Map();
function getScopes(location) {
const sourceId = location.source.id;
let parsedScopes = parsedScopesCache.get(sourceId);
if (!parsedScopes) {
parsedScopes = parseSourceScopes(sourceId);
parsedScopesCache.set(sourceId, parsedScopes);
}
return parsedScopes ? findScopes(parsedScopes, location) : [];
}
function clearScopes(sourceIds) {
for (const sourceId of sourceIds) {
parsedScopesCache.delete(sourceId);
}
}
/**
* Searches all scopes and their bindings at the specific location.
*/
function findScopes(scopes, location) {
// Find inner most in the tree structure.
let searchInScopes = scopes;
const found = [];
while (searchInScopes) {
const foundOne = searchInScopes.some(s => {
if (
compareLocations(s.start, location) <= 0 &&
compareLocations(location, s.end) < 0
) {
// Found the next scope, trying to search recusevly in its children.
found.unshift(s);
searchInScopes = s.children;
return true;
}
return false;
});
if (!foundOne) {
break;
}
}
return found.map(i => ({
type: i.type,
scopeKind: i.scopeKind,
displayName: i.displayName,
start: i.start,
end: i.end,
bindings: i.bindings,
}));
}
function compareLocations(a, b) {
// According to type of Location.column can be undefined, if will not be the
// case here, ignoring flow error.
return a.line == b.line ? a.column - b.column : a.line - b.line;
}
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
function startsBefore(a, b) {
let before = a.start.line < b.line;
if (a.start.line === b.line) {
before =
a.start.column >= 0 && b.column >= 0 ? a.start.column <= b.column : true;
}
return before;
}
function endsAfter(a, b) {
let after = a.end.line > b.line;
if (a.end.line === b.line) {
after =
a.end.column >= 0 && b.column >= 0 ? a.end.column >= b.column : true;
}
return after;
}
function containsPosition(a, b) {
return startsBefore(a, b) && endsAfter(a, b);
}
function containsLocation(a, b) {
return containsPosition(a, b.start) && containsPosition(a, b.end);
}
function findSymbols(source) {
const { functions, comments } = getInternalSymbols(source);
return { functions, comments };
}
/**
* Returns the location for a given function path. If the path represents a
* function declaration, the location will begin after the function identifier
* but before the function parameters.
*/
function getLocation(func) {
const location = { ...func.location };
// if the function has an identifier, start the block after it so the
// identifier is included in the "scope" of its parent
const identifierEnd = func?.identifier?.loc?.end;
if (identifierEnd) {
location.start = identifierEnd;
}
return location;
}
/**
* Find the nearest location containing the input position and
* return inner locations under that nearest location
*
* @param {Array<Object>} locations Notice! The locations MUST be sorted by `sortByStart`
* so that we can do linear time complexity operation.
* @returns {Array<Object>}
*/
function getInnerLocations(locations, position) {
// First, let's find the nearest position-enclosing function location,
// which is to find the last location enclosing the position.
let parentIndex;
for (let i = locations.length - 1; i >= 0; i--) {
const loc = locations[i];
if (containsPosition(loc, position)) {
parentIndex = i;
break;
}
}
if (parentIndex == undefined) {
return [];
}
const parentLoc = locations[parentIndex];
// Then, from the nearest location, loop locations again and put locations into
// the innerLocations array until we get to a location not enclosed by the nearest location.
const innerLocations = [];
for (let i = parentIndex + 1; i < locations.length; i++) {
const loc = locations[i];
if (!containsLocation(parentLoc, loc)) {
break;
}
innerLocations.push(loc);
}
return innerLocations;
}
/**
* Return an new locations array which excludes
* items that are completely enclosed by another location in the input locations
*
* @param locations Notice! The locations MUST be sorted by `sortByStart`
* so that we can do linear time complexity operation.
*/
function removeOverlaps(locations) {
if (!locations.length) {
return [];
}
const firstParent = locations[0];
return locations.reduce(deduplicateNode, [firstParent]);
}
function deduplicateNode(nodes, location) {
const parent = nodes[nodes.length - 1];
if (!containsLocation(parent, location)) {
nodes.push(location);
}
return nodes;
}
/**
* Sorts an array of locations by start position
*/
function sortByStart(a, b) {
if (a.start.line < b.start.line) {
return -1;
} else if (a.start.line === b.start.line) {
return a.start.column - b.start.column;
}
return 1;
}
/**
* Returns an array of locations that are considered out of scope for the given
* location.
*/
function findOutOfScopeLocations(location) {
const { functions, comments } = findSymbols(location.source.id);
const commentLocations = comments.map(c => c.location);
const locations = functions
.map(getLocation)
.concat(commentLocations)
.sort(sortByStart);
const innerLocations = getInnerLocations(locations, location);
const outerLocations = locations.filter(loc => {
if (innerLocations.includes(loc)) {
return false;
}
return !containsPosition(loc, location);
});
return removeOverlaps(outerLocations);
}
function findBestMatchExpression(sourceId, tokenPos) {
const symbols = getInternalSymbols(sourceId);
if (!symbols) {
return null;
}
const { line, column } = tokenPos;
const { memberExpressions, identifiers, literals } = symbols;
function matchExpression(expression) {
const { location } = expression;
const { start, end } = location;
return start.line == line && start.column <= column && end.column >= column;
}
function matchMemberExpression(expression) {
// For member expressions we ignore "computed" member expressions `foo[bar]`,
// to only match the one that looks like: `foo.bar`.
return !expression.computed && matchExpression(expression);
}
// Avoid duplicating these arrays and be careful about performance as they can be large
//
// Process member expressions first as they can be including identifiers which
// are subset of the member expression.
// Ex: `foo.bar` is a member expression made of `foo` and `bar` identifiers.
return (
memberExpressions.find(matchMemberExpression) ||
literals.find(matchExpression) ||
identifiers.find(matchExpression)
);
}
// NOTE: this will only work if we are replacing an original identifier
function replaceNode(ancestors, node) {
const ancestor = ancestors[ancestors.length - 1];
if (typeof ancestor.index === "number") {
ancestor.node[ancestor.key][ancestor.index] = node;
} else {
ancestor.node[ancestor.key] = node;
}
}
function getFirstExpression(ast) {
const statements = ast.program.body;
if (!statements.length) {
return null;
}
return statements[0].expression;
}
function locationKey(start) {
return `${start.line}:${start.column}`;
}
function mapOriginalExpression(expression, ast, mappings) {
const scopes = buildScopeList(ast, "");
let shouldUpdate = false;
const nodes = new Map();
const replacements = new Map();
// The ref-only global bindings are the ones that are accessed, but not
// declared anywhere in the parsed code, meaning they are either global,
// or declared somewhere in a scope outside the parsed code, so we
// rewrite all of those specifically to avoid rewritting declarations that
// shadow outer mappings.
for (const name of Object.keys(scopes[0].bindings)) {
const { refs } = scopes[0].bindings[name];
const mapping = mappings[name];
if (
!refs.every(ref => ref.type === "ref") ||
!mapping ||
mapping === name
) {
continue;
}
let node = nodes.get(name);
if (!node) {
node = getFirstExpression(parseScript(mapping));
nodes.set(name, node);
}
for (const ref of refs) {
let { line, column } = ref.start;
// This shouldn't happen, just keeping Flow happy.
if (typeof column !== "number") {
column = 0;
}
replacements.set(locationKey({ line, column }), node);
}
}
if (replacements.size === 0) {
// Avoid the extra code generation work and also avoid potentially
// reformatting the user's code unnecessarily.
return expression;
}
libExports$2.traverse(ast, (node, ancestors) => {
if (!libExports$2.isIdentifier(node) && !libExports$2.isThisExpression(node)) {
return;
}
const ancestor = ancestors[ancestors.length - 1];
// Shorthand properties can have a key and value with `node.loc.start` value
// and we only want to replace the value.
if (libExports$2.isObjectProperty(ancestor.node) && ancestor.key !== "value") {
return;
}
const replacement = replacements.get(locationKey(node.loc.start));
if (replacement) {
replaceNode(ancestors, libExports$2.cloneNode(replacement));
shouldUpdate = true;
}
});
if (shouldUpdate) {
return generate(ast).code;
}
return expression;
}
function getAssignmentTarget(node, bindings) {
if (libExports$2.isObjectPattern(node)) {
for (const property of node.properties) {
if (libExports$2.isRestElement(property)) {
property.argument = getAssignmentTarget(property.argument, bindings);
} else {
property.value = getAssignmentTarget(property.value, bindings);
}
}
return node;
}
if (libExports$2.isArrayPattern(node)) {
for (const [i, element] of node.elements.entries()) {
node.elements[i] = getAssignmentTarget(element, bindings);
}
return node;
}
if (libExports$2.isAssignmentPattern(node)) {
node.left = getAssignmentTarget(node.left, bindings);
return node;
}
if (libExports$2.isRestElement(node)) {
node.argument = getAssignmentTarget(node.argument, bindings);
return node;
}
if (libExports$2.isIdentifier(node)) {
return bindings.includes(node.name)
? node
: libExports$2.memberExpression(libExports$2.identifier("self"), node);
}
return node;
}
// translates new bindings `var a = 3` into `self.a = 3`
// and existing bindings `var a = 3` into `a = 3` for re-assignments
function globalizeDeclaration(node, bindings) {
return node.declarations.map(declaration =>
libExports$2.expressionStatement(
libExports$2.assignmentExpression(
"=",
getAssignmentTarget(declaration.id, bindings),
declaration.init || libExports$2.unaryExpression("void", libExports$2.numericLiteral(0))
)
)
);
}
// translates new bindings `a = 3` into `self.a = 3`
// and keeps assignments the same for existing bindings.
function globalizeAssignment(node, bindings) {
return libExports$2.assignmentExpression(
node.operator,
getAssignmentTarget(node.left, bindings),
node.right
);
}
function mapExpressionBindings(expression, ast, bindings = []) {
let isMapped = false;
let shouldUpdate = true;
libExports$2.traverse(ast, (node, ancestors) => {
const parent = ancestors[ancestors.length - 1];
if (libExports$2.isWithStatement(node)) {
shouldUpdate = false;
return;
}
if (!isTopLevel(ancestors)) {
return;
}
if (libExports$2.isAssignmentExpression(node)) {
if (libExports$2.isIdentifier(node.left) || libExports$2.isPattern(node.left)) {
const newNode = globalizeAssignment(node, bindings);
isMapped = true;
replaceNode$1(ancestors, newNode);
return;
}
return;
}
if (!libExports$2.isVariableDeclaration(node)) {
return;
}
if (!libExports$2.isForStatement(parent.node)) {
const newNodes = globalizeDeclaration(node, bindings);
isMapped = true;
replaceNode$1(ancestors, newNodes);
}
});
if (!shouldUpdate || !isMapped) {
return expression;
}
return generate(ast).code;
}
function hasTopLevelAwait(ast) {
const hasAwait = hasNode(
ast,
(node, ancestors) => libExports$2.isAwaitExpression(node) && isTopLevel(ancestors)
);
return hasAwait;
}
// translates new bindings `var a = 3` into `a = 3`.
function translateDeclarationIntoAssignment(node) {
return node.declarations.reduce((acc, declaration) => {
// Don't translate declaration without initial assignment (e.g. `var a;`)
if (!declaration.init) {
return acc;
}
acc.push(
libExports$2.expressionStatement(
libExports$2.assignmentExpression("=", declaration.id, declaration.init)
)
);
return acc;
}, []);
}
/**
* Given an AST, modify it to return the last evaluated statement's expression value if possible.
* This is to preserve existing console behavior of displaying the last executed expression value.
*/
function addReturnNode(ast) {
const statements = ast.program.body;
const lastStatement = statements.pop();
// if the last expression is an awaitExpression, strip the `await` part and directly
// return the argument to avoid calling the argument's `then` function twice when the
if (libExports$2.isAwaitExpression(lastStatement.expression)) {
lastStatement.expression = lastStatement.expression.argument;
}
// NOTE: For more complicated cases such as an if/for statement, the last evaluated
// expression value probably can not be displayed, unless doing hacky workarounds such
// as returning the `eval` of the final statement (won't always work due to CSP issues?)
statements.push(
libExports$2.isExpressionStatement(lastStatement)
? libExports$2.returnStatement(lastStatement.expression)
: lastStatement
);
return statements;
}
function getDeclarations(node) {
const { kind, declarations } = node;
const declaratorNodes = declarations.reduce((acc, d) => {
const declarators = getVariableDeclarators(d.id);
return acc.concat(declarators);
}, []);
// We can't declare const variables outside of the async iife because we
// wouldn't be able to re-assign them. As a workaround, we transform them
// to `let` which should be good enough for those case.
return libExports$2.variableDeclaration(
kind === "const" ? "let" : kind,
declaratorNodes
);
}
function getVariableDeclarators(node) {
if (libExports$2.isIdentifier(node)) {
return libExports$2.variableDeclarator(libExports$2.identifier(node.name));
}
if (libExports$2.isObjectProperty(node)) {
return getVariableDeclarators(node.value);
}
if (libExports$2.isRestElement(node)) {
return getVariableDeclarators(node.argument);
}
if (libExports$2.isAssignmentPattern(node)) {
return getVariableDeclarators(node.left);
}
if (libExports$2.isArrayPattern(node)) {
return node.elements.reduce(
(acc, element) => acc.concat(getVariableDeclarators(element)),
[]
);
}
if (libExports$2.isObjectPattern(node)) {
return node.properties.reduce(
(acc, property) => acc.concat(getVariableDeclarators(property)),
[]
);
}
return [];
}
/**
* Given an AST and an array of variableDeclaration nodes, return a new AST with
* all the declarations at the top of the AST.
*/
function addTopDeclarationNodes(ast, declarationNodes) {
const statements = [];
declarationNodes.forEach(declarationNode => {
statements.push(getDeclarations(declarationNode));
});
statements.push(ast);
return libExports$2.program(statements);
}
/**
* Given an AST, return an object of the following shape:
* - newAst: {AST} the AST where variable declarations were transformed into
* variable assignments
* - declarations: {Array<Node>} An array of all the declaration nodes needed
* outside of the async iife.
*/
function translateDeclarationsIntoAssignment(ast) {
const declarations = [];
libExports$2.traverse(ast, (node, ancestors) => {
const parent = ancestors[ancestors.length - 1];
if (
libExports$2.isWithStatement(node) ||
!isTopLevel(ancestors) ||
libExports$2.isAssignmentExpression(node) ||
!libExports$2.isVariableDeclaration(node) ||
libExports$2.isForStatement(parent.node) ||
libExports$2.isForXStatement(parent.node) ||
!Array.isArray(node.declarations) ||
node.declarations.length === 0
) {
return;
}
const newNodes = translateDeclarationIntoAssignment(node);
replaceNode$1(ancestors, newNodes);
declarations.push(node);
});
return {
newAst: ast,
declarations,
};
}
/**
* Given an AST, wrap its body in an async iife, transform variable declarations
* in assignments and move the variable declarations outside of the async iife.
* Example: With the AST for the following expression: `let a = await 123`, the
* function will return:
* let a;
* (async => {
* return a = await 123;
* })();
*/
function wrapExpressionFromAst(ast) {
// Transform let and var declarations into assignments, and get back an array
// of variable declarations.
let { newAst, declarations } = translateDeclarationsIntoAssignment(ast);
const body = addReturnNode(newAst);
// Create the async iife.
newAst = libExports$2.expressionStatement(
libExports$2.callExpression(
libExports$2.arrowFunctionExpression([], libExports$2.blockStatement(body), true),
[]
)
);
// Now let's put all the variable declarations at the top of the async iife.
newAst = addTopDeclarationNodes(newAst, declarations);
return generate(newAst).code;
}
function mapTopLevelAwait(expression, ast) {
if (!ast) {
// If there's no ast this means the expression is malformed. And if the
// expression contains the await keyword, we still want to wrap it in an
// async iife in order to get a meaningful message (without this, the
// engine will throw an Error stating that await keywords are only valid
// in async functions and generators).
if (expression.includes("await ")) {
return `(async () => { ${expression} })();`;
}
return expression;
}
if (!hasTopLevelAwait(ast)) {
return expression;
}
return wrapExpressionFromAst(ast);
}
function mapExpression(
expression,
mappings,
bindings,
shouldMapBindings = true,
shouldMapAwait = true
) {
const mapped = {
await: false,
bindings: false,
originalExpression: false,
};
const ast = parseConsoleScript(expression);
try {
if (mappings && ast) {
const beforeOriginalExpression = expression;
expression = mapOriginalExpression(expression, ast, mappings);
mapped.originalExpression = beforeOriginalExpression !== expression;
}
if (shouldMapBindings && ast) {
const beforeBindings = expression;
expression = mapExpressionBindings(expression, ast, bindings);
mapped.bindings = beforeBindings !== expression;
}
if (shouldMapAwait) {
const beforeAwait = expression;
expression = mapTopLevelAwait(expression, ast);
mapped.await = beforeAwait !== expression;
}
} catch (e) {
console.warn(`Error when mapping ${expression} expression:`, e);
}
return {
expression,
mapped,
};
}
var workerUtils = {exports: {}};
var hasRequiredWorkerUtils;
function requireWorkerUtils () {
if (hasRequiredWorkerUtils) return workerUtils.exports;
hasRequiredWorkerUtils = 1;
(function (module) {
class WorkerDispatcher {
#msgId = 1;
#worker = null;
// Map of message ids -> promise resolution functions, for dispatching worker responses
#pendingCalls = new Map();
#url = "";
constructor(url) {
this.#url = url;
}
start() {
// When running in debugger jest test, we don't have access to ChromeWorker
if (typeof ChromeWorker == "function") {
this.#worker = new ChromeWorker(this.#url);
} else {
this.#worker = new Worker(this.#url);
}
this.#worker.onerror = err => {
console.error(`Error in worker ${this.#url}`, err.message);
};
this.#worker.addEventListener("message", this.#onMessage);
}
stop() {
if (!this.#worker) {
return;
}
this.#worker.removeEventListener("message", this.#onMessage);
this.#worker.terminate();
this.#worker = null;
this.#pendingCalls.clear();
}
task(method, { queue = false } = {}) {
const calls = [];
const push = args => {
return new Promise((resolve, reject) => {
if (queue && calls.length === 0) {
Promise.resolve().then(flush);
}
calls.push({ args, resolve, reject });
if (!queue) {
flush();
}
});
};
const flush = () => {
const items = calls.slice();
calls.length = 0;
if (!this.#worker) {
this.start();
}
const id = this.#msgId++;
this.#worker.postMessage({
id,
method,
calls: items.map(item => item.args),
});
this.#pendingCalls.set(id, items);
};
return (...args) => push(args);
}
invoke(method, ...args) {
return this.task(method)(...args);
}
#onMessage = ({ data: result }) => {
const items = this.#pendingCalls.get(result.id);
this.#pendingCalls.delete(result.id);
if (!items) {
return;
}
if (!this.#worker) {
return;
}
result.results.forEach((resultData, i) => {
const { resolve, reject } = items[i];
if (resultData.error) {
const err = new Error(resultData.message);
err.metadata = resultData.metadata;
reject(err);
} else {
resolve(resultData.response);
}
});
};
}
function workerHandler(publicInterface) {
return function (msg) {
const { id, method, calls } = msg.data;
Promise.all(
calls.map(args => {
try {
const response = publicInterface[method].apply(undefined, args);
if (response instanceof Promise) {
return response.then(
val => ({ response: val }),
err => asErrorMessage(err)
);
}
return { response };
} catch (error) {
return asErrorMessage(error);
}
})
).then(results => {
globalThis.postMessage({ id, results });
});
};
}
function asErrorMessage(error) {
if (typeof error === "object" && error && "message" in error) {
// Error can't be sent via postMessage, so be sure to convert to
// string.
return {
error: true,
message: error.message,
metadata: error.metadata,
};
}
return {
error: true,
message: error == null ? error : error.toString(),
metadata: undefined,
};
}
// Might be loaded within a worker thread where `module` isn't available.
{
module.exports = {
WorkerDispatcher,
workerHandler,
};
}
} (workerUtils));
return workerUtils.exports;
}
var workerUtilsExports = requireWorkerUtils();
function clearAllHelpersForSources(sourceIds) {
clearASTs(sourceIds);
clearScopes(sourceIds);
clearSources(sourceIds);
clearSymbols(sourceIds);
}
self.onmessage = workerUtilsExports.workerHandler({
findOutOfScopeLocations,
findBestMatchExpression,
getSymbols,
getFunctionSymbols,
getClassSymbols,
getClosestFunctionName,
getScopes,
clearSources: clearAllHelpersForSources,
mapExpression,
setSource,
});
}));